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.
5 This file is part of GCC.
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
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
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
33 #include "tree-inline.h"
34 #include "diagnostic.h"
40 cpp_reader *parse_in; /* Declared in c-lex.h. */
42 #undef WCHAR_TYPE_SIZE
43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
45 /* We let tm.h override the types used here, to handle trivial differences
46 such as the choice of unsigned int or long unsigned int for size_t.
47 When machines start needing nontrivial differences in the size type,
48 it would be best to do something here to figure out automatically
49 from other information what type to use. */
52 #define SIZE_TYPE "long unsigned int"
56 #define WCHAR_TYPE "int"
60 #define PTRDIFF_TYPE "long int"
64 #define WINT_TYPE "unsigned int"
68 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
70 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
78 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 ? "long unsigned int" \
80 : "long long unsigned int"))
83 /* The variant of the C language being processed. */
85 enum c_language_kind c_language;
87 /* The following symbols are subsumed in the c_global_trees array, and
88 listed here individually for documentation purposes.
90 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
92 tree short_integer_type_node;
93 tree long_integer_type_node;
94 tree long_long_integer_type_node;
96 tree short_unsigned_type_node;
97 tree long_unsigned_type_node;
98 tree long_long_unsigned_type_node;
100 tree boolean_type_node;
101 tree boolean_false_node;
102 tree boolean_true_node;
104 tree ptrdiff_type_node;
106 tree unsigned_char_type_node;
107 tree signed_char_type_node;
108 tree wchar_type_node;
109 tree signed_wchar_type_node;
110 tree unsigned_wchar_type_node;
112 tree float_type_node;
113 tree double_type_node;
114 tree long_double_type_node;
116 tree complex_integer_type_node;
117 tree complex_float_type_node;
118 tree complex_double_type_node;
119 tree complex_long_double_type_node;
121 tree intQI_type_node;
122 tree intHI_type_node;
123 tree intSI_type_node;
124 tree intDI_type_node;
125 tree intTI_type_node;
127 tree unsigned_intQI_type_node;
128 tree unsigned_intHI_type_node;
129 tree unsigned_intSI_type_node;
130 tree unsigned_intDI_type_node;
131 tree unsigned_intTI_type_node;
133 tree widest_integer_literal_type_node;
134 tree widest_unsigned_literal_type_node;
136 Nodes for types `void *' and `const void *'.
138 tree ptr_type_node, const_ptr_type_node;
140 Nodes for types `char *' and `const char *'.
142 tree string_type_node, const_string_type_node;
144 Type `char[SOMENUMBER]'.
145 Used when an array of char is needed and the size is irrelevant.
147 tree char_array_type_node;
149 Type `int[SOMENUMBER]' or something like it.
150 Used when an array of int needed and the size is irrelevant.
152 tree int_array_type_node;
154 Type `wchar_t[SOMENUMBER]' or something like it.
155 Used when a wide string literal is created.
157 tree wchar_array_type_node;
159 Type `int ()' -- used for implicit declaration of functions.
161 tree default_function_type;
163 A VOID_TYPE node, packaged in a TREE_LIST.
167 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
168 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
169 VAR_DECLS, but C++ does.)
171 tree function_name_decl_node;
172 tree pretty_function_name_decl_node;
173 tree c99_function_name_decl_node;
175 Stack of nested function name VAR_DECLs.
177 tree saved_function_name_decls;
181 tree c_global_trees[CTI_MAX];
183 /* Nonzero means don't recognize the non-ANSI builtin functions. */
187 /* Nonzero means don't recognize the non-ANSI builtin functions.
190 int flag_no_nonansi_builtin;
192 /* Nonzero means give `double' the same size as `float'. */
194 int flag_short_double;
196 /* Nonzero means give `wchar_t' the same size as `short'. */
198 int flag_short_wchar;
200 /* Nonzero means warn about possible violations of sequence point rules. */
202 int warn_sequence_point;
204 /* Nonzero means to warn about compile-time division by zero. */
205 int warn_div_by_zero = 1;
207 /* The elements of `ridpointers' are identifier nodes for the reserved
208 type names and storage classes. It is indexed by a RID_... value. */
211 tree (*make_fname_decl) PARAMS ((tree, int));
213 /* If non-NULL, the address of a language-specific function that
214 returns 1 for language-specific statement codes. */
215 int (*lang_statement_code_p) PARAMS ((enum tree_code));
217 /* If non-NULL, the address of a language-specific function that takes
218 any action required right before expand_function_end is called. */
219 void (*lang_expand_function_end) PARAMS ((void));
221 /* Nonzero means the expression being parsed will never be evaluated.
222 This is a count, since unevaluated expressions can nest. */
225 /* Information about how a function name is generated. */
228 tree *const decl; /* pointer to the VAR_DECL. */
229 const unsigned rid; /* RID number for the identifier. */
230 const int pretty; /* How pretty is it? */
233 /* The three ways of getting then name of the current function. */
235 const struct fname_var_t fname_vars[] =
237 /* C99 compliant __func__, must be first. */
238 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
239 /* GCC __FUNCTION__ compliant. */
240 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
241 /* GCC __PRETTY_FUNCTION__ compliant. */
242 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
246 static int constant_fits_type_p PARAMS ((tree, tree));
248 /* Keep a stack of if statements. We record the number of compound
249 statements seen up to the if keyword, as well as the line number
250 and file of the if. If a potentially ambiguous else is seen, that
251 fact is recorded; the warning is issued when we can be sure that
252 the enclosing if statement does not have an else branch. */
262 static if_elt *if_stack;
264 /* Amount of space in the if statement stack. */
265 static int if_stack_space = 0;
268 static int if_stack_pointer = 0;
270 /* Record the start of an if-then, and record the start of it
271 for ambiguous else detection. */
274 c_expand_start_cond (cond, compstmt_count)
280 /* Make sure there is enough space on the stack. */
281 if (if_stack_space == 0)
284 if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
286 else if (if_stack_space == if_stack_pointer)
288 if_stack_space += 10;
289 if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
292 if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
293 IF_COND (if_stmt) = cond;
296 /* Record this if statement. */
297 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
298 if_stack[if_stack_pointer].file = input_filename;
299 if_stack[if_stack_pointer].line = lineno;
300 if_stack[if_stack_pointer].needs_warning = 0;
301 if_stack[if_stack_pointer].if_stmt = if_stmt;
305 /* Called after the then-clause for an if-statement is processed. */
310 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
311 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
314 /* Record the end of an if-then. Optionally warn if a nested
315 if statement had an ambiguous else clause. */
321 if (if_stack[if_stack_pointer].needs_warning)
322 warning_with_file_and_line (if_stack[if_stack_pointer].file,
323 if_stack[if_stack_pointer].line,
324 "suggest explicit braces to avoid ambiguous `else'");
325 last_expr_type = NULL_TREE;
328 /* Called between the then-clause and the else-clause
329 of an if-then-else. */
332 c_expand_start_else ()
334 /* An ambiguous else warning must be generated for the enclosing if
335 statement, unless we see an else branch for that one, too. */
337 && if_stack_pointer > 1
338 && (if_stack[if_stack_pointer - 1].compstmt_count
339 == if_stack[if_stack_pointer - 2].compstmt_count))
340 if_stack[if_stack_pointer - 2].needs_warning = 1;
342 /* Even if a nested if statement had an else branch, it can't be
343 ambiguous if this one also has an else. So don't warn in that
344 case. Also don't warn for any if statements nested in this else. */
345 if_stack[if_stack_pointer - 1].needs_warning = 0;
346 if_stack[if_stack_pointer - 1].compstmt_count--;
349 /* Called after the else-clause for an if-statement is processed. */
354 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
355 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
358 /* Push current bindings for the function name VAR_DECLS. */
364 tree saved = NULL_TREE;
366 for (ix = 0; fname_vars[ix].decl; ix++)
368 tree decl = *fname_vars[ix].decl;
372 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
373 *fname_vars[ix].decl = NULL_TREE;
376 if (saved || saved_function_name_decls)
377 /* Normally they'll have been NULL, so only push if we've got a
378 stack, or they are non-NULL. */
379 saved_function_name_decls = tree_cons (saved, NULL_TREE,
380 saved_function_name_decls);
383 /* Finish up the current bindings, adding them into the
384 current function's statement tree. This is done by wrapping the
385 function's body in a COMPOUND_STMT containing these decls too. This
386 must be done _before_ finish_stmt_tree is called. If there is no
387 current function, we must be at file scope and no statements are
388 involved. Pop the previous bindings. */
391 finish_fname_decls ()
394 tree body = NULL_TREE;
395 tree stack = saved_function_name_decls;
397 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
398 body = chainon (TREE_VALUE (stack), body);
402 /* They were called into existence, so add to statement tree. */
403 body = chainon (body,
404 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
405 body = build_stmt (COMPOUND_STMT, body);
407 COMPOUND_STMT_NO_SCOPE (body) = 1;
408 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
411 for (ix = 0; fname_vars[ix].decl; ix++)
412 *fname_vars[ix].decl = NULL_TREE;
416 /* We had saved values, restore them. */
419 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
421 tree decl = TREE_PURPOSE (saved);
422 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
424 *fname_vars[ix].decl = decl;
426 stack = TREE_CHAIN (stack);
428 saved_function_name_decls = stack;
431 /* Return the text name of the current function, suitable prettified
435 fname_as_string (pretty_p)
438 const char *name = NULL;
441 name = (current_function_decl
442 ? (*decl_printable_name) (current_function_decl, 2)
444 else if (current_function_decl && DECL_NAME (current_function_decl))
445 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
451 /* Return the text name of the current function, formatted as
452 required by the supplied RID value. */
460 for (ix = 0; fname_vars[ix].decl; ix++)
461 if (fname_vars[ix].rid == rid)
463 return fname_as_string (fname_vars[ix].pretty);
466 /* Return the VAR_DECL for a const char array naming the current
467 function. If the VAR_DECL has not yet been created, create it
468 now. RID indicates how it should be formatted and IDENTIFIER_NODE
469 ID is its name (unfortunately C and C++ hold the RID values of
470 keywords in different places, so we can't derive RID from ID in
471 this language independent code. */
479 tree decl = NULL_TREE;
481 for (ix = 0; fname_vars[ix].decl; ix++)
482 if (fname_vars[ix].rid == rid)
485 decl = *fname_vars[ix].decl;
488 tree saved_last_tree = last_tree;
490 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
491 if (last_tree != saved_last_tree)
493 /* We created some statement tree for the decl. This belongs
494 at the start of the function, so remove it now and reinsert
495 it after the function is complete. */
496 tree stmts = TREE_CHAIN (saved_last_tree);
498 TREE_CHAIN (saved_last_tree) = NULL_TREE;
499 last_tree = saved_last_tree;
500 saved_function_name_decls = tree_cons (decl, stmts,
501 saved_function_name_decls);
503 *fname_vars[ix].decl = decl;
505 if (!ix && !current_function_decl)
506 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
511 /* Given a chain of STRING_CST nodes,
512 concatenate them into one STRING_CST
513 and give it a suitable array-of-chars data type. */
516 combine_strings (strings)
523 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
525 const int nchars_max = flag_isoc99 ? 4095 : 509;
527 if (TREE_CHAIN (strings))
529 /* More than one in the chain, so concatenate. */
532 /* Don't include the \0 at the end of each substring,
533 except for the last one.
534 Count wide strings and ordinary strings separately. */
535 for (t = strings; t; t = TREE_CHAIN (t))
537 if (TREE_TYPE (t) == wchar_array_type_node)
539 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
544 length += (TREE_STRING_LENGTH (t) - 1);
545 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
546 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
550 /* If anything is wide, the non-wides will be converted,
551 which makes them take more space. */
553 length = length * wchar_bytes + wide_length;
557 /* Copy the individual strings into the new combined string.
558 If the combined string is wide, convert the chars to ints
559 for any individual strings that are not wide. */
562 for (t = strings; t; t = TREE_CHAIN (t))
564 int len = (TREE_STRING_LENGTH (t)
565 - ((TREE_TYPE (t) == wchar_array_type_node)
567 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
569 memcpy (q, TREE_STRING_POINTER (t), len);
575 for (i = 0; i < len; i++)
577 if (BYTES_BIG_ENDIAN)
579 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
581 *q++ = TREE_STRING_POINTER (t)[i];
585 *q++ = TREE_STRING_POINTER (t)[i];
586 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
595 for (i = 0; i < wchar_bytes; i++)
601 value = build_string (length, p);
606 length = TREE_STRING_LENGTH (value);
607 if (TREE_TYPE (value) == wchar_array_type_node)
611 /* Compute the number of elements, for the array type. */
612 nchars = wide_flag ? length / wchar_bytes : length;
614 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
615 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
616 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
618 /* Create the array type for the string constant.
619 -Wwrite-strings says make the string constant an array of const char
620 so that copying it to a non-const pointer will get a warning.
621 For C++, this is the standard behavior. */
622 if (flag_const_strings
623 && (! flag_traditional && ! flag_writable_strings))
626 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
629 = build_array_type (elements,
630 build_index_type (build_int_2 (nchars - 1, 0)));
634 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
635 build_index_type (build_int_2 (nchars - 1, 0)));
637 TREE_CONSTANT (value) = 1;
638 TREE_READONLY (value) = ! flag_writable_strings;
639 TREE_STATIC (value) = 1;
643 static int is_valid_printf_arglist PARAMS ((tree));
644 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
645 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
646 enum expand_modifier, int, int));
647 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
648 enum expand_modifier, int, int));
650 /* Print a warning if a constant expression had overflow in folding.
651 Invoke this function on every expression that the language
652 requires to be a constant expression.
653 Note the ANSI C standard says it is erroneous for a
654 constant expression to overflow. */
657 constant_expression_warning (value)
660 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
661 || TREE_CODE (value) == COMPLEX_CST)
662 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
663 pedwarn ("overflow in constant expression");
666 /* Print a warning if an expression had overflow in folding.
667 Invoke this function on every expression that
668 (1) appears in the source code, and
669 (2) might be a constant expression that overflowed, and
670 (3) is not already checked by convert_and_check;
671 however, do not invoke this function on operands of explicit casts. */
674 overflow_warning (value)
677 if ((TREE_CODE (value) == INTEGER_CST
678 || (TREE_CODE (value) == COMPLEX_CST
679 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
680 && TREE_OVERFLOW (value))
682 TREE_OVERFLOW (value) = 0;
683 if (skip_evaluation == 0)
684 warning ("integer overflow in expression");
686 else if ((TREE_CODE (value) == REAL_CST
687 || (TREE_CODE (value) == COMPLEX_CST
688 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
689 && TREE_OVERFLOW (value))
691 TREE_OVERFLOW (value) = 0;
692 if (skip_evaluation == 0)
693 warning ("floating point overflow in expression");
697 /* Print a warning if a large constant is truncated to unsigned,
698 or if -Wconversion is used and a constant < 0 is converted to unsigned.
699 Invoke this function on every expression that might be implicitly
700 converted to an unsigned type. */
703 unsigned_conversion_warning (result, operand)
704 tree result, operand;
706 if (TREE_CODE (operand) == INTEGER_CST
707 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
708 && TREE_UNSIGNED (TREE_TYPE (result))
709 && skip_evaluation == 0
710 && !int_fits_type_p (operand, TREE_TYPE (result)))
712 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
713 /* This detects cases like converting -129 or 256 to unsigned char. */
714 warning ("large integer implicitly truncated to unsigned type");
715 else if (warn_conversion)
716 warning ("negative integer implicitly converted to unsigned type");
720 /* Nonzero if constant C has a value that is permissible
721 for type TYPE (an INTEGER_TYPE). */
724 constant_fits_type_p (c, type)
727 if (TREE_CODE (c) == INTEGER_CST)
728 return int_fits_type_p (c, type);
730 c = convert (type, c);
731 return !TREE_OVERFLOW (c);
734 /* Convert EXPR to TYPE, warning about conversion problems with constants.
735 Invoke this function on every expression that is converted implicitly,
736 i.e. because of language rules and not because of an explicit cast. */
739 convert_and_check (type, expr)
742 tree t = convert (type, expr);
743 if (TREE_CODE (t) == INTEGER_CST)
745 if (TREE_OVERFLOW (t))
747 TREE_OVERFLOW (t) = 0;
749 /* Do not diagnose overflow in a constant expression merely
750 because a conversion overflowed. */
751 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
753 /* No warning for converting 0x80000000 to int. */
754 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
755 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
756 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
757 /* If EXPR fits in the unsigned version of TYPE,
758 don't warn unless pedantic. */
760 || TREE_UNSIGNED (type)
761 || ! constant_fits_type_p (expr, unsigned_type (type)))
762 && skip_evaluation == 0)
763 warning ("overflow in implicit constant conversion");
766 unsigned_conversion_warning (t, expr);
771 /* A node in a list that describes references to variables (EXPR), which are
772 either read accesses if WRITER is zero, or write accesses, in which case
773 WRITER is the parent of EXPR. */
780 /* Used to implement a cache the results of a call to verify_tree. We only
781 use this for SAVE_EXPRs. */
784 struct tlist_cache *next;
785 struct tlist *cache_before_sp;
786 struct tlist *cache_after_sp;
790 /* Obstack to use when allocating tlist structures, and corresponding
792 static struct obstack tlist_obstack;
793 static char *tlist_firstobj = 0;
795 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
797 static struct tlist *warned_ids;
798 /* SAVE_EXPRs need special treatment. We process them only once and then
799 cache the results. */
800 static struct tlist_cache *save_expr_cache;
802 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
803 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
804 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
805 static int warning_candidate_p PARAMS ((tree));
806 static void warn_for_collisions PARAMS ((struct tlist *));
807 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
808 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
809 static void verify_sequence_points PARAMS ((tree));
811 /* Create a new struct tlist and fill in its fields. */
812 static struct tlist *
813 new_tlist (next, t, writer)
819 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
826 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
827 is nonnull, we ignore any node we find which has a writer equal to it. */
830 add_tlist (to, add, exclude_writer, copy)
838 struct tlist *next = add->next;
841 if (! exclude_writer || add->writer != exclude_writer)
842 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
847 /* Merge the nodes of ADD into TO. This merging process is done so that for
848 each variable that already exists in TO, no new node is added; however if
849 there is a write access recorded in ADD, and an occurrence on TO is only
850 a read access, then the occurrence in TO will be modified to record the
854 merge_tlist (to, add, copy)
859 struct tlist **end = to;
868 struct tlist *next = add->next;
870 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
871 if (tmp2->expr == add->expr)
875 tmp2->writer = add->writer;
879 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
887 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
888 references in list LIST conflict with it, excluding reads if ONLY writers
892 warn_for_collisions_1 (written, writer, list, only_writes)
893 tree written, writer;
899 /* Avoid duplicate warnings. */
900 for (tmp = warned_ids; tmp; tmp = tmp->next)
901 if (tmp->expr == written)
906 if (list->expr == written
907 && list->writer != writer
908 && (! only_writes || list->writer))
910 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
911 warning ("operation on `%s' may be undefined",
912 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
918 /* Given a list LIST of references to variables, find whether any of these
919 can cause conflicts due to missing sequence points. */
922 warn_for_collisions (list)
927 for (tmp = list; tmp; tmp = tmp->next)
930 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
934 /* Return nonzero if X is a tree that can be verified by the sequence point
937 warning_candidate_p (x)
940 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
943 /* Walk the tree X, and record accesses to variables. If X is written by the
944 parent tree, WRITER is the parent.
945 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
946 expression or its only operand forces a sequence point, then everything up
947 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
949 Once we return, we will have emitted warnings if any subexpression before
950 such a sequence point could be undefined. On a higher level, however, the
951 sequence point may not be relevant, and we'll merge the two lists.
953 Example: (b++, a) + b;
954 The call that processes the COMPOUND_EXPR will store the increment of B
955 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
956 processes the PLUS_EXPR will need to merge the two lists so that
957 eventually, all accesses end up on the same list (and we'll warn about the
958 unordered subexpressions b++ and b.
960 A note on merging. If we modify the former example so that our expression
963 care must be taken not simply to add all three expressions into the final
964 PNO_SP list. The function merge_tlist takes care of that by merging the
965 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
966 way, so that no more than one access to B is recorded. */
969 verify_tree (x, pbefore_sp, pno_sp, writer)
971 struct tlist **pbefore_sp, **pno_sp;
974 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
978 /* X may be NULL if it is the operand of an empty statement expression
984 code = TREE_CODE (x);
985 class = TREE_CODE_CLASS (code);
987 if (warning_candidate_p (x))
989 *pno_sp = new_tlist (*pno_sp, x, writer);
999 case TRUTH_ANDIF_EXPR:
1000 case TRUTH_ORIF_EXPR:
1001 tmp_before = tmp_nosp = tmp_list3 = 0;
1002 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1003 warn_for_collisions (tmp_nosp);
1004 merge_tlist (pbefore_sp, tmp_before, 0);
1005 merge_tlist (pbefore_sp, tmp_nosp, 0);
1006 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1007 merge_tlist (pbefore_sp, tmp_list3, 0);
1011 tmp_before = tmp_list2 = 0;
1012 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1013 warn_for_collisions (tmp_list2);
1014 merge_tlist (pbefore_sp, tmp_before, 0);
1015 merge_tlist (pbefore_sp, tmp_list2, 1);
1017 tmp_list3 = tmp_nosp = 0;
1018 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1019 warn_for_collisions (tmp_nosp);
1020 merge_tlist (pbefore_sp, tmp_list3, 0);
1022 tmp_list3 = tmp_list2 = 0;
1023 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1024 warn_for_collisions (tmp_list2);
1025 merge_tlist (pbefore_sp, tmp_list3, 0);
1026 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1027 two first, to avoid warning for (a ? b++ : b++). */
1028 merge_tlist (&tmp_nosp, tmp_list2, 0);
1029 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1032 case PREDECREMENT_EXPR:
1033 case PREINCREMENT_EXPR:
1034 case POSTDECREMENT_EXPR:
1035 case POSTINCREMENT_EXPR:
1036 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1040 tmp_before = tmp_nosp = tmp_list3 = 0;
1041 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1042 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1043 /* Expressions inside the LHS are not ordered wrt. the sequence points
1044 in the RHS. Example:
1046 Despite the fact that the modification of "a" is in the before_sp
1047 list (tmp_before), it conflicts with the use of "a" in the LHS.
1048 We can handle this by adding the contents of tmp_list3
1049 to those of tmp_before, and redoing the collision warnings for that
1051 add_tlist (&tmp_before, tmp_list3, x, 1);
1052 warn_for_collisions (tmp_before);
1053 /* Exclude the LHS itself here; we first have to merge it into the
1054 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1055 didn't exclude the LHS, we'd get it twice, once as a read and once
1057 add_tlist (pno_sp, tmp_list3, x, 0);
1058 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1060 merge_tlist (pbefore_sp, tmp_before, 0);
1061 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1062 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1063 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1067 /* We need to warn about conflicts among arguments and conflicts between
1068 args and the function address. Side effects of the function address,
1069 however, are not ordered by the sequence point of the call. */
1070 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1071 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1072 if (TREE_OPERAND (x, 1))
1073 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1074 merge_tlist (&tmp_list3, tmp_list2, 0);
1075 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1076 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1077 warn_for_collisions (tmp_before);
1078 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1082 /* Scan all the list, e.g. indices of multi dimensional array. */
1085 tmp_before = tmp_nosp = 0;
1086 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1087 merge_tlist (&tmp_nosp, tmp_before, 0);
1088 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1095 struct tlist_cache *t;
1096 for (t = save_expr_cache; t; t = t->next)
1102 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1104 t->next = save_expr_cache;
1106 save_expr_cache = t;
1108 tmp_before = tmp_nosp = 0;
1109 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1110 warn_for_collisions (tmp_nosp);
1115 struct tlist *t = tmp_nosp;
1117 merge_tlist (&tmp_list3, t, 0);
1119 t->cache_before_sp = tmp_before;
1120 t->cache_after_sp = tmp_list3;
1122 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1123 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1132 if (first_rtl_op (code) == 0)
1134 x = TREE_OPERAND (x, 0);
1150 int max = first_rtl_op (TREE_CODE (x));
1151 for (lp = 0; lp < max; lp++)
1153 tmp_before = tmp_nosp = 0;
1154 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1155 merge_tlist (&tmp_nosp, tmp_before, 0);
1156 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1163 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1167 verify_sequence_points (expr)
1170 struct tlist *before_sp = 0, *after_sp = 0;
1173 save_expr_cache = 0;
1174 if (tlist_firstobj == 0)
1176 gcc_obstack_init (&tlist_obstack);
1177 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1180 verify_tree (expr, &before_sp, &after_sp, 0);
1181 warn_for_collisions (after_sp);
1182 obstack_free (&tlist_obstack, tlist_firstobj);
1186 c_expand_expr_stmt (expr)
1189 /* Do default conversion if safe and possibly important,
1190 in case within ({...}). */
1191 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1192 && (flag_isoc99 || lvalue_p (expr)))
1193 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1194 expr = default_conversion (expr);
1196 if (warn_sequence_point)
1197 verify_sequence_points (expr);
1199 if (TREE_TYPE (expr) != error_mark_node
1200 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1201 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1202 error ("expression statement has incomplete type");
1204 last_expr_type = TREE_TYPE (expr);
1205 return add_stmt (build_stmt (EXPR_STMT, expr));
1208 /* Validate the expression after `case' and apply default promotions. */
1211 check_case_value (value)
1214 if (value == NULL_TREE)
1217 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1218 STRIP_TYPE_NOPS (value);
1219 /* In C++, the following is allowed:
1222 switch (...) { case i: ... }
1224 So, we try to reduce the VALUE to a constant that way. */
1225 if (c_language == clk_cplusplus)
1227 value = decl_constant_value (value);
1228 STRIP_TYPE_NOPS (value);
1229 value = fold (value);
1232 if (TREE_CODE (value) != INTEGER_CST
1233 && value != error_mark_node)
1235 error ("case label does not reduce to an integer constant");
1236 value = error_mark_node;
1239 /* Promote char or short to int. */
1240 value = default_conversion (value);
1242 constant_expression_warning (value);
1247 /* Return an integer type with BITS bits of precision,
1248 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1251 type_for_size (bits, unsignedp)
1255 if (bits == TYPE_PRECISION (integer_type_node))
1256 return unsignedp ? unsigned_type_node : integer_type_node;
1258 if (bits == TYPE_PRECISION (signed_char_type_node))
1259 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1261 if (bits == TYPE_PRECISION (short_integer_type_node))
1262 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1264 if (bits == TYPE_PRECISION (long_integer_type_node))
1265 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1267 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1268 return (unsignedp ? long_long_unsigned_type_node
1269 : long_long_integer_type_node);
1271 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1272 return (unsignedp ? widest_unsigned_literal_type_node
1273 : widest_integer_literal_type_node);
1275 if (bits <= TYPE_PRECISION (intQI_type_node))
1276 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1278 if (bits <= TYPE_PRECISION (intHI_type_node))
1279 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1281 if (bits <= TYPE_PRECISION (intSI_type_node))
1282 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1284 if (bits <= TYPE_PRECISION (intDI_type_node))
1285 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1290 /* Return a data type that has machine mode MODE.
1291 If the mode is an integer,
1292 then UNSIGNEDP selects between signed and unsigned types. */
1295 type_for_mode (mode, unsignedp)
1296 enum machine_mode mode;
1299 if (mode == TYPE_MODE (integer_type_node))
1300 return unsignedp ? unsigned_type_node : integer_type_node;
1302 if (mode == TYPE_MODE (signed_char_type_node))
1303 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1305 if (mode == TYPE_MODE (short_integer_type_node))
1306 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1308 if (mode == TYPE_MODE (long_integer_type_node))
1309 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1311 if (mode == TYPE_MODE (long_long_integer_type_node))
1312 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1314 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1315 return unsignedp ? widest_unsigned_literal_type_node
1316 : widest_integer_literal_type_node;
1319 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1322 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1325 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1328 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1330 #if HOST_BITS_PER_WIDE_INT >= 64
1331 if (mode == TYPE_MODE (intTI_type_node))
1332 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1335 if (mode == TYPE_MODE (float_type_node))
1336 return float_type_node;
1338 if (mode == TYPE_MODE (double_type_node))
1339 return double_type_node;
1341 if (mode == TYPE_MODE (long_double_type_node))
1342 return long_double_type_node;
1344 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1345 return build_pointer_type (char_type_node);
1347 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1348 return build_pointer_type (integer_type_node);
1350 #ifdef VECTOR_MODE_SUPPORTED_P
1351 if (VECTOR_MODE_SUPPORTED_P (mode))
1356 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1358 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1360 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1362 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1364 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1366 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1368 return V4SF_type_node;
1370 return V2SF_type_node;
1380 /* Return an unsigned type the same as TYPE in other respects. */
1382 unsigned_type (type)
1385 tree type1 = TYPE_MAIN_VARIANT (type);
1386 if (type1 == signed_char_type_node || type1 == char_type_node)
1387 return unsigned_char_type_node;
1388 if (type1 == integer_type_node)
1389 return unsigned_type_node;
1390 if (type1 == short_integer_type_node)
1391 return short_unsigned_type_node;
1392 if (type1 == long_integer_type_node)
1393 return long_unsigned_type_node;
1394 if (type1 == long_long_integer_type_node)
1395 return long_long_unsigned_type_node;
1396 if (type1 == widest_integer_literal_type_node)
1397 return widest_unsigned_literal_type_node;
1398 #if HOST_BITS_PER_WIDE_INT >= 64
1399 if (type1 == intTI_type_node)
1400 return unsigned_intTI_type_node;
1402 if (type1 == intDI_type_node)
1403 return unsigned_intDI_type_node;
1404 if (type1 == intSI_type_node)
1405 return unsigned_intSI_type_node;
1406 if (type1 == intHI_type_node)
1407 return unsigned_intHI_type_node;
1408 if (type1 == intQI_type_node)
1409 return unsigned_intQI_type_node;
1411 return signed_or_unsigned_type (1, type);
1414 /* Return a signed type the same as TYPE in other respects. */
1420 tree type1 = TYPE_MAIN_VARIANT (type);
1421 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1422 return signed_char_type_node;
1423 if (type1 == unsigned_type_node)
1424 return integer_type_node;
1425 if (type1 == short_unsigned_type_node)
1426 return short_integer_type_node;
1427 if (type1 == long_unsigned_type_node)
1428 return long_integer_type_node;
1429 if (type1 == long_long_unsigned_type_node)
1430 return long_long_integer_type_node;
1431 if (type1 == widest_unsigned_literal_type_node)
1432 return widest_integer_literal_type_node;
1433 #if HOST_BITS_PER_WIDE_INT >= 64
1434 if (type1 == unsigned_intTI_type_node)
1435 return intTI_type_node;
1437 if (type1 == unsigned_intDI_type_node)
1438 return intDI_type_node;
1439 if (type1 == unsigned_intSI_type_node)
1440 return intSI_type_node;
1441 if (type1 == unsigned_intHI_type_node)
1442 return intHI_type_node;
1443 if (type1 == unsigned_intQI_type_node)
1444 return intQI_type_node;
1446 return signed_or_unsigned_type (0, type);
1449 /* Return a type the same as TYPE except unsigned or
1450 signed according to UNSIGNEDP. */
1453 signed_or_unsigned_type (unsignedp, type)
1457 if (! INTEGRAL_TYPE_P (type)
1458 || TREE_UNSIGNED (type) == unsignedp)
1461 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1462 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1463 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1464 return unsignedp ? unsigned_type_node : integer_type_node;
1465 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1466 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1467 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1468 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1469 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1470 return (unsignedp ? long_long_unsigned_type_node
1471 : long_long_integer_type_node);
1472 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1473 return (unsignedp ? widest_unsigned_literal_type_node
1474 : widest_integer_literal_type_node);
1476 #if HOST_BITS_PER_WIDE_INT >= 64
1477 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1478 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1480 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1481 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1482 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1483 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1484 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1485 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1486 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1487 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1492 /* Return the minimum number of bits needed to represent VALUE in a
1493 signed or unsigned type, UNSIGNEDP says which. */
1496 min_precision (value, unsignedp)
1502 /* If the value is negative, compute its negative minus 1. The latter
1503 adjustment is because the absolute value of the largest negative value
1504 is one larger than the largest positive value. This is equivalent to
1505 a bit-wise negation, so use that operation instead. */
1507 if (tree_int_cst_sgn (value) < 0)
1508 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1510 /* Return the number of bits needed, taking into account the fact
1511 that we need one more bit for a signed than unsigned type. */
1513 if (integer_zerop (value))
1516 log = tree_floor_log2 (value);
1518 return log + 1 + ! unsignedp;
1521 /* Print an error message for invalid operands to arith operation CODE.
1522 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1525 binary_op_error (code)
1526 enum tree_code code;
1533 error ("invalid truth-value expression");
1537 opname = "+"; break;
1539 opname = "-"; break;
1541 opname = "*"; break;
1543 opname = "max"; break;
1545 opname = "min"; break;
1547 opname = "=="; break;
1549 opname = "!="; break;
1551 opname = "<="; break;
1553 opname = ">="; break;
1555 opname = "<"; break;
1557 opname = ">"; break;
1559 opname = "<<"; break;
1561 opname = ">>"; break;
1562 case TRUNC_MOD_EXPR:
1563 case FLOOR_MOD_EXPR:
1564 opname = "%"; break;
1565 case TRUNC_DIV_EXPR:
1566 case FLOOR_DIV_EXPR:
1567 opname = "/"; break;
1569 opname = "&"; break;
1571 opname = "|"; break;
1572 case TRUTH_ANDIF_EXPR:
1573 opname = "&&"; break;
1574 case TRUTH_ORIF_EXPR:
1575 opname = "||"; break;
1577 opname = "^"; break;
1580 opname = "rotate"; break;
1582 opname = "unknown"; break;
1584 error ("invalid operands to binary %s", opname);
1587 /* Subroutine of build_binary_op, used for comparison operations.
1588 See if the operands have both been converted from subword integer types
1589 and, if so, perhaps change them both back to their original type.
1590 This function is also responsible for converting the two operands
1591 to the proper common type for comparison.
1593 The arguments of this function are all pointers to local variables
1594 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1595 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1597 If this function returns nonzero, it means that the comparison has
1598 a constant value. What this function returns is an expression for
1602 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1603 tree *op0_ptr, *op1_ptr;
1605 enum tree_code *rescode_ptr;
1608 tree op0 = *op0_ptr;
1609 tree op1 = *op1_ptr;
1610 int unsignedp0, unsignedp1;
1612 tree primop0, primop1;
1613 enum tree_code code = *rescode_ptr;
1615 /* Throw away any conversions to wider types
1616 already present in the operands. */
1618 primop0 = get_narrower (op0, &unsignedp0);
1619 primop1 = get_narrower (op1, &unsignedp1);
1621 /* Handle the case that OP0 does not *contain* a conversion
1622 but it *requires* conversion to FINAL_TYPE. */
1624 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1625 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1626 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1627 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1629 /* If one of the operands must be floated, we cannot optimize. */
1630 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1631 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1633 /* If first arg is constant, swap the args (changing operation
1634 so value is preserved), for canonicalization. Don't do this if
1635 the second arg is 0. */
1637 if (TREE_CONSTANT (primop0)
1638 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1641 int temi = unsignedp0;
1649 unsignedp0 = unsignedp1;
1672 *rescode_ptr = code;
1675 /* If comparing an integer against a constant more bits wide,
1676 maybe we can deduce a value of 1 or 0 independent of the data.
1677 Or else truncate the constant now
1678 rather than extend the variable at run time.
1680 This is only interesting if the constant is the wider arg.
1681 Also, it is not safe if the constant is unsigned and the
1682 variable arg is signed, since in this case the variable
1683 would be sign-extended and then regarded as unsigned.
1684 Our technique fails in this case because the lowest/highest
1685 possible unsigned results don't follow naturally from the
1686 lowest/highest possible values of the variable operand.
1687 For just EQ_EXPR and NE_EXPR there is another technique that
1688 could be used: see if the constant can be faithfully represented
1689 in the other operand's type, by truncating it and reextending it
1690 and see if that preserves the constant's value. */
1692 if (!real1 && !real2
1693 && TREE_CODE (primop1) == INTEGER_CST
1694 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1696 int min_gt, max_gt, min_lt, max_lt;
1697 tree maxval, minval;
1698 /* 1 if comparison is nominally unsigned. */
1699 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1702 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1704 /* If TYPE is an enumeration, then we need to get its min/max
1705 values from it's underlying integral type, not the enumerated
1707 if (TREE_CODE (type) == ENUMERAL_TYPE)
1708 type = type_for_size (TYPE_PRECISION (type), unsignedp0);
1710 maxval = TYPE_MAX_VALUE (type);
1711 minval = TYPE_MIN_VALUE (type);
1713 if (unsignedp && !unsignedp0)
1714 *restype_ptr = signed_type (*restype_ptr);
1716 if (TREE_TYPE (primop1) != *restype_ptr)
1717 primop1 = convert (*restype_ptr, primop1);
1718 if (type != *restype_ptr)
1720 minval = convert (*restype_ptr, minval);
1721 maxval = convert (*restype_ptr, maxval);
1724 if (unsignedp && unsignedp0)
1726 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1727 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1728 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1729 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1733 min_gt = INT_CST_LT (primop1, minval);
1734 max_gt = INT_CST_LT (primop1, maxval);
1735 min_lt = INT_CST_LT (minval, primop1);
1736 max_lt = INT_CST_LT (maxval, primop1);
1740 /* This used to be a switch, but Genix compiler can't handle that. */
1741 if (code == NE_EXPR)
1743 if (max_lt || min_gt)
1744 val = boolean_true_node;
1746 else if (code == EQ_EXPR)
1748 if (max_lt || min_gt)
1749 val = boolean_false_node;
1751 else if (code == LT_EXPR)
1754 val = boolean_true_node;
1756 val = boolean_false_node;
1758 else if (code == GT_EXPR)
1761 val = boolean_true_node;
1763 val = boolean_false_node;
1765 else if (code == LE_EXPR)
1768 val = boolean_true_node;
1770 val = boolean_false_node;
1772 else if (code == GE_EXPR)
1775 val = boolean_true_node;
1777 val = boolean_false_node;
1780 /* If primop0 was sign-extended and unsigned comparison specd,
1781 we did a signed comparison above using the signed type bounds.
1782 But the comparison we output must be unsigned.
1784 Also, for inequalities, VAL is no good; but if the signed
1785 comparison had *any* fixed result, it follows that the
1786 unsigned comparison just tests the sign in reverse
1787 (positive values are LE, negative ones GE).
1788 So we can generate an unsigned comparison
1789 against an extreme value of the signed type. */
1791 if (unsignedp && !unsignedp0)
1798 primop1 = TYPE_MIN_VALUE (type);
1804 primop1 = TYPE_MAX_VALUE (type);
1811 type = unsigned_type (type);
1814 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1816 /* This is the case of (char)x >?< 0x80, which people used to use
1817 expecting old C compilers to change the 0x80 into -0x80. */
1818 if (val == boolean_false_node)
1819 warning ("comparison is always false due to limited range of data type");
1820 if (val == boolean_true_node)
1821 warning ("comparison is always true due to limited range of data type");
1824 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1826 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1827 if (val == boolean_false_node)
1828 warning ("comparison is always false due to limited range of data type");
1829 if (val == boolean_true_node)
1830 warning ("comparison is always true due to limited range of data type");
1835 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1836 if (TREE_SIDE_EFFECTS (primop0))
1837 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1841 /* Value is not predetermined, but do the comparison
1842 in the type of the operand that is not constant.
1843 TYPE is already properly set. */
1845 else if (real1 && real2
1846 && (TYPE_PRECISION (TREE_TYPE (primop0))
1847 == TYPE_PRECISION (TREE_TYPE (primop1))))
1848 type = TREE_TYPE (primop0);
1850 /* If args' natural types are both narrower than nominal type
1851 and both extend in the same manner, compare them
1852 in the type of the wider arg.
1853 Otherwise must actually extend both to the nominal
1854 common type lest different ways of extending
1856 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1858 else if (unsignedp0 == unsignedp1 && real1 == real2
1859 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1860 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1862 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1863 type = signed_or_unsigned_type (unsignedp0
1864 || TREE_UNSIGNED (*restype_ptr),
1866 /* Make sure shorter operand is extended the right way
1867 to match the longer operand. */
1868 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1870 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1875 /* Here we must do the comparison on the nominal type
1876 using the args exactly as we received them. */
1877 type = *restype_ptr;
1881 if (!real1 && !real2 && integer_zerop (primop1)
1882 && TREE_UNSIGNED (*restype_ptr))
1888 /* All unsigned values are >= 0, so we warn if extra warnings
1889 are requested. However, if OP0 is a constant that is
1890 >= 0, the signedness of the comparison isn't an issue,
1891 so suppress the warning. */
1892 if (extra_warnings && !in_system_header
1893 && ! (TREE_CODE (primop0) == INTEGER_CST
1894 && ! TREE_OVERFLOW (convert (signed_type (type),
1896 warning ("comparison of unsigned expression >= 0 is always true");
1897 value = boolean_true_node;
1901 if (extra_warnings && !in_system_header
1902 && ! (TREE_CODE (primop0) == INTEGER_CST
1903 && ! TREE_OVERFLOW (convert (signed_type (type),
1905 warning ("comparison of unsigned expression < 0 is always false");
1906 value = boolean_false_node;
1915 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1916 if (TREE_SIDE_EFFECTS (primop0))
1917 return build (COMPOUND_EXPR, TREE_TYPE (value),
1924 *op0_ptr = convert (type, primop0);
1925 *op1_ptr = convert (type, primop1);
1927 *restype_ptr = boolean_type_node;
1932 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1933 or validate its data type for an `if' or `while' statement or ?..: exp.
1935 This preparation consists of taking the ordinary
1936 representation of an expression expr and producing a valid tree
1937 boolean expression describing whether expr is nonzero. We could
1938 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1939 but we optimize comparisons, &&, ||, and !.
1941 The resulting type should always be `boolean_type_node'. */
1944 truthvalue_conversion (expr)
1947 if (TREE_CODE (expr) == ERROR_MARK)
1950 #if 0 /* This appears to be wrong for C++. */
1951 /* These really should return error_mark_node after 2.4 is stable.
1952 But not all callers handle ERROR_MARK properly. */
1953 switch (TREE_CODE (TREE_TYPE (expr)))
1956 error ("struct type value used where scalar is required");
1957 return boolean_false_node;
1960 error ("union type value used where scalar is required");
1961 return boolean_false_node;
1964 error ("array type value used where scalar is required");
1965 return boolean_false_node;
1972 switch (TREE_CODE (expr))
1975 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1976 case TRUTH_ANDIF_EXPR:
1977 case TRUTH_ORIF_EXPR:
1978 case TRUTH_AND_EXPR:
1980 case TRUTH_XOR_EXPR:
1981 case TRUTH_NOT_EXPR:
1982 TREE_TYPE (expr) = boolean_type_node;
1989 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
1992 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
1995 /* If we are taking the address of an external decl, it might be zero
1996 if it is weak, so we cannot optimize. */
1997 if (DECL_P (TREE_OPERAND (expr, 0))
1998 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2001 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2002 return build (COMPOUND_EXPR, boolean_type_node,
2003 TREE_OPERAND (expr, 0), boolean_true_node);
2005 return boolean_true_node;
2008 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2009 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2010 truthvalue_conversion (TREE_OPERAND (expr, 0)),
2011 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2018 /* These don't change whether an object is non-zero or zero. */
2019 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2023 /* These don't change whether an object is zero or non-zero, but
2024 we can't ignore them if their second arg has side-effects. */
2025 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2026 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2027 truthvalue_conversion (TREE_OPERAND (expr, 0)));
2029 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2032 /* Distribute the conversion into the arms of a COND_EXPR. */
2033 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2034 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2035 truthvalue_conversion (TREE_OPERAND (expr, 2))));
2038 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2039 since that affects how `default_conversion' will behave. */
2040 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2041 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2043 /* fall through... */
2045 /* If this is widening the argument, we can ignore it. */
2046 if (TYPE_PRECISION (TREE_TYPE (expr))
2047 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2048 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2052 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2054 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2055 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2057 /* fall through... */
2059 /* This and MINUS_EXPR can be changed into a comparison of the
2061 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2062 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2063 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2064 TREE_OPERAND (expr, 1), 1);
2065 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2066 fold (build1 (NOP_EXPR,
2067 TREE_TYPE (TREE_OPERAND (expr, 0)),
2068 TREE_OPERAND (expr, 1))), 1);
2071 if (integer_onep (TREE_OPERAND (expr, 1))
2072 && TREE_TYPE (expr) != boolean_type_node)
2073 /* Using convert here would cause infinite recursion. */
2074 return build1 (NOP_EXPR, boolean_type_node, expr);
2078 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2079 warning ("suggest parentheses around assignment used as truth value");
2086 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2088 tree tem = save_expr (expr);
2089 return (build_binary_op
2090 ((TREE_SIDE_EFFECTS (expr)
2091 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2092 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2093 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2097 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2100 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2101 int, enum built_in_class, int, int,
2104 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2105 down to the element type of an array. */
2108 c_build_qualified_type (type, type_quals)
2112 /* A restrict-qualified pointer type must be a pointer to object or
2113 incomplete type. Note that the use of POINTER_TYPE_P also allows
2114 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2115 the C++ front-end also use POINTER_TYPE for pointer-to-member
2116 values, so even though it should be illegal to use `restrict'
2117 with such an entity we don't flag that here. Thus, special case
2118 code for that case is required in the C++ front-end. */
2119 if ((type_quals & TYPE_QUAL_RESTRICT)
2120 && (!POINTER_TYPE_P (type)
2121 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2123 error ("invalid use of `restrict'");
2124 type_quals &= ~TYPE_QUAL_RESTRICT;
2127 if (TREE_CODE (type) == ARRAY_TYPE)
2128 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2130 TYPE_DOMAIN (type));
2131 return build_qualified_type (type, type_quals);
2134 /* Apply the TYPE_QUALS to the new DECL. */
2137 c_apply_type_quals_to_decl (type_quals, decl)
2141 if ((type_quals & TYPE_QUAL_CONST)
2142 || (TREE_TYPE (decl)
2143 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2144 TREE_READONLY (decl) = 1;
2145 if (type_quals & TYPE_QUAL_VOLATILE)
2147 TREE_SIDE_EFFECTS (decl) = 1;
2148 TREE_THIS_VOLATILE (decl) = 1;
2150 if (type_quals & TYPE_QUAL_RESTRICT)
2152 if (!TREE_TYPE (decl)
2153 || !POINTER_TYPE_P (TREE_TYPE (decl))
2154 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2155 error ("invalid use of `restrict'");
2156 else if (flag_strict_aliasing)
2157 /* Indicate we need to make a unique alias set for this pointer.
2158 We can't do it here because it might be pointing to an
2160 DECL_POINTER_ALIAS_SET (decl) = -2;
2165 /* Return the typed-based alias set for T, which may be an expression
2166 or a type. Return -1 if we don't do anything special. */
2169 c_common_get_alias_set (t)
2174 /* We know nothing about vector types */
2175 if (TREE_CODE (t) == VECTOR_TYPE)
2178 /* Permit type-punning when accessing a union, provided the access
2179 is directly through the union. For example, this code does not
2180 permit taking the address of a union member and then storing
2181 through it. Even the type-punning allowed here is a GCC
2182 extension, albeit a common and useful one; the C standard says
2183 that such accesses have implementation-defined behavior. */
2185 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2186 u = TREE_OPERAND (u, 0))
2187 if (TREE_CODE (u) == COMPONENT_REF
2188 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2191 /* If this is a char *, the ANSI C standard says it can alias
2192 anything. Note that all references need do this. */
2193 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2194 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2195 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2198 /* That's all the expressions we handle specially. */
2202 /* The C standard specifically allows aliasing between signed and
2203 unsigned variants of the same type. We treat the signed
2204 variant as canonical. */
2205 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2207 tree t1 = signed_type (t);
2209 /* t1 == t can happen for boolean nodes which are always unsigned. */
2211 return get_alias_set (t1);
2213 else if (POINTER_TYPE_P (t))
2217 /* Unfortunately, there is no canonical form of a pointer type.
2218 In particular, if we have `typedef int I', then `int *', and
2219 `I *' are different types. So, we have to pick a canonical
2220 representative. We do this below.
2222 Technically, this approach is actually more conservative that
2223 it needs to be. In particular, `const int *' and `int *'
2224 should be in different alias sets, according to the C and C++
2225 standard, since their types are not the same, and so,
2226 technically, an `int **' and `const int **' cannot point at
2229 But, the standard is wrong. In particular, this code is
2234 const int* const* cipp = &ipp;
2236 And, it doesn't make sense for that to be legal unless you
2237 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2238 the pointed-to types. This issue has been reported to the
2240 t1 = build_type_no_quals (t);
2242 return get_alias_set (t1);
2248 /* Implement the __alignof keyword: Return the minimum required
2249 alignment of TYPE, measured in bytes. */
2255 enum tree_code code = TREE_CODE (type);
2258 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2259 if (code == REFERENCE_TYPE)
2261 type = TREE_TYPE (type);
2262 code = TREE_CODE (type);
2265 if (code == FUNCTION_TYPE)
2266 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2267 else if (code == VOID_TYPE || code == ERROR_MARK)
2269 else if (!COMPLETE_TYPE_P (type))
2271 error ("__alignof__ applied to an incomplete type");
2275 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2277 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2280 /* Implement the __alignof keyword: Return the minimum required
2281 alignment of EXPR, measured in bytes. For VAR_DECL's and
2282 FIELD_DECL's return DECL_ALIGN (which can be set from an
2283 "aligned" __attribute__ specification). */
2286 c_alignof_expr (expr)
2291 if (TREE_CODE (expr) == VAR_DECL)
2292 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2294 else if (TREE_CODE (expr) == COMPONENT_REF
2295 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2297 error ("`__alignof' applied to a bit-field");
2300 else if (TREE_CODE (expr) == COMPONENT_REF
2301 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2302 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2304 else if (TREE_CODE (expr) == INDIRECT_REF)
2306 tree t = TREE_OPERAND (expr, 0);
2308 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2310 while (TREE_CODE (t) == NOP_EXPR
2311 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2315 t = TREE_OPERAND (t, 0);
2316 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2317 if (thisalign > bestalign)
2318 best = t, bestalign = thisalign;
2320 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2323 return c_alignof (TREE_TYPE (expr));
2325 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2328 /* Give the specifications for the format attributes, used by C and all
2331 static const struct attribute_spec c_format_attribute_table[] =
2333 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2334 { "format", 3, 3, false, true, true,
2335 handle_format_attribute },
2336 { "format_arg", 1, 1, false, true, true,
2337 handle_format_arg_attribute },
2338 { NULL, 0, 0, false, false, false, NULL }
2341 /* Build tree nodes and builtin functions common to both C and C++ language
2345 c_common_nodes_and_builtins ()
2349 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2350 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2351 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2352 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2353 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2354 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2355 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2356 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2357 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2358 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2359 #include "builtin-types.def"
2360 #undef DEF_PRIMITIVE_TYPE
2361 #undef DEF_FUNCTION_TYPE_0
2362 #undef DEF_FUNCTION_TYPE_1
2363 #undef DEF_FUNCTION_TYPE_2
2364 #undef DEF_FUNCTION_TYPE_3
2365 #undef DEF_FUNCTION_TYPE_4
2366 #undef DEF_FUNCTION_TYPE_VAR_0
2367 #undef DEF_FUNCTION_TYPE_VAR_1
2368 #undef DEF_FUNCTION_TYPE_VAR_2
2369 #undef DEF_POINTER_TYPE
2373 typedef enum builtin_type builtin_type;
2375 tree builtin_types[(int)BT_LAST];
2376 int wchar_type_size;
2377 tree array_domain_type;
2378 /* Either char* or void*. */
2379 tree traditional_ptr_type_node;
2380 /* Either const char* or const void*. */
2381 tree traditional_cptr_type_node;
2382 tree traditional_len_type_node;
2383 tree va_list_ref_type_node;
2384 tree va_list_arg_type_node;
2386 /* We must initialize this before any builtin functions (which might have
2387 attributes) are declared. (c_common_init is too late.) */
2388 format_attribute_table = c_format_attribute_table;
2390 /* Define `int' and `char' first so that dbx will output them first. */
2391 record_builtin_type (RID_INT, NULL, integer_type_node);
2392 record_builtin_type (RID_CHAR, "char", char_type_node);
2394 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2395 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2396 but not C. Are the conditionals here needed? */
2397 if (c_language == clk_cplusplus)
2398 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2399 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2400 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2401 record_builtin_type (RID_MAX, "long unsigned int",
2402 long_unsigned_type_node);
2403 if (c_language == clk_cplusplus)
2404 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2405 record_builtin_type (RID_MAX, "long long int",
2406 long_long_integer_type_node);
2407 record_builtin_type (RID_MAX, "long long unsigned int",
2408 long_long_unsigned_type_node);
2409 if (c_language == clk_cplusplus)
2410 record_builtin_type (RID_MAX, "long long unsigned",
2411 long_long_unsigned_type_node);
2412 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2413 record_builtin_type (RID_MAX, "short unsigned int",
2414 short_unsigned_type_node);
2415 if (c_language == clk_cplusplus)
2416 record_builtin_type (RID_MAX, "unsigned short",
2417 short_unsigned_type_node);
2419 /* Define both `signed char' and `unsigned char'. */
2420 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2421 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2423 /* These are types that type_for_size and type_for_mode use. */
2424 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2425 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2426 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2427 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2428 #if HOST_BITS_PER_WIDE_INT >= 64
2429 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2431 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2432 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2433 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2434 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2435 #if HOST_BITS_PER_WIDE_INT >= 64
2436 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2439 /* Create the widest literal types. */
2440 widest_integer_literal_type_node
2441 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2442 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2443 widest_integer_literal_type_node));
2445 widest_unsigned_literal_type_node
2446 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2447 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2448 widest_unsigned_literal_type_node));
2450 /* `unsigned long' is the standard type for sizeof.
2451 Note that stddef.h uses `unsigned long',
2452 and this must agree, even if long and int are the same size. */
2454 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2455 signed_size_type_node = signed_type (c_size_type_node);
2456 if (flag_traditional)
2457 c_size_type_node = signed_size_type_node;
2458 set_sizetype (c_size_type_node);
2460 build_common_tree_nodes_2 (flag_short_double);
2462 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2463 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2464 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2466 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2467 complex_integer_type_node));
2468 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2469 complex_float_type_node));
2470 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2471 complex_double_type_node));
2472 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2473 complex_long_double_type_node));
2475 record_builtin_type (RID_VOID, NULL, void_type_node);
2477 void_zero_node = build_int_2 (0, 0);
2478 TREE_TYPE (void_zero_node) = void_type_node;
2480 void_list_node = build_void_list_node ();
2482 /* Make a type to be the domain of a few array types
2483 whose domains don't really matter.
2484 200 is small enough that it always fits in size_t
2485 and large enough that it can hold most function names for the
2486 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2487 array_domain_type = build_index_type (size_int (200));
2489 /* Make a type for arrays of characters.
2490 With luck nothing will ever really depend on the length of this
2492 char_array_type_node
2493 = build_array_type (char_type_node, array_domain_type);
2495 /* Likewise for arrays of ints. */
2497 = build_array_type (integer_type_node, array_domain_type);
2499 string_type_node = build_pointer_type (char_type_node);
2500 const_string_type_node
2501 = build_pointer_type (build_qualified_type
2502 (char_type_node, TYPE_QUAL_CONST));
2504 traditional_ptr_type_node = ((flag_traditional &&
2505 c_language != clk_cplusplus)
2506 ? string_type_node : ptr_type_node);
2507 traditional_cptr_type_node = ((flag_traditional &&
2508 c_language != clk_cplusplus)
2509 ? const_string_type_node : const_ptr_type_node);
2511 (*targetm.init_builtins) ();
2513 /* This is special for C++ so functions can be overloaded. */
2514 wchar_type_node = get_identifier (flag_short_wchar
2515 ? "short unsigned int"
2517 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2518 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2519 if (c_language == clk_cplusplus)
2521 if (TREE_UNSIGNED (wchar_type_node))
2522 wchar_type_node = make_unsigned_type (wchar_type_size);
2524 wchar_type_node = make_signed_type (wchar_type_size);
2525 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2529 signed_wchar_type_node = signed_type (wchar_type_node);
2530 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2533 /* This is for wide string constants. */
2534 wchar_array_type_node
2535 = build_array_type (wchar_type_node, array_domain_type);
2538 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2541 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2543 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2545 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2547 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2548 unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2550 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2551 va_list_type_node));
2553 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2554 ptrdiff_type_node));
2556 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2559 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2561 va_list_arg_type_node = va_list_ref_type_node =
2562 build_pointer_type (TREE_TYPE (va_list_type_node));
2566 va_list_arg_type_node = va_list_type_node;
2567 va_list_ref_type_node = build_reference_type (va_list_type_node);
2570 traditional_len_type_node = ((flag_traditional &&
2571 c_language != clk_cplusplus)
2572 ? integer_type_node : sizetype);
2574 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2575 builtin_types[(int) ENUM] = VALUE;
2576 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2577 builtin_types[(int) ENUM] \
2578 = build_function_type (builtin_types[(int) RETURN], \
2580 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2581 builtin_types[(int) ENUM] \
2582 = build_function_type (builtin_types[(int) RETURN], \
2583 tree_cons (NULL_TREE, \
2584 builtin_types[(int) ARG1], \
2586 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2587 builtin_types[(int) ENUM] \
2588 = build_function_type \
2589 (builtin_types[(int) RETURN], \
2590 tree_cons (NULL_TREE, \
2591 builtin_types[(int) ARG1], \
2592 tree_cons (NULL_TREE, \
2593 builtin_types[(int) ARG2], \
2595 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2596 builtin_types[(int) ENUM] \
2597 = build_function_type \
2598 (builtin_types[(int) RETURN], \
2599 tree_cons (NULL_TREE, \
2600 builtin_types[(int) ARG1], \
2601 tree_cons (NULL_TREE, \
2602 builtin_types[(int) ARG2], \
2603 tree_cons (NULL_TREE, \
2604 builtin_types[(int) ARG3], \
2606 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2607 builtin_types[(int) ENUM] \
2608 = build_function_type \
2609 (builtin_types[(int) RETURN], \
2610 tree_cons (NULL_TREE, \
2611 builtin_types[(int) ARG1], \
2612 tree_cons (NULL_TREE, \
2613 builtin_types[(int) ARG2], \
2616 builtin_types[(int) ARG3], \
2617 tree_cons (NULL_TREE, \
2618 builtin_types[(int) ARG4], \
2619 void_list_node)))));
2620 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2621 builtin_types[(int) ENUM] \
2622 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2623 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2624 builtin_types[(int) ENUM] \
2625 = build_function_type (builtin_types[(int) RETURN], \
2626 tree_cons (NULL_TREE, \
2627 builtin_types[(int) ARG1], \
2630 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2631 builtin_types[(int) ENUM] \
2632 = build_function_type \
2633 (builtin_types[(int) RETURN], \
2634 tree_cons (NULL_TREE, \
2635 builtin_types[(int) ARG1], \
2636 tree_cons (NULL_TREE, \
2637 builtin_types[(int) ARG2], \
2639 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2640 builtin_types[(int) ENUM] \
2641 = build_pointer_type (builtin_types[(int) TYPE]);
2642 #include "builtin-types.def"
2643 #undef DEF_PRIMITIVE_TYPE
2644 #undef DEF_FUNCTION_TYPE_1
2645 #undef DEF_FUNCTION_TYPE_2
2646 #undef DEF_FUNCTION_TYPE_3
2647 #undef DEF_FUNCTION_TYPE_4
2648 #undef DEF_FUNCTION_TYPE_VAR_0
2649 #undef DEF_FUNCTION_TYPE_VAR_1
2650 #undef DEF_POINTER_TYPE
2652 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2653 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2658 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2662 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2665 ? (NAME + strlen ("__builtin_")) \
2668 decl = builtin_function_2 (NAME, \
2669 NAME + strlen ("__builtin_"), \
2670 builtin_types[TYPE], \
2671 builtin_types[LIBTYPE], \
2676 /*noreturn_p=*/0); \
2678 built_in_decls[(int) ENUM] = decl; \
2680 #include "builtins.def"
2683 /* Declare _exit and _Exit just to mark them as non-returning. */
2684 builtin_function_2 (NULL, "_exit", NULL_TREE,
2685 builtin_types[BT_FN_VOID_INT],
2686 0, NOT_BUILT_IN, 0, 1, 1);
2687 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2688 builtin_types[BT_FN_VOID_INT],
2689 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2691 /* Declare these functions non-returning
2692 to avoid spurious "control drops through" warnings. */
2693 builtin_function_2 (NULL, "abort",
2694 NULL_TREE, ((c_language == clk_cplusplus)
2695 ? builtin_types[BT_FN_VOID]
2696 : builtin_types[BT_FN_VOID_VAR]),
2697 0, NOT_BUILT_IN, 0, 0, 1);
2699 builtin_function_2 (NULL, "exit",
2700 NULL_TREE, ((c_language == clk_cplusplus)
2701 ? builtin_types[BT_FN_VOID_INT]
2702 : builtin_types[BT_FN_VOID_VAR]),
2703 0, NOT_BUILT_IN, 0, 0, 1);
2705 main_identifier_node = get_identifier ("main");
2707 /* ??? Perhaps there's a better place to do this. But it is related
2708 to __builtin_va_arg, so it isn't that off-the-wall. */
2709 lang_type_promotes_to = simple_type_promotes_to;
2713 build_va_arg (expr, type)
2716 return build1 (VA_ARG_EXPR, type, expr);
2720 /* Linked list of disabled built-in functions. */
2722 typedef struct disabled_builtin
2725 struct disabled_builtin *next;
2727 static disabled_builtin *disabled_builtins = NULL;
2729 static bool builtin_function_disabled_p PARAMS ((const char *));
2731 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2732 begins with "__builtin_", give an error. */
2735 disable_builtin_function (name)
2738 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2739 error ("cannot disable built-in function `%s'", name);
2742 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2744 new->next = disabled_builtins;
2745 disabled_builtins = new;
2750 /* Return true if the built-in function NAME has been disabled, false
2754 builtin_function_disabled_p (name)
2757 disabled_builtin *p;
2758 for (p = disabled_builtins; p != NULL; p = p->next)
2760 if (strcmp (name, p->name) == 0)
2767 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2768 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2769 of these may be NULL (though both being NULL is useless).
2770 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2771 TYPE is the type of the function with the ordinary name. These
2772 may differ if the ordinary name is declared with a looser type to avoid
2773 conflicts with headers. FUNCTION_CODE and CLASS are as for
2774 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2775 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2776 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2777 NORETURN_P is nonzero, the function is marked as non-returning.
2778 Returns the declaration of BUILTIN_NAME, if any, otherwise
2779 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2780 or if NONANSI_P and flag_no_nonansi_builtin. */
2783 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2784 class, library_name_p, nonansi_p, noreturn_p)
2785 const char *builtin_name;
2790 enum built_in_class class;
2795 tree bdecl = NULL_TREE;
2796 tree decl = NULL_TREE;
2797 if (builtin_name != 0)
2799 bdecl = builtin_function (builtin_name, builtin_type, function_code,
2800 class, library_name_p ? name : NULL);
2803 TREE_THIS_VOLATILE (bdecl) = 1;
2804 TREE_SIDE_EFFECTS (bdecl) = 1;
2807 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
2808 && !(nonansi_p && flag_no_nonansi_builtin))
2810 decl = builtin_function (name, type, function_code, class, NULL);
2812 DECL_BUILT_IN_NONANSI (decl) = 1;
2815 TREE_THIS_VOLATILE (decl) = 1;
2816 TREE_SIDE_EFFECTS (decl) = 1;
2819 return (bdecl != 0 ? bdecl : decl);
2822 /* Nonzero if the type T promotes to int. This is (nearly) the
2823 integral promotions defined in ISO C99 6.3.1.1/2. */
2826 c_promoting_integer_type_p (t)
2829 switch (TREE_CODE (t))
2832 return (TYPE_MAIN_VARIANT (t) == char_type_node
2833 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2834 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2835 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2836 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
2837 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
2840 /* ??? Technically all enumerations not larger than an int
2841 promote to an int. But this is used along code paths
2842 that only want to notice a size change. */
2843 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
2853 /* Given a type, apply default promotions wrt unnamed function arguments
2854 and return the new type. Return NULL_TREE if no change. */
2855 /* ??? There is a function of the same name in the C++ front end that
2856 does something similar, but is more thorough and does not return NULL
2857 if no change. We could perhaps share code, but it would make the
2858 self_promoting_type property harder to identify. */
2861 simple_type_promotes_to (type)
2864 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2865 return double_type_node;
2867 if (c_promoting_integer_type_p (type))
2869 /* Traditionally, unsignedness is preserved in default promotions.
2870 Also preserve unsignedness if not really getting any wider. */
2871 if (TREE_UNSIGNED (type)
2872 && (flag_traditional
2873 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
2874 return unsigned_type_node;
2875 return integer_type_node;
2881 /* Return 1 if PARMS specifies a fixed number of parameters
2882 and none of their types is affected by default promotions. */
2885 self_promoting_args_p (parms)
2889 for (t = parms; t; t = TREE_CHAIN (t))
2891 tree type = TREE_VALUE (t);
2893 if (TREE_CHAIN (t) == 0 && type != void_type_node)
2899 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2902 if (c_promoting_integer_type_p (type))
2908 /* Recursively examines the array elements of TYPE, until a non-array
2909 element type is found. */
2912 strip_array_types (type)
2915 while (TREE_CODE (type) == ARRAY_TYPE)
2916 type = TREE_TYPE (type);
2921 /* Recognize certain built-in functions so we can make tree-codes
2922 other than CALL_EXPR. We do this when it enables fold-const.c
2923 to do something useful. */
2924 /* ??? By rights this should go in builtins.c, but only C and C++
2925 implement build_{binary,unary}_op. Not exactly sure what bits
2926 of functionality are actually needed from those functions, or
2927 where the similar functionality exists in the other front ends. */
2930 expand_tree_builtin (function, params, coerced_params)
2931 tree function, params, coerced_params;
2933 enum tree_code code;
2935 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
2938 switch (DECL_FUNCTION_CODE (function))
2942 case BUILT_IN_LLABS:
2943 case BUILT_IN_IMAXABS:
2945 case BUILT_IN_FABSL:
2946 case BUILT_IN_FABSF:
2947 if (coerced_params == 0)
2948 return integer_zero_node;
2949 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2952 case BUILT_IN_CONJF:
2953 case BUILT_IN_CONJL:
2954 if (coerced_params == 0)
2955 return integer_zero_node;
2956 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
2958 case BUILT_IN_CREAL:
2959 case BUILT_IN_CREALF:
2960 case BUILT_IN_CREALL:
2961 if (coerced_params == 0)
2962 return integer_zero_node;
2963 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
2965 case BUILT_IN_CIMAG:
2966 case BUILT_IN_CIMAGF:
2967 case BUILT_IN_CIMAGL:
2968 if (coerced_params == 0)
2969 return integer_zero_node;
2970 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
2972 case BUILT_IN_ISGREATER:
2973 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2979 case BUILT_IN_ISGREATEREQUAL:
2980 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2986 case BUILT_IN_ISLESS:
2987 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2993 case BUILT_IN_ISLESSEQUAL:
2994 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3000 case BUILT_IN_ISLESSGREATER:
3001 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3007 case BUILT_IN_ISUNORDERED:
3008 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3009 return integer_zero_node;
3010 code = UNORDERED_EXPR;
3018 || TREE_CHAIN (params) == 0)
3020 error ("too few arguments to function `%s'",
3021 IDENTIFIER_POINTER (DECL_NAME (function)));
3022 return error_mark_node;
3024 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3026 error ("too many arguments to function `%s'",
3027 IDENTIFIER_POINTER (DECL_NAME (function)));
3028 return error_mark_node;
3031 arg0 = TREE_VALUE (params);
3032 arg1 = TREE_VALUE (TREE_CHAIN (params));
3033 arg0 = build_binary_op (code, arg0, arg1, 0);
3034 if (code != UNORDERED_EXPR)
3035 arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3047 /* Returns non-zero if CODE is the code for a statement. */
3050 statement_code_p (code)
3051 enum tree_code code;
3074 if (lang_statement_code_p)
3075 return (*lang_statement_code_p) (code);
3080 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3081 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3082 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3083 value, the traversal is aborted, and the value returned by FUNC is
3084 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3085 the node being visited are not walked.
3087 We don't need a without_duplicates variant of this one because the
3088 statement tree is a tree, not a graph. */
3091 walk_stmt_tree (tp, func, data)
3096 enum tree_code code;
3101 #define WALK_SUBTREE(NODE) \
3104 result = walk_stmt_tree (&(NODE), func, data); \
3110 /* Skip empty subtrees. */
3114 /* Skip subtrees below non-statement nodes. */
3115 if (!statement_code_p (TREE_CODE (*tp)))
3118 /* Call the function. */
3120 result = (*func) (tp, &walk_subtrees, data);
3122 /* If we found something, return it. */
3126 /* FUNC may have modified the tree, recheck that we're looking at a
3128 code = TREE_CODE (*tp);
3129 if (!statement_code_p (code))
3132 /* Visit the subtrees unless FUNC decided that there was nothing
3133 interesting below this point in the tree. */
3136 /* Walk over all the sub-trees of this operand. Statement nodes
3137 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3138 len = TREE_CODE_LENGTH (code);
3140 /* Go through the subtrees. We need to do this in forward order so
3141 that the scope of a FOR_EXPR is handled properly. */
3142 for (i = 0; i < len; ++i)
3143 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3146 /* Finally visit the chain. This can be tail-recursion optimized if
3147 we write it this way. */
3148 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3153 /* Used to compare case labels. K1 and K2 are actually tree nodes
3154 representing case labels, or NULL_TREE for a `default' label.
3155 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3156 K2, and 0 if K1 and K2 are equal. */
3159 case_compare (k1, k2)
3163 /* Consider a NULL key (such as arises with a `default' label) to be
3164 smaller than anything else. */
3170 return tree_int_cst_compare ((tree) k1, (tree) k2);
3173 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3174 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3175 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3176 case label was declared using the usual C/C++ syntax, rather than
3177 the GNU case range extension. CASES is a tree containing all the
3178 case ranges processed so far; COND is the condition for the
3179 switch-statement itself. Returns the CASE_LABEL created, or
3180 ERROR_MARK_NODE if no CASE_LABEL is created. */
3183 c_add_case_label (cases, cond, low_value, high_value)
3192 splay_tree_node node;
3194 /* Create the LABEL_DECL itself. */
3195 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3196 DECL_CONTEXT (label) = current_function_decl;
3198 /* If there was an error processing the switch condition, bail now
3199 before we get more confused. */
3200 if (!cond || cond == error_mark_node)
3202 /* Add a label anyhow so that the back-end doesn't think that
3203 the beginning of the switch is unreachable. */
3205 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3206 return error_mark_node;
3209 if ((low_value && TREE_TYPE (low_value)
3210 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3211 || (high_value && TREE_TYPE (high_value)
3212 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3213 error ("pointers are not permitted as case values");
3215 /* Case ranges are a GNU extension. */
3216 if (high_value && pedantic)
3218 if (c_language == clk_cplusplus)
3219 pedwarn ("ISO C++ forbids range expressions in switch statements");
3221 pedwarn ("ISO C forbids range expressions in switch statements");
3224 type = TREE_TYPE (cond);
3227 low_value = check_case_value (low_value);
3228 low_value = convert_and_check (type, low_value);
3232 high_value = check_case_value (high_value);
3233 high_value = convert_and_check (type, high_value);
3236 /* If an error has occurred, bail out now. */
3237 if (low_value == error_mark_node || high_value == error_mark_node)
3240 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3241 return error_mark_node;
3244 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3245 really a case range, even though it was written that way. Remove
3246 the HIGH_VALUE to simplify later processing. */
3247 if (tree_int_cst_equal (low_value, high_value))
3248 high_value = NULL_TREE;
3249 if (low_value && high_value
3250 && !tree_int_cst_lt (low_value, high_value))
3251 warning ("empty range specified");
3253 /* Look up the LOW_VALUE in the table of case labels we already
3255 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3256 /* If there was not an exact match, check for overlapping ranges.
3257 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3258 that's a `default' label and the only overlap is an exact match. */
3259 if (!node && (low_value || high_value))
3261 splay_tree_node low_bound;
3262 splay_tree_node high_bound;
3264 /* Even though there wasn't an exact match, there might be an
3265 overlap between this case range and another case range.
3266 Since we've (inductively) not allowed any overlapping case
3267 ranges, we simply need to find the greatest low case label
3268 that is smaller that LOW_VALUE, and the smallest low case
3269 label that is greater than LOW_VALUE. If there is an overlap
3270 it will occur in one of these two ranges. */
3271 low_bound = splay_tree_predecessor (cases,
3272 (splay_tree_key) low_value);
3273 high_bound = splay_tree_successor (cases,
3274 (splay_tree_key) low_value);
3276 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3277 the LOW_VALUE, so there is no need to check unless the
3278 LOW_BOUND is in fact itself a case range. */
3280 && CASE_HIGH ((tree) low_bound->value)
3281 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3284 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3285 range is bigger than the low end of the current range, so we
3286 are only interested if the current range is a real range, and
3287 not an ordinary case label. */
3290 && (tree_int_cst_compare ((tree) high_bound->key,
3295 /* If there was an overlap, issue an error. */
3298 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3302 error ("duplicate (or overlapping) case value");
3303 error_with_decl (duplicate,
3304 "this is the first entry overlapping that value");
3308 error ("duplicate case value") ;
3309 error_with_decl (duplicate, "previously used here");
3313 error ("multiple default labels in one switch");
3314 error_with_decl (duplicate, "this is the first default label");
3317 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3320 /* Add a CASE_LABEL to the statement-tree. */
3321 case_label = add_stmt (build_case_label (low_value, high_value, label));
3322 /* Register this case label in the splay tree. */
3323 splay_tree_insert (cases,
3324 (splay_tree_key) low_value,
3325 (splay_tree_value) case_label);
3330 /* Finish an expression taking the address of LABEL. Returns an
3331 expression for the address. */
3334 finish_label_address_expr (label)
3341 if (c_language == clk_cplusplus)
3342 pedwarn ("ISO C++ forbids taking the address of a label");
3344 pedwarn ("ISO C forbids taking the address of a label");
3347 label = lookup_label (label);
3348 if (label == NULL_TREE)
3349 result = null_pointer_node;
3352 TREE_USED (label) = 1;
3353 result = build1 (ADDR_EXPR, ptr_type_node, label);
3354 TREE_CONSTANT (result) = 1;
3355 /* The current function in not necessarily uninlinable.
3356 Computed gotos are incompatible with inlining, but the value
3357 here could be used only in a diagnostic, for example. */
3363 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3364 parameter allows this function to be used as a GC-marking
3371 stmt_tree st = (stmt_tree) p;
3373 ggc_mark_tree (st->x_last_stmt);
3374 ggc_mark_tree (st->x_last_expr_type);
3377 /* Mark LD for GC. */
3380 c_mark_lang_decl (c)
3381 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3385 /* Mark F for GC. */
3388 mark_c_language_function (f)
3389 struct language_function *f;
3394 mark_stmt_tree (&f->x_stmt_tree);
3395 ggc_mark_tree (f->x_scope_stmt_stack);
3398 /* Hook used by expand_expr to expand language-specific tree codes. */
3401 c_expand_expr (exp, target, tmode, modifier)
3404 enum machine_mode tmode;
3405 enum expand_modifier modifier;
3407 switch (TREE_CODE (exp))
3414 /* Since expand_expr_stmt calls free_temp_slots after every
3415 expression statement, we must call push_temp_slots here.
3416 Otherwise, any temporaries in use now would be considered
3417 out-of-scope after the first EXPR_STMT from within the
3420 rtl_expr = expand_start_stmt_expr ();
3422 /* If we want the result of this expression, find the last
3423 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3424 if (target != const0_rtx
3425 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3426 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3428 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3429 tree last = TREE_CHAIN (expr);
3431 while (TREE_CHAIN (last))
3434 last = TREE_CHAIN (last);
3437 if (TREE_CODE (last) == SCOPE_STMT
3438 && TREE_CODE (expr) == EXPR_STMT)
3439 TREE_ADDRESSABLE (expr) = 1;
3442 expand_stmt (STMT_EXPR_STMT (exp));
3443 expand_end_stmt_expr (rtl_expr);
3444 result = expand_expr (rtl_expr, target, tmode, modifier);
3452 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3453 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3455 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3456 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3457 == BUILT_IN_FRONTEND))
3458 return c_expand_builtin (exp, target, tmode, modifier);
3464 case COMPOUND_LITERAL_EXPR:
3466 /* Initialize the anonymous variable declared in the compound
3467 literal, then return the variable. */
3468 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3469 emit_local_var (decl);
3470 return expand_expr (decl, target, tmode, modifier);
3481 /* Hook used by safe_from_p to handle language-specific tree codes. */
3484 c_safe_from_p (target, exp)
3488 /* We can see statements here when processing the body of a
3489 statement-expression. For a declaration statement declaring a
3490 variable, look at the variable's initializer. */
3491 if (TREE_CODE (exp) == DECL_STMT)
3493 tree decl = DECL_STMT_DECL (exp);
3495 if (TREE_CODE (decl) == VAR_DECL
3496 && DECL_INITIAL (decl)
3497 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3501 /* For any statement, we must follow the statement-chain. */
3502 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3503 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3505 /* Assume everything else is safe. */
3509 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3512 c_unsafe_for_reeval (exp)
3515 /* Statement expressions may not be reevaluated. */
3516 if (TREE_CODE (exp) == STMT_EXPR)
3519 /* Walk all other expressions. */
3523 /* Hook used by staticp to handle language-specific tree codes. */
3529 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3530 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3535 /* Tree code classes. */
3537 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3539 static const char c_tree_code_type[] = {
3541 #include "c-common.def"
3545 /* Table indexed by tree code giving number of expression
3546 operands beyond the fixed part of the node structure.
3547 Not used for types or decls. */
3549 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3551 static const int c_tree_code_length[] = {
3553 #include "c-common.def"
3557 /* Names of tree components.
3558 Used for printing out the tree and error messages. */
3559 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3561 static const char *const c_tree_code_name[] = {
3563 #include "c-common.def"
3567 /* Adds the tree codes specific to the C front end to the list of all
3573 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3575 (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3576 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3578 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3579 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3581 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
3582 lang_unsafe_for_reeval = c_unsafe_for_reeval;
3585 #define CALLED_AS_BUILT_IN(NODE) \
3586 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3589 c_expand_builtin (exp, target, tmode, modifier)
3592 enum machine_mode tmode;
3593 enum expand_modifier modifier;
3595 tree type = TREE_TYPE (exp);
3596 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3597 tree arglist = TREE_OPERAND (exp, 1);
3598 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3599 enum tree_code code = TREE_CODE (exp);
3600 const int ignore = (target == const0_rtx
3601 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3602 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3603 || code == COND_EXPR)
3604 && TREE_CODE (type) == VOID_TYPE));
3606 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3607 return expand_call (exp, target, ignore);
3611 case BUILT_IN_PRINTF:
3612 target = c_expand_builtin_printf (arglist, target, tmode,
3613 modifier, ignore,/*unlocked=*/ 0);
3618 case BUILT_IN_PRINTF_UNLOCKED:
3619 target = c_expand_builtin_printf (arglist, target, tmode,
3620 modifier, ignore,/*unlocked=*/ 1);
3625 case BUILT_IN_FPRINTF:
3626 target = c_expand_builtin_fprintf (arglist, target, tmode,
3627 modifier, ignore,/*unlocked=*/ 0);
3632 case BUILT_IN_FPRINTF_UNLOCKED:
3633 target = c_expand_builtin_fprintf (arglist, target, tmode,
3634 modifier, ignore,/*unlocked=*/ 1);
3639 default: /* just do library call, if unknown builtin */
3640 error ("built-in function `%s' not currently supported",
3641 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3644 /* The switch statement above can drop through to cause the function
3645 to be called normally. */
3646 return expand_call (exp, target, ignore);
3649 /* Check an arglist to *printf for problems. The arglist should start
3650 at the format specifier, with the remaining arguments immediately
3653 is_valid_printf_arglist (arglist)
3656 /* Save this value so we can restore it later. */
3657 const int SAVE_pedantic = pedantic;
3658 int diagnostic_occurred = 0;
3661 /* Set this to a known value so the user setting won't affect code
3664 /* Check to make sure there are no format specifier errors. */
3665 attrs = tree_cons (get_identifier ("format"),
3666 tree_cons (NULL_TREE,
3667 get_identifier ("printf"),
3668 tree_cons (NULL_TREE,
3670 tree_cons (NULL_TREE,
3674 check_function_format (&diagnostic_occurred, attrs, arglist);
3676 /* Restore the value of `pedantic'. */
3677 pedantic = SAVE_pedantic;
3679 /* If calling `check_function_format_ptr' produces a warning, we
3680 return false, otherwise we return true. */
3681 return ! diagnostic_occurred;
3684 /* If the arguments passed to printf are suitable for optimizations,
3685 we attempt to transform the call. */
3687 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
3690 enum machine_mode tmode;
3691 enum expand_modifier modifier;
3695 tree fn_putchar = unlocked ?
3696 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
3697 tree fn_puts = unlocked ?
3698 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
3699 tree fn, format_arg, stripped_string;
3701 /* If the return value is used, or the replacement _DECL isn't
3702 initialized, don't do the transformation. */
3703 if (!ignore || !fn_putchar || !fn_puts)
3706 /* Verify the required arguments in the original call. */
3708 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3711 /* Check the specifier vs. the parameters. */
3712 if (!is_valid_printf_arglist (arglist))
3715 format_arg = TREE_VALUE (arglist);
3716 stripped_string = format_arg;
3717 STRIP_NOPS (stripped_string);
3718 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3719 stripped_string = TREE_OPERAND (stripped_string, 0);
3721 /* If the format specifier isn't a STRING_CST, punt. */
3722 if (TREE_CODE (stripped_string) != STRING_CST)
3725 /* OK! We can attempt optimization. */
3727 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3728 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3730 arglist = TREE_CHAIN (arglist);
3733 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3734 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3736 arglist = TREE_CHAIN (arglist);
3741 /* We can't handle anything else with % args or %% ... yet. */
3742 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3745 /* If the resulting constant string has a length of 1, call
3746 putchar. Note, TREE_STRING_LENGTH includes the terminating
3747 NULL in its count. */
3748 if (TREE_STRING_LENGTH (stripped_string) == 2)
3750 /* Given printf("c"), (where c is any one character,)
3751 convert "c"[0] to an int and pass that to the replacement
3753 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3754 arglist = build_tree_list (NULL_TREE, arglist);
3758 /* If the resulting constant was "string\n", call
3759 __builtin_puts("string"). Ensure "string" has at least one
3760 character besides the trailing \n. Note, TREE_STRING_LENGTH
3761 includes the terminating NULL in its count. */
3762 else if (TREE_STRING_LENGTH (stripped_string) > 2
3763 && TREE_STRING_POINTER (stripped_string)
3764 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3766 /* Create a NULL-terminated string that's one char shorter
3767 than the original, stripping off the trailing '\n'. */
3768 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3769 char *newstr = (char *) alloca (newlen);
3770 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3771 newstr[newlen - 1] = 0;
3773 arglist = combine_strings (build_string (newlen, newstr));
3774 arglist = build_tree_list (NULL_TREE, arglist);
3778 /* We'd like to arrange to call fputs(string) here, but we
3779 need stdout and don't have a way to get it ... yet. */
3783 return expand_expr (build_function_call (fn, arglist),
3784 (ignore ? const0_rtx : target),
3788 /* If the arguments passed to fprintf are suitable for optimizations,
3789 we attempt to transform the call. */
3791 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
3794 enum machine_mode tmode;
3795 enum expand_modifier modifier;
3799 tree fn_fputc = unlocked ?
3800 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
3801 tree fn_fputs = unlocked ?
3802 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
3803 tree fn, format_arg, stripped_string;
3805 /* If the return value is used, or the replacement _DECL isn't
3806 initialized, don't do the transformation. */
3807 if (!ignore || !fn_fputc || !fn_fputs)
3810 /* Verify the required arguments in the original call. */
3812 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3813 || (TREE_CHAIN (arglist) == 0)
3814 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3818 /* Check the specifier vs. the parameters. */
3819 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3822 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3823 stripped_string = format_arg;
3824 STRIP_NOPS (stripped_string);
3825 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3826 stripped_string = TREE_OPERAND (stripped_string, 0);
3828 /* If the format specifier isn't a STRING_CST, punt. */
3829 if (TREE_CODE (stripped_string) != STRING_CST)
3832 /* OK! We can attempt optimization. */
3834 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3835 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3837 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3838 arglist = tree_cons (NULL_TREE,
3839 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3843 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3844 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3846 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3847 arglist = tree_cons (NULL_TREE,
3848 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3854 /* We can't handle anything else with % args or %% ... yet. */
3855 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3858 /* When "string" doesn't contain %, replace all cases of
3859 fprintf(stream,string) with fputs(string,stream). The fputs
3860 builtin will take take of special cases like length==1. */
3861 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
3862 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
3866 return expand_expr (build_function_call (fn, arglist),
3867 (ignore ? const0_rtx : target),
3872 /* Given a boolean expression ARG, return a tree representing an increment
3873 or decrement (as indicated by CODE) of ARG. The front end must check for
3874 invalid cases (e.g., decrement in C++). */
3876 boolean_increment (code, arg)
3877 enum tree_code code;
3881 tree true_res = (c_language == clk_cplusplus
3883 : c_bool_true_node);
3884 arg = stabilize_reference (arg);
3887 case PREINCREMENT_EXPR:
3888 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3890 case POSTINCREMENT_EXPR:
3891 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3892 arg = save_expr (arg);
3893 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3894 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3896 case PREDECREMENT_EXPR:
3897 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3899 case POSTDECREMENT_EXPR:
3900 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3901 arg = save_expr (arg);
3902 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3903 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3908 TREE_SIDE_EFFECTS (val) = 1;
3912 /* Handle C and C++ default attributes. */
3914 enum built_in_attribute
3916 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3917 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3918 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3919 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3920 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3921 #include "builtin-attrs.def"
3922 #undef DEF_ATTR_NULL_TREE
3924 #undef DEF_ATTR_IDENT
3925 #undef DEF_ATTR_TREE_LIST
3930 static tree built_in_attributes[(int) ATTR_LAST];
3932 static bool c_attrs_initialized = false;
3934 static void c_init_attributes PARAMS ((void));
3936 /* Common initialization before parsing options. */
3938 c_common_init_options (lang)
3939 enum c_language_kind lang;
3942 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
3943 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
3945 /* Mark as "unspecified" (see c_common_post_options). */
3946 flag_bounds_check = -1;
3949 /* Post-switch processing. */
3951 c_common_post_options ()
3953 cpp_post_options (parse_in);
3955 /* Use tree inlining if possible. Function instrumentation is only
3956 done in the RTL level, so we disable tree inlining. */
3957 if (! flag_instrument_function_entry_exit)
3959 if (!flag_no_inline)
3961 flag_inline_trees = 1;
3964 if (flag_inline_functions)
3966 flag_inline_trees = 2;
3967 flag_inline_functions = 0;
3971 /* If still "unspecified", make it match -fbounded-pointers. */
3972 if (flag_bounds_check == -1)
3973 flag_bounds_check = flag_bounded_pointers;
3975 /* Special format checking options don't work without -Wformat; warn if
3977 if (warn_format_y2k && !warn_format)
3978 warning ("-Wformat-y2k ignored without -Wformat");
3979 if (warn_format_extra_args && !warn_format)
3980 warning ("-Wformat-extra-args ignored without -Wformat");
3981 if (warn_format_nonliteral && !warn_format)
3982 warning ("-Wformat-nonliteral ignored without -Wformat");
3983 if (warn_format_security && !warn_format)
3984 warning ("-Wformat-security ignored without -Wformat");
3985 if (warn_missing_format_attribute && !warn_format)
3986 warning ("-Wmissing-format-attribute ignored without -Wformat");
3989 /* Front end initialization common to C, ObjC and C++. */
3991 c_common_init (filename)
3992 const char *filename;
3994 /* Do this before initializing pragmas, as then cpplib's hash table
3996 filename = init_c_lex (filename);
4000 if (!c_attrs_initialized)
4001 c_init_attributes ();
4006 /* Common finish hook for the C, ObjC and C++ front ends. */
4010 cpp_finish (parse_in);
4012 /* For performance, avoid tearing down cpplib's internal structures.
4013 Call cpp_errors () instead of cpp_destroy (). */
4014 errorcount += cpp_errors (parse_in);
4018 c_init_attributes ()
4020 /* Fill in the built_in_attributes array. */
4021 #define DEF_ATTR_NULL_TREE(ENUM) \
4022 built_in_attributes[(int) ENUM] = NULL_TREE;
4023 #define DEF_ATTR_INT(ENUM, VALUE) \
4024 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4025 #define DEF_ATTR_IDENT(ENUM, STRING) \
4026 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4027 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4028 built_in_attributes[(int) ENUM] \
4029 = tree_cons (built_in_attributes[(int) PURPOSE], \
4030 built_in_attributes[(int) VALUE], \
4031 built_in_attributes[(int) CHAIN]);
4032 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4033 #include "builtin-attrs.def"
4034 #undef DEF_ATTR_NULL_TREE
4036 #undef DEF_ATTR_IDENT
4037 #undef DEF_ATTR_TREE_LIST
4039 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4040 c_attrs_initialized = true;
4043 /* Depending on the name of DECL, apply default attributes to it. */
4046 c_common_insert_default_attributes (decl)
4049 tree name = DECL_NAME (decl);
4051 if (!c_attrs_initialized)
4052 c_init_attributes ();
4054 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4055 #define DEF_ATTR_INT(ENUM, VALUE)
4056 #define DEF_ATTR_IDENT(ENUM, STRING)
4057 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4058 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4059 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4060 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4061 ATTR_FLAG_BUILT_IN);
4062 #include "builtin-attrs.def"
4063 #undef DEF_ATTR_NULL_TREE
4065 #undef DEF_ATTR_IDENT
4066 #undef DEF_ATTR_TREE_LIST
4070 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4071 additionally give the location of the previous declaration DECL. */
4073 shadow_warning (msgid, name, decl)
4077 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4078 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4079 DECL_SOURCE_LINE (decl),
4080 "shadowed declaration is here");