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
38 cpp_reader *parse_in; /* Declared in c-lex.h. */
40 #undef WCHAR_TYPE_SIZE
41 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
43 /* We let tm.h override the types used here, to handle trivial differences
44 such as the choice of unsigned int or long unsigned int for size_t.
45 When machines start needing nontrivial differences in the size type,
46 it would be best to do something here to figure out automatically
47 from other information what type to use. */
50 #define SIZE_TYPE "long unsigned int"
54 #define WCHAR_TYPE "int"
58 #define PTRDIFF_TYPE "long int"
62 #define WINT_TYPE "unsigned int"
66 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
68 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
74 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 ? "long unsigned int" \
78 : "long long unsigned int"))
81 /* The following symbols are subsumed in the c_global_trees array, and
82 listed here individually for documentation purposes.
84 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
86 tree short_integer_type_node;
87 tree long_integer_type_node;
88 tree long_long_integer_type_node;
90 tree short_unsigned_type_node;
91 tree long_unsigned_type_node;
92 tree long_long_unsigned_type_node;
94 tree boolean_type_node;
95 tree boolean_false_node;
96 tree boolean_true_node;
98 tree ptrdiff_type_node;
100 tree unsigned_char_type_node;
101 tree signed_char_type_node;
102 tree wchar_type_node;
103 tree signed_wchar_type_node;
104 tree unsigned_wchar_type_node;
106 tree float_type_node;
107 tree double_type_node;
108 tree long_double_type_node;
110 tree complex_integer_type_node;
111 tree complex_float_type_node;
112 tree complex_double_type_node;
113 tree complex_long_double_type_node;
115 tree intQI_type_node;
116 tree intHI_type_node;
117 tree intSI_type_node;
118 tree intDI_type_node;
119 tree intTI_type_node;
121 tree unsigned_intQI_type_node;
122 tree unsigned_intHI_type_node;
123 tree unsigned_intSI_type_node;
124 tree unsigned_intDI_type_node;
125 tree unsigned_intTI_type_node;
127 tree widest_integer_literal_type_node;
128 tree widest_unsigned_literal_type_node;
130 Nodes for types `void *' and `const void *'.
132 tree ptr_type_node, const_ptr_type_node;
134 Nodes for types `char *' and `const char *'.
136 tree string_type_node, const_string_type_node;
138 Type `char[SOMENUMBER]'.
139 Used when an array of char is needed and the size is irrelevant.
141 tree char_array_type_node;
143 Type `int[SOMENUMBER]' or something like it.
144 Used when an array of int needed and the size is irrelevant.
146 tree int_array_type_node;
148 Type `wchar_t[SOMENUMBER]' or something like it.
149 Used when a wide string literal is created.
151 tree wchar_array_type_node;
153 Type `int ()' -- used for implicit declaration of functions.
155 tree default_function_type;
157 A VOID_TYPE node, packaged in a TREE_LIST.
161 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
162 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
163 VAR_DECLS, but C++ does.)
165 tree function_name_decl_node;
166 tree pretty_function_name_decl_node;
167 tree c99_function_name_decl_node;
169 Stack of nested function name VAR_DECLs.
171 tree saved_function_name_decls;
175 tree c_global_trees[CTI_MAX];
177 /* Nonzero means don't recognize the non-ANSI builtin functions. */
181 /* Nonzero means don't recognize the non-ANSI builtin functions.
184 int flag_no_nonansi_builtin;
186 /* Nonzero means give `double' the same size as `float'. */
188 int flag_short_double;
190 /* Nonzero means give `wchar_t' the same size as `short'. */
192 int flag_short_wchar;
194 /* Nonzero means warn about possible violations of sequence point rules. */
196 int warn_sequence_point;
198 /* Nonzero means to warn about compile-time division by zero. */
199 int warn_div_by_zero = 1;
201 /* The elements of `ridpointers' are identifier nodes for the reserved
202 type names and storage classes. It is indexed by a RID_... value. */
205 tree (*make_fname_decl) PARAMS ((tree, int));
207 /* If non-NULL, the address of a language-specific function that
208 returns 1 for language-specific statement codes. */
209 int (*lang_statement_code_p) PARAMS ((enum tree_code));
211 /* If non-NULL, the address of a language-specific function that takes
212 any action required right before expand_function_end is called. */
213 void (*lang_expand_function_end) PARAMS ((void));
215 /* If this variable is defined to a non-NULL value, it will be called
216 after the file has been completely parsed. */
217 void (*back_end_hook) PARAMS ((tree));
219 /* Nonzero means the expression being parsed will never be evaluated.
220 This is a count, since unevaluated expressions can nest. */
223 /* Information about how a function name is generated. */
226 tree *const decl; /* pointer to the VAR_DECL. */
227 const unsigned rid; /* RID number for the identifier. */
228 const int pretty; /* How pretty is it? */
231 /* The three ways of getting then name of the current function. */
233 const struct fname_var_t fname_vars[] =
235 /* C99 compliant __func__, must be first. */
236 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
237 /* GCC __FUNCTION__ compliant. */
238 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
239 /* GCC __PRETTY_FUNCTION__ compliant. */
240 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
244 static int constant_fits_type_p PARAMS ((tree, tree));
246 /* Keep a stack of if statements. We record the number of compound
247 statements seen up to the if keyword, as well as the line number
248 and file of the if. If a potentially ambiguous else is seen, that
249 fact is recorded; the warning is issued when we can be sure that
250 the enclosing if statement does not have an else branch. */
260 static if_elt *if_stack;
262 /* Amount of space in the if statement stack. */
263 static int if_stack_space = 0;
266 static int if_stack_pointer = 0;
268 /* Record the start of an if-then, and record the start of it
269 for ambiguous else detection. */
272 c_expand_start_cond (cond, compstmt_count)
278 /* Make sure there is enough space on the stack. */
279 if (if_stack_space == 0)
282 if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
284 else if (if_stack_space == if_stack_pointer)
286 if_stack_space += 10;
287 if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
290 if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
291 IF_COND (if_stmt) = cond;
294 /* Record this if statement. */
295 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
296 if_stack[if_stack_pointer].file = input_filename;
297 if_stack[if_stack_pointer].line = lineno;
298 if_stack[if_stack_pointer].needs_warning = 0;
299 if_stack[if_stack_pointer].if_stmt = if_stmt;
303 /* Called after the then-clause for an if-statement is processed. */
308 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
309 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
312 /* Record the end of an if-then. Optionally warn if a nested
313 if statement had an ambiguous else clause. */
319 if (if_stack[if_stack_pointer].needs_warning)
320 warning_with_file_and_line (if_stack[if_stack_pointer].file,
321 if_stack[if_stack_pointer].line,
322 "suggest explicit braces to avoid ambiguous `else'");
323 last_expr_type = NULL_TREE;
326 /* Called between the then-clause and the else-clause
327 of an if-then-else. */
330 c_expand_start_else ()
332 /* An ambiguous else warning must be generated for the enclosing if
333 statement, unless we see an else branch for that one, too. */
335 && if_stack_pointer > 1
336 && (if_stack[if_stack_pointer - 1].compstmt_count
337 == if_stack[if_stack_pointer - 2].compstmt_count))
338 if_stack[if_stack_pointer - 2].needs_warning = 1;
340 /* Even if a nested if statement had an else branch, it can't be
341 ambiguous if this one also has an else. So don't warn in that
342 case. Also don't warn for any if statements nested in this else. */
343 if_stack[if_stack_pointer - 1].needs_warning = 0;
344 if_stack[if_stack_pointer - 1].compstmt_count--;
347 /* Called after the else-clause for an if-statement is processed. */
352 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
353 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
356 /* Push current bindings for the function name VAR_DECLS. */
362 tree saved = NULL_TREE;
364 for (ix = 0; fname_vars[ix].decl; ix++)
366 tree decl = *fname_vars[ix].decl;
370 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
371 *fname_vars[ix].decl = NULL_TREE;
374 if (saved || saved_function_name_decls)
375 /* Normally they'll have been NULL, so only push if we've got a
376 stack, or they are non-NULL. */
377 saved_function_name_decls = tree_cons (saved, NULL_TREE,
378 saved_function_name_decls);
381 /* Finish up the current bindings, adding them into the
382 current function's statement tree. This is done by wrapping the
383 function's body in a COMPOUND_STMT containing these decls too. This
384 must be done _before_ finish_stmt_tree is called. If there is no
385 current function, we must be at file scope and no statements are
386 involved. Pop the previous bindings. */
389 finish_fname_decls ()
392 tree body = NULL_TREE;
393 tree stack = saved_function_name_decls;
395 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
396 body = chainon (TREE_VALUE (stack), body);
400 /* They were called into existence, so add to statement tree. */
401 body = chainon (body,
402 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
403 body = build_stmt (COMPOUND_STMT, body);
405 COMPOUND_STMT_NO_SCOPE (body) = 1;
406 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
409 for (ix = 0; fname_vars[ix].decl; ix++)
410 *fname_vars[ix].decl = NULL_TREE;
414 /* We had saved values, restore them. */
417 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
419 tree decl = TREE_PURPOSE (saved);
420 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
422 *fname_vars[ix].decl = decl;
424 stack = TREE_CHAIN (stack);
426 saved_function_name_decls = stack;
429 /* Return the text name of the current function, suitable prettified
433 fname_as_string (pretty_p)
436 const char *name = NULL;
439 name = (current_function_decl
440 ? (*decl_printable_name) (current_function_decl, 2)
442 else if (current_function_decl && DECL_NAME (current_function_decl))
443 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
449 /* Return the text name of the current function, formatted as
450 required by the supplied RID value. */
458 for (ix = 0; fname_vars[ix].decl; ix++)
459 if (fname_vars[ix].rid == rid)
461 return fname_as_string (fname_vars[ix].pretty);
464 /* Return the VAR_DECL for a const char array naming the current
465 function. If the VAR_DECL has not yet been created, create it
466 now. RID indicates how it should be formatted and IDENTIFIER_NODE
467 ID is its name (unfortunately C and C++ hold the RID values of
468 keywords in different places, so we can't derive RID from ID in
469 this language independent code. */
477 tree decl = NULL_TREE;
479 for (ix = 0; fname_vars[ix].decl; ix++)
480 if (fname_vars[ix].rid == rid)
483 decl = *fname_vars[ix].decl;
486 tree saved_last_tree = last_tree;
488 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
489 if (last_tree != saved_last_tree)
491 /* We created some statement tree for the decl. This belongs
492 at the start of the function, so remove it now and reinsert
493 it after the function is complete. */
494 tree stmts = TREE_CHAIN (saved_last_tree);
496 TREE_CHAIN (saved_last_tree) = NULL_TREE;
497 last_tree = saved_last_tree;
498 saved_function_name_decls = tree_cons (decl, stmts,
499 saved_function_name_decls);
501 *fname_vars[ix].decl = decl;
503 if (!ix && !current_function_decl)
504 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
509 /* Given a chain of STRING_CST nodes,
510 concatenate them into one STRING_CST
511 and give it a suitable array-of-chars data type. */
514 combine_strings (strings)
521 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
523 const int nchars_max = flag_isoc99 ? 4095 : 509;
525 if (TREE_CHAIN (strings))
527 /* More than one in the chain, so concatenate. */
530 /* Don't include the \0 at the end of each substring,
531 except for the last one.
532 Count wide strings and ordinary strings separately. */
533 for (t = strings; t; t = TREE_CHAIN (t))
535 if (TREE_TYPE (t) == wchar_array_type_node)
537 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
541 length += (TREE_STRING_LENGTH (t) - 1);
544 /* If anything is wide, the non-wides will be converted,
545 which makes them take more space. */
547 length = length * wchar_bytes + wide_length;
551 /* Copy the individual strings into the new combined string.
552 If the combined string is wide, convert the chars to ints
553 for any individual strings that are not wide. */
556 for (t = strings; t; t = TREE_CHAIN (t))
558 int len = (TREE_STRING_LENGTH (t)
559 - ((TREE_TYPE (t) == wchar_array_type_node)
561 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
563 memcpy (q, TREE_STRING_POINTER (t), len);
569 for (i = 0; i < len; i++)
571 if (BYTES_BIG_ENDIAN)
573 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
575 *q++ = TREE_STRING_POINTER (t)[i];
579 *q++ = TREE_STRING_POINTER (t)[i];
580 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
589 for (i = 0; i < wchar_bytes; i++)
595 value = build_string (length, p);
600 length = TREE_STRING_LENGTH (value);
601 if (TREE_TYPE (value) == wchar_array_type_node)
605 /* Compute the number of elements, for the array type. */
606 nchars = wide_flag ? length / wchar_bytes : length;
608 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
609 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
610 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
612 /* Create the array type for the string constant.
613 -Wwrite-strings says make the string constant an array of const char
614 so that copying it to a non-const pointer will get a warning.
615 For C++, this is the standard behavior. */
616 if (flag_const_strings
617 && (! flag_traditional && ! flag_writable_strings))
620 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
623 = build_array_type (elements,
624 build_index_type (build_int_2 (nchars - 1, 0)));
628 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
629 build_index_type (build_int_2 (nchars - 1, 0)));
631 TREE_CONSTANT (value) = 1;
632 TREE_READONLY (value) = ! flag_writable_strings;
633 TREE_STATIC (value) = 1;
637 static int is_valid_printf_arglist PARAMS ((tree));
638 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
639 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
640 enum expand_modifier, int));
641 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
642 enum expand_modifier, int));
644 /* Print a warning if a constant expression had overflow in folding.
645 Invoke this function on every expression that the language
646 requires to be a constant expression.
647 Note the ANSI C standard says it is erroneous for a
648 constant expression to overflow. */
651 constant_expression_warning (value)
654 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
655 || TREE_CODE (value) == COMPLEX_CST)
656 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
657 pedwarn ("overflow in constant expression");
660 /* Print a warning if an expression had overflow in folding.
661 Invoke this function on every expression that
662 (1) appears in the source code, and
663 (2) might be a constant expression that overflowed, and
664 (3) is not already checked by convert_and_check;
665 however, do not invoke this function on operands of explicit casts. */
668 overflow_warning (value)
671 if ((TREE_CODE (value) == INTEGER_CST
672 || (TREE_CODE (value) == COMPLEX_CST
673 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
674 && TREE_OVERFLOW (value))
676 TREE_OVERFLOW (value) = 0;
677 if (skip_evaluation == 0)
678 warning ("integer overflow in expression");
680 else if ((TREE_CODE (value) == REAL_CST
681 || (TREE_CODE (value) == COMPLEX_CST
682 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
683 && TREE_OVERFLOW (value))
685 TREE_OVERFLOW (value) = 0;
686 if (skip_evaluation == 0)
687 warning ("floating point overflow in expression");
691 /* Print a warning if a large constant is truncated to unsigned,
692 or if -Wconversion is used and a constant < 0 is converted to unsigned.
693 Invoke this function on every expression that might be implicitly
694 converted to an unsigned type. */
697 unsigned_conversion_warning (result, operand)
698 tree result, operand;
700 if (TREE_CODE (operand) == INTEGER_CST
701 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
702 && TREE_UNSIGNED (TREE_TYPE (result))
703 && skip_evaluation == 0
704 && !int_fits_type_p (operand, TREE_TYPE (result)))
706 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
707 /* This detects cases like converting -129 or 256 to unsigned char. */
708 warning ("large integer implicitly truncated to unsigned type");
709 else if (warn_conversion)
710 warning ("negative integer implicitly converted to unsigned type");
714 /* Nonzero if constant C has a value that is permissible
715 for type TYPE (an INTEGER_TYPE). */
718 constant_fits_type_p (c, type)
721 if (TREE_CODE (c) == INTEGER_CST)
722 return int_fits_type_p (c, type);
724 c = convert (type, c);
725 return !TREE_OVERFLOW (c);
728 /* Convert EXPR to TYPE, warning about conversion problems with constants.
729 Invoke this function on every expression that is converted implicitly,
730 i.e. because of language rules and not because of an explicit cast. */
733 convert_and_check (type, expr)
736 tree t = convert (type, expr);
737 if (TREE_CODE (t) == INTEGER_CST)
739 if (TREE_OVERFLOW (t))
741 TREE_OVERFLOW (t) = 0;
743 /* Do not diagnose overflow in a constant expression merely
744 because a conversion overflowed. */
745 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
747 /* No warning for converting 0x80000000 to int. */
748 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
749 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
750 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
751 /* If EXPR fits in the unsigned version of TYPE,
752 don't warn unless pedantic. */
754 || TREE_UNSIGNED (type)
755 || ! constant_fits_type_p (expr, unsigned_type (type)))
756 && skip_evaluation == 0)
757 warning ("overflow in implicit constant conversion");
760 unsigned_conversion_warning (t, expr);
765 /* A node in a list that describes references to variables (EXPR), which are
766 either read accesses if WRITER is zero, or write accesses, in which case
767 WRITER is the parent of EXPR. */
774 /* Used to implement a cache the results of a call to verify_tree. We only
775 use this for SAVE_EXPRs. */
778 struct tlist_cache *next;
779 struct tlist *cache_before_sp;
780 struct tlist *cache_after_sp;
784 /* Obstack to use when allocating tlist structures, and corresponding
786 static struct obstack tlist_obstack;
787 static char *tlist_firstobj = 0;
789 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
791 static struct tlist *warned_ids;
792 /* SAVE_EXPRs need special treatment. We process them only once and then
793 cache the results. */
794 static struct tlist_cache *save_expr_cache;
796 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
797 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
798 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
799 static int warning_candidate_p PARAMS ((tree));
800 static void warn_for_collisions PARAMS ((struct tlist *));
801 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
802 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
803 static void verify_sequence_points PARAMS ((tree));
805 /* Create a new struct tlist and fill in its fields. */
806 static struct tlist *
807 new_tlist (next, t, writer)
813 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
820 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
821 is nonnull, we ignore any node we find which has a writer equal to it. */
824 add_tlist (to, add, exclude_writer, copy)
832 struct tlist *next = add->next;
835 if (! exclude_writer || add->writer != exclude_writer)
836 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
841 /* Merge the nodes of ADD into TO. This merging process is done so that for
842 each variable that already exists in TO, no new node is added; however if
843 there is a write access recorded in ADD, and an occurrence on TO is only
844 a read access, then the occurrence in TO will be modified to record the
848 merge_tlist (to, add, copy)
853 struct tlist **end = to;
862 struct tlist *next = add->next;
864 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
865 if (tmp2->expr == add->expr)
869 tmp2->writer = add->writer;
873 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
881 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
882 references in list LIST conflict with it, excluding reads if ONLY writers
886 warn_for_collisions_1 (written, writer, list, only_writes)
887 tree written, writer;
893 /* Avoid duplicate warnings. */
894 for (tmp = warned_ids; tmp; tmp = tmp->next)
895 if (tmp->expr == written)
900 if (list->expr == written
901 && list->writer != writer
902 && (! only_writes || list->writer))
904 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
905 warning ("operation on `%s' may be undefined",
906 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
912 /* Given a list LIST of references to variables, find whether any of these
913 can cause conflicts due to missing sequence points. */
916 warn_for_collisions (list)
921 for (tmp = list; tmp; tmp = tmp->next)
924 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
928 /* Return nonzero if X is a tree that can be verified by the sequence point
931 warning_candidate_p (x)
934 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
937 /* Walk the tree X, and record accesses to variables. If X is written by the
938 parent tree, WRITER is the parent.
939 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
940 expression or its only operand forces a sequence point, then everything up
941 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
943 Once we return, we will have emitted warnings if any subexpression before
944 such a sequence point could be undefined. On a higher level, however, the
945 sequence point may not be relevant, and we'll merge the two lists.
947 Example: (b++, a) + b;
948 The call that processes the COMPOUND_EXPR will store the increment of B
949 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
950 processes the PLUS_EXPR will need to merge the two lists so that
951 eventually, all accesses end up on the same list (and we'll warn about the
952 unordered subexpressions b++ and b.
954 A note on merging. If we modify the former example so that our expression
957 care must be taken not simply to add all three expressions into the final
958 PNO_SP list. The function merge_tlist takes care of that by merging the
959 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
960 way, so that no more than one access to B is recorded. */
963 verify_tree (x, pbefore_sp, pno_sp, writer)
965 struct tlist **pbefore_sp, **pno_sp;
968 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
972 /* X may be NULL if it is the operand of an empty statement expression
978 code = TREE_CODE (x);
979 class = TREE_CODE_CLASS (code);
981 if (warning_candidate_p (x))
983 *pno_sp = new_tlist (*pno_sp, x, writer);
993 case TRUTH_ANDIF_EXPR:
994 case TRUTH_ORIF_EXPR:
995 tmp_before = tmp_nosp = tmp_list3 = 0;
996 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
997 warn_for_collisions (tmp_nosp);
998 merge_tlist (pbefore_sp, tmp_before, 0);
999 merge_tlist (pbefore_sp, tmp_nosp, 0);
1000 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1001 merge_tlist (pbefore_sp, tmp_list3, 0);
1005 tmp_before = tmp_list2 = 0;
1006 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1007 warn_for_collisions (tmp_list2);
1008 merge_tlist (pbefore_sp, tmp_before, 0);
1009 merge_tlist (pbefore_sp, tmp_list2, 1);
1011 tmp_list3 = tmp_nosp = 0;
1012 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1013 warn_for_collisions (tmp_nosp);
1014 merge_tlist (pbefore_sp, tmp_list3, 0);
1016 tmp_list3 = tmp_list2 = 0;
1017 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1018 warn_for_collisions (tmp_list2);
1019 merge_tlist (pbefore_sp, tmp_list3, 0);
1020 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1021 two first, to avoid warning for (a ? b++ : b++). */
1022 merge_tlist (&tmp_nosp, tmp_list2, 0);
1023 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1026 case PREDECREMENT_EXPR:
1027 case PREINCREMENT_EXPR:
1028 case POSTDECREMENT_EXPR:
1029 case POSTINCREMENT_EXPR:
1030 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1034 tmp_before = tmp_nosp = tmp_list3 = 0;
1035 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1036 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1037 /* Expressions inside the LHS are not ordered wrt. the sequence points
1038 in the RHS. Example:
1040 Despite the fact that the modification of "a" is in the before_sp
1041 list (tmp_before), it conflicts with the use of "a" in the LHS.
1042 We can handle this by adding the contents of tmp_list3
1043 to those of tmp_before, and redoing the collision warnings for that
1045 add_tlist (&tmp_before, tmp_list3, x, 1);
1046 warn_for_collisions (tmp_before);
1047 /* Exclude the LHS itself here; we first have to merge it into the
1048 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1049 didn't exclude the LHS, we'd get it twice, once as a read and once
1051 add_tlist (pno_sp, tmp_list3, x, 0);
1052 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1054 merge_tlist (pbefore_sp, tmp_before, 0);
1055 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1056 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1057 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1061 /* We need to warn about conflicts among arguments and conflicts between
1062 args and the function address. Side effects of the function address,
1063 however, are not ordered by the sequence point of the call. */
1064 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1065 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1066 if (TREE_OPERAND (x, 1))
1067 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1068 merge_tlist (&tmp_list3, tmp_list2, 0);
1069 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1070 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1071 warn_for_collisions (tmp_before);
1072 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1076 /* Scan all the list, e.g. indices of multi dimensional array. */
1079 tmp_before = tmp_nosp = 0;
1080 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1081 merge_tlist (&tmp_nosp, tmp_before, 0);
1082 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1089 struct tlist_cache *t;
1090 for (t = save_expr_cache; t; t = t->next)
1096 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1098 t->next = save_expr_cache;
1100 save_expr_cache = t;
1102 tmp_before = tmp_nosp = 0;
1103 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1104 warn_for_collisions (tmp_nosp);
1109 struct tlist *t = tmp_nosp;
1111 merge_tlist (&tmp_list3, t, 0);
1113 t->cache_before_sp = tmp_before;
1114 t->cache_after_sp = tmp_list3;
1116 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1117 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1126 if (first_rtl_op (code) == 0)
1128 x = TREE_OPERAND (x, 0);
1144 int max = first_rtl_op (TREE_CODE (x));
1145 for (lp = 0; lp < max; lp++)
1147 tmp_before = tmp_nosp = 0;
1148 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1149 merge_tlist (&tmp_nosp, tmp_before, 0);
1150 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1157 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1161 verify_sequence_points (expr)
1164 struct tlist *before_sp = 0, *after_sp = 0;
1167 save_expr_cache = 0;
1168 if (tlist_firstobj == 0)
1170 gcc_obstack_init (&tlist_obstack);
1171 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1174 verify_tree (expr, &before_sp, &after_sp, 0);
1175 warn_for_collisions (after_sp);
1176 obstack_free (&tlist_obstack, tlist_firstobj);
1180 c_expand_expr_stmt (expr)
1183 /* Do default conversion if safe and possibly important,
1184 in case within ({...}). */
1185 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1186 && (flag_isoc99 || lvalue_p (expr)))
1187 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1188 expr = default_conversion (expr);
1190 if (warn_sequence_point)
1191 verify_sequence_points (expr);
1193 if (TREE_TYPE (expr) != error_mark_node
1194 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1195 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1196 error ("expression statement has incomplete type");
1198 last_expr_type = TREE_TYPE (expr);
1199 return add_stmt (build_stmt (EXPR_STMT, expr));
1202 /* Validate the expression after `case' and apply default promotions. */
1205 check_case_value (value)
1208 if (value == NULL_TREE)
1211 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1212 STRIP_TYPE_NOPS (value);
1213 /* In C++, the following is allowed:
1216 switch (...) { case i: ... }
1218 So, we try to reduce the VALUE to a constant that way. */
1219 if (c_language == clk_cplusplus)
1221 value = decl_constant_value (value);
1222 STRIP_TYPE_NOPS (value);
1223 value = fold (value);
1226 if (TREE_CODE (value) != INTEGER_CST
1227 && value != error_mark_node)
1229 error ("case label does not reduce to an integer constant");
1230 value = error_mark_node;
1233 /* Promote char or short to int. */
1234 value = default_conversion (value);
1236 constant_expression_warning (value);
1241 /* Return an integer type with BITS bits of precision,
1242 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1245 type_for_size (bits, unsignedp)
1249 if (bits == TYPE_PRECISION (integer_type_node))
1250 return unsignedp ? unsigned_type_node : integer_type_node;
1252 if (bits == TYPE_PRECISION (signed_char_type_node))
1253 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1255 if (bits == TYPE_PRECISION (short_integer_type_node))
1256 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1258 if (bits == TYPE_PRECISION (long_integer_type_node))
1259 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1261 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1262 return (unsignedp ? long_long_unsigned_type_node
1263 : long_long_integer_type_node);
1265 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1266 return (unsignedp ? widest_unsigned_literal_type_node
1267 : widest_integer_literal_type_node);
1269 if (bits <= TYPE_PRECISION (intQI_type_node))
1270 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1272 if (bits <= TYPE_PRECISION (intHI_type_node))
1273 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1275 if (bits <= TYPE_PRECISION (intSI_type_node))
1276 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1278 if (bits <= TYPE_PRECISION (intDI_type_node))
1279 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1284 /* Return a data type that has machine mode MODE.
1285 If the mode is an integer,
1286 then UNSIGNEDP selects between signed and unsigned types. */
1289 type_for_mode (mode, unsignedp)
1290 enum machine_mode mode;
1293 if (mode == TYPE_MODE (integer_type_node))
1294 return unsignedp ? unsigned_type_node : integer_type_node;
1296 if (mode == TYPE_MODE (signed_char_type_node))
1297 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1299 if (mode == TYPE_MODE (short_integer_type_node))
1300 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1302 if (mode == TYPE_MODE (long_integer_type_node))
1303 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1305 if (mode == TYPE_MODE (long_long_integer_type_node))
1306 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1308 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1309 return unsignedp ? widest_unsigned_literal_type_node
1310 : widest_integer_literal_type_node;
1312 if (mode == TYPE_MODE (intQI_type_node))
1313 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1315 if (mode == TYPE_MODE (intHI_type_node))
1316 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1318 if (mode == TYPE_MODE (intSI_type_node))
1319 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1321 if (mode == TYPE_MODE (intDI_type_node))
1322 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1324 #if HOST_BITS_PER_WIDE_INT >= 64
1325 if (mode == TYPE_MODE (intTI_type_node))
1326 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1329 if (mode == TYPE_MODE (float_type_node))
1330 return float_type_node;
1332 if (mode == TYPE_MODE (double_type_node))
1333 return double_type_node;
1335 if (mode == TYPE_MODE (long_double_type_node))
1336 return long_double_type_node;
1338 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1339 return build_pointer_type (char_type_node);
1341 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1342 return build_pointer_type (integer_type_node);
1344 #ifdef VECTOR_MODE_SUPPORTED_P
1345 if (mode == TYPE_MODE (V16QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1346 return V16QI_type_node;
1347 if (mode == TYPE_MODE (V8HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1348 return V8HI_type_node;
1349 if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1350 return V4SF_type_node;
1351 if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1352 return V4SI_type_node;
1353 if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1354 return V2SI_type_node;
1355 if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1356 return V4HI_type_node;
1357 if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1358 return V8QI_type_node;
1359 if (mode == TYPE_MODE (V2SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1360 return V2SF_type_node;
1366 /* Return an unsigned type the same as TYPE in other respects. */
1368 unsigned_type (type)
1371 tree type1 = TYPE_MAIN_VARIANT (type);
1372 if (type1 == signed_char_type_node || type1 == char_type_node)
1373 return unsigned_char_type_node;
1374 if (type1 == integer_type_node)
1375 return unsigned_type_node;
1376 if (type1 == short_integer_type_node)
1377 return short_unsigned_type_node;
1378 if (type1 == long_integer_type_node)
1379 return long_unsigned_type_node;
1380 if (type1 == long_long_integer_type_node)
1381 return long_long_unsigned_type_node;
1382 if (type1 == widest_integer_literal_type_node)
1383 return widest_unsigned_literal_type_node;
1384 #if HOST_BITS_PER_WIDE_INT >= 64
1385 if (type1 == intTI_type_node)
1386 return unsigned_intTI_type_node;
1388 if (type1 == intDI_type_node)
1389 return unsigned_intDI_type_node;
1390 if (type1 == intSI_type_node)
1391 return unsigned_intSI_type_node;
1392 if (type1 == intHI_type_node)
1393 return unsigned_intHI_type_node;
1394 if (type1 == intQI_type_node)
1395 return unsigned_intQI_type_node;
1397 return signed_or_unsigned_type (1, type);
1400 /* Return a signed type the same as TYPE in other respects. */
1406 tree type1 = TYPE_MAIN_VARIANT (type);
1407 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1408 return signed_char_type_node;
1409 if (type1 == unsigned_type_node)
1410 return integer_type_node;
1411 if (type1 == short_unsigned_type_node)
1412 return short_integer_type_node;
1413 if (type1 == long_unsigned_type_node)
1414 return long_integer_type_node;
1415 if (type1 == long_long_unsigned_type_node)
1416 return long_long_integer_type_node;
1417 if (type1 == widest_unsigned_literal_type_node)
1418 return widest_integer_literal_type_node;
1419 #if HOST_BITS_PER_WIDE_INT >= 64
1420 if (type1 == unsigned_intTI_type_node)
1421 return intTI_type_node;
1423 if (type1 == unsigned_intDI_type_node)
1424 return intDI_type_node;
1425 if (type1 == unsigned_intSI_type_node)
1426 return intSI_type_node;
1427 if (type1 == unsigned_intHI_type_node)
1428 return intHI_type_node;
1429 if (type1 == unsigned_intQI_type_node)
1430 return intQI_type_node;
1432 return signed_or_unsigned_type (0, type);
1435 /* Return a type the same as TYPE except unsigned or
1436 signed according to UNSIGNEDP. */
1439 signed_or_unsigned_type (unsignedp, type)
1443 if (! INTEGRAL_TYPE_P (type)
1444 || TREE_UNSIGNED (type) == unsignedp)
1447 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1448 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1449 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1450 return unsignedp ? unsigned_type_node : integer_type_node;
1451 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1452 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1453 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1454 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1455 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1456 return (unsignedp ? long_long_unsigned_type_node
1457 : long_long_integer_type_node);
1458 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1459 return (unsignedp ? widest_unsigned_literal_type_node
1460 : widest_integer_literal_type_node);
1462 #if HOST_BITS_PER_WIDE_INT >= 64
1463 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1464 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1466 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1467 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1468 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1469 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1470 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1471 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1472 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1473 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1478 /* Return the minimum number of bits needed to represent VALUE in a
1479 signed or unsigned type, UNSIGNEDP says which. */
1482 min_precision (value, unsignedp)
1488 /* If the value is negative, compute its negative minus 1. The latter
1489 adjustment is because the absolute value of the largest negative value
1490 is one larger than the largest positive value. This is equivalent to
1491 a bit-wise negation, so use that operation instead. */
1493 if (tree_int_cst_sgn (value) < 0)
1494 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1496 /* Return the number of bits needed, taking into account the fact
1497 that we need one more bit for a signed than unsigned type. */
1499 if (integer_zerop (value))
1502 log = tree_floor_log2 (value);
1504 return log + 1 + ! unsignedp;
1507 /* Print an error message for invalid operands to arith operation CODE.
1508 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1511 binary_op_error (code)
1512 enum tree_code code;
1519 error ("invalid truth-value expression");
1523 opname = "+"; break;
1525 opname = "-"; break;
1527 opname = "*"; break;
1529 opname = "max"; break;
1531 opname = "min"; break;
1533 opname = "=="; break;
1535 opname = "!="; break;
1537 opname = "<="; break;
1539 opname = ">="; break;
1541 opname = "<"; break;
1543 opname = ">"; break;
1545 opname = "<<"; break;
1547 opname = ">>"; break;
1548 case TRUNC_MOD_EXPR:
1549 case FLOOR_MOD_EXPR:
1550 opname = "%"; break;
1551 case TRUNC_DIV_EXPR:
1552 case FLOOR_DIV_EXPR:
1553 opname = "/"; break;
1555 opname = "&"; break;
1557 opname = "|"; break;
1558 case TRUTH_ANDIF_EXPR:
1559 opname = "&&"; break;
1560 case TRUTH_ORIF_EXPR:
1561 opname = "||"; break;
1563 opname = "^"; break;
1566 opname = "rotate"; break;
1568 opname = "unknown"; break;
1570 error ("invalid operands to binary %s", opname);
1573 /* Subroutine of build_binary_op, used for comparison operations.
1574 See if the operands have both been converted from subword integer types
1575 and, if so, perhaps change them both back to their original type.
1576 This function is also responsible for converting the two operands
1577 to the proper common type for comparison.
1579 The arguments of this function are all pointers to local variables
1580 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1581 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1583 If this function returns nonzero, it means that the comparison has
1584 a constant value. What this function returns is an expression for
1588 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1589 tree *op0_ptr, *op1_ptr;
1591 enum tree_code *rescode_ptr;
1594 tree op0 = *op0_ptr;
1595 tree op1 = *op1_ptr;
1596 int unsignedp0, unsignedp1;
1598 tree primop0, primop1;
1599 enum tree_code code = *rescode_ptr;
1601 /* Throw away any conversions to wider types
1602 already present in the operands. */
1604 primop0 = get_narrower (op0, &unsignedp0);
1605 primop1 = get_narrower (op1, &unsignedp1);
1607 /* Handle the case that OP0 does not *contain* a conversion
1608 but it *requires* conversion to FINAL_TYPE. */
1610 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1611 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1612 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1613 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1615 /* If one of the operands must be floated, we cannot optimize. */
1616 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1617 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1619 /* If first arg is constant, swap the args (changing operation
1620 so value is preserved), for canonicalization. Don't do this if
1621 the second arg is 0. */
1623 if (TREE_CONSTANT (primop0)
1624 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1627 int temi = unsignedp0;
1635 unsignedp0 = unsignedp1;
1658 *rescode_ptr = code;
1661 /* If comparing an integer against a constant more bits wide,
1662 maybe we can deduce a value of 1 or 0 independent of the data.
1663 Or else truncate the constant now
1664 rather than extend the variable at run time.
1666 This is only interesting if the constant is the wider arg.
1667 Also, it is not safe if the constant is unsigned and the
1668 variable arg is signed, since in this case the variable
1669 would be sign-extended and then regarded as unsigned.
1670 Our technique fails in this case because the lowest/highest
1671 possible unsigned results don't follow naturally from the
1672 lowest/highest possible values of the variable operand.
1673 For just EQ_EXPR and NE_EXPR there is another technique that
1674 could be used: see if the constant can be faithfully represented
1675 in the other operand's type, by truncating it and reextending it
1676 and see if that preserves the constant's value. */
1678 if (!real1 && !real2
1679 && TREE_CODE (primop1) == INTEGER_CST
1680 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1682 int min_gt, max_gt, min_lt, max_lt;
1683 tree maxval, minval;
1684 /* 1 if comparison is nominally unsigned. */
1685 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1688 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1690 /* If TYPE is an enumeration, then we need to get its min/max
1691 values from it's underlying integral type, not the enumerated
1693 if (TREE_CODE (type) == ENUMERAL_TYPE)
1694 type = type_for_size (TYPE_PRECISION (type), unsignedp0);
1696 maxval = TYPE_MAX_VALUE (type);
1697 minval = TYPE_MIN_VALUE (type);
1699 if (unsignedp && !unsignedp0)
1700 *restype_ptr = signed_type (*restype_ptr);
1702 if (TREE_TYPE (primop1) != *restype_ptr)
1703 primop1 = convert (*restype_ptr, primop1);
1704 if (type != *restype_ptr)
1706 minval = convert (*restype_ptr, minval);
1707 maxval = convert (*restype_ptr, maxval);
1710 if (unsignedp && unsignedp0)
1712 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1713 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1714 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1715 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1719 min_gt = INT_CST_LT (primop1, minval);
1720 max_gt = INT_CST_LT (primop1, maxval);
1721 min_lt = INT_CST_LT (minval, primop1);
1722 max_lt = INT_CST_LT (maxval, primop1);
1726 /* This used to be a switch, but Genix compiler can't handle that. */
1727 if (code == NE_EXPR)
1729 if (max_lt || min_gt)
1730 val = boolean_true_node;
1732 else if (code == EQ_EXPR)
1734 if (max_lt || min_gt)
1735 val = boolean_false_node;
1737 else if (code == LT_EXPR)
1740 val = boolean_true_node;
1742 val = boolean_false_node;
1744 else if (code == GT_EXPR)
1747 val = boolean_true_node;
1749 val = boolean_false_node;
1751 else if (code == LE_EXPR)
1754 val = boolean_true_node;
1756 val = boolean_false_node;
1758 else if (code == GE_EXPR)
1761 val = boolean_true_node;
1763 val = boolean_false_node;
1766 /* If primop0 was sign-extended and unsigned comparison specd,
1767 we did a signed comparison above using the signed type bounds.
1768 But the comparison we output must be unsigned.
1770 Also, for inequalities, VAL is no good; but if the signed
1771 comparison had *any* fixed result, it follows that the
1772 unsigned comparison just tests the sign in reverse
1773 (positive values are LE, negative ones GE).
1774 So we can generate an unsigned comparison
1775 against an extreme value of the signed type. */
1777 if (unsignedp && !unsignedp0)
1784 primop1 = TYPE_MIN_VALUE (type);
1790 primop1 = TYPE_MAX_VALUE (type);
1797 type = unsigned_type (type);
1800 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1802 /* This is the case of (char)x >?< 0x80, which people used to use
1803 expecting old C compilers to change the 0x80 into -0x80. */
1804 if (val == boolean_false_node)
1805 warning ("comparison is always false due to limited range of data type");
1806 if (val == boolean_true_node)
1807 warning ("comparison is always true due to limited range of data type");
1810 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1812 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1813 if (val == boolean_false_node)
1814 warning ("comparison is always false due to limited range of data type");
1815 if (val == boolean_true_node)
1816 warning ("comparison is always true due to limited range of data type");
1821 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1822 if (TREE_SIDE_EFFECTS (primop0))
1823 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1827 /* Value is not predetermined, but do the comparison
1828 in the type of the operand that is not constant.
1829 TYPE is already properly set. */
1831 else if (real1 && real2
1832 && (TYPE_PRECISION (TREE_TYPE (primop0))
1833 == TYPE_PRECISION (TREE_TYPE (primop1))))
1834 type = TREE_TYPE (primop0);
1836 /* If args' natural types are both narrower than nominal type
1837 and both extend in the same manner, compare them
1838 in the type of the wider arg.
1839 Otherwise must actually extend both to the nominal
1840 common type lest different ways of extending
1842 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1844 else if (unsignedp0 == unsignedp1 && real1 == real2
1845 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1846 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1848 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1849 type = signed_or_unsigned_type (unsignedp0
1850 || TREE_UNSIGNED (*restype_ptr),
1852 /* Make sure shorter operand is extended the right way
1853 to match the longer operand. */
1854 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1856 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1861 /* Here we must do the comparison on the nominal type
1862 using the args exactly as we received them. */
1863 type = *restype_ptr;
1867 if (!real1 && !real2 && integer_zerop (primop1)
1868 && TREE_UNSIGNED (*restype_ptr))
1874 /* All unsigned values are >= 0, so we warn if extra warnings
1875 are requested. However, if OP0 is a constant that is
1876 >= 0, the signedness of the comparison isn't an issue,
1877 so suppress the warning. */
1878 if (extra_warnings && !in_system_header
1879 && ! (TREE_CODE (primop0) == INTEGER_CST
1880 && ! TREE_OVERFLOW (convert (signed_type (type),
1882 warning ("comparison of unsigned expression >= 0 is always true");
1883 value = boolean_true_node;
1887 if (extra_warnings && !in_system_header
1888 && ! (TREE_CODE (primop0) == INTEGER_CST
1889 && ! TREE_OVERFLOW (convert (signed_type (type),
1891 warning ("comparison of unsigned expression < 0 is always false");
1892 value = boolean_false_node;
1901 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1902 if (TREE_SIDE_EFFECTS (primop0))
1903 return build (COMPOUND_EXPR, TREE_TYPE (value),
1910 *op0_ptr = convert (type, primop0);
1911 *op1_ptr = convert (type, primop1);
1913 *restype_ptr = boolean_type_node;
1918 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1919 or validate its data type for an `if' or `while' statement or ?..: exp.
1921 This preparation consists of taking the ordinary
1922 representation of an expression expr and producing a valid tree
1923 boolean expression describing whether expr is nonzero. We could
1924 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1925 but we optimize comparisons, &&, ||, and !.
1927 The resulting type should always be `boolean_type_node'. */
1930 truthvalue_conversion (expr)
1933 if (TREE_CODE (expr) == ERROR_MARK)
1936 #if 0 /* This appears to be wrong for C++. */
1937 /* These really should return error_mark_node after 2.4 is stable.
1938 But not all callers handle ERROR_MARK properly. */
1939 switch (TREE_CODE (TREE_TYPE (expr)))
1942 error ("struct type value used where scalar is required");
1943 return boolean_false_node;
1946 error ("union type value used where scalar is required");
1947 return boolean_false_node;
1950 error ("array type value used where scalar is required");
1951 return boolean_false_node;
1958 switch (TREE_CODE (expr))
1961 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1962 case TRUTH_ANDIF_EXPR:
1963 case TRUTH_ORIF_EXPR:
1964 case TRUTH_AND_EXPR:
1966 case TRUTH_XOR_EXPR:
1967 case TRUTH_NOT_EXPR:
1968 TREE_TYPE (expr) = boolean_type_node;
1975 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
1978 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
1981 /* If we are taking the address of an external decl, it might be zero
1982 if it is weak, so we cannot optimize. */
1983 if (DECL_P (TREE_OPERAND (expr, 0))
1984 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
1987 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
1988 return build (COMPOUND_EXPR, boolean_type_node,
1989 TREE_OPERAND (expr, 0), boolean_true_node);
1991 return boolean_true_node;
1994 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
1995 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
1996 truthvalue_conversion (TREE_OPERAND (expr, 0)),
1997 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2004 /* These don't change whether an object is non-zero or zero. */
2005 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2009 /* These don't change whether an object is zero or non-zero, but
2010 we can't ignore them if their second arg has side-effects. */
2011 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2012 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2013 truthvalue_conversion (TREE_OPERAND (expr, 0)));
2015 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2018 /* Distribute the conversion into the arms of a COND_EXPR. */
2019 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2020 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2021 truthvalue_conversion (TREE_OPERAND (expr, 2))));
2024 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2025 since that affects how `default_conversion' will behave. */
2026 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2027 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2029 /* fall through... */
2031 /* If this is widening the argument, we can ignore it. */
2032 if (TYPE_PRECISION (TREE_TYPE (expr))
2033 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2034 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2038 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2040 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2041 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2043 /* fall through... */
2045 /* This and MINUS_EXPR can be changed into a comparison of the
2047 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2048 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2049 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2050 TREE_OPERAND (expr, 1), 1);
2051 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2052 fold (build1 (NOP_EXPR,
2053 TREE_TYPE (TREE_OPERAND (expr, 0)),
2054 TREE_OPERAND (expr, 1))), 1);
2057 if (integer_onep (TREE_OPERAND (expr, 1))
2058 && TREE_TYPE (expr) != boolean_type_node)
2059 /* Using convert here would cause infinite recursion. */
2060 return build1 (NOP_EXPR, boolean_type_node, expr);
2064 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2065 warning ("suggest parentheses around assignment used as truth value");
2072 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2074 tree tem = save_expr (expr);
2075 return (build_binary_op
2076 ((TREE_SIDE_EFFECTS (expr)
2077 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2078 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2079 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2083 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2086 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2087 int, enum built_in_class, int, int,
2090 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2091 down to the element type of an array. */
2094 c_build_qualified_type (type, type_quals)
2098 /* A restrict-qualified pointer type must be a pointer to object or
2099 incomplete type. Note that the use of POINTER_TYPE_P also allows
2100 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2101 the C++ front-end also use POINTER_TYPE for pointer-to-member
2102 values, so even though it should be illegal to use `restrict'
2103 with such an entity we don't flag that here. Thus, special case
2104 code for that case is required in the C++ front-end. */
2105 if ((type_quals & TYPE_QUAL_RESTRICT)
2106 && (!POINTER_TYPE_P (type)
2107 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2109 error ("invalid use of `restrict'");
2110 type_quals &= ~TYPE_QUAL_RESTRICT;
2113 if (TREE_CODE (type) == ARRAY_TYPE)
2114 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2116 TYPE_DOMAIN (type));
2117 return build_qualified_type (type, type_quals);
2120 /* Apply the TYPE_QUALS to the new DECL. */
2123 c_apply_type_quals_to_decl (type_quals, decl)
2127 if ((type_quals & TYPE_QUAL_CONST)
2128 || (TREE_TYPE (decl)
2129 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2130 TREE_READONLY (decl) = 1;
2131 if (type_quals & TYPE_QUAL_VOLATILE)
2133 TREE_SIDE_EFFECTS (decl) = 1;
2134 TREE_THIS_VOLATILE (decl) = 1;
2136 if (type_quals & TYPE_QUAL_RESTRICT)
2138 if (!TREE_TYPE (decl)
2139 || !POINTER_TYPE_P (TREE_TYPE (decl))
2140 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2141 error ("invalid use of `restrict'");
2142 else if (flag_strict_aliasing)
2143 /* Indicate we need to make a unique alias set for this pointer.
2144 We can't do it here because it might be pointing to an
2146 DECL_POINTER_ALIAS_SET (decl) = -2;
2151 /* Return the typed-based alias set for T, which may be an expression
2152 or a type. Return -1 if we don't do anything special. */
2155 c_common_get_alias_set (t)
2160 /* We know nothing about vector types */
2161 if (TREE_CODE (t) == VECTOR_TYPE)
2164 /* Permit type-punning when accessing a union, provided the access
2165 is directly through the union. For example, this code does not
2166 permit taking the address of a union member and then storing
2167 through it. Even the type-punning allowed here is a GCC
2168 extension, albeit a common and useful one; the C standard says
2169 that such accesses have implementation-defined behavior. */
2171 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2172 u = TREE_OPERAND (u, 0))
2173 if (TREE_CODE (u) == COMPONENT_REF
2174 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2177 /* If this is a char *, the ANSI C standard says it can alias
2178 anything. Note that all references need do this. */
2179 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2180 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2181 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2184 /* That's all the expressions we handle specially. */
2188 /* The C standard specifically allows aliasing between signed and
2189 unsigned variants of the same type. We treat the signed
2190 variant as canonical. */
2191 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2193 tree t1 = signed_type (t);
2195 /* t1 == t can happen for boolean nodes which are always unsigned. */
2197 return get_alias_set (t1);
2199 else if (POINTER_TYPE_P (t))
2203 /* Unfortunately, there is no canonical form of a pointer type.
2204 In particular, if we have `typedef int I', then `int *', and
2205 `I *' are different types. So, we have to pick a canonical
2206 representative. We do this below.
2208 Technically, this approach is actually more conservative that
2209 it needs to be. In particular, `const int *' and `int *'
2210 should be in different alias sets, according to the C and C++
2211 standard, since their types are not the same, and so,
2212 technically, an `int **' and `const int **' cannot point at
2215 But, the standard is wrong. In particular, this code is
2220 const int* const* cipp = &ipp;
2222 And, it doesn't make sense for that to be legal unless you
2223 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2224 the pointed-to types. This issue has been reported to the
2226 t1 = build_type_no_quals (t);
2228 return get_alias_set (t1);
2234 /* Implement the __alignof keyword: Return the minimum required
2235 alignment of TYPE, measured in bytes. */
2241 enum tree_code code = TREE_CODE (type);
2244 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2245 if (code == REFERENCE_TYPE)
2247 type = TREE_TYPE (type);
2248 code = TREE_CODE (type);
2251 if (code == FUNCTION_TYPE)
2252 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2253 else if (code == VOID_TYPE || code == ERROR_MARK)
2255 else if (!COMPLETE_TYPE_P (type))
2257 error ("__alignof__ applied to an incomplete type");
2261 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2263 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2266 /* Implement the __alignof keyword: Return the minimum required
2267 alignment of EXPR, measured in bytes. For VAR_DECL's and
2268 FIELD_DECL's return DECL_ALIGN (which can be set from an
2269 "aligned" __attribute__ specification). */
2272 c_alignof_expr (expr)
2277 if (TREE_CODE (expr) == VAR_DECL)
2278 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2280 else if (TREE_CODE (expr) == COMPONENT_REF
2281 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2283 error ("`__alignof' applied to a bit-field");
2286 else if (TREE_CODE (expr) == COMPONENT_REF
2287 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2288 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2290 else if (TREE_CODE (expr) == INDIRECT_REF)
2292 tree t = TREE_OPERAND (expr, 0);
2294 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2296 while (TREE_CODE (t) == NOP_EXPR
2297 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2301 t = TREE_OPERAND (t, 0);
2302 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2303 if (thisalign > bestalign)
2304 best = t, bestalign = thisalign;
2306 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2309 return c_alignof (TREE_TYPE (expr));
2311 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2314 /* Give the specifications for the format attributes, used by C and all
2317 static const struct attribute_spec c_format_attribute_table[] =
2319 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2320 { "format", 3, 3, false, true, true,
2321 handle_format_attribute },
2322 { "format_arg", 1, 1, false, true, true,
2323 handle_format_arg_attribute },
2324 { NULL, 0, 0, false, false, false, NULL }
2327 /* Build tree nodes and builtin functions common to both C and C++ language
2331 c_common_nodes_and_builtins ()
2335 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2336 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2337 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2338 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2339 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2340 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2341 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2342 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2343 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2344 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2345 #include "builtin-types.def"
2346 #undef DEF_PRIMITIVE_TYPE
2347 #undef DEF_FUNCTION_TYPE_0
2348 #undef DEF_FUNCTION_TYPE_1
2349 #undef DEF_FUNCTION_TYPE_2
2350 #undef DEF_FUNCTION_TYPE_3
2351 #undef DEF_FUNCTION_TYPE_4
2352 #undef DEF_FUNCTION_TYPE_VAR_0
2353 #undef DEF_FUNCTION_TYPE_VAR_1
2354 #undef DEF_FUNCTION_TYPE_VAR_2
2355 #undef DEF_POINTER_TYPE
2359 typedef enum builtin_type builtin_type;
2361 tree builtin_types[(int)BT_LAST];
2362 int wchar_type_size;
2363 tree array_domain_type;
2364 /* Either char* or void*. */
2365 tree traditional_ptr_type_node;
2366 /* Either const char* or const void*. */
2367 tree traditional_cptr_type_node;
2368 tree traditional_len_type_node;
2369 tree va_list_ref_type_node;
2370 tree va_list_arg_type_node;
2372 /* We must initialize this before any builtin functions (which might have
2373 attributes) are declared. (c_common_lang_init is too late.) */
2374 format_attribute_table = c_format_attribute_table;
2376 /* Define `int' and `char' first so that dbx will output them first. */
2377 record_builtin_type (RID_INT, NULL, integer_type_node);
2378 record_builtin_type (RID_CHAR, "char", char_type_node);
2380 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2381 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2382 but not C. Are the conditionals here needed? */
2383 if (c_language == clk_cplusplus)
2384 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2385 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2386 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2387 record_builtin_type (RID_MAX, "long unsigned int",
2388 long_unsigned_type_node);
2389 if (c_language == clk_cplusplus)
2390 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2391 record_builtin_type (RID_MAX, "long long int",
2392 long_long_integer_type_node);
2393 record_builtin_type (RID_MAX, "long long unsigned int",
2394 long_long_unsigned_type_node);
2395 if (c_language == clk_cplusplus)
2396 record_builtin_type (RID_MAX, "long long unsigned",
2397 long_long_unsigned_type_node);
2398 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2399 record_builtin_type (RID_MAX, "short unsigned int",
2400 short_unsigned_type_node);
2401 if (c_language == clk_cplusplus)
2402 record_builtin_type (RID_MAX, "unsigned short",
2403 short_unsigned_type_node);
2405 /* Define both `signed char' and `unsigned char'. */
2406 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2407 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2409 /* These are types that type_for_size and type_for_mode use. */
2410 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2411 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2412 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2413 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2414 #if HOST_BITS_PER_WIDE_INT >= 64
2415 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2417 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2418 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2419 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2420 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2421 #if HOST_BITS_PER_WIDE_INT >= 64
2422 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2425 /* Create the widest literal types. */
2426 widest_integer_literal_type_node
2427 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2428 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2429 widest_integer_literal_type_node));
2431 widest_unsigned_literal_type_node
2432 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2433 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2434 widest_unsigned_literal_type_node));
2436 /* `unsigned long' is the standard type for sizeof.
2437 Note that stddef.h uses `unsigned long',
2438 and this must agree, even if long and int are the same size. */
2440 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2441 signed_size_type_node = signed_type (c_size_type_node);
2442 if (flag_traditional)
2443 c_size_type_node = signed_size_type_node;
2444 set_sizetype (c_size_type_node);
2446 build_common_tree_nodes_2 (flag_short_double);
2448 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2449 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2450 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2452 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2453 complex_integer_type_node));
2454 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2455 complex_float_type_node));
2456 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2457 complex_double_type_node));
2458 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2459 complex_long_double_type_node));
2461 record_builtin_type (RID_VOID, NULL, void_type_node);
2463 void_zero_node = build_int_2 (0, 0);
2464 TREE_TYPE (void_zero_node) = void_type_node;
2466 void_list_node = build_void_list_node ();
2468 /* Make a type to be the domain of a few array types
2469 whose domains don't really matter.
2470 200 is small enough that it always fits in size_t
2471 and large enough that it can hold most function names for the
2472 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2473 array_domain_type = build_index_type (size_int (200));
2475 /* Make a type for arrays of characters.
2476 With luck nothing will ever really depend on the length of this
2478 char_array_type_node
2479 = build_array_type (char_type_node, array_domain_type);
2481 /* Likewise for arrays of ints. */
2483 = build_array_type (integer_type_node, array_domain_type);
2485 string_type_node = build_pointer_type (char_type_node);
2486 const_string_type_node
2487 = build_pointer_type (build_qualified_type
2488 (char_type_node, TYPE_QUAL_CONST));
2490 traditional_ptr_type_node = ((flag_traditional &&
2491 c_language != clk_cplusplus)
2492 ? string_type_node : ptr_type_node);
2493 traditional_cptr_type_node = ((flag_traditional &&
2494 c_language != clk_cplusplus)
2495 ? const_string_type_node : const_ptr_type_node);
2497 (*targetm.init_builtins) ();
2499 /* This is special for C++ so functions can be overloaded. */
2500 wchar_type_node = get_identifier (flag_short_wchar
2501 ? "short unsigned int"
2503 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2504 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2505 if (c_language == clk_cplusplus)
2507 if (TREE_UNSIGNED (wchar_type_node))
2508 wchar_type_node = make_unsigned_type (wchar_type_size);
2510 wchar_type_node = make_signed_type (wchar_type_size);
2511 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2515 signed_wchar_type_node = signed_type (wchar_type_node);
2516 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2519 /* This is for wide string constants. */
2520 wchar_array_type_node
2521 = build_array_type (wchar_type_node, array_domain_type);
2524 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2527 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2529 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2531 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2533 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2534 unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2536 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2537 va_list_type_node));
2539 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2540 ptrdiff_type_node));
2542 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2545 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2547 va_list_arg_type_node = va_list_ref_type_node =
2548 build_pointer_type (TREE_TYPE (va_list_type_node));
2552 va_list_arg_type_node = va_list_type_node;
2553 va_list_ref_type_node = build_reference_type (va_list_type_node);
2556 traditional_len_type_node = ((flag_traditional &&
2557 c_language != clk_cplusplus)
2558 ? integer_type_node : sizetype);
2560 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2561 builtin_types[(int) ENUM] = VALUE;
2562 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2563 builtin_types[(int) ENUM] \
2564 = build_function_type (builtin_types[(int) RETURN], \
2566 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2567 builtin_types[(int) ENUM] \
2568 = build_function_type (builtin_types[(int) RETURN], \
2569 tree_cons (NULL_TREE, \
2570 builtin_types[(int) ARG1], \
2572 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2573 builtin_types[(int) ENUM] \
2574 = build_function_type \
2575 (builtin_types[(int) RETURN], \
2576 tree_cons (NULL_TREE, \
2577 builtin_types[(int) ARG1], \
2578 tree_cons (NULL_TREE, \
2579 builtin_types[(int) ARG2], \
2581 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2582 builtin_types[(int) ENUM] \
2583 = build_function_type \
2584 (builtin_types[(int) RETURN], \
2585 tree_cons (NULL_TREE, \
2586 builtin_types[(int) ARG1], \
2587 tree_cons (NULL_TREE, \
2588 builtin_types[(int) ARG2], \
2589 tree_cons (NULL_TREE, \
2590 builtin_types[(int) ARG3], \
2592 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2593 builtin_types[(int) ENUM] \
2594 = build_function_type \
2595 (builtin_types[(int) RETURN], \
2596 tree_cons (NULL_TREE, \
2597 builtin_types[(int) ARG1], \
2598 tree_cons (NULL_TREE, \
2599 builtin_types[(int) ARG2], \
2602 builtin_types[(int) ARG3], \
2603 tree_cons (NULL_TREE, \
2604 builtin_types[(int) ARG4], \
2605 void_list_node)))));
2606 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2607 builtin_types[(int) ENUM] \
2608 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2609 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2610 builtin_types[(int) ENUM] \
2611 = build_function_type (builtin_types[(int) RETURN], \
2612 tree_cons (NULL_TREE, \
2613 builtin_types[(int) ARG1], \
2616 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2617 builtin_types[(int) ENUM] \
2618 = build_function_type \
2619 (builtin_types[(int) RETURN], \
2620 tree_cons (NULL_TREE, \
2621 builtin_types[(int) ARG1], \
2622 tree_cons (NULL_TREE, \
2623 builtin_types[(int) ARG2], \
2625 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2626 builtin_types[(int) ENUM] \
2627 = build_pointer_type (builtin_types[(int) TYPE]);
2628 #include "builtin-types.def"
2629 #undef DEF_PRIMITIVE_TYPE
2630 #undef DEF_FUNCTION_TYPE_1
2631 #undef DEF_FUNCTION_TYPE_2
2632 #undef DEF_FUNCTION_TYPE_3
2633 #undef DEF_FUNCTION_TYPE_4
2634 #undef DEF_FUNCTION_TYPE_VAR_0
2635 #undef DEF_FUNCTION_TYPE_VAR_1
2636 #undef DEF_POINTER_TYPE
2638 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2639 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2644 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2648 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2651 ? (NAME + strlen ("__builtin_")) \
2654 decl = builtin_function_2 (NAME, \
2655 NAME + strlen ("__builtin_"), \
2656 builtin_types[TYPE], \
2657 builtin_types[LIBTYPE], \
2662 /*noreturn_p=*/0); \
2664 built_in_decls[(int) ENUM] = decl; \
2666 #include "builtins.def"
2669 /* Declare _exit and _Exit just to mark them as non-returning. */
2670 builtin_function_2 (NULL, "_exit", NULL_TREE,
2671 builtin_types[BT_FN_VOID_INT],
2672 0, NOT_BUILT_IN, 0, 1, 1);
2673 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2674 builtin_types[BT_FN_VOID_INT],
2675 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2677 /* Declare these functions non-returning
2678 to avoid spurious "control drops through" warnings. */
2679 builtin_function_2 (NULL, "abort",
2680 NULL_TREE, ((c_language == clk_cplusplus)
2681 ? builtin_types[BT_FN_VOID]
2682 : builtin_types[BT_FN_VOID_VAR]),
2683 0, NOT_BUILT_IN, 0, 0, 1);
2685 builtin_function_2 (NULL, "exit",
2686 NULL_TREE, ((c_language == clk_cplusplus)
2687 ? builtin_types[BT_FN_VOID_INT]
2688 : builtin_types[BT_FN_VOID_VAR]),
2689 0, NOT_BUILT_IN, 0, 0, 1);
2691 main_identifier_node = get_identifier ("main");
2693 /* ??? Perhaps there's a better place to do this. But it is related
2694 to __builtin_va_arg, so it isn't that off-the-wall. */
2695 lang_type_promotes_to = simple_type_promotes_to;
2699 build_va_arg (expr, type)
2702 return build1 (VA_ARG_EXPR, type, expr);
2706 /* Linked list of disabled built-in functions. */
2708 typedef struct disabled_builtin
2711 struct disabled_builtin *next;
2713 static disabled_builtin *disabled_builtins = NULL;
2715 static bool builtin_function_disabled_p PARAMS ((const char *));
2717 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2718 begins with "__builtin_", give an error. */
2721 disable_builtin_function (name)
2724 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2725 error ("cannot disable built-in function `%s'", name);
2728 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2730 new->next = disabled_builtins;
2731 disabled_builtins = new;
2736 /* Return true if the built-in function NAME has been disabled, false
2740 builtin_function_disabled_p (name)
2743 disabled_builtin *p;
2744 for (p = disabled_builtins; p != NULL; p = p->next)
2746 if (strcmp (name, p->name) == 0)
2753 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2754 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2755 of these may be NULL (though both being NULL is useless).
2756 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2757 TYPE is the type of the function with the ordinary name. These
2758 may differ if the ordinary name is declared with a looser type to avoid
2759 conflicts with headers. FUNCTION_CODE and CLASS are as for
2760 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2761 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2762 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2763 NORETURN_P is nonzero, the function is marked as non-returning.
2764 Returns the declaration of BUILTIN_NAME, if any, otherwise
2765 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2766 or if NONANSI_P and flag_no_nonansi_builtin. */
2769 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2770 class, library_name_p, nonansi_p, noreturn_p)
2771 const char *builtin_name;
2776 enum built_in_class class;
2781 tree bdecl = NULL_TREE;
2782 tree decl = NULL_TREE;
2783 if (builtin_name != 0)
2785 bdecl = builtin_function (builtin_name, builtin_type, function_code,
2786 class, library_name_p ? name : NULL);
2789 TREE_THIS_VOLATILE (bdecl) = 1;
2790 TREE_SIDE_EFFECTS (bdecl) = 1;
2793 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
2794 && !(nonansi_p && flag_no_nonansi_builtin))
2796 decl = builtin_function (name, type, function_code, class, NULL);
2798 DECL_BUILT_IN_NONANSI (decl) = 1;
2801 TREE_THIS_VOLATILE (decl) = 1;
2802 TREE_SIDE_EFFECTS (decl) = 1;
2805 return (bdecl != 0 ? bdecl : decl);
2808 /* Nonzero if the type T promotes to int. This is (nearly) the
2809 integral promotions defined in ISO C99 6.3.1.1/2. */
2812 c_promoting_integer_type_p (t)
2815 switch (TREE_CODE (t))
2818 return (TYPE_MAIN_VARIANT (t) == char_type_node
2819 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2820 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2821 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2822 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
2823 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
2826 /* ??? Technically all enumerations not larger than an int
2827 promote to an int. But this is used along code paths
2828 that only want to notice a size change. */
2829 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
2839 /* Given a type, apply default promotions wrt unnamed function arguments
2840 and return the new type. Return NULL_TREE if no change. */
2841 /* ??? There is a function of the same name in the C++ front end that
2842 does something similar, but is more thorough and does not return NULL
2843 if no change. We could perhaps share code, but it would make the
2844 self_promoting_type property harder to identify. */
2847 simple_type_promotes_to (type)
2850 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2851 return double_type_node;
2853 if (c_promoting_integer_type_p (type))
2855 /* Traditionally, unsignedness is preserved in default promotions.
2856 Also preserve unsignedness if not really getting any wider. */
2857 if (TREE_UNSIGNED (type)
2858 && (flag_traditional
2859 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
2860 return unsigned_type_node;
2861 return integer_type_node;
2867 /* Return 1 if PARMS specifies a fixed number of parameters
2868 and none of their types is affected by default promotions. */
2871 self_promoting_args_p (parms)
2875 for (t = parms; t; t = TREE_CHAIN (t))
2877 tree type = TREE_VALUE (t);
2879 if (TREE_CHAIN (t) == 0 && type != void_type_node)
2885 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2888 if (c_promoting_integer_type_p (type))
2894 /* Recursively examines the array elements of TYPE, until a non-array
2895 element type is found. */
2898 strip_array_types (type)
2901 while (TREE_CODE (type) == ARRAY_TYPE)
2902 type = TREE_TYPE (type);
2907 /* Recognize certain built-in functions so we can make tree-codes
2908 other than CALL_EXPR. We do this when it enables fold-const.c
2909 to do something useful. */
2910 /* ??? By rights this should go in builtins.c, but only C and C++
2911 implement build_{binary,unary}_op. Not exactly sure what bits
2912 of functionality are actually needed from those functions, or
2913 where the similar functionality exists in the other front ends. */
2916 expand_tree_builtin (function, params, coerced_params)
2917 tree function, params, coerced_params;
2919 enum tree_code code;
2921 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
2924 switch (DECL_FUNCTION_CODE (function))
2928 case BUILT_IN_LLABS:
2929 case BUILT_IN_IMAXABS:
2931 case BUILT_IN_FABSL:
2932 case BUILT_IN_FABSF:
2933 if (coerced_params == 0)
2934 return integer_zero_node;
2935 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2938 case BUILT_IN_CONJF:
2939 case BUILT_IN_CONJL:
2940 if (coerced_params == 0)
2941 return integer_zero_node;
2942 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
2944 case BUILT_IN_CREAL:
2945 case BUILT_IN_CREALF:
2946 case BUILT_IN_CREALL:
2947 if (coerced_params == 0)
2948 return integer_zero_node;
2949 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
2951 case BUILT_IN_CIMAG:
2952 case BUILT_IN_CIMAGF:
2953 case BUILT_IN_CIMAGL:
2954 if (coerced_params == 0)
2955 return integer_zero_node;
2956 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
2958 case BUILT_IN_ISGREATER:
2959 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2965 case BUILT_IN_ISGREATEREQUAL:
2966 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2972 case BUILT_IN_ISLESS:
2973 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2979 case BUILT_IN_ISLESSEQUAL:
2980 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2986 case BUILT_IN_ISLESSGREATER:
2987 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2993 case BUILT_IN_ISUNORDERED:
2994 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
2995 return integer_zero_node;
2996 code = UNORDERED_EXPR;
3004 || TREE_CHAIN (params) == 0)
3006 error ("too few arguments to function `%s'",
3007 IDENTIFIER_POINTER (DECL_NAME (function)));
3008 return error_mark_node;
3010 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3012 error ("too many arguments to function `%s'",
3013 IDENTIFIER_POINTER (DECL_NAME (function)));
3014 return error_mark_node;
3017 arg0 = TREE_VALUE (params);
3018 arg1 = TREE_VALUE (TREE_CHAIN (params));
3019 arg0 = build_binary_op (code, arg0, arg1, 0);
3020 if (code != UNORDERED_EXPR)
3021 arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
3033 /* Returns non-zero if CODE is the code for a statement. */
3036 statement_code_p (code)
3037 enum tree_code code;
3060 if (lang_statement_code_p)
3061 return (*lang_statement_code_p) (code);
3066 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3067 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3068 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3069 value, the traversal is aborted, and the value returned by FUNC is
3070 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3071 the node being visited are not walked.
3073 We don't need a without_duplicates variant of this one because the
3074 statement tree is a tree, not a graph. */
3077 walk_stmt_tree (tp, func, data)
3082 enum tree_code code;
3087 #define WALK_SUBTREE(NODE) \
3090 result = walk_stmt_tree (&(NODE), func, data); \
3096 /* Skip empty subtrees. */
3100 /* Skip subtrees below non-statement nodes. */
3101 if (!statement_code_p (TREE_CODE (*tp)))
3104 /* Call the function. */
3106 result = (*func) (tp, &walk_subtrees, data);
3108 /* If we found something, return it. */
3112 /* FUNC may have modified the tree, recheck that we're looking at a
3114 code = TREE_CODE (*tp);
3115 if (!statement_code_p (code))
3118 /* Visit the subtrees unless FUNC decided that there was nothing
3119 interesting below this point in the tree. */
3122 /* Walk over all the sub-trees of this operand. Statement nodes
3123 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3124 len = TREE_CODE_LENGTH (code);
3126 /* Go through the subtrees. We need to do this in forward order so
3127 that the scope of a FOR_EXPR is handled properly. */
3128 for (i = 0; i < len; ++i)
3129 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3132 /* Finally visit the chain. This can be tail-recursion optimized if
3133 we write it this way. */
3134 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3139 /* Used to compare case labels. K1 and K2 are actually tree nodes
3140 representing case labels, or NULL_TREE for a `default' label.
3141 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3142 K2, and 0 if K1 and K2 are equal. */
3145 case_compare (k1, k2)
3149 /* Consider a NULL key (such as arises with a `default' label) to be
3150 smaller than anything else. */
3156 return tree_int_cst_compare ((tree) k1, (tree) k2);
3159 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3160 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3161 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3162 case label was declared using the usual C/C++ syntax, rather than
3163 the GNU case range extension. CASES is a tree containing all the
3164 case ranges processed so far; COND is the condition for the
3165 switch-statement itself. Returns the CASE_LABEL created, or
3166 ERROR_MARK_NODE if no CASE_LABEL is created. */
3169 c_add_case_label (cases, cond, low_value, high_value)
3178 splay_tree_node node;
3180 /* Create the LABEL_DECL itself. */
3181 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3182 DECL_CONTEXT (label) = current_function_decl;
3184 /* If there was an error processing the switch condition, bail now
3185 before we get more confused. */
3186 if (!cond || cond == error_mark_node)
3188 /* Add a label anyhow so that the back-end doesn't think that
3189 the beginning of the switch is unreachable. */
3191 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3192 return error_mark_node;
3195 if ((low_value && TREE_TYPE (low_value)
3196 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3197 || (high_value && TREE_TYPE (high_value)
3198 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3199 error ("pointers are not permitted as case values");
3201 /* Case ranges are a GNU extension. */
3202 if (high_value && pedantic)
3204 if (c_language == clk_cplusplus)
3205 pedwarn ("ISO C++ forbids range expressions in switch statements");
3207 pedwarn ("ISO C forbids range expressions in switch statements");
3210 type = TREE_TYPE (cond);
3213 low_value = check_case_value (low_value);
3214 low_value = convert_and_check (type, low_value);
3218 high_value = check_case_value (high_value);
3219 high_value = convert_and_check (type, high_value);
3222 /* If an error has occurred, bail out now. */
3223 if (low_value == error_mark_node || high_value == error_mark_node)
3226 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3227 return error_mark_node;
3230 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3231 really a case range, even though it was written that way. Remove
3232 the HIGH_VALUE to simplify later processing. */
3233 if (tree_int_cst_equal (low_value, high_value))
3234 high_value = NULL_TREE;
3235 if (low_value && high_value
3236 && !tree_int_cst_lt (low_value, high_value))
3237 warning ("empty range specified");
3239 /* Look up the LOW_VALUE in the table of case labels we already
3241 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3242 /* If there was not an exact match, check for overlapping ranges.
3243 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3244 that's a `default' label and the only overlap is an exact match. */
3245 if (!node && (low_value || high_value))
3247 splay_tree_node low_bound;
3248 splay_tree_node high_bound;
3250 /* Even though there wasn't an exact match, there might be an
3251 overlap between this case range and another case range.
3252 Since we've (inductively) not allowed any overlapping case
3253 ranges, we simply need to find the greatest low case label
3254 that is smaller that LOW_VALUE, and the smallest low case
3255 label that is greater than LOW_VALUE. If there is an overlap
3256 it will occur in one of these two ranges. */
3257 low_bound = splay_tree_predecessor (cases,
3258 (splay_tree_key) low_value);
3259 high_bound = splay_tree_successor (cases,
3260 (splay_tree_key) low_value);
3262 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3263 the LOW_VALUE, so there is no need to check unless the
3264 LOW_BOUND is in fact itself a case range. */
3266 && CASE_HIGH ((tree) low_bound->value)
3267 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3270 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3271 range is bigger than the low end of the current range, so we
3272 are only interested if the current range is a real range, and
3273 not an ordinary case label. */
3276 && (tree_int_cst_compare ((tree) high_bound->key,
3281 /* If there was an overlap, issue an error. */
3284 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3288 error ("duplicate (or overlapping) case value");
3289 error_with_decl (duplicate,
3290 "this is the first entry overlapping that value");
3294 error ("duplicate case value") ;
3295 error_with_decl (duplicate, "previously used here");
3299 error ("multiple default labels in one switch");
3300 error_with_decl (duplicate, "this is the first default label");
3303 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3306 /* Add a CASE_LABEL to the statement-tree. */
3307 case_label = add_stmt (build_case_label (low_value, high_value, label));
3308 /* Register this case label in the splay tree. */
3309 splay_tree_insert (cases,
3310 (splay_tree_key) low_value,
3311 (splay_tree_value) case_label);
3316 /* Finish an expression taking the address of LABEL. Returns an
3317 expression for the address. */
3320 finish_label_address_expr (label)
3327 if (c_language == clk_cplusplus)
3328 pedwarn ("ISO C++ forbids taking the address of a label");
3330 pedwarn ("ISO C forbids taking the address of a label");
3333 label = lookup_label (label);
3334 if (label == NULL_TREE)
3335 result = null_pointer_node;
3338 TREE_USED (label) = 1;
3339 result = build1 (ADDR_EXPR, ptr_type_node, label);
3340 TREE_CONSTANT (result) = 1;
3341 /* The current function in not necessarily uninlinable.
3342 Computed gotos are incompatible with inlining, but the value
3343 here could be used only in a diagnostic, for example. */
3349 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3350 parameter allows this function to be used as a GC-marking
3357 stmt_tree st = (stmt_tree) p;
3359 ggc_mark_tree (st->x_last_stmt);
3360 ggc_mark_tree (st->x_last_expr_type);
3363 /* Mark LD for GC. */
3366 c_mark_lang_decl (c)
3367 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3371 /* Mark F for GC. */
3374 mark_c_language_function (f)
3375 struct language_function *f;
3380 mark_stmt_tree (&f->x_stmt_tree);
3381 ggc_mark_tree (f->x_scope_stmt_stack);
3384 /* Hook used by expand_expr to expand language-specific tree codes. */
3387 c_expand_expr (exp, target, tmode, modifier)
3390 enum machine_mode tmode;
3391 enum expand_modifier modifier;
3393 switch (TREE_CODE (exp))
3400 /* Since expand_expr_stmt calls free_temp_slots after every
3401 expression statement, we must call push_temp_slots here.
3402 Otherwise, any temporaries in use now would be considered
3403 out-of-scope after the first EXPR_STMT from within the
3406 rtl_expr = expand_start_stmt_expr ();
3407 expand_stmt (STMT_EXPR_STMT (exp));
3408 expand_end_stmt_expr (rtl_expr);
3409 result = expand_expr (rtl_expr, target, tmode, modifier);
3417 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3418 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3420 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3421 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3422 == BUILT_IN_FRONTEND))
3423 return c_expand_builtin (exp, target, tmode, modifier);
3437 /* Hook used by safe_from_p to handle language-specific tree codes. */
3440 c_safe_from_p (target, exp)
3444 /* We can see statements here when processing the body of a
3445 statement-expression. For a declaration statement declaring a
3446 variable, look at the variable's initializer. */
3447 if (TREE_CODE (exp) == DECL_STMT)
3449 tree decl = DECL_STMT_DECL (exp);
3451 if (TREE_CODE (decl) == VAR_DECL
3452 && DECL_INITIAL (decl)
3453 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3457 /* For any statement, we must follow the statement-chain. */
3458 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3459 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3461 /* Assume everything else is safe. */
3465 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3468 c_unsafe_for_reeval (exp)
3471 /* Statement expressions may not be reevaluated. */
3472 if (TREE_CODE (exp) == STMT_EXPR)
3475 /* Walk all other expressions. */
3479 /* Tree code classes. */
3481 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3483 static const char c_tree_code_type[] = {
3485 #include "c-common.def"
3489 /* Table indexed by tree code giving number of expression
3490 operands beyond the fixed part of the node structure.
3491 Not used for types or decls. */
3493 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3495 static const int c_tree_code_length[] = {
3497 #include "c-common.def"
3501 /* Names of tree components.
3502 Used for printing out the tree and error messages. */
3503 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3505 static const char *const c_tree_code_name[] = {
3507 #include "c-common.def"
3511 /* Adds the tree codes specific to the C front end to the list of all
3517 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3519 (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3520 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3522 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3523 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3525 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
3526 lang_unsafe_for_reeval = c_unsafe_for_reeval;
3529 #define CALLED_AS_BUILT_IN(NODE) \
3530 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3533 c_expand_builtin (exp, target, tmode, modifier)
3536 enum machine_mode tmode;
3537 enum expand_modifier modifier;
3539 tree type = TREE_TYPE (exp);
3540 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3541 tree arglist = TREE_OPERAND (exp, 1);
3542 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3543 enum tree_code code = TREE_CODE (exp);
3544 const int ignore = (target == const0_rtx
3545 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3546 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3547 || code == COND_EXPR)
3548 && TREE_CODE (type) == VOID_TYPE));
3550 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3551 return expand_call (exp, target, ignore);
3555 case BUILT_IN_PRINTF:
3556 target = c_expand_builtin_printf (arglist, target, tmode,
3562 case BUILT_IN_FPRINTF:
3563 target = c_expand_builtin_fprintf (arglist, target, tmode,
3569 default: /* just do library call, if unknown builtin */
3570 error ("built-in function `%s' not currently supported",
3571 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3574 /* The switch statement above can drop through to cause the function
3575 to be called normally. */
3576 return expand_call (exp, target, ignore);
3579 /* Check an arglist to *printf for problems. The arglist should start
3580 at the format specifier, with the remaining arguments immediately
3583 is_valid_printf_arglist (arglist)
3586 /* Save this value so we can restore it later. */
3587 const int SAVE_pedantic = pedantic;
3588 int diagnostic_occurred = 0;
3591 /* Set this to a known value so the user setting won't affect code
3594 /* Check to make sure there are no format specifier errors. */
3595 attrs = tree_cons (get_identifier ("format"),
3596 tree_cons (NULL_TREE,
3597 get_identifier ("printf"),
3598 tree_cons (NULL_TREE,
3600 tree_cons (NULL_TREE,
3604 check_function_format (&diagnostic_occurred, attrs, arglist);
3606 /* Restore the value of `pedantic'. */
3607 pedantic = SAVE_pedantic;
3609 /* If calling `check_function_format_ptr' produces a warning, we
3610 return false, otherwise we return true. */
3611 return ! diagnostic_occurred;
3614 /* If the arguments passed to printf are suitable for optimizations,
3615 we attempt to transform the call. */
3617 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
3620 enum machine_mode tmode;
3621 enum expand_modifier modifier;
3624 tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
3625 fn_puts = built_in_decls[BUILT_IN_PUTS];
3626 tree fn, format_arg, stripped_string;
3628 /* If the return value is used, or the replacement _DECL isn't
3629 initialized, don't do the transformation. */
3630 if (!ignore || !fn_putchar || !fn_puts)
3633 /* Verify the required arguments in the original call. */
3635 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3638 /* Check the specifier vs. the parameters. */
3639 if (!is_valid_printf_arglist (arglist))
3642 format_arg = TREE_VALUE (arglist);
3643 stripped_string = format_arg;
3644 STRIP_NOPS (stripped_string);
3645 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3646 stripped_string = TREE_OPERAND (stripped_string, 0);
3648 /* If the format specifier isn't a STRING_CST, punt. */
3649 if (TREE_CODE (stripped_string) != STRING_CST)
3652 /* OK! We can attempt optimization. */
3654 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3655 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3657 arglist = TREE_CHAIN (arglist);
3660 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3661 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3663 arglist = TREE_CHAIN (arglist);
3668 /* We can't handle anything else with % args or %% ... yet. */
3669 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3672 /* If the resulting constant string has a length of 1, call
3673 putchar. Note, TREE_STRING_LENGTH includes the terminating
3674 NULL in its count. */
3675 if (TREE_STRING_LENGTH (stripped_string) == 2)
3677 /* Given printf("c"), (where c is any one character,)
3678 convert "c"[0] to an int and pass that to the replacement
3680 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3681 arglist = build_tree_list (NULL_TREE, arglist);
3685 /* If the resulting constant was "string\n", call
3686 __builtin_puts("string"). Ensure "string" has at least one
3687 character besides the trailing \n. Note, TREE_STRING_LENGTH
3688 includes the terminating NULL in its count. */
3689 else if (TREE_STRING_LENGTH (stripped_string) > 2
3690 && TREE_STRING_POINTER (stripped_string)
3691 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3693 /* Create a NULL-terminated string that's one char shorter
3694 than the original, stripping off the trailing '\n'. */
3695 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3696 char *newstr = (char *) alloca (newlen);
3697 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3698 newstr[newlen - 1] = 0;
3700 arglist = combine_strings (build_string (newlen, newstr));
3701 arglist = build_tree_list (NULL_TREE, arglist);
3705 /* We'd like to arrange to call fputs(string) here, but we
3706 need stdout and don't have a way to get it ... yet. */
3710 return expand_expr (build_function_call (fn, arglist),
3711 (ignore ? const0_rtx : target),
3715 /* If the arguments passed to fprintf are suitable for optimizations,
3716 we attempt to transform the call. */
3718 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
3721 enum machine_mode tmode;
3722 enum expand_modifier modifier;
3725 tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
3726 fn_fputs = built_in_decls[BUILT_IN_FPUTS];
3727 tree fn, format_arg, stripped_string;
3729 /* If the return value is used, or the replacement _DECL isn't
3730 initialized, don't do the transformation. */
3731 if (!ignore || !fn_fputc || !fn_fputs)
3734 /* Verify the required arguments in the original call. */
3736 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3737 || (TREE_CHAIN (arglist) == 0)
3738 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3742 /* Check the specifier vs. the parameters. */
3743 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3746 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3747 stripped_string = format_arg;
3748 STRIP_NOPS (stripped_string);
3749 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3750 stripped_string = TREE_OPERAND (stripped_string, 0);
3752 /* If the format specifier isn't a STRING_CST, punt. */
3753 if (TREE_CODE (stripped_string) != STRING_CST)
3756 /* OK! We can attempt optimization. */
3758 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3759 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3761 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3762 arglist = tree_cons (NULL_TREE,
3763 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3767 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3768 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3770 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3771 arglist = tree_cons (NULL_TREE,
3772 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3778 /* We can't handle anything else with % args or %% ... yet. */
3779 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3782 /* When "string" doesn't contain %, replace all cases of
3783 fprintf(stream,string) with fputs(string,stream). The fputs
3784 builtin will take take of special cases like length==1. */
3785 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
3786 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
3790 return expand_expr (build_function_call (fn, arglist),
3791 (ignore ? const0_rtx : target),
3796 /* Given a boolean expression ARG, return a tree representing an increment
3797 or decrement (as indicated by CODE) of ARG. The front end must check for
3798 invalid cases (e.g., decrement in C++). */
3800 boolean_increment (code, arg)
3801 enum tree_code code;
3805 tree true_res = (c_language == clk_cplusplus
3807 : c_bool_true_node);
3808 arg = stabilize_reference (arg);
3811 case PREINCREMENT_EXPR:
3812 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3814 case POSTINCREMENT_EXPR:
3815 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3816 arg = save_expr (arg);
3817 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3818 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3820 case PREDECREMENT_EXPR:
3821 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3823 case POSTDECREMENT_EXPR:
3824 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3825 arg = save_expr (arg);
3826 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3827 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3832 TREE_SIDE_EFFECTS (val) = 1;
3836 /* Handle C and C++ default attributes. */
3838 enum built_in_attribute
3840 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3841 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3842 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3843 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3844 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3845 #include "builtin-attrs.def"
3846 #undef DEF_ATTR_NULL_TREE
3848 #undef DEF_ATTR_IDENT
3849 #undef DEF_ATTR_TREE_LIST
3854 static tree built_in_attributes[(int) ATTR_LAST];
3856 static bool c_attrs_initialized = false;
3858 static void c_init_attributes PARAMS ((void));
3860 /* Do the parts of lang_init common to C and C++. */
3862 c_common_lang_init (filename)
3863 const char *filename;
3865 filename = init_c_lex (filename);
3869 /* If still "unspecified", make it match -fbounded-pointers. */
3870 if (flag_bounds_check < 0)
3871 flag_bounds_check = flag_bounded_pointers;
3873 /* Special format checking options don't work without -Wformat; warn if
3875 if (warn_format_y2k && !warn_format)
3876 warning ("-Wformat-y2k ignored without -Wformat");
3877 if (warn_format_extra_args && !warn_format)
3878 warning ("-Wformat-extra-args ignored without -Wformat");
3879 if (warn_format_nonliteral && !warn_format)
3880 warning ("-Wformat-nonliteral ignored without -Wformat");
3881 if (warn_format_security && !warn_format)
3882 warning ("-Wformat-security ignored without -Wformat");
3883 if (warn_missing_format_attribute && !warn_format)
3884 warning ("-Wmissing-format-attribute ignored without -Wformat");
3886 if (!c_attrs_initialized)
3887 c_init_attributes ();
3893 c_init_attributes ()
3895 /* Fill in the built_in_attributes array. */
3896 #define DEF_ATTR_NULL_TREE(ENUM) \
3897 built_in_attributes[(int) ENUM] = NULL_TREE;
3898 #define DEF_ATTR_INT(ENUM, VALUE) \
3899 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3900 #define DEF_ATTR_IDENT(ENUM, STRING) \
3901 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3902 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3903 built_in_attributes[(int) ENUM] \
3904 = tree_cons (built_in_attributes[(int) PURPOSE], \
3905 built_in_attributes[(int) VALUE], \
3906 built_in_attributes[(int) CHAIN]);
3907 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
3908 #include "builtin-attrs.def"
3909 #undef DEF_ATTR_NULL_TREE
3911 #undef DEF_ATTR_IDENT
3912 #undef DEF_ATTR_TREE_LIST
3914 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
3915 c_attrs_initialized = true;
3918 /* Depending on the name of DECL, apply default attributes to it. */
3921 c_common_insert_default_attributes (decl)
3924 tree name = DECL_NAME (decl);
3926 if (!c_attrs_initialized)
3927 c_init_attributes ();
3929 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
3930 #define DEF_ATTR_INT(ENUM, VALUE)
3931 #define DEF_ATTR_IDENT(ENUM, STRING)
3932 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
3933 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
3934 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
3935 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
3936 ATTR_FLAG_BUILT_IN);
3937 #include "builtin-attrs.def"
3938 #undef DEF_ATTR_NULL_TREE
3940 #undef DEF_ATTR_IDENT
3941 #undef DEF_ATTR_TREE_LIST