1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 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 /* If this variable is defined to a non-NULL value, it will be called
222 after the file has been completely parsed. */
223 void (*back_end_hook) PARAMS ((tree));
225 /* Nonzero means the expression being parsed will never be evaluated.
226 This is a count, since unevaluated expressions can nest. */
229 /* Information about how a function name is generated. */
232 tree *const decl; /* pointer to the VAR_DECL. */
233 const unsigned rid; /* RID number for the identifier. */
234 const int pretty; /* How pretty is it? */
237 /* The three ways of getting then name of the current function. */
239 const struct fname_var_t fname_vars[] =
241 /* C99 compliant __func__, must be first. */
242 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
243 /* GCC __FUNCTION__ compliant. */
244 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
245 /* GCC __PRETTY_FUNCTION__ compliant. */
246 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
250 static int constant_fits_type_p PARAMS ((tree, tree));
252 /* Keep a stack of if statements. We record the number of compound
253 statements seen up to the if keyword, as well as the line number
254 and file of the if. If a potentially ambiguous else is seen, that
255 fact is recorded; the warning is issued when we can be sure that
256 the enclosing if statement does not have an else branch. */
266 static if_elt *if_stack;
268 /* Amount of space in the if statement stack. */
269 static int if_stack_space = 0;
272 static int if_stack_pointer = 0;
274 /* Record the start of an if-then, and record the start of it
275 for ambiguous else detection. */
278 c_expand_start_cond (cond, compstmt_count)
284 /* Make sure there is enough space on the stack. */
285 if (if_stack_space == 0)
288 if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
290 else if (if_stack_space == if_stack_pointer)
292 if_stack_space += 10;
293 if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
296 if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
297 IF_COND (if_stmt) = cond;
300 /* Record this if statement. */
301 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
302 if_stack[if_stack_pointer].file = input_filename;
303 if_stack[if_stack_pointer].line = lineno;
304 if_stack[if_stack_pointer].needs_warning = 0;
305 if_stack[if_stack_pointer].if_stmt = if_stmt;
309 /* Called after the then-clause for an if-statement is processed. */
314 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
315 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
318 /* Record the end of an if-then. Optionally warn if a nested
319 if statement had an ambiguous else clause. */
325 if (if_stack[if_stack_pointer].needs_warning)
326 warning_with_file_and_line (if_stack[if_stack_pointer].file,
327 if_stack[if_stack_pointer].line,
328 "suggest explicit braces to avoid ambiguous `else'");
329 last_expr_type = NULL_TREE;
332 /* Called between the then-clause and the else-clause
333 of an if-then-else. */
336 c_expand_start_else ()
338 /* An ambiguous else warning must be generated for the enclosing if
339 statement, unless we see an else branch for that one, too. */
341 && if_stack_pointer > 1
342 && (if_stack[if_stack_pointer - 1].compstmt_count
343 == if_stack[if_stack_pointer - 2].compstmt_count))
344 if_stack[if_stack_pointer - 2].needs_warning = 1;
346 /* Even if a nested if statement had an else branch, it can't be
347 ambiguous if this one also has an else. So don't warn in that
348 case. Also don't warn for any if statements nested in this else. */
349 if_stack[if_stack_pointer - 1].needs_warning = 0;
350 if_stack[if_stack_pointer - 1].compstmt_count--;
353 /* Called after the else-clause for an if-statement is processed. */
358 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
359 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
362 /* Push current bindings for the function name VAR_DECLS. */
368 tree saved = NULL_TREE;
370 for (ix = 0; fname_vars[ix].decl; ix++)
372 tree decl = *fname_vars[ix].decl;
376 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
377 *fname_vars[ix].decl = NULL_TREE;
380 if (saved || saved_function_name_decls)
381 /* Normally they'll have been NULL, so only push if we've got a
382 stack, or they are non-NULL. */
383 saved_function_name_decls = tree_cons (saved, NULL_TREE,
384 saved_function_name_decls);
387 /* Finish up the current bindings, adding them into the
388 current function's statement tree. This is done by wrapping the
389 function's body in a COMPOUND_STMT containing these decls too. This
390 must be done _before_ finish_stmt_tree is called. If there is no
391 current function, we must be at file scope and no statements are
392 involved. Pop the previous bindings. */
395 finish_fname_decls ()
398 tree body = NULL_TREE;
399 tree stack = saved_function_name_decls;
401 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
402 body = chainon (TREE_VALUE (stack), body);
406 /* They were called into existence, so add to statement tree. */
407 body = chainon (body,
408 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
409 body = build_stmt (COMPOUND_STMT, body);
411 COMPOUND_STMT_NO_SCOPE (body) = 1;
412 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
415 for (ix = 0; fname_vars[ix].decl; ix++)
416 *fname_vars[ix].decl = NULL_TREE;
420 /* We had saved values, restore them. */
423 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
425 tree decl = TREE_PURPOSE (saved);
426 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
428 *fname_vars[ix].decl = decl;
430 stack = TREE_CHAIN (stack);
432 saved_function_name_decls = stack;
435 /* Return the text name of the current function, suitable prettified
439 fname_as_string (pretty_p)
442 const char *name = NULL;
445 name = (current_function_decl
446 ? (*decl_printable_name) (current_function_decl, 2)
448 else if (current_function_decl && DECL_NAME (current_function_decl))
449 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
455 /* Return the text name of the current function, formatted as
456 required by the supplied RID value. */
464 for (ix = 0; fname_vars[ix].decl; ix++)
465 if (fname_vars[ix].rid == rid)
467 return fname_as_string (fname_vars[ix].pretty);
470 /* Return the VAR_DECL for a const char array naming the current
471 function. If the VAR_DECL has not yet been created, create it
472 now. RID indicates how it should be formatted and IDENTIFIER_NODE
473 ID is its name (unfortunately C and C++ hold the RID values of
474 keywords in different places, so we can't derive RID from ID in
475 this language independent code. */
483 tree decl = NULL_TREE;
485 for (ix = 0; fname_vars[ix].decl; ix++)
486 if (fname_vars[ix].rid == rid)
489 decl = *fname_vars[ix].decl;
492 tree saved_last_tree = last_tree;
494 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
495 if (last_tree != saved_last_tree)
497 /* We created some statement tree for the decl. This belongs
498 at the start of the function, so remove it now and reinsert
499 it after the function is complete. */
500 tree stmts = TREE_CHAIN (saved_last_tree);
502 TREE_CHAIN (saved_last_tree) = NULL_TREE;
503 last_tree = saved_last_tree;
504 saved_function_name_decls = tree_cons (decl, stmts,
505 saved_function_name_decls);
507 *fname_vars[ix].decl = decl;
509 if (!ix && !current_function_decl)
510 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
515 /* Given a chain of STRING_CST nodes,
516 concatenate them into one STRING_CST
517 and give it a suitable array-of-chars data type. */
520 combine_strings (strings)
527 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
529 const int nchars_max = flag_isoc99 ? 4095 : 509;
531 if (TREE_CHAIN (strings))
533 /* More than one in the chain, so concatenate. */
536 /* Don't include the \0 at the end of each substring,
537 except for the last one.
538 Count wide strings and ordinary strings separately. */
539 for (t = strings; t; t = TREE_CHAIN (t))
541 if (TREE_TYPE (t) == wchar_array_type_node)
543 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
548 length += (TREE_STRING_LENGTH (t) - 1);
549 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
550 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
554 /* If anything is wide, the non-wides will be converted,
555 which makes them take more space. */
557 length = length * wchar_bytes + wide_length;
561 /* Copy the individual strings into the new combined string.
562 If the combined string is wide, convert the chars to ints
563 for any individual strings that are not wide. */
566 for (t = strings; t; t = TREE_CHAIN (t))
568 int len = (TREE_STRING_LENGTH (t)
569 - ((TREE_TYPE (t) == wchar_array_type_node)
571 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
573 memcpy (q, TREE_STRING_POINTER (t), len);
579 for (i = 0; i < len; i++)
581 if (BYTES_BIG_ENDIAN)
583 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
585 *q++ = TREE_STRING_POINTER (t)[i];
589 *q++ = TREE_STRING_POINTER (t)[i];
590 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
599 for (i = 0; i < wchar_bytes; i++)
605 value = build_string (length, p);
610 length = TREE_STRING_LENGTH (value);
611 if (TREE_TYPE (value) == wchar_array_type_node)
615 /* Compute the number of elements, for the array type. */
616 nchars = wide_flag ? length / wchar_bytes : length;
618 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
619 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
620 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
622 /* Create the array type for the string constant.
623 -Wwrite-strings says make the string constant an array of const char
624 so that copying it to a non-const pointer will get a warning.
625 For C++, this is the standard behavior. */
626 if (flag_const_strings
627 && (! flag_traditional && ! flag_writable_strings))
630 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
633 = build_array_type (elements,
634 build_index_type (build_int_2 (nchars - 1, 0)));
638 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
639 build_index_type (build_int_2 (nchars - 1, 0)));
641 TREE_CONSTANT (value) = 1;
642 TREE_READONLY (value) = ! flag_writable_strings;
643 TREE_STATIC (value) = 1;
647 static int is_valid_printf_arglist PARAMS ((tree));
648 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
649 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
650 enum expand_modifier, int));
651 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
652 enum expand_modifier, int));
654 /* Print a warning if a constant expression had overflow in folding.
655 Invoke this function on every expression that the language
656 requires to be a constant expression.
657 Note the ANSI C standard says it is erroneous for a
658 constant expression to overflow. */
661 constant_expression_warning (value)
664 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
665 || TREE_CODE (value) == COMPLEX_CST)
666 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
667 pedwarn ("overflow in constant expression");
670 /* Print a warning if an expression had overflow in folding.
671 Invoke this function on every expression that
672 (1) appears in the source code, and
673 (2) might be a constant expression that overflowed, and
674 (3) is not already checked by convert_and_check;
675 however, do not invoke this function on operands of explicit casts. */
678 overflow_warning (value)
681 if ((TREE_CODE (value) == INTEGER_CST
682 || (TREE_CODE (value) == COMPLEX_CST
683 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
684 && TREE_OVERFLOW (value))
686 TREE_OVERFLOW (value) = 0;
687 if (skip_evaluation == 0)
688 warning ("integer overflow in expression");
690 else if ((TREE_CODE (value) == REAL_CST
691 || (TREE_CODE (value) == COMPLEX_CST
692 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
693 && TREE_OVERFLOW (value))
695 TREE_OVERFLOW (value) = 0;
696 if (skip_evaluation == 0)
697 warning ("floating point overflow in expression");
701 /* Print a warning if a large constant is truncated to unsigned,
702 or if -Wconversion is used and a constant < 0 is converted to unsigned.
703 Invoke this function on every expression that might be implicitly
704 converted to an unsigned type. */
707 unsigned_conversion_warning (result, operand)
708 tree result, operand;
710 if (TREE_CODE (operand) == INTEGER_CST
711 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
712 && TREE_UNSIGNED (TREE_TYPE (result))
713 && skip_evaluation == 0
714 && !int_fits_type_p (operand, TREE_TYPE (result)))
716 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
717 /* This detects cases like converting -129 or 256 to unsigned char. */
718 warning ("large integer implicitly truncated to unsigned type");
719 else if (warn_conversion)
720 warning ("negative integer implicitly converted to unsigned type");
724 /* Nonzero if constant C has a value that is permissible
725 for type TYPE (an INTEGER_TYPE). */
728 constant_fits_type_p (c, type)
731 if (TREE_CODE (c) == INTEGER_CST)
732 return int_fits_type_p (c, type);
734 c = convert (type, c);
735 return !TREE_OVERFLOW (c);
738 /* Convert EXPR to TYPE, warning about conversion problems with constants.
739 Invoke this function on every expression that is converted implicitly,
740 i.e. because of language rules and not because of an explicit cast. */
743 convert_and_check (type, expr)
746 tree t = convert (type, expr);
747 if (TREE_CODE (t) == INTEGER_CST)
749 if (TREE_OVERFLOW (t))
751 TREE_OVERFLOW (t) = 0;
753 /* Do not diagnose overflow in a constant expression merely
754 because a conversion overflowed. */
755 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
757 /* No warning for converting 0x80000000 to int. */
758 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
759 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
760 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
761 /* If EXPR fits in the unsigned version of TYPE,
762 don't warn unless pedantic. */
764 || TREE_UNSIGNED (type)
765 || ! constant_fits_type_p (expr, unsigned_type (type)))
766 && skip_evaluation == 0)
767 warning ("overflow in implicit constant conversion");
770 unsigned_conversion_warning (t, expr);
775 /* A node in a list that describes references to variables (EXPR), which are
776 either read accesses if WRITER is zero, or write accesses, in which case
777 WRITER is the parent of EXPR. */
784 /* Used to implement a cache the results of a call to verify_tree. We only
785 use this for SAVE_EXPRs. */
788 struct tlist_cache *next;
789 struct tlist *cache_before_sp;
790 struct tlist *cache_after_sp;
794 /* Obstack to use when allocating tlist structures, and corresponding
796 static struct obstack tlist_obstack;
797 static char *tlist_firstobj = 0;
799 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
801 static struct tlist *warned_ids;
802 /* SAVE_EXPRs need special treatment. We process them only once and then
803 cache the results. */
804 static struct tlist_cache *save_expr_cache;
806 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
807 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
808 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
809 static int warning_candidate_p PARAMS ((tree));
810 static void warn_for_collisions PARAMS ((struct tlist *));
811 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
812 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
813 static void verify_sequence_points PARAMS ((tree));
815 /* Create a new struct tlist and fill in its fields. */
816 static struct tlist *
817 new_tlist (next, t, writer)
823 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
830 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
831 is nonnull, we ignore any node we find which has a writer equal to it. */
834 add_tlist (to, add, exclude_writer, copy)
842 struct tlist *next = add->next;
845 if (! exclude_writer || add->writer != exclude_writer)
846 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
851 /* Merge the nodes of ADD into TO. This merging process is done so that for
852 each variable that already exists in TO, no new node is added; however if
853 there is a write access recorded in ADD, and an occurrence on TO is only
854 a read access, then the occurrence in TO will be modified to record the
858 merge_tlist (to, add, copy)
863 struct tlist **end = to;
872 struct tlist *next = add->next;
874 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
875 if (tmp2->expr == add->expr)
879 tmp2->writer = add->writer;
883 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
891 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
892 references in list LIST conflict with it, excluding reads if ONLY writers
896 warn_for_collisions_1 (written, writer, list, only_writes)
897 tree written, writer;
903 /* Avoid duplicate warnings. */
904 for (tmp = warned_ids; tmp; tmp = tmp->next)
905 if (tmp->expr == written)
910 if (list->expr == written
911 && list->writer != writer
912 && (! only_writes || list->writer))
914 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
915 warning ("operation on `%s' may be undefined",
916 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
922 /* Given a list LIST of references to variables, find whether any of these
923 can cause conflicts due to missing sequence points. */
926 warn_for_collisions (list)
931 for (tmp = list; tmp; tmp = tmp->next)
934 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
938 /* Return nonzero if X is a tree that can be verified by the sequence point
941 warning_candidate_p (x)
944 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
947 /* Walk the tree X, and record accesses to variables. If X is written by the
948 parent tree, WRITER is the parent.
949 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
950 expression or its only operand forces a sequence point, then everything up
951 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
953 Once we return, we will have emitted warnings if any subexpression before
954 such a sequence point could be undefined. On a higher level, however, the
955 sequence point may not be relevant, and we'll merge the two lists.
957 Example: (b++, a) + b;
958 The call that processes the COMPOUND_EXPR will store the increment of B
959 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
960 processes the PLUS_EXPR will need to merge the two lists so that
961 eventually, all accesses end up on the same list (and we'll warn about the
962 unordered subexpressions b++ and b.
964 A note on merging. If we modify the former example so that our expression
967 care must be taken not simply to add all three expressions into the final
968 PNO_SP list. The function merge_tlist takes care of that by merging the
969 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
970 way, so that no more than one access to B is recorded. */
973 verify_tree (x, pbefore_sp, pno_sp, writer)
975 struct tlist **pbefore_sp, **pno_sp;
978 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
982 /* X may be NULL if it is the operand of an empty statement expression
988 code = TREE_CODE (x);
989 class = TREE_CODE_CLASS (code);
991 if (warning_candidate_p (x))
993 *pno_sp = new_tlist (*pno_sp, x, writer);
1003 case TRUTH_ANDIF_EXPR:
1004 case TRUTH_ORIF_EXPR:
1005 tmp_before = tmp_nosp = tmp_list3 = 0;
1006 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1007 warn_for_collisions (tmp_nosp);
1008 merge_tlist (pbefore_sp, tmp_before, 0);
1009 merge_tlist (pbefore_sp, tmp_nosp, 0);
1010 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1011 merge_tlist (pbefore_sp, tmp_list3, 0);
1015 tmp_before = tmp_list2 = 0;
1016 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1017 warn_for_collisions (tmp_list2);
1018 merge_tlist (pbefore_sp, tmp_before, 0);
1019 merge_tlist (pbefore_sp, tmp_list2, 1);
1021 tmp_list3 = tmp_nosp = 0;
1022 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1023 warn_for_collisions (tmp_nosp);
1024 merge_tlist (pbefore_sp, tmp_list3, 0);
1026 tmp_list3 = tmp_list2 = 0;
1027 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1028 warn_for_collisions (tmp_list2);
1029 merge_tlist (pbefore_sp, tmp_list3, 0);
1030 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1031 two first, to avoid warning for (a ? b++ : b++). */
1032 merge_tlist (&tmp_nosp, tmp_list2, 0);
1033 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1036 case PREDECREMENT_EXPR:
1037 case PREINCREMENT_EXPR:
1038 case POSTDECREMENT_EXPR:
1039 case POSTINCREMENT_EXPR:
1040 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1044 tmp_before = tmp_nosp = tmp_list3 = 0;
1045 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1046 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1047 /* Expressions inside the LHS are not ordered wrt. the sequence points
1048 in the RHS. Example:
1050 Despite the fact that the modification of "a" is in the before_sp
1051 list (tmp_before), it conflicts with the use of "a" in the LHS.
1052 We can handle this by adding the contents of tmp_list3
1053 to those of tmp_before, and redoing the collision warnings for that
1055 add_tlist (&tmp_before, tmp_list3, x, 1);
1056 warn_for_collisions (tmp_before);
1057 /* Exclude the LHS itself here; we first have to merge it into the
1058 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1059 didn't exclude the LHS, we'd get it twice, once as a read and once
1061 add_tlist (pno_sp, tmp_list3, x, 0);
1062 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1064 merge_tlist (pbefore_sp, tmp_before, 0);
1065 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1066 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1067 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1071 /* We need to warn about conflicts among arguments and conflicts between
1072 args and the function address. Side effects of the function address,
1073 however, are not ordered by the sequence point of the call. */
1074 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1075 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1076 if (TREE_OPERAND (x, 1))
1077 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1078 merge_tlist (&tmp_list3, tmp_list2, 0);
1079 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1080 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1081 warn_for_collisions (tmp_before);
1082 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1086 /* Scan all the list, e.g. indices of multi dimensional array. */
1089 tmp_before = tmp_nosp = 0;
1090 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1091 merge_tlist (&tmp_nosp, tmp_before, 0);
1092 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1099 struct tlist_cache *t;
1100 for (t = save_expr_cache; t; t = t->next)
1106 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1108 t->next = save_expr_cache;
1110 save_expr_cache = t;
1112 tmp_before = tmp_nosp = 0;
1113 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1114 warn_for_collisions (tmp_nosp);
1119 struct tlist *t = tmp_nosp;
1121 merge_tlist (&tmp_list3, t, 0);
1123 t->cache_before_sp = tmp_before;
1124 t->cache_after_sp = tmp_list3;
1126 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1127 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1136 if (first_rtl_op (code) == 0)
1138 x = TREE_OPERAND (x, 0);
1154 int max = first_rtl_op (TREE_CODE (x));
1155 for (lp = 0; lp < max; lp++)
1157 tmp_before = tmp_nosp = 0;
1158 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1159 merge_tlist (&tmp_nosp, tmp_before, 0);
1160 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1167 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1171 verify_sequence_points (expr)
1174 struct tlist *before_sp = 0, *after_sp = 0;
1177 save_expr_cache = 0;
1178 if (tlist_firstobj == 0)
1180 gcc_obstack_init (&tlist_obstack);
1181 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1184 verify_tree (expr, &before_sp, &after_sp, 0);
1185 warn_for_collisions (after_sp);
1186 obstack_free (&tlist_obstack, tlist_firstobj);
1190 c_expand_expr_stmt (expr)
1193 /* Do default conversion if safe and possibly important,
1194 in case within ({...}). */
1195 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1196 && (flag_isoc99 || lvalue_p (expr)))
1197 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1198 expr = default_conversion (expr);
1200 if (warn_sequence_point)
1201 verify_sequence_points (expr);
1203 if (TREE_TYPE (expr) != error_mark_node
1204 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1205 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1206 error ("expression statement has incomplete type");
1208 last_expr_type = TREE_TYPE (expr);
1209 return add_stmt (build_stmt (EXPR_STMT, expr));
1212 /* Validate the expression after `case' and apply default promotions. */
1215 check_case_value (value)
1218 if (value == NULL_TREE)
1221 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1222 STRIP_TYPE_NOPS (value);
1223 /* In C++, the following is allowed:
1226 switch (...) { case i: ... }
1228 So, we try to reduce the VALUE to a constant that way. */
1229 if (c_language == clk_cplusplus)
1231 value = decl_constant_value (value);
1232 STRIP_TYPE_NOPS (value);
1233 value = fold (value);
1236 if (TREE_CODE (value) != INTEGER_CST
1237 && value != error_mark_node)
1239 error ("case label does not reduce to an integer constant");
1240 value = error_mark_node;
1243 /* Promote char or short to int. */
1244 value = default_conversion (value);
1246 constant_expression_warning (value);
1251 /* Return an integer type with BITS bits of precision,
1252 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1255 type_for_size (bits, unsignedp)
1259 if (bits == TYPE_PRECISION (integer_type_node))
1260 return unsignedp ? unsigned_type_node : integer_type_node;
1262 if (bits == TYPE_PRECISION (signed_char_type_node))
1263 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1265 if (bits == TYPE_PRECISION (short_integer_type_node))
1266 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1268 if (bits == TYPE_PRECISION (long_integer_type_node))
1269 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1271 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1272 return (unsignedp ? long_long_unsigned_type_node
1273 : long_long_integer_type_node);
1275 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1276 return (unsignedp ? widest_unsigned_literal_type_node
1277 : widest_integer_literal_type_node);
1279 if (bits <= TYPE_PRECISION (intQI_type_node))
1280 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1282 if (bits <= TYPE_PRECISION (intHI_type_node))
1283 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1285 if (bits <= TYPE_PRECISION (intSI_type_node))
1286 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1288 if (bits <= TYPE_PRECISION (intDI_type_node))
1289 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1294 /* Return a data type that has machine mode MODE.
1295 If the mode is an integer,
1296 then UNSIGNEDP selects between signed and unsigned types. */
1299 type_for_mode (mode, unsignedp)
1300 enum machine_mode mode;
1303 if (mode == TYPE_MODE (integer_type_node))
1304 return unsignedp ? unsigned_type_node : integer_type_node;
1306 if (mode == TYPE_MODE (signed_char_type_node))
1307 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1309 if (mode == TYPE_MODE (short_integer_type_node))
1310 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1312 if (mode == TYPE_MODE (long_integer_type_node))
1313 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1315 if (mode == TYPE_MODE (long_long_integer_type_node))
1316 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1318 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1319 return unsignedp ? widest_unsigned_literal_type_node
1320 : widest_integer_literal_type_node;
1323 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1326 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1329 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1332 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1334 #if HOST_BITS_PER_WIDE_INT >= 64
1335 if (mode == TYPE_MODE (intTI_type_node))
1336 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1339 if (mode == TYPE_MODE (float_type_node))
1340 return float_type_node;
1342 if (mode == TYPE_MODE (double_type_node))
1343 return double_type_node;
1345 if (mode == TYPE_MODE (long_double_type_node))
1346 return long_double_type_node;
1348 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1349 return build_pointer_type (char_type_node);
1351 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1352 return build_pointer_type (integer_type_node);
1354 #ifdef VECTOR_MODE_SUPPORTED_P
1355 if (VECTOR_MODE_SUPPORTED_P (mode))
1360 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1362 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1364 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1366 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1368 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1370 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1372 return V4SF_type_node;
1374 return V2SF_type_node;
1384 /* Return an unsigned type the same as TYPE in other respects. */
1386 unsigned_type (type)
1389 tree type1 = TYPE_MAIN_VARIANT (type);
1390 if (type1 == signed_char_type_node || type1 == char_type_node)
1391 return unsigned_char_type_node;
1392 if (type1 == integer_type_node)
1393 return unsigned_type_node;
1394 if (type1 == short_integer_type_node)
1395 return short_unsigned_type_node;
1396 if (type1 == long_integer_type_node)
1397 return long_unsigned_type_node;
1398 if (type1 == long_long_integer_type_node)
1399 return long_long_unsigned_type_node;
1400 if (type1 == widest_integer_literal_type_node)
1401 return widest_unsigned_literal_type_node;
1402 #if HOST_BITS_PER_WIDE_INT >= 64
1403 if (type1 == intTI_type_node)
1404 return unsigned_intTI_type_node;
1406 if (type1 == intDI_type_node)
1407 return unsigned_intDI_type_node;
1408 if (type1 == intSI_type_node)
1409 return unsigned_intSI_type_node;
1410 if (type1 == intHI_type_node)
1411 return unsigned_intHI_type_node;
1412 if (type1 == intQI_type_node)
1413 return unsigned_intQI_type_node;
1415 return signed_or_unsigned_type (1, type);
1418 /* Return a signed type the same as TYPE in other respects. */
1424 tree type1 = TYPE_MAIN_VARIANT (type);
1425 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1426 return signed_char_type_node;
1427 if (type1 == unsigned_type_node)
1428 return integer_type_node;
1429 if (type1 == short_unsigned_type_node)
1430 return short_integer_type_node;
1431 if (type1 == long_unsigned_type_node)
1432 return long_integer_type_node;
1433 if (type1 == long_long_unsigned_type_node)
1434 return long_long_integer_type_node;
1435 if (type1 == widest_unsigned_literal_type_node)
1436 return widest_integer_literal_type_node;
1437 #if HOST_BITS_PER_WIDE_INT >= 64
1438 if (type1 == unsigned_intTI_type_node)
1439 return intTI_type_node;
1441 if (type1 == unsigned_intDI_type_node)
1442 return intDI_type_node;
1443 if (type1 == unsigned_intSI_type_node)
1444 return intSI_type_node;
1445 if (type1 == unsigned_intHI_type_node)
1446 return intHI_type_node;
1447 if (type1 == unsigned_intQI_type_node)
1448 return intQI_type_node;
1450 return signed_or_unsigned_type (0, type);
1453 /* Return a type the same as TYPE except unsigned or
1454 signed according to UNSIGNEDP. */
1457 signed_or_unsigned_type (unsignedp, type)
1461 if (! INTEGRAL_TYPE_P (type)
1462 || TREE_UNSIGNED (type) == unsignedp)
1465 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1466 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1467 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1468 return unsignedp ? unsigned_type_node : integer_type_node;
1469 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1470 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1471 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1472 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1473 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1474 return (unsignedp ? long_long_unsigned_type_node
1475 : long_long_integer_type_node);
1476 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1477 return (unsignedp ? widest_unsigned_literal_type_node
1478 : widest_integer_literal_type_node);
1480 #if HOST_BITS_PER_WIDE_INT >= 64
1481 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1482 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1484 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1485 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1486 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1487 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1488 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1489 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1490 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1491 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1496 /* Return the minimum number of bits needed to represent VALUE in a
1497 signed or unsigned type, UNSIGNEDP says which. */
1500 min_precision (value, unsignedp)
1506 /* If the value is negative, compute its negative minus 1. The latter
1507 adjustment is because the absolute value of the largest negative value
1508 is one larger than the largest positive value. This is equivalent to
1509 a bit-wise negation, so use that operation instead. */
1511 if (tree_int_cst_sgn (value) < 0)
1512 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1514 /* Return the number of bits needed, taking into account the fact
1515 that we need one more bit for a signed than unsigned type. */
1517 if (integer_zerop (value))
1520 log = tree_floor_log2 (value);
1522 return log + 1 + ! unsignedp;
1525 /* Print an error message for invalid operands to arith operation CODE.
1526 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1529 binary_op_error (code)
1530 enum tree_code code;
1537 error ("invalid truth-value expression");
1541 opname = "+"; break;
1543 opname = "-"; break;
1545 opname = "*"; break;
1547 opname = "max"; break;
1549 opname = "min"; break;
1551 opname = "=="; break;
1553 opname = "!="; break;
1555 opname = "<="; break;
1557 opname = ">="; break;
1559 opname = "<"; break;
1561 opname = ">"; break;
1563 opname = "<<"; break;
1565 opname = ">>"; break;
1566 case TRUNC_MOD_EXPR:
1567 case FLOOR_MOD_EXPR:
1568 opname = "%"; break;
1569 case TRUNC_DIV_EXPR:
1570 case FLOOR_DIV_EXPR:
1571 opname = "/"; break;
1573 opname = "&"; break;
1575 opname = "|"; break;
1576 case TRUTH_ANDIF_EXPR:
1577 opname = "&&"; break;
1578 case TRUTH_ORIF_EXPR:
1579 opname = "||"; break;
1581 opname = "^"; break;
1584 opname = "rotate"; break;
1586 opname = "unknown"; break;
1588 error ("invalid operands to binary %s", opname);
1591 /* Subroutine of build_binary_op, used for comparison operations.
1592 See if the operands have both been converted from subword integer types
1593 and, if so, perhaps change them both back to their original type.
1594 This function is also responsible for converting the two operands
1595 to the proper common type for comparison.
1597 The arguments of this function are all pointers to local variables
1598 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1599 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1601 If this function returns nonzero, it means that the comparison has
1602 a constant value. What this function returns is an expression for
1606 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1607 tree *op0_ptr, *op1_ptr;
1609 enum tree_code *rescode_ptr;
1612 tree op0 = *op0_ptr;
1613 tree op1 = *op1_ptr;
1614 int unsignedp0, unsignedp1;
1616 tree primop0, primop1;
1617 enum tree_code code = *rescode_ptr;
1619 /* Throw away any conversions to wider types
1620 already present in the operands. */
1622 primop0 = get_narrower (op0, &unsignedp0);
1623 primop1 = get_narrower (op1, &unsignedp1);
1625 /* Handle the case that OP0 does not *contain* a conversion
1626 but it *requires* conversion to FINAL_TYPE. */
1628 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1629 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1630 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1631 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1633 /* If one of the operands must be floated, we cannot optimize. */
1634 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1635 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1637 /* If first arg is constant, swap the args (changing operation
1638 so value is preserved), for canonicalization. Don't do this if
1639 the second arg is 0. */
1641 if (TREE_CONSTANT (primop0)
1642 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1645 int temi = unsignedp0;
1653 unsignedp0 = unsignedp1;
1676 *rescode_ptr = code;
1679 /* If comparing an integer against a constant more bits wide,
1680 maybe we can deduce a value of 1 or 0 independent of the data.
1681 Or else truncate the constant now
1682 rather than extend the variable at run time.
1684 This is only interesting if the constant is the wider arg.
1685 Also, it is not safe if the constant is unsigned and the
1686 variable arg is signed, since in this case the variable
1687 would be sign-extended and then regarded as unsigned.
1688 Our technique fails in this case because the lowest/highest
1689 possible unsigned results don't follow naturally from the
1690 lowest/highest possible values of the variable operand.
1691 For just EQ_EXPR and NE_EXPR there is another technique that
1692 could be used: see if the constant can be faithfully represented
1693 in the other operand's type, by truncating it and reextending it
1694 and see if that preserves the constant's value. */
1696 if (!real1 && !real2
1697 && TREE_CODE (primop1) == INTEGER_CST
1698 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1700 int min_gt, max_gt, min_lt, max_lt;
1701 tree maxval, minval;
1702 /* 1 if comparison is nominally unsigned. */
1703 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1706 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1708 /* If TYPE is an enumeration, then we need to get its min/max
1709 values from it's underlying integral type, not the enumerated
1711 if (TREE_CODE (type) == ENUMERAL_TYPE)
1712 type = type_for_size (TYPE_PRECISION (type), unsignedp0);
1714 maxval = TYPE_MAX_VALUE (type);
1715 minval = TYPE_MIN_VALUE (type);
1717 if (unsignedp && !unsignedp0)
1718 *restype_ptr = signed_type (*restype_ptr);
1720 if (TREE_TYPE (primop1) != *restype_ptr)
1721 primop1 = convert (*restype_ptr, primop1);
1722 if (type != *restype_ptr)
1724 minval = convert (*restype_ptr, minval);
1725 maxval = convert (*restype_ptr, maxval);
1728 if (unsignedp && unsignedp0)
1730 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1731 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1732 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1733 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1737 min_gt = INT_CST_LT (primop1, minval);
1738 max_gt = INT_CST_LT (primop1, maxval);
1739 min_lt = INT_CST_LT (minval, primop1);
1740 max_lt = INT_CST_LT (maxval, primop1);
1744 /* This used to be a switch, but Genix compiler can't handle that. */
1745 if (code == NE_EXPR)
1747 if (max_lt || min_gt)
1748 val = boolean_true_node;
1750 else if (code == EQ_EXPR)
1752 if (max_lt || min_gt)
1753 val = boolean_false_node;
1755 else if (code == LT_EXPR)
1758 val = boolean_true_node;
1760 val = boolean_false_node;
1762 else if (code == GT_EXPR)
1765 val = boolean_true_node;
1767 val = boolean_false_node;
1769 else if (code == LE_EXPR)
1772 val = boolean_true_node;
1774 val = boolean_false_node;
1776 else if (code == GE_EXPR)
1779 val = boolean_true_node;
1781 val = boolean_false_node;
1784 /* If primop0 was sign-extended and unsigned comparison specd,
1785 we did a signed comparison above using the signed type bounds.
1786 But the comparison we output must be unsigned.
1788 Also, for inequalities, VAL is no good; but if the signed
1789 comparison had *any* fixed result, it follows that the
1790 unsigned comparison just tests the sign in reverse
1791 (positive values are LE, negative ones GE).
1792 So we can generate an unsigned comparison
1793 against an extreme value of the signed type. */
1795 if (unsignedp && !unsignedp0)
1802 primop1 = TYPE_MIN_VALUE (type);
1808 primop1 = TYPE_MAX_VALUE (type);
1815 type = unsigned_type (type);
1818 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1820 /* This is the case of (char)x >?< 0x80, which people used to use
1821 expecting old C compilers to change the 0x80 into -0x80. */
1822 if (val == boolean_false_node)
1823 warning ("comparison is always false due to limited range of data type");
1824 if (val == boolean_true_node)
1825 warning ("comparison is always true due to limited range of data type");
1828 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1830 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1831 if (val == boolean_false_node)
1832 warning ("comparison is always false due to limited range of data type");
1833 if (val == boolean_true_node)
1834 warning ("comparison is always true due to limited range of data type");
1839 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1840 if (TREE_SIDE_EFFECTS (primop0))
1841 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1845 /* Value is not predetermined, but do the comparison
1846 in the type of the operand that is not constant.
1847 TYPE is already properly set. */
1849 else if (real1 && real2
1850 && (TYPE_PRECISION (TREE_TYPE (primop0))
1851 == TYPE_PRECISION (TREE_TYPE (primop1))))
1852 type = TREE_TYPE (primop0);
1854 /* If args' natural types are both narrower than nominal type
1855 and both extend in the same manner, compare them
1856 in the type of the wider arg.
1857 Otherwise must actually extend both to the nominal
1858 common type lest different ways of extending
1860 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1862 else if (unsignedp0 == unsignedp1 && real1 == real2
1863 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1864 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1866 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1867 type = signed_or_unsigned_type (unsignedp0
1868 || TREE_UNSIGNED (*restype_ptr),
1870 /* Make sure shorter operand is extended the right way
1871 to match the longer operand. */
1872 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1874 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1879 /* Here we must do the comparison on the nominal type
1880 using the args exactly as we received them. */
1881 type = *restype_ptr;
1885 if (!real1 && !real2 && integer_zerop (primop1)
1886 && TREE_UNSIGNED (*restype_ptr))
1892 /* All unsigned values are >= 0, so we warn if extra warnings
1893 are requested. However, if OP0 is a constant that is
1894 >= 0, the signedness of the comparison isn't an issue,
1895 so suppress the warning. */
1896 if (extra_warnings && !in_system_header
1897 && ! (TREE_CODE (primop0) == INTEGER_CST
1898 && ! TREE_OVERFLOW (convert (signed_type (type),
1900 warning ("comparison of unsigned expression >= 0 is always true");
1901 value = boolean_true_node;
1905 if (extra_warnings && !in_system_header
1906 && ! (TREE_CODE (primop0) == INTEGER_CST
1907 && ! TREE_OVERFLOW (convert (signed_type (type),
1909 warning ("comparison of unsigned expression < 0 is always false");
1910 value = boolean_false_node;
1919 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1920 if (TREE_SIDE_EFFECTS (primop0))
1921 return build (COMPOUND_EXPR, TREE_TYPE (value),
1928 *op0_ptr = convert (type, primop0);
1929 *op1_ptr = convert (type, primop1);
1931 *restype_ptr = boolean_type_node;
1936 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1937 or validate its data type for an `if' or `while' statement or ?..: exp.
1939 This preparation consists of taking the ordinary
1940 representation of an expression expr and producing a valid tree
1941 boolean expression describing whether expr is nonzero. We could
1942 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1943 but we optimize comparisons, &&, ||, and !.
1945 The resulting type should always be `boolean_type_node'. */
1948 truthvalue_conversion (expr)
1951 if (TREE_CODE (expr) == ERROR_MARK)
1954 #if 0 /* This appears to be wrong for C++. */
1955 /* These really should return error_mark_node after 2.4 is stable.
1956 But not all callers handle ERROR_MARK properly. */
1957 switch (TREE_CODE (TREE_TYPE (expr)))
1960 error ("struct type value used where scalar is required");
1961 return boolean_false_node;
1964 error ("union type value used where scalar is required");
1965 return boolean_false_node;
1968 error ("array type value used where scalar is required");
1969 return boolean_false_node;
1976 switch (TREE_CODE (expr))
1979 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1980 case TRUTH_ANDIF_EXPR:
1981 case TRUTH_ORIF_EXPR:
1982 case TRUTH_AND_EXPR:
1984 case TRUTH_XOR_EXPR:
1985 case TRUTH_NOT_EXPR:
1986 TREE_TYPE (expr) = boolean_type_node;
1993 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
1996 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
1999 /* If we are taking the address of an external decl, it might be zero
2000 if it is weak, so we cannot optimize. */
2001 if (DECL_P (TREE_OPERAND (expr, 0))
2002 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2005 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2006 return build (COMPOUND_EXPR, boolean_type_node,
2007 TREE_OPERAND (expr, 0), boolean_true_node);
2009 return boolean_true_node;
2012 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2013 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2014 truthvalue_conversion (TREE_OPERAND (expr, 0)),
2015 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2022 /* These don't change whether an object is non-zero or zero. */
2023 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2027 /* These don't change whether an object is zero or non-zero, but
2028 we can't ignore them if their second arg has side-effects. */
2029 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2030 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2031 truthvalue_conversion (TREE_OPERAND (expr, 0)));
2033 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2036 /* Distribute the conversion into the arms of a COND_EXPR. */
2037 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2038 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2039 truthvalue_conversion (TREE_OPERAND (expr, 2))));
2042 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2043 since that affects how `default_conversion' will behave. */
2044 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2045 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2047 /* fall through... */
2049 /* If this is widening the argument, we can ignore it. */
2050 if (TYPE_PRECISION (TREE_TYPE (expr))
2051 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2052 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2056 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2058 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2059 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2061 /* fall through... */
2063 /* This and MINUS_EXPR can be changed into a comparison of the
2065 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2066 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2067 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2068 TREE_OPERAND (expr, 1), 1);
2069 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2070 fold (build1 (NOP_EXPR,
2071 TREE_TYPE (TREE_OPERAND (expr, 0)),
2072 TREE_OPERAND (expr, 1))), 1);
2075 if (integer_onep (TREE_OPERAND (expr, 1))
2076 && TREE_TYPE (expr) != boolean_type_node)
2077 /* Using convert here would cause infinite recursion. */
2078 return build1 (NOP_EXPR, boolean_type_node, expr);
2082 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2083 warning ("suggest parentheses around assignment used as truth value");
2090 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2092 tree tem = save_expr (expr);
2093 return (build_binary_op
2094 ((TREE_SIDE_EFFECTS (expr)
2095 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2096 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2097 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2101 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2104 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2105 int, enum built_in_class, int, int,
2108 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2109 down to the element type of an array. */
2112 c_build_qualified_type (type, type_quals)
2116 /* A restrict-qualified pointer type must be a pointer to object or
2117 incomplete type. Note that the use of POINTER_TYPE_P also allows
2118 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2119 the C++ front-end also use POINTER_TYPE for pointer-to-member
2120 values, so even though it should be illegal to use `restrict'
2121 with such an entity we don't flag that here. Thus, special case
2122 code for that case is required in the C++ front-end. */
2123 if ((type_quals & TYPE_QUAL_RESTRICT)
2124 && (!POINTER_TYPE_P (type)
2125 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2127 error ("invalid use of `restrict'");
2128 type_quals &= ~TYPE_QUAL_RESTRICT;
2131 if (TREE_CODE (type) == ARRAY_TYPE)
2132 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2134 TYPE_DOMAIN (type));
2135 return build_qualified_type (type, type_quals);
2138 /* Apply the TYPE_QUALS to the new DECL. */
2141 c_apply_type_quals_to_decl (type_quals, decl)
2145 if ((type_quals & TYPE_QUAL_CONST)
2146 || (TREE_TYPE (decl)
2147 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2148 TREE_READONLY (decl) = 1;
2149 if (type_quals & TYPE_QUAL_VOLATILE)
2151 TREE_SIDE_EFFECTS (decl) = 1;
2152 TREE_THIS_VOLATILE (decl) = 1;
2154 if (type_quals & TYPE_QUAL_RESTRICT)
2156 if (!TREE_TYPE (decl)
2157 || !POINTER_TYPE_P (TREE_TYPE (decl))
2158 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2159 error ("invalid use of `restrict'");
2160 else if (flag_strict_aliasing)
2161 /* Indicate we need to make a unique alias set for this pointer.
2162 We can't do it here because it might be pointing to an
2164 DECL_POINTER_ALIAS_SET (decl) = -2;
2169 /* Return the typed-based alias set for T, which may be an expression
2170 or a type. Return -1 if we don't do anything special. */
2173 c_common_get_alias_set (t)
2178 /* We know nothing about vector types */
2179 if (TREE_CODE (t) == VECTOR_TYPE)
2182 /* Permit type-punning when accessing a union, provided the access
2183 is directly through the union. For example, this code does not
2184 permit taking the address of a union member and then storing
2185 through it. Even the type-punning allowed here is a GCC
2186 extension, albeit a common and useful one; the C standard says
2187 that such accesses have implementation-defined behavior. */
2189 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2190 u = TREE_OPERAND (u, 0))
2191 if (TREE_CODE (u) == COMPONENT_REF
2192 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2195 /* If this is a char *, the ANSI C standard says it can alias
2196 anything. Note that all references need do this. */
2197 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2198 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2199 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2202 /* That's all the expressions we handle specially. */
2206 /* The C standard specifically allows aliasing between signed and
2207 unsigned variants of the same type. We treat the signed
2208 variant as canonical. */
2209 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2211 tree t1 = signed_type (t);
2213 /* t1 == t can happen for boolean nodes which are always unsigned. */
2215 return get_alias_set (t1);
2217 else if (POINTER_TYPE_P (t))
2221 /* Unfortunately, there is no canonical form of a pointer type.
2222 In particular, if we have `typedef int I', then `int *', and
2223 `I *' are different types. So, we have to pick a canonical
2224 representative. We do this below.
2226 Technically, this approach is actually more conservative that
2227 it needs to be. In particular, `const int *' and `int *'
2228 should be in different alias sets, according to the C and C++
2229 standard, since their types are not the same, and so,
2230 technically, an `int **' and `const int **' cannot point at
2233 But, the standard is wrong. In particular, this code is
2238 const int* const* cipp = &ipp;
2240 And, it doesn't make sense for that to be legal unless you
2241 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2242 the pointed-to types. This issue has been reported to the
2244 t1 = build_type_no_quals (t);
2246 return get_alias_set (t1);
2252 /* Implement the __alignof keyword: Return the minimum required
2253 alignment of TYPE, measured in bytes. */
2259 enum tree_code code = TREE_CODE (type);
2262 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2263 if (code == REFERENCE_TYPE)
2265 type = TREE_TYPE (type);
2266 code = TREE_CODE (type);
2269 if (code == FUNCTION_TYPE)
2270 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2271 else if (code == VOID_TYPE || code == ERROR_MARK)
2273 else if (!COMPLETE_TYPE_P (type))
2275 error ("__alignof__ applied to an incomplete type");
2279 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2281 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2284 /* Implement the __alignof keyword: Return the minimum required
2285 alignment of EXPR, measured in bytes. For VAR_DECL's and
2286 FIELD_DECL's return DECL_ALIGN (which can be set from an
2287 "aligned" __attribute__ specification). */
2290 c_alignof_expr (expr)
2295 if (TREE_CODE (expr) == VAR_DECL)
2296 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2298 else if (TREE_CODE (expr) == COMPONENT_REF
2299 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2301 error ("`__alignof' applied to a bit-field");
2304 else if (TREE_CODE (expr) == COMPONENT_REF
2305 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2306 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2308 else if (TREE_CODE (expr) == INDIRECT_REF)
2310 tree t = TREE_OPERAND (expr, 0);
2312 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2314 while (TREE_CODE (t) == NOP_EXPR
2315 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2319 t = TREE_OPERAND (t, 0);
2320 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2321 if (thisalign > bestalign)
2322 best = t, bestalign = thisalign;
2324 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2327 return c_alignof (TREE_TYPE (expr));
2329 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2332 /* Give the specifications for the format attributes, used by C and all
2335 static const struct attribute_spec c_format_attribute_table[] =
2337 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2338 { "format", 3, 3, false, true, true,
2339 handle_format_attribute },
2340 { "format_arg", 1, 1, false, true, true,
2341 handle_format_arg_attribute },
2342 { NULL, 0, 0, false, false, false, NULL }
2345 /* Build tree nodes and builtin functions common to both C and C++ language
2349 c_common_nodes_and_builtins ()
2353 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2354 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2355 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2356 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2357 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2358 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2359 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2360 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2361 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2362 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2363 #include "builtin-types.def"
2364 #undef DEF_PRIMITIVE_TYPE
2365 #undef DEF_FUNCTION_TYPE_0
2366 #undef DEF_FUNCTION_TYPE_1
2367 #undef DEF_FUNCTION_TYPE_2
2368 #undef DEF_FUNCTION_TYPE_3
2369 #undef DEF_FUNCTION_TYPE_4
2370 #undef DEF_FUNCTION_TYPE_VAR_0
2371 #undef DEF_FUNCTION_TYPE_VAR_1
2372 #undef DEF_FUNCTION_TYPE_VAR_2
2373 #undef DEF_POINTER_TYPE
2377 typedef enum builtin_type builtin_type;
2379 tree builtin_types[(int)BT_LAST];
2380 int wchar_type_size;
2381 tree array_domain_type;
2382 /* Either char* or void*. */
2383 tree traditional_ptr_type_node;
2384 /* Either const char* or const void*. */
2385 tree traditional_cptr_type_node;
2386 tree traditional_len_type_node;
2387 tree va_list_ref_type_node;
2388 tree va_list_arg_type_node;
2390 /* We must initialize this before any builtin functions (which might have
2391 attributes) are declared. (c_common_init is too late.) */
2392 format_attribute_table = c_format_attribute_table;
2394 /* Define `int' and `char' first so that dbx will output them first. */
2395 record_builtin_type (RID_INT, NULL, integer_type_node);
2396 record_builtin_type (RID_CHAR, "char", char_type_node);
2398 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2399 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2400 but not C. Are the conditionals here needed? */
2401 if (c_language == clk_cplusplus)
2402 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2403 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2404 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2405 record_builtin_type (RID_MAX, "long unsigned int",
2406 long_unsigned_type_node);
2407 if (c_language == clk_cplusplus)
2408 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2409 record_builtin_type (RID_MAX, "long long int",
2410 long_long_integer_type_node);
2411 record_builtin_type (RID_MAX, "long long unsigned int",
2412 long_long_unsigned_type_node);
2413 if (c_language == clk_cplusplus)
2414 record_builtin_type (RID_MAX, "long long unsigned",
2415 long_long_unsigned_type_node);
2416 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2417 record_builtin_type (RID_MAX, "short unsigned int",
2418 short_unsigned_type_node);
2419 if (c_language == clk_cplusplus)
2420 record_builtin_type (RID_MAX, "unsigned short",
2421 short_unsigned_type_node);
2423 /* Define both `signed char' and `unsigned char'. */
2424 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2425 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2427 /* These are types that type_for_size and type_for_mode use. */
2428 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2429 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2430 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2431 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2432 #if HOST_BITS_PER_WIDE_INT >= 64
2433 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2435 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2436 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2437 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2438 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2439 #if HOST_BITS_PER_WIDE_INT >= 64
2440 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2443 /* Create the widest literal types. */
2444 widest_integer_literal_type_node
2445 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2446 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2447 widest_integer_literal_type_node));
2449 widest_unsigned_literal_type_node
2450 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2451 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2452 widest_unsigned_literal_type_node));
2454 /* `unsigned long' is the standard type for sizeof.
2455 Note that stddef.h uses `unsigned long',
2456 and this must agree, even if long and int are the same size. */
2458 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2459 signed_size_type_node = signed_type (c_size_type_node);
2460 if (flag_traditional)
2461 c_size_type_node = signed_size_type_node;
2462 set_sizetype (c_size_type_node);
2464 build_common_tree_nodes_2 (flag_short_double);
2466 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2467 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2468 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2470 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2471 complex_integer_type_node));
2472 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2473 complex_float_type_node));
2474 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2475 complex_double_type_node));
2476 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2477 complex_long_double_type_node));
2479 record_builtin_type (RID_VOID, NULL, void_type_node);
2481 void_zero_node = build_int_2 (0, 0);
2482 TREE_TYPE (void_zero_node) = void_type_node;
2484 void_list_node = build_void_list_node ();
2486 /* Make a type to be the domain of a few array types
2487 whose domains don't really matter.
2488 200 is small enough that it always fits in size_t
2489 and large enough that it can hold most function names for the
2490 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2491 array_domain_type = build_index_type (size_int (200));
2493 /* Make a type for arrays of characters.
2494 With luck nothing will ever really depend on the length of this
2496 char_array_type_node
2497 = build_array_type (char_type_node, array_domain_type);
2499 /* Likewise for arrays of ints. */
2501 = build_array_type (integer_type_node, array_domain_type);
2503 string_type_node = build_pointer_type (char_type_node);
2504 const_string_type_node
2505 = build_pointer_type (build_qualified_type
2506 (char_type_node, TYPE_QUAL_CONST));
2508 traditional_ptr_type_node = ((flag_traditional &&
2509 c_language != clk_cplusplus)
2510 ? string_type_node : ptr_type_node);
2511 traditional_cptr_type_node = ((flag_traditional &&
2512 c_language != clk_cplusplus)
2513 ? const_string_type_node : const_ptr_type_node);
2515 (*targetm.init_builtins) ();
2517 /* This is special for C++ so functions can be overloaded. */
2518 wchar_type_node = get_identifier (flag_short_wchar
2519 ? "short unsigned int"
2521 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2522 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2523 if (c_language == clk_cplusplus)
2525 if (TREE_UNSIGNED (wchar_type_node))
2526 wchar_type_node = make_unsigned_type (wchar_type_size);
2528 wchar_type_node = make_signed_type (wchar_type_size);
2529 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2533 signed_wchar_type_node = signed_type (wchar_type_node);
2534 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2537 /* This is for wide string constants. */
2538 wchar_array_type_node
2539 = build_array_type (wchar_type_node, array_domain_type);
2542 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2545 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2547 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2549 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2551 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2552 unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2554 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2555 va_list_type_node));
2557 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2558 ptrdiff_type_node));
2560 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2563 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2565 va_list_arg_type_node = va_list_ref_type_node =
2566 build_pointer_type (TREE_TYPE (va_list_type_node));
2570 va_list_arg_type_node = va_list_type_node;
2571 va_list_ref_type_node = build_reference_type (va_list_type_node);
2574 traditional_len_type_node = ((flag_traditional &&
2575 c_language != clk_cplusplus)
2576 ? integer_type_node : sizetype);
2578 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2579 builtin_types[(int) ENUM] = VALUE;
2580 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2581 builtin_types[(int) ENUM] \
2582 = build_function_type (builtin_types[(int) RETURN], \
2584 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2585 builtin_types[(int) ENUM] \
2586 = build_function_type (builtin_types[(int) RETURN], \
2587 tree_cons (NULL_TREE, \
2588 builtin_types[(int) ARG1], \
2590 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2591 builtin_types[(int) ENUM] \
2592 = build_function_type \
2593 (builtin_types[(int) RETURN], \
2594 tree_cons (NULL_TREE, \
2595 builtin_types[(int) ARG1], \
2596 tree_cons (NULL_TREE, \
2597 builtin_types[(int) ARG2], \
2599 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2600 builtin_types[(int) ENUM] \
2601 = build_function_type \
2602 (builtin_types[(int) RETURN], \
2603 tree_cons (NULL_TREE, \
2604 builtin_types[(int) ARG1], \
2605 tree_cons (NULL_TREE, \
2606 builtin_types[(int) ARG2], \
2607 tree_cons (NULL_TREE, \
2608 builtin_types[(int) ARG3], \
2610 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2611 builtin_types[(int) ENUM] \
2612 = build_function_type \
2613 (builtin_types[(int) RETURN], \
2614 tree_cons (NULL_TREE, \
2615 builtin_types[(int) ARG1], \
2616 tree_cons (NULL_TREE, \
2617 builtin_types[(int) ARG2], \
2620 builtin_types[(int) ARG3], \
2621 tree_cons (NULL_TREE, \
2622 builtin_types[(int) ARG4], \
2623 void_list_node)))));
2624 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2625 builtin_types[(int) ENUM] \
2626 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2627 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2628 builtin_types[(int) ENUM] \
2629 = build_function_type (builtin_types[(int) RETURN], \
2630 tree_cons (NULL_TREE, \
2631 builtin_types[(int) ARG1], \
2634 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2635 builtin_types[(int) ENUM] \
2636 = build_function_type \
2637 (builtin_types[(int) RETURN], \
2638 tree_cons (NULL_TREE, \
2639 builtin_types[(int) ARG1], \
2640 tree_cons (NULL_TREE, \
2641 builtin_types[(int) ARG2], \
2643 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2644 builtin_types[(int) ENUM] \
2645 = build_pointer_type (builtin_types[(int) TYPE]);
2646 #include "builtin-types.def"
2647 #undef DEF_PRIMITIVE_TYPE
2648 #undef DEF_FUNCTION_TYPE_1
2649 #undef DEF_FUNCTION_TYPE_2
2650 #undef DEF_FUNCTION_TYPE_3
2651 #undef DEF_FUNCTION_TYPE_4
2652 #undef DEF_FUNCTION_TYPE_VAR_0
2653 #undef DEF_FUNCTION_TYPE_VAR_1
2654 #undef DEF_POINTER_TYPE
2656 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2657 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2662 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2666 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2669 ? (NAME + strlen ("__builtin_")) \
2672 decl = builtin_function_2 (NAME, \
2673 NAME + strlen ("__builtin_"), \
2674 builtin_types[TYPE], \
2675 builtin_types[LIBTYPE], \
2680 /*noreturn_p=*/0); \
2682 built_in_decls[(int) ENUM] = decl; \
2684 #include "builtins.def"
2687 /* Declare _exit and _Exit just to mark them as non-returning. */
2688 builtin_function_2 (NULL, "_exit", NULL_TREE,
2689 builtin_types[BT_FN_VOID_INT],
2690 0, NOT_BUILT_IN, 0, 1, 1);
2691 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2692 builtin_types[BT_FN_VOID_INT],
2693 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2695 /* Declare these functions non-returning
2696 to avoid spurious "control drops through" warnings. */
2697 builtin_function_2 (NULL, "abort",
2698 NULL_TREE, ((c_language == clk_cplusplus)
2699 ? builtin_types[BT_FN_VOID]
2700 : builtin_types[BT_FN_VOID_VAR]),
2701 0, NOT_BUILT_IN, 0, 0, 1);
2703 builtin_function_2 (NULL, "exit",
2704 NULL_TREE, ((c_language == clk_cplusplus)
2705 ? builtin_types[BT_FN_VOID_INT]
2706 : builtin_types[BT_FN_VOID_VAR]),
2707 0, NOT_BUILT_IN, 0, 0, 1);
2709 main_identifier_node = get_identifier ("main");
2711 /* ??? Perhaps there's a better place to do this. But it is related
2712 to __builtin_va_arg, so it isn't that off-the-wall. */
2713 lang_type_promotes_to = simple_type_promotes_to;
2717 build_va_arg (expr, type)
2720 return build1 (VA_ARG_EXPR, type, expr);
2724 /* Linked list of disabled built-in functions. */
2726 typedef struct disabled_builtin
2729 struct disabled_builtin *next;
2731 static disabled_builtin *disabled_builtins = NULL;
2733 static bool builtin_function_disabled_p PARAMS ((const char *));
2735 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2736 begins with "__builtin_", give an error. */
2739 disable_builtin_function (name)
2742 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2743 error ("cannot disable built-in function `%s'", name);
2746 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2748 new->next = disabled_builtins;
2749 disabled_builtins = new;
2754 /* Return true if the built-in function NAME has been disabled, false
2758 builtin_function_disabled_p (name)
2761 disabled_builtin *p;
2762 for (p = disabled_builtins; p != NULL; p = p->next)
2764 if (strcmp (name, p->name) == 0)
2771 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2772 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2773 of these may be NULL (though both being NULL is useless).
2774 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2775 TYPE is the type of the function with the ordinary name. These
2776 may differ if the ordinary name is declared with a looser type to avoid
2777 conflicts with headers. FUNCTION_CODE and CLASS are as for
2778 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2779 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2780 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2781 NORETURN_P is nonzero, the function is marked as non-returning.
2782 Returns the declaration of BUILTIN_NAME, if any, otherwise
2783 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2784 or if NONANSI_P and flag_no_nonansi_builtin. */
2787 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2788 class, library_name_p, nonansi_p, noreturn_p)
2789 const char *builtin_name;
2794 enum built_in_class class;
2799 tree bdecl = NULL_TREE;
2800 tree decl = NULL_TREE;
2801 if (builtin_name != 0)
2803 bdecl = builtin_function (builtin_name, builtin_type, function_code,
2804 class, library_name_p ? name : NULL);
2807 TREE_THIS_VOLATILE (bdecl) = 1;
2808 TREE_SIDE_EFFECTS (bdecl) = 1;
2811 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
2812 && !(nonansi_p && flag_no_nonansi_builtin))
2814 decl = builtin_function (name, type, function_code, class, NULL);
2816 DECL_BUILT_IN_NONANSI (decl) = 1;
2819 TREE_THIS_VOLATILE (decl) = 1;
2820 TREE_SIDE_EFFECTS (decl) = 1;
2823 return (bdecl != 0 ? bdecl : decl);
2826 /* Nonzero if the type T promotes to int. This is (nearly) the
2827 integral promotions defined in ISO C99 6.3.1.1/2. */
2830 c_promoting_integer_type_p (t)
2833 switch (TREE_CODE (t))
2836 return (TYPE_MAIN_VARIANT (t) == char_type_node
2837 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2838 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2839 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2840 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
2841 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
2844 /* ??? Technically all enumerations not larger than an int
2845 promote to an int. But this is used along code paths
2846 that only want to notice a size change. */
2847 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
2857 /* Given a type, apply default promotions wrt unnamed function arguments
2858 and return the new type. Return NULL_TREE if no change. */
2859 /* ??? There is a function of the same name in the C++ front end that
2860 does something similar, but is more thorough and does not return NULL
2861 if no change. We could perhaps share code, but it would make the
2862 self_promoting_type property harder to identify. */
2865 simple_type_promotes_to (type)
2868 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2869 return double_type_node;
2871 if (c_promoting_integer_type_p (type))
2873 /* Traditionally, unsignedness is preserved in default promotions.
2874 Also preserve unsignedness if not really getting any wider. */
2875 if (TREE_UNSIGNED (type)
2876 && (flag_traditional
2877 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
2878 return unsigned_type_node;
2879 return integer_type_node;
2885 /* Return 1 if PARMS specifies a fixed number of parameters
2886 and none of their types is affected by default promotions. */
2889 self_promoting_args_p (parms)
2893 for (t = parms; t; t = TREE_CHAIN (t))
2895 tree type = TREE_VALUE (t);
2897 if (TREE_CHAIN (t) == 0 && type != void_type_node)
2903 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2906 if (c_promoting_integer_type_p (type))
2912 /* Recursively examines the array elements of TYPE, until a non-array
2913 element type is found. */
2916 strip_array_types (type)
2919 while (TREE_CODE (type) == ARRAY_TYPE)
2920 type = TREE_TYPE (type);
2925 /* Recognize certain built-in functions so we can make tree-codes
2926 other than CALL_EXPR. We do this when it enables fold-const.c
2927 to do something useful. */
2928 /* ??? By rights this should go in builtins.c, but only C and C++
2929 implement build_{binary,unary}_op. Not exactly sure what bits
2930 of functionality are actually needed from those functions, or
2931 where the similar functionality exists in the other front ends. */
2934 expand_tree_builtin (function, params, coerced_params)
2935 tree function, params, coerced_params;
2937 enum tree_code code;
2939 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
2942 switch (DECL_FUNCTION_CODE (function))
2946 case BUILT_IN_LLABS:
2947 case BUILT_IN_IMAXABS:
2949 case BUILT_IN_FABSL:
2950 case BUILT_IN_FABSF:
2951 if (coerced_params == 0)
2952 return integer_zero_node;
2953 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2956 case BUILT_IN_CONJF:
2957 case BUILT_IN_CONJL:
2958 if (coerced_params == 0)
2959 return integer_zero_node;
2960 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
2962 case BUILT_IN_CREAL:
2963 case BUILT_IN_CREALF:
2964 case BUILT_IN_CREALL:
2965 if (coerced_params == 0)
2966 return integer_zero_node;
2967 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
2969 case BUILT_IN_CIMAG:
2970 case BUILT_IN_CIMAGF:
2971 case BUILT_IN_CIMAGL:
2972 if (coerced_params == 0)
2973 return integer_zero_node;
2974 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
2976 case BUILT_IN_ISGREATER:
2977 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2983 case BUILT_IN_ISGREATEREQUAL:
2984 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2990 case BUILT_IN_ISLESS:
2991 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2997 case BUILT_IN_ISLESSEQUAL:
2998 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3004 case BUILT_IN_ISLESSGREATER:
3005 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
3011 case BUILT_IN_ISUNORDERED:
3012 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
3013 return integer_zero_node;
3014 code = UNORDERED_EXPR;
3022 || TREE_CHAIN (params) == 0)
3024 error ("too few arguments to function `%s'",
3025 IDENTIFIER_POINTER (DECL_NAME (function)));
3026 return error_mark_node;
3028 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3030 error ("too many arguments to function `%s'",
3031 IDENTIFIER_POINTER (DECL_NAME (function)));
3032 return error_mark_node;
3035 arg0 = TREE_VALUE (params);
3036 arg1 = TREE_VALUE (TREE_CHAIN (params));
3037 arg0 = build_binary_op (code, arg0, arg1, 0);
3038 if (code != UNORDERED_EXPR)
3039 arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3051 /* Returns non-zero if CODE is the code for a statement. */
3054 statement_code_p (code)
3055 enum tree_code code;
3078 if (lang_statement_code_p)
3079 return (*lang_statement_code_p) (code);
3084 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3085 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3086 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3087 value, the traversal is aborted, and the value returned by FUNC is
3088 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3089 the node being visited are not walked.
3091 We don't need a without_duplicates variant of this one because the
3092 statement tree is a tree, not a graph. */
3095 walk_stmt_tree (tp, func, data)
3100 enum tree_code code;
3105 #define WALK_SUBTREE(NODE) \
3108 result = walk_stmt_tree (&(NODE), func, data); \
3114 /* Skip empty subtrees. */
3118 /* Skip subtrees below non-statement nodes. */
3119 if (!statement_code_p (TREE_CODE (*tp)))
3122 /* Call the function. */
3124 result = (*func) (tp, &walk_subtrees, data);
3126 /* If we found something, return it. */
3130 /* FUNC may have modified the tree, recheck that we're looking at a
3132 code = TREE_CODE (*tp);
3133 if (!statement_code_p (code))
3136 /* Visit the subtrees unless FUNC decided that there was nothing
3137 interesting below this point in the tree. */
3140 /* Walk over all the sub-trees of this operand. Statement nodes
3141 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3142 len = TREE_CODE_LENGTH (code);
3144 /* Go through the subtrees. We need to do this in forward order so
3145 that the scope of a FOR_EXPR is handled properly. */
3146 for (i = 0; i < len; ++i)
3147 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3150 /* Finally visit the chain. This can be tail-recursion optimized if
3151 we write it this way. */
3152 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3157 /* Used to compare case labels. K1 and K2 are actually tree nodes
3158 representing case labels, or NULL_TREE for a `default' label.
3159 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3160 K2, and 0 if K1 and K2 are equal. */
3163 case_compare (k1, k2)
3167 /* Consider a NULL key (such as arises with a `default' label) to be
3168 smaller than anything else. */
3174 return tree_int_cst_compare ((tree) k1, (tree) k2);
3177 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3178 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3179 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3180 case label was declared using the usual C/C++ syntax, rather than
3181 the GNU case range extension. CASES is a tree containing all the
3182 case ranges processed so far; COND is the condition for the
3183 switch-statement itself. Returns the CASE_LABEL created, or
3184 ERROR_MARK_NODE if no CASE_LABEL is created. */
3187 c_add_case_label (cases, cond, low_value, high_value)
3196 splay_tree_node node;
3198 /* Create the LABEL_DECL itself. */
3199 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3200 DECL_CONTEXT (label) = current_function_decl;
3202 /* If there was an error processing the switch condition, bail now
3203 before we get more confused. */
3204 if (!cond || cond == error_mark_node)
3206 /* Add a label anyhow so that the back-end doesn't think that
3207 the beginning of the switch is unreachable. */
3209 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3210 return error_mark_node;
3213 if ((low_value && TREE_TYPE (low_value)
3214 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3215 || (high_value && TREE_TYPE (high_value)
3216 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3217 error ("pointers are not permitted as case values");
3219 /* Case ranges are a GNU extension. */
3220 if (high_value && pedantic)
3222 if (c_language == clk_cplusplus)
3223 pedwarn ("ISO C++ forbids range expressions in switch statements");
3225 pedwarn ("ISO C forbids range expressions in switch statements");
3228 type = TREE_TYPE (cond);
3231 low_value = check_case_value (low_value);
3232 low_value = convert_and_check (type, low_value);
3236 high_value = check_case_value (high_value);
3237 high_value = convert_and_check (type, high_value);
3240 /* If an error has occurred, bail out now. */
3241 if (low_value == error_mark_node || high_value == error_mark_node)
3244 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3245 return error_mark_node;
3248 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3249 really a case range, even though it was written that way. Remove
3250 the HIGH_VALUE to simplify later processing. */
3251 if (tree_int_cst_equal (low_value, high_value))
3252 high_value = NULL_TREE;
3253 if (low_value && high_value
3254 && !tree_int_cst_lt (low_value, high_value))
3255 warning ("empty range specified");
3257 /* Look up the LOW_VALUE in the table of case labels we already
3259 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3260 /* If there was not an exact match, check for overlapping ranges.
3261 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3262 that's a `default' label and the only overlap is an exact match. */
3263 if (!node && (low_value || high_value))
3265 splay_tree_node low_bound;
3266 splay_tree_node high_bound;
3268 /* Even though there wasn't an exact match, there might be an
3269 overlap between this case range and another case range.
3270 Since we've (inductively) not allowed any overlapping case
3271 ranges, we simply need to find the greatest low case label
3272 that is smaller that LOW_VALUE, and the smallest low case
3273 label that is greater than LOW_VALUE. If there is an overlap
3274 it will occur in one of these two ranges. */
3275 low_bound = splay_tree_predecessor (cases,
3276 (splay_tree_key) low_value);
3277 high_bound = splay_tree_successor (cases,
3278 (splay_tree_key) low_value);
3280 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3281 the LOW_VALUE, so there is no need to check unless the
3282 LOW_BOUND is in fact itself a case range. */
3284 && CASE_HIGH ((tree) low_bound->value)
3285 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3288 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3289 range is bigger than the low end of the current range, so we
3290 are only interested if the current range is a real range, and
3291 not an ordinary case label. */
3294 && (tree_int_cst_compare ((tree) high_bound->key,
3299 /* If there was an overlap, issue an error. */
3302 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3306 error ("duplicate (or overlapping) case value");
3307 error_with_decl (duplicate,
3308 "this is the first entry overlapping that value");
3312 error ("duplicate case value") ;
3313 error_with_decl (duplicate, "previously used here");
3317 error ("multiple default labels in one switch");
3318 error_with_decl (duplicate, "this is the first default label");
3321 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3324 /* Add a CASE_LABEL to the statement-tree. */
3325 case_label = add_stmt (build_case_label (low_value, high_value, label));
3326 /* Register this case label in the splay tree. */
3327 splay_tree_insert (cases,
3328 (splay_tree_key) low_value,
3329 (splay_tree_value) case_label);
3334 /* Finish an expression taking the address of LABEL. Returns an
3335 expression for the address. */
3338 finish_label_address_expr (label)
3345 if (c_language == clk_cplusplus)
3346 pedwarn ("ISO C++ forbids taking the address of a label");
3348 pedwarn ("ISO C forbids taking the address of a label");
3351 label = lookup_label (label);
3352 if (label == NULL_TREE)
3353 result = null_pointer_node;
3356 TREE_USED (label) = 1;
3357 result = build1 (ADDR_EXPR, ptr_type_node, label);
3358 TREE_CONSTANT (result) = 1;
3359 /* The current function in not necessarily uninlinable.
3360 Computed gotos are incompatible with inlining, but the value
3361 here could be used only in a diagnostic, for example. */
3367 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3368 parameter allows this function to be used as a GC-marking
3375 stmt_tree st = (stmt_tree) p;
3377 ggc_mark_tree (st->x_last_stmt);
3378 ggc_mark_tree (st->x_last_expr_type);
3381 /* Mark LD for GC. */
3384 c_mark_lang_decl (c)
3385 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3389 /* Mark F for GC. */
3392 mark_c_language_function (f)
3393 struct language_function *f;
3398 mark_stmt_tree (&f->x_stmt_tree);
3399 ggc_mark_tree (f->x_scope_stmt_stack);
3402 /* Hook used by expand_expr to expand language-specific tree codes. */
3405 c_expand_expr (exp, target, tmode, modifier)
3408 enum machine_mode tmode;
3409 enum expand_modifier modifier;
3411 switch (TREE_CODE (exp))
3418 /* Since expand_expr_stmt calls free_temp_slots after every
3419 expression statement, we must call push_temp_slots here.
3420 Otherwise, any temporaries in use now would be considered
3421 out-of-scope after the first EXPR_STMT from within the
3424 rtl_expr = expand_start_stmt_expr ();
3425 expand_stmt (STMT_EXPR_STMT (exp));
3426 expand_end_stmt_expr (rtl_expr);
3427 result = expand_expr (rtl_expr, target, tmode, modifier);
3435 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3436 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3438 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3439 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3440 == BUILT_IN_FRONTEND))
3441 return c_expand_builtin (exp, target, tmode, modifier);
3447 case COMPOUND_LITERAL_EXPR:
3449 /* Initialize the anonymous variable declared in the compound
3450 literal, then return the variable. */
3451 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3452 emit_local_var (decl);
3453 return expand_expr (decl, target, tmode, modifier);
3464 /* Hook used by safe_from_p to handle language-specific tree codes. */
3467 c_safe_from_p (target, exp)
3471 /* We can see statements here when processing the body of a
3472 statement-expression. For a declaration statement declaring a
3473 variable, look at the variable's initializer. */
3474 if (TREE_CODE (exp) == DECL_STMT)
3476 tree decl = DECL_STMT_DECL (exp);
3478 if (TREE_CODE (decl) == VAR_DECL
3479 && DECL_INITIAL (decl)
3480 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3484 /* For any statement, we must follow the statement-chain. */
3485 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3486 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3488 /* Assume everything else is safe. */
3492 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3495 c_unsafe_for_reeval (exp)
3498 /* Statement expressions may not be reevaluated. */
3499 if (TREE_CODE (exp) == STMT_EXPR)
3502 /* Walk all other expressions. */
3506 /* Hook used by staticp to handle language-specific tree codes. */
3512 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3513 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3518 /* Tree code classes. */
3520 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3522 static const char c_tree_code_type[] = {
3524 #include "c-common.def"
3528 /* Table indexed by tree code giving number of expression
3529 operands beyond the fixed part of the node structure.
3530 Not used for types or decls. */
3532 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3534 static const int c_tree_code_length[] = {
3536 #include "c-common.def"
3540 /* Names of tree components.
3541 Used for printing out the tree and error messages. */
3542 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3544 static const char *const c_tree_code_name[] = {
3546 #include "c-common.def"
3550 /* Adds the tree codes specific to the C front end to the list of all
3556 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3558 (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3559 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3561 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3562 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3564 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
3565 lang_unsafe_for_reeval = c_unsafe_for_reeval;
3568 #define CALLED_AS_BUILT_IN(NODE) \
3569 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3572 c_expand_builtin (exp, target, tmode, modifier)
3575 enum machine_mode tmode;
3576 enum expand_modifier modifier;
3578 tree type = TREE_TYPE (exp);
3579 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3580 tree arglist = TREE_OPERAND (exp, 1);
3581 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3582 enum tree_code code = TREE_CODE (exp);
3583 const int ignore = (target == const0_rtx
3584 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3585 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3586 || code == COND_EXPR)
3587 && TREE_CODE (type) == VOID_TYPE));
3589 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3590 return expand_call (exp, target, ignore);
3594 case BUILT_IN_PRINTF:
3595 target = c_expand_builtin_printf (arglist, target, tmode,
3601 case BUILT_IN_FPRINTF:
3602 target = c_expand_builtin_fprintf (arglist, target, tmode,
3608 default: /* just do library call, if unknown builtin */
3609 error ("built-in function `%s' not currently supported",
3610 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3613 /* The switch statement above can drop through to cause the function
3614 to be called normally. */
3615 return expand_call (exp, target, ignore);
3618 /* Check an arglist to *printf for problems. The arglist should start
3619 at the format specifier, with the remaining arguments immediately
3622 is_valid_printf_arglist (arglist)
3625 /* Save this value so we can restore it later. */
3626 const int SAVE_pedantic = pedantic;
3627 int diagnostic_occurred = 0;
3630 /* Set this to a known value so the user setting won't affect code
3633 /* Check to make sure there are no format specifier errors. */
3634 attrs = tree_cons (get_identifier ("format"),
3635 tree_cons (NULL_TREE,
3636 get_identifier ("printf"),
3637 tree_cons (NULL_TREE,
3639 tree_cons (NULL_TREE,
3643 check_function_format (&diagnostic_occurred, attrs, arglist);
3645 /* Restore the value of `pedantic'. */
3646 pedantic = SAVE_pedantic;
3648 /* If calling `check_function_format_ptr' produces a warning, we
3649 return false, otherwise we return true. */
3650 return ! diagnostic_occurred;
3653 /* If the arguments passed to printf are suitable for optimizations,
3654 we attempt to transform the call. */
3656 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
3659 enum machine_mode tmode;
3660 enum expand_modifier modifier;
3663 tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
3664 fn_puts = built_in_decls[BUILT_IN_PUTS];
3665 tree fn, format_arg, stripped_string;
3667 /* If the return value is used, or the replacement _DECL isn't
3668 initialized, don't do the transformation. */
3669 if (!ignore || !fn_putchar || !fn_puts)
3672 /* Verify the required arguments in the original call. */
3674 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3677 /* Check the specifier vs. the parameters. */
3678 if (!is_valid_printf_arglist (arglist))
3681 format_arg = TREE_VALUE (arglist);
3682 stripped_string = format_arg;
3683 STRIP_NOPS (stripped_string);
3684 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3685 stripped_string = TREE_OPERAND (stripped_string, 0);
3687 /* If the format specifier isn't a STRING_CST, punt. */
3688 if (TREE_CODE (stripped_string) != STRING_CST)
3691 /* OK! We can attempt optimization. */
3693 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3694 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3696 arglist = TREE_CHAIN (arglist);
3699 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3700 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3702 arglist = TREE_CHAIN (arglist);
3707 /* We can't handle anything else with % args or %% ... yet. */
3708 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3711 /* If the resulting constant string has a length of 1, call
3712 putchar. Note, TREE_STRING_LENGTH includes the terminating
3713 NULL in its count. */
3714 if (TREE_STRING_LENGTH (stripped_string) == 2)
3716 /* Given printf("c"), (where c is any one character,)
3717 convert "c"[0] to an int and pass that to the replacement
3719 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3720 arglist = build_tree_list (NULL_TREE, arglist);
3724 /* If the resulting constant was "string\n", call
3725 __builtin_puts("string"). Ensure "string" has at least one
3726 character besides the trailing \n. Note, TREE_STRING_LENGTH
3727 includes the terminating NULL in its count. */
3728 else if (TREE_STRING_LENGTH (stripped_string) > 2
3729 && TREE_STRING_POINTER (stripped_string)
3730 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3732 /* Create a NULL-terminated string that's one char shorter
3733 than the original, stripping off the trailing '\n'. */
3734 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3735 char *newstr = (char *) alloca (newlen);
3736 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3737 newstr[newlen - 1] = 0;
3739 arglist = combine_strings (build_string (newlen, newstr));
3740 arglist = build_tree_list (NULL_TREE, arglist);
3744 /* We'd like to arrange to call fputs(string) here, but we
3745 need stdout and don't have a way to get it ... yet. */
3749 return expand_expr (build_function_call (fn, arglist),
3750 (ignore ? const0_rtx : target),
3754 /* If the arguments passed to fprintf are suitable for optimizations,
3755 we attempt to transform the call. */
3757 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
3760 enum machine_mode tmode;
3761 enum expand_modifier modifier;
3764 tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
3765 fn_fputs = built_in_decls[BUILT_IN_FPUTS];
3766 tree fn, format_arg, stripped_string;
3768 /* If the return value is used, or the replacement _DECL isn't
3769 initialized, don't do the transformation. */
3770 if (!ignore || !fn_fputc || !fn_fputs)
3773 /* Verify the required arguments in the original call. */
3775 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3776 || (TREE_CHAIN (arglist) == 0)
3777 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3781 /* Check the specifier vs. the parameters. */
3782 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3785 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3786 stripped_string = format_arg;
3787 STRIP_NOPS (stripped_string);
3788 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3789 stripped_string = TREE_OPERAND (stripped_string, 0);
3791 /* If the format specifier isn't a STRING_CST, punt. */
3792 if (TREE_CODE (stripped_string) != STRING_CST)
3795 /* OK! We can attempt optimization. */
3797 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3798 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3800 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3801 arglist = tree_cons (NULL_TREE,
3802 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3806 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3807 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3809 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3810 arglist = tree_cons (NULL_TREE,
3811 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3817 /* We can't handle anything else with % args or %% ... yet. */
3818 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3821 /* When "string" doesn't contain %, replace all cases of
3822 fprintf(stream,string) with fputs(string,stream). The fputs
3823 builtin will take take of special cases like length==1. */
3824 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
3825 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
3829 return expand_expr (build_function_call (fn, arglist),
3830 (ignore ? const0_rtx : target),
3835 /* Given a boolean expression ARG, return a tree representing an increment
3836 or decrement (as indicated by CODE) of ARG. The front end must check for
3837 invalid cases (e.g., decrement in C++). */
3839 boolean_increment (code, arg)
3840 enum tree_code code;
3844 tree true_res = (c_language == clk_cplusplus
3846 : c_bool_true_node);
3847 arg = stabilize_reference (arg);
3850 case PREINCREMENT_EXPR:
3851 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3853 case POSTINCREMENT_EXPR:
3854 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3855 arg = save_expr (arg);
3856 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3857 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3859 case PREDECREMENT_EXPR:
3860 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3862 case POSTDECREMENT_EXPR:
3863 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3864 arg = save_expr (arg);
3865 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3866 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3871 TREE_SIDE_EFFECTS (val) = 1;
3875 /* Handle C and C++ default attributes. */
3877 enum built_in_attribute
3879 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3880 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3881 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3882 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3883 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3884 #include "builtin-attrs.def"
3885 #undef DEF_ATTR_NULL_TREE
3887 #undef DEF_ATTR_IDENT
3888 #undef DEF_ATTR_TREE_LIST
3893 static tree built_in_attributes[(int) ATTR_LAST];
3895 static bool c_attrs_initialized = false;
3897 static void c_init_attributes PARAMS ((void));
3899 /* Common initialization before parsing options. */
3901 c_common_init_options (lang)
3902 enum c_language_kind lang;
3905 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
3906 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
3908 /* Mark as "unspecified" (see c_common_post_options). */
3909 flag_bounds_check = -1;
3912 /* Post-switch processing. */
3914 c_common_post_options ()
3916 cpp_post_options (parse_in);
3918 /* Use tree inlining if possible. Function instrumentation is only
3919 done in the RTL level, so we disable tree inlining. */
3920 if (! flag_instrument_function_entry_exit)
3922 if (!flag_no_inline)
3924 flag_inline_trees = 1;
3927 if (flag_inline_functions)
3929 flag_inline_trees = 2;
3930 flag_inline_functions = 0;
3934 /* If still "unspecified", make it match -fbounded-pointers. */
3935 if (flag_bounds_check == -1)
3936 flag_bounds_check = flag_bounded_pointers;
3938 /* Special format checking options don't work without -Wformat; warn if
3940 if (warn_format_y2k && !warn_format)
3941 warning ("-Wformat-y2k ignored without -Wformat");
3942 if (warn_format_extra_args && !warn_format)
3943 warning ("-Wformat-extra-args ignored without -Wformat");
3944 if (warn_format_nonliteral && !warn_format)
3945 warning ("-Wformat-nonliteral ignored without -Wformat");
3946 if (warn_format_security && !warn_format)
3947 warning ("-Wformat-security ignored without -Wformat");
3948 if (warn_missing_format_attribute && !warn_format)
3949 warning ("-Wmissing-format-attribute ignored without -Wformat");
3952 /* Front end initialization common to C, ObjC and C++. */
3954 c_common_init (filename)
3955 const char *filename;
3957 /* Do this before initializing pragmas, as then cpplib's hash table
3959 filename = init_c_lex (filename);
3963 if (!c_attrs_initialized)
3964 c_init_attributes ();
3969 /* Common finish hook for the C, ObjC and C++ front ends. */
3973 cpp_finish (parse_in);
3975 /* For performance, avoid tearing down cpplib's internal structures.
3976 Call cpp_errors () instead of cpp_destroy (). */
3977 errorcount += cpp_errors (parse_in);
3981 c_init_attributes ()
3983 /* Fill in the built_in_attributes array. */
3984 #define DEF_ATTR_NULL_TREE(ENUM) \
3985 built_in_attributes[(int) ENUM] = NULL_TREE;
3986 #define DEF_ATTR_INT(ENUM, VALUE) \
3987 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3988 #define DEF_ATTR_IDENT(ENUM, STRING) \
3989 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3990 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3991 built_in_attributes[(int) ENUM] \
3992 = tree_cons (built_in_attributes[(int) PURPOSE], \
3993 built_in_attributes[(int) VALUE], \
3994 built_in_attributes[(int) CHAIN]);
3995 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
3996 #include "builtin-attrs.def"
3997 #undef DEF_ATTR_NULL_TREE
3999 #undef DEF_ATTR_IDENT
4000 #undef DEF_ATTR_TREE_LIST
4002 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4003 c_attrs_initialized = true;
4006 /* Depending on the name of DECL, apply default attributes to it. */
4009 c_common_insert_default_attributes (decl)
4012 tree name = DECL_NAME (decl);
4014 if (!c_attrs_initialized)
4015 c_init_attributes ();
4017 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4018 #define DEF_ATTR_INT(ENUM, VALUE)
4019 #define DEF_ATTR_IDENT(ENUM, STRING)
4020 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4021 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4022 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4023 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4024 ATTR_FLAG_BUILT_IN);
4025 #include "builtin-attrs.def"
4026 #undef DEF_ATTR_NULL_TREE
4028 #undef DEF_ATTR_IDENT
4029 #undef DEF_ATTR_TREE_LIST
4033 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4034 additionally give the location of the previous declaration DECL. */
4036 shadow_warning (msgid, name, decl)
4040 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4041 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4042 DECL_SOURCE_LINE (decl),
4043 "shadowed declaration is here");