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
25 #include "tree-inline.h"
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_declnode;
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 /* The elements of `ridpointers' are identifier nodes for the reserved
199 type names and storage classes. It is indexed by a RID_... value. */
202 tree (*make_fname_decl) PARAMS ((tree, int));
204 /* If non-NULL, the address of a language-specific function that
205 returns 1 for language-specific statement codes. */
206 int (*lang_statement_code_p) PARAMS ((enum tree_code));
208 /* If non-NULL, the address of a language-specific function that takes
209 any action required right before expand_function_end is called. */
210 void (*lang_expand_function_end) PARAMS ((void));
212 /* If this variable is defined to a non-NULL value, it will be called
213 after the file has been completely parsed. */
214 void (*back_end_hook) PARAMS ((tree));
216 /* Nonzero means the expression being parsed will never be evaluated.
217 This is a count, since unevaluated expressions can nest. */
220 /* Information about how a function name is generated. */
223 tree *const decl; /* pointer to the VAR_DECL. */
224 const unsigned rid; /* RID number for the identifier. */
225 const int pretty; /* How pretty is it? */
228 /* The three ways of getting then name of the current function. */
230 const struct fname_var_t fname_vars[] =
232 /* C99 compliant __func__, must be first. */
233 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
234 /* GCC __FUNCTION__ compliant. */
235 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
236 /* GCC __PRETTY_FUNCTION__ compliant. */
237 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
241 static int constant_fits_type_p PARAMS ((tree, tree));
243 /* Keep a stack of if statements. We record the number of compound
244 statements seen up to the if keyword, as well as the line number
245 and file of the if. If a potentially ambiguous else is seen, that
246 fact is recorded; the warning is issued when we can be sure that
247 the enclosing if statement does not have an else branch. */
257 static if_elt *if_stack;
259 /* Amount of space in the if statement stack. */
260 static int if_stack_space = 0;
263 static int if_stack_pointer = 0;
265 /* Record the start of an if-then, and record the start of it
266 for ambiguous else detection. */
269 c_expand_start_cond (cond, compstmt_count)
275 /* Make sure there is enough space on the stack. */
276 if (if_stack_space == 0)
279 if_stack = (if_elt *)xmalloc (10 * sizeof (if_elt));
281 else if (if_stack_space == if_stack_pointer)
283 if_stack_space += 10;
284 if_stack = (if_elt *)xrealloc (if_stack, if_stack_space * sizeof (if_elt));
287 if_stmt = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
288 IF_COND (if_stmt) = cond;
291 /* Record this if statement. */
292 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
293 if_stack[if_stack_pointer].file = input_filename;
294 if_stack[if_stack_pointer].line = lineno;
295 if_stack[if_stack_pointer].needs_warning = 0;
296 if_stack[if_stack_pointer].if_stmt = if_stmt;
300 /* Called after the then-clause for an if-statement is processed. */
305 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
306 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
309 /* Record the end of an if-then. Optionally warn if a nested
310 if statement had an ambiguous else clause. */
316 if (if_stack[if_stack_pointer].needs_warning)
317 warning_with_file_and_line (if_stack[if_stack_pointer].file,
318 if_stack[if_stack_pointer].line,
319 "suggest explicit braces to avoid ambiguous `else'");
320 last_expr_type = NULL_TREE;
323 /* Called between the then-clause and the else-clause
324 of an if-then-else. */
327 c_expand_start_else ()
329 /* An ambiguous else warning must be generated for the enclosing if
330 statement, unless we see an else branch for that one, too. */
332 && if_stack_pointer > 1
333 && (if_stack[if_stack_pointer - 1].compstmt_count
334 == if_stack[if_stack_pointer - 2].compstmt_count))
335 if_stack[if_stack_pointer - 2].needs_warning = 1;
337 /* Even if a nested if statement had an else branch, it can't be
338 ambiguous if this one also has an else. So don't warn in that
339 case. Also don't warn for any if statements nested in this else. */
340 if_stack[if_stack_pointer - 1].needs_warning = 0;
341 if_stack[if_stack_pointer - 1].compstmt_count--;
344 /* Called after the else-clause for an if-statement is processed. */
349 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
350 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
353 /* Push current bindings for the function name VAR_DECLS. */
359 tree saved = NULL_TREE;
361 for (ix = 0; fname_vars[ix].decl; ix++)
363 tree decl = *fname_vars[ix].decl;
367 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
368 *fname_vars[ix].decl = NULL_TREE;
371 if (saved || saved_function_name_decls)
372 /* Normally they'll have been NULL, so only push if we've got a
373 stack, or they are non-NULL. */
374 saved_function_name_decls = tree_cons (saved, NULL_TREE,
375 saved_function_name_decls);
378 /* Finish up the current bindings, adding them into the
379 current function's statement tree. This is done by wrapping the
380 function's body in a COMPOUND_STMT containing these decls too. This
381 must be done _before_ finish_stmt_tree is called. If there is no
382 current function, we must be at file scope and no statements are
383 involved. Pop the previous bindings. */
386 finish_fname_decls ()
389 tree body = NULL_TREE;
390 tree stack = saved_function_name_decls;
392 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
393 body = chainon (TREE_VALUE (stack), body);
397 /* They were called into existance, so add to statement tree. */
398 body = chainon (body,
399 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
400 body = build_stmt (COMPOUND_STMT, body);
402 COMPOUND_STMT_NO_SCOPE (body) = 1;
403 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
406 for (ix = 0; fname_vars[ix].decl; ix++)
407 *fname_vars[ix].decl = NULL_TREE;
411 /* We had saved values, restore them. */
414 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
416 tree decl = TREE_PURPOSE (saved);
417 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
419 *fname_vars[ix].decl = decl;
421 stack = TREE_CHAIN (stack);
423 saved_function_name_decls = stack;
426 /* Return the text name of the current function, suitable prettified
430 fname_as_string (pretty_p)
433 const char *name = NULL;
436 name = (current_function_decl
437 ? (*decl_printable_name) (current_function_decl, 2)
439 else if (current_function_decl && DECL_NAME (current_function_decl))
440 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
446 /* Return the text name of the current function, formatted as
447 required by the supplied RID value. */
455 for (ix = 0; fname_vars[ix].decl; ix++)
456 if (fname_vars[ix].rid == rid)
458 return fname_as_string (fname_vars[ix].pretty);
461 /* Return the VAR_DECL for a const char array naming the current
462 function. If the VAR_DECL has not yet been created, create it
463 now. RID indicates how it should be formatted and IDENTIFIER_NODE
464 ID is its name (unfortunately C and C++ hold the RID values of
465 keywords in different places, so we can't derive RID from ID in
466 this language independant code. */
474 tree decl = NULL_TREE;
476 for (ix = 0; fname_vars[ix].decl; ix++)
477 if (fname_vars[ix].rid == rid)
480 decl = *fname_vars[ix].decl;
483 tree saved_last_tree = last_tree;
485 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
486 if (last_tree != saved_last_tree)
488 /* We created some statement tree for the decl. This belongs
489 at the start of the function, so remove it now and reinsert
490 it after the function is complete. */
491 tree stmts = TREE_CHAIN (saved_last_tree);
493 TREE_CHAIN (saved_last_tree) = NULL_TREE;
494 last_tree = saved_last_tree;
495 saved_function_name_decls = tree_cons (decl, stmts,
496 saved_function_name_decls);
498 *fname_vars[ix].decl = decl;
500 if (!ix && !current_function_decl)
501 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
506 /* Given a chain of STRING_CST nodes,
507 concatenate them into one STRING_CST
508 and give it a suitable array-of-chars data type. */
511 combine_strings (strings)
514 register tree value, t;
515 register int length = 1;
518 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
520 const int nchars_max = flag_isoc99 ? 4095 : 509;
522 if (TREE_CHAIN (strings))
524 /* More than one in the chain, so concatenate. */
525 register char *p, *q;
527 /* Don't include the \0 at the end of each substring,
528 except for the last one.
529 Count wide strings and ordinary strings separately. */
530 for (t = strings; t; t = TREE_CHAIN (t))
532 if (TREE_TYPE (t) == wchar_array_type_node)
534 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
538 length += (TREE_STRING_LENGTH (t) - 1);
541 /* If anything is wide, the non-wides will be converted,
542 which makes them take more space. */
544 length = length * wchar_bytes + wide_length;
548 /* Copy the individual strings into the new combined string.
549 If the combined string is wide, convert the chars to ints
550 for any individual strings that are not wide. */
553 for (t = strings; t; t = TREE_CHAIN (t))
555 int len = (TREE_STRING_LENGTH (t)
556 - ((TREE_TYPE (t) == wchar_array_type_node)
558 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
560 memcpy (q, TREE_STRING_POINTER (t), len);
566 for (i = 0; i < len; i++)
568 if (BYTES_BIG_ENDIAN)
570 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
572 *q++ = TREE_STRING_POINTER (t)[i];
576 *q++ = TREE_STRING_POINTER (t)[i];
577 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
586 for (i = 0; i < wchar_bytes; i++)
592 value = build_string (length, p);
597 length = TREE_STRING_LENGTH (value);
598 if (TREE_TYPE (value) == wchar_array_type_node)
602 /* Compute the number of elements, for the array type. */
603 nchars = wide_flag ? length / wchar_bytes : length;
605 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
606 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
607 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
609 /* Create the array type for the string constant.
610 -Wwrite-strings says make the string constant an array of const char
611 so that copying it to a non-const pointer will get a warning.
612 For C++, this is the standard behavior. */
613 if (flag_const_strings
614 && (! flag_traditional && ! flag_writable_strings))
617 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
620 = build_array_type (elements,
621 build_index_type (build_int_2 (nchars - 1, 0)));
625 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
626 build_index_type (build_int_2 (nchars - 1, 0)));
628 TREE_CONSTANT (value) = 1;
629 TREE_READONLY (value) = ! flag_writable_strings;
630 TREE_STATIC (value) = 1;
634 static int is_valid_printf_arglist PARAMS ((tree));
635 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
636 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
637 enum expand_modifier, int));
638 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
639 enum expand_modifier, int));
641 /* Print a warning if a constant expression had overflow in folding.
642 Invoke this function on every expression that the language
643 requires to be a constant expression.
644 Note the ANSI C standard says it is erroneous for a
645 constant expression to overflow. */
648 constant_expression_warning (value)
651 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
652 || TREE_CODE (value) == COMPLEX_CST)
653 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
654 pedwarn ("overflow in constant expression");
657 /* Print a warning if an expression had overflow in folding.
658 Invoke this function on every expression that
659 (1) appears in the source code, and
660 (2) might be a constant expression that overflowed, and
661 (3) is not already checked by convert_and_check;
662 however, do not invoke this function on operands of explicit casts. */
665 overflow_warning (value)
668 if ((TREE_CODE (value) == INTEGER_CST
669 || (TREE_CODE (value) == COMPLEX_CST
670 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
671 && TREE_OVERFLOW (value))
673 TREE_OVERFLOW (value) = 0;
674 if (skip_evaluation == 0)
675 warning ("integer overflow in expression");
677 else if ((TREE_CODE (value) == REAL_CST
678 || (TREE_CODE (value) == COMPLEX_CST
679 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
680 && TREE_OVERFLOW (value))
682 TREE_OVERFLOW (value) = 0;
683 if (skip_evaluation == 0)
684 warning ("floating point overflow in expression");
688 /* Print a warning if a large constant is truncated to unsigned,
689 or if -Wconversion is used and a constant < 0 is converted to unsigned.
690 Invoke this function on every expression that might be implicitly
691 converted to an unsigned type. */
694 unsigned_conversion_warning (result, operand)
695 tree result, operand;
697 if (TREE_CODE (operand) == INTEGER_CST
698 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
699 && TREE_UNSIGNED (TREE_TYPE (result))
700 && skip_evaluation == 0
701 && !int_fits_type_p (operand, TREE_TYPE (result)))
703 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
704 /* This detects cases like converting -129 or 256 to unsigned char. */
705 warning ("large integer implicitly truncated to unsigned type");
706 else if (warn_conversion)
707 warning ("negative integer implicitly converted to unsigned type");
711 /* Nonzero if constant C has a value that is permissible
712 for type TYPE (an INTEGER_TYPE). */
715 constant_fits_type_p (c, type)
718 if (TREE_CODE (c) == INTEGER_CST)
719 return int_fits_type_p (c, type);
721 c = convert (type, c);
722 return !TREE_OVERFLOW (c);
725 /* Convert EXPR to TYPE, warning about conversion problems with constants.
726 Invoke this function on every expression that is converted implicitly,
727 i.e. because of language rules and not because of an explicit cast. */
730 convert_and_check (type, expr)
733 tree t = convert (type, expr);
734 if (TREE_CODE (t) == INTEGER_CST)
736 if (TREE_OVERFLOW (t))
738 TREE_OVERFLOW (t) = 0;
740 /* Do not diagnose overflow in a constant expression merely
741 because a conversion overflowed. */
742 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
744 /* No warning for converting 0x80000000 to int. */
745 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
746 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
747 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
748 /* If EXPR fits in the unsigned version of TYPE,
749 don't warn unless pedantic. */
751 || TREE_UNSIGNED (type)
752 || ! constant_fits_type_p (expr, unsigned_type (type)))
753 && skip_evaluation == 0)
754 warning ("overflow in implicit constant conversion");
757 unsigned_conversion_warning (t, expr);
762 /* A node in a list that describes references to variables (EXPR), which are
763 either read accesses if WRITER is zero, or write accesses, in which case
764 WRITER is the parent of EXPR. */
771 /* Used to implement a cache the results of a call to verify_tree. We only
772 use this for SAVE_EXPRs. */
775 struct tlist_cache *next;
776 struct tlist *cache_before_sp;
777 struct tlist *cache_after_sp;
781 /* Obstack to use when allocating tlist structures, and corresponding
783 static struct obstack tlist_obstack;
784 static char *tlist_firstobj = 0;
786 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
788 static struct tlist *warned_ids;
789 /* SAVE_EXPRs need special treatment. We process them only once and then
790 cache the results. */
791 static struct tlist_cache *save_expr_cache;
793 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
794 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
795 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
796 static int warning_candidate_p PARAMS ((tree));
797 static void warn_for_collisions PARAMS ((struct tlist *));
798 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
799 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
800 static void verify_sequence_points PARAMS ((tree));
802 /* Create a new struct tlist and fill in its fields. */
803 static struct tlist *
804 new_tlist (next, t, writer)
810 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
817 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
818 is nonnull, we ignore any node we find which has a writer equal to it. */
821 add_tlist (to, add, exclude_writer, copy)
829 struct tlist *next = add->next;
832 if (! exclude_writer || add->writer != exclude_writer)
833 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
838 /* Merge the nodes of ADD into TO. This merging process is done so that for
839 each variable that already exists in TO, no new node is added; however if
840 there is a write access recorded in ADD, and an occurrence on TO is only
841 a read access, then the occurrence in TO will be modified to record the
845 merge_tlist (to, add, copy)
850 struct tlist **end = to;
859 struct tlist *next = add->next;
861 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
862 if (tmp2->expr == add->expr)
866 tmp2->writer = add->writer;
870 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
878 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
879 references in list LIST conflict with it, excluding reads if ONLY writers
883 warn_for_collisions_1 (written, writer, list, only_writes)
884 tree written, writer;
890 /* Avoid duplicate warnings. */
891 for (tmp = warned_ids; tmp; tmp = tmp->next)
892 if (tmp->expr == written)
897 if (list->expr == written
898 && list->writer != writer
899 && (! only_writes || list->writer))
901 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
902 warning ("operation on `%s' may be undefined",
903 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
909 /* Given a list LIST of references to variables, find whether any of these
910 can cause conflicts due to missing sequence points. */
913 warn_for_collisions (list)
918 for (tmp = list; tmp; tmp = tmp->next)
921 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
925 /* Return nonzero if X is a tree that can be verified by the sequence poitn
928 warning_candidate_p (x)
931 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
934 /* Walk the tree X, and record accesses to variables. If X is written by the
935 parent tree, WRITER is the parent.
936 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
937 expression or its only operand forces a sequence point, then everything up
938 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
940 Once we return, we will have emitted warnings if any subexpression before
941 such a sequence point could be undefined. On a higher level, however, the
942 sequence point may not be relevant, and we'll merge the two lists.
944 Example: (b++, a) + b;
945 The call that processes the COMPOUND_EXPR will store the increment of B
946 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
947 processes the PLUS_EXPR will need to merge the two lists so that
948 eventually, all accesses end up on the same list (and we'll warn about the
949 unordered subexpressions b++ and b.
951 A note on merging. If we modify the former example so that our expression
954 care must be taken not simply to add all three expressions into the final
955 PNO_SP list. The function merge_tlist takes care of that by merging the
956 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
957 way, so that no more than one access to B is recorded. */
960 verify_tree (x, pbefore_sp, pno_sp, writer)
962 struct tlist **pbefore_sp, **pno_sp;
965 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
969 /* X may be NULL if it is the operand of an empty statement expression
975 code = TREE_CODE (x);
976 class = TREE_CODE_CLASS (code);
978 if (warning_candidate_p (x))
980 *pno_sp = new_tlist (*pno_sp, x, writer);
990 case TRUTH_ANDIF_EXPR:
991 case TRUTH_ORIF_EXPR:
992 tmp_before = tmp_nosp = tmp_list3 = 0;
993 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
994 warn_for_collisions (tmp_nosp);
995 merge_tlist (pbefore_sp, tmp_before, 0);
996 merge_tlist (pbefore_sp, tmp_nosp, 0);
997 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
998 merge_tlist (pbefore_sp, tmp_list3, 0);
1002 tmp_before = tmp_list2 = 0;
1003 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1004 warn_for_collisions (tmp_list2);
1005 merge_tlist (pbefore_sp, tmp_before, 0);
1006 merge_tlist (pbefore_sp, tmp_list2, 1);
1008 tmp_list3 = tmp_nosp = 0;
1009 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1010 warn_for_collisions (tmp_nosp);
1011 merge_tlist (pbefore_sp, tmp_list3, 0);
1013 tmp_list3 = tmp_list2 = 0;
1014 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1015 warn_for_collisions (tmp_list2);
1016 merge_tlist (pbefore_sp, tmp_list3, 0);
1017 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1018 two first, to avoid warning for (a ? b++ : b++). */
1019 merge_tlist (&tmp_nosp, tmp_list2, 0);
1020 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1023 case PREDECREMENT_EXPR:
1024 case PREINCREMENT_EXPR:
1025 case POSTDECREMENT_EXPR:
1026 case POSTINCREMENT_EXPR:
1027 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1031 tmp_before = tmp_nosp = tmp_list3 = 0;
1032 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1033 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1034 /* Expressions inside the LHS are not ordered wrt. the sequence points
1035 in the RHS. Example:
1037 Despite the fact that the modification of "a" is in the before_sp
1038 list (tmp_before), it conflicts with the use of "a" in the LHS.
1039 We can handle this by adding the contents of tmp_list3
1040 to those of tmp_before, and redoing the collision warnings for that
1042 add_tlist (&tmp_before, tmp_list3, x, 1);
1043 warn_for_collisions (tmp_before);
1044 /* Exclude the LHS itself here; we first have to merge it into the
1045 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1046 didn't exclude the LHS, we'd get it twice, once as a read and once
1048 add_tlist (pno_sp, tmp_list3, x, 0);
1049 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1051 merge_tlist (pbefore_sp, tmp_before, 0);
1052 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1053 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1054 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1058 /* We need to warn about conflicts among arguments and conflicts between
1059 args and the function address. Side effects of the function address,
1060 however, are not ordered by the sequence point of the call. */
1061 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1062 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1063 if (TREE_OPERAND (x, 1))
1064 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1065 merge_tlist (&tmp_list3, tmp_list2, 0);
1066 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1067 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1068 warn_for_collisions (tmp_before);
1069 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1073 /* Scan all the list, e.g. indices of multi dimensional array. */
1076 tmp_before = tmp_nosp = 0;
1077 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1078 merge_tlist (&tmp_nosp, tmp_before, 0);
1079 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1086 struct tlist_cache *t;
1087 for (t = save_expr_cache; t; t = t->next)
1093 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1095 t->next = save_expr_cache;
1097 save_expr_cache = t;
1099 tmp_before = tmp_nosp = 0;
1100 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1101 warn_for_collisions (tmp_nosp);
1106 struct tlist *t = tmp_nosp;
1108 merge_tlist (&tmp_list3, t, 0);
1110 t->cache_before_sp = tmp_before;
1111 t->cache_after_sp = tmp_list3;
1113 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1114 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1123 if (first_rtl_op (code) == 0)
1125 x = TREE_OPERAND (x, 0);
1141 int max = first_rtl_op (TREE_CODE (x));
1142 for (lp = 0; lp < max; lp++)
1144 tmp_before = tmp_nosp = 0;
1145 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1146 merge_tlist (&tmp_nosp, tmp_before, 0);
1147 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1154 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1158 verify_sequence_points (expr)
1161 struct tlist *before_sp = 0, *after_sp = 0;
1164 save_expr_cache = 0;
1165 if (tlist_firstobj == 0)
1167 gcc_obstack_init (&tlist_obstack);
1168 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1171 verify_tree (expr, &before_sp, &after_sp, 0);
1172 warn_for_collisions (after_sp);
1173 obstack_free (&tlist_obstack, tlist_firstobj);
1177 c_expand_expr_stmt (expr)
1180 /* Do default conversion if safe and possibly important,
1181 in case within ({...}). */
1182 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr))
1183 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1184 expr = default_conversion (expr);
1186 if (warn_sequence_point)
1187 verify_sequence_points (expr);
1189 if (TREE_TYPE (expr) != error_mark_node
1190 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1191 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1192 error ("expression statement has incomplete type");
1194 last_expr_type = TREE_TYPE (expr);
1195 return add_stmt (build_stmt (EXPR_STMT, expr));
1198 /* Validate the expression after `case' and apply default promotions. */
1201 check_case_value (value)
1204 if (value == NULL_TREE)
1207 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1208 STRIP_TYPE_NOPS (value);
1209 /* In C++, the following is allowed:
1212 switch (...) { case i: ... }
1214 So, we try to reduce the VALUE to a constant that way. */
1215 if (c_language == clk_cplusplus)
1217 value = decl_constant_value (value);
1218 STRIP_TYPE_NOPS (value);
1219 value = fold (value);
1222 if (TREE_CODE (value) != INTEGER_CST
1223 && value != error_mark_node)
1225 error ("case label does not reduce to an integer constant");
1226 value = error_mark_node;
1229 /* Promote char or short to int. */
1230 value = default_conversion (value);
1232 constant_expression_warning (value);
1237 /* Return an integer type with BITS bits of precision,
1238 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1241 type_for_size (bits, unsignedp)
1245 if (bits == TYPE_PRECISION (integer_type_node))
1246 return unsignedp ? unsigned_type_node : integer_type_node;
1248 if (bits == TYPE_PRECISION (signed_char_type_node))
1249 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1251 if (bits == TYPE_PRECISION (short_integer_type_node))
1252 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1254 if (bits == TYPE_PRECISION (long_integer_type_node))
1255 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1257 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1258 return (unsignedp ? long_long_unsigned_type_node
1259 : long_long_integer_type_node);
1261 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1262 return (unsignedp ? widest_unsigned_literal_type_node
1263 : widest_integer_literal_type_node);
1265 if (bits <= TYPE_PRECISION (intQI_type_node))
1266 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1268 if (bits <= TYPE_PRECISION (intHI_type_node))
1269 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1271 if (bits <= TYPE_PRECISION (intSI_type_node))
1272 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1274 if (bits <= TYPE_PRECISION (intDI_type_node))
1275 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1280 /* Return a data type that has machine mode MODE.
1281 If the mode is an integer,
1282 then UNSIGNEDP selects between signed and unsigned types. */
1285 type_for_mode (mode, unsignedp)
1286 enum machine_mode mode;
1289 if (mode == TYPE_MODE (integer_type_node))
1290 return unsignedp ? unsigned_type_node : integer_type_node;
1292 if (mode == TYPE_MODE (signed_char_type_node))
1293 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1295 if (mode == TYPE_MODE (short_integer_type_node))
1296 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1298 if (mode == TYPE_MODE (long_integer_type_node))
1299 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1301 if (mode == TYPE_MODE (long_long_integer_type_node))
1302 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1304 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1305 return unsignedp ? widest_unsigned_literal_type_node
1306 : widest_integer_literal_type_node;
1308 if (mode == TYPE_MODE (intQI_type_node))
1309 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1311 if (mode == TYPE_MODE (intHI_type_node))
1312 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1314 if (mode == TYPE_MODE (intSI_type_node))
1315 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1317 if (mode == TYPE_MODE (intDI_type_node))
1318 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1320 #if HOST_BITS_PER_WIDE_INT >= 64
1321 if (mode == TYPE_MODE (intTI_type_node))
1322 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1325 if (mode == TYPE_MODE (float_type_node))
1326 return float_type_node;
1328 if (mode == TYPE_MODE (double_type_node))
1329 return double_type_node;
1331 if (mode == TYPE_MODE (long_double_type_node))
1332 return long_double_type_node;
1334 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1335 return build_pointer_type (char_type_node);
1337 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1338 return build_pointer_type (integer_type_node);
1340 #ifdef VECTOR_MODE_SUPPORTED_P
1341 if (mode == TYPE_MODE (V4SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1342 return V4SF_type_node;
1343 if (mode == TYPE_MODE (V4SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1344 return V4SI_type_node;
1345 if (mode == TYPE_MODE (V2SI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1346 return V2SI_type_node;
1347 if (mode == TYPE_MODE (V4HI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1348 return V4HI_type_node;
1349 if (mode == TYPE_MODE (V8QI_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1350 return V8QI_type_node;
1351 if (mode == TYPE_MODE (V2SF_type_node) && VECTOR_MODE_SUPPORTED_P (mode))
1352 return V2SF_type_node;
1358 /* Return an unsigned type the same as TYPE in other respects. */
1360 unsigned_type (type)
1363 tree type1 = TYPE_MAIN_VARIANT (type);
1364 if (type1 == signed_char_type_node || type1 == char_type_node)
1365 return unsigned_char_type_node;
1366 if (type1 == integer_type_node)
1367 return unsigned_type_node;
1368 if (type1 == short_integer_type_node)
1369 return short_unsigned_type_node;
1370 if (type1 == long_integer_type_node)
1371 return long_unsigned_type_node;
1372 if (type1 == long_long_integer_type_node)
1373 return long_long_unsigned_type_node;
1374 if (type1 == widest_integer_literal_type_node)
1375 return widest_unsigned_literal_type_node;
1376 #if HOST_BITS_PER_WIDE_INT >= 64
1377 if (type1 == intTI_type_node)
1378 return unsigned_intTI_type_node;
1380 if (type1 == intDI_type_node)
1381 return unsigned_intDI_type_node;
1382 if (type1 == intSI_type_node)
1383 return unsigned_intSI_type_node;
1384 if (type1 == intHI_type_node)
1385 return unsigned_intHI_type_node;
1386 if (type1 == intQI_type_node)
1387 return unsigned_intQI_type_node;
1389 return signed_or_unsigned_type (1, type);
1392 /* Return a signed type the same as TYPE in other respects. */
1398 tree type1 = TYPE_MAIN_VARIANT (type);
1399 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1400 return signed_char_type_node;
1401 if (type1 == unsigned_type_node)
1402 return integer_type_node;
1403 if (type1 == short_unsigned_type_node)
1404 return short_integer_type_node;
1405 if (type1 == long_unsigned_type_node)
1406 return long_integer_type_node;
1407 if (type1 == long_long_unsigned_type_node)
1408 return long_long_integer_type_node;
1409 if (type1 == widest_unsigned_literal_type_node)
1410 return widest_integer_literal_type_node;
1411 #if HOST_BITS_PER_WIDE_INT >= 64
1412 if (type1 == unsigned_intTI_type_node)
1413 return intTI_type_node;
1415 if (type1 == unsigned_intDI_type_node)
1416 return intDI_type_node;
1417 if (type1 == unsigned_intSI_type_node)
1418 return intSI_type_node;
1419 if (type1 == unsigned_intHI_type_node)
1420 return intHI_type_node;
1421 if (type1 == unsigned_intQI_type_node)
1422 return intQI_type_node;
1424 return signed_or_unsigned_type (0, type);
1427 /* Return a type the same as TYPE except unsigned or
1428 signed according to UNSIGNEDP. */
1431 signed_or_unsigned_type (unsignedp, type)
1435 if (! INTEGRAL_TYPE_P (type)
1436 || TREE_UNSIGNED (type) == unsignedp)
1439 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1440 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1441 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1442 return unsignedp ? unsigned_type_node : integer_type_node;
1443 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1444 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1445 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1446 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1447 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1448 return (unsignedp ? long_long_unsigned_type_node
1449 : long_long_integer_type_node);
1450 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1451 return (unsignedp ? widest_unsigned_literal_type_node
1452 : widest_integer_literal_type_node);
1454 #if HOST_BITS_PER_WIDE_INT >= 64
1455 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1456 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1458 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1459 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1460 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1461 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1462 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1463 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1464 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1465 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1470 /* Return the minimum number of bits needed to represent VALUE in a
1471 signed or unsigned type, UNSIGNEDP says which. */
1474 min_precision (value, unsignedp)
1480 /* If the value is negative, compute its negative minus 1. The latter
1481 adjustment is because the absolute value of the largest negative value
1482 is one larger than the largest positive value. This is equivalent to
1483 a bit-wise negation, so use that operation instead. */
1485 if (tree_int_cst_sgn (value) < 0)
1486 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1488 /* Return the number of bits needed, taking into account the fact
1489 that we need one more bit for a signed than unsigned type. */
1491 if (integer_zerop (value))
1494 log = tree_floor_log2 (value);
1496 return log + 1 + ! unsignedp;
1499 /* Print an error message for invalid operands to arith operation CODE.
1500 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1503 binary_op_error (code)
1504 enum tree_code code;
1506 register const char *opname;
1511 error ("invalid truth-value expression");
1515 opname = "+"; break;
1517 opname = "-"; break;
1519 opname = "*"; break;
1521 opname = "max"; break;
1523 opname = "min"; break;
1525 opname = "=="; break;
1527 opname = "!="; break;
1529 opname = "<="; break;
1531 opname = ">="; break;
1533 opname = "<"; break;
1535 opname = ">"; break;
1537 opname = "<<"; break;
1539 opname = ">>"; break;
1540 case TRUNC_MOD_EXPR:
1541 case FLOOR_MOD_EXPR:
1542 opname = "%"; break;
1543 case TRUNC_DIV_EXPR:
1544 case FLOOR_DIV_EXPR:
1545 opname = "/"; break;
1547 opname = "&"; break;
1549 opname = "|"; break;
1550 case TRUTH_ANDIF_EXPR:
1551 opname = "&&"; break;
1552 case TRUTH_ORIF_EXPR:
1553 opname = "||"; break;
1555 opname = "^"; break;
1558 opname = "rotate"; break;
1560 opname = "unknown"; break;
1562 error ("invalid operands to binary %s", opname);
1565 /* Subroutine of build_binary_op, used for comparison operations.
1566 See if the operands have both been converted from subword integer types
1567 and, if so, perhaps change them both back to their original type.
1568 This function is also responsible for converting the two operands
1569 to the proper common type for comparison.
1571 The arguments of this function are all pointers to local variables
1572 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1573 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1575 If this function returns nonzero, it means that the comparison has
1576 a constant value. What this function returns is an expression for
1580 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1581 tree *op0_ptr, *op1_ptr;
1583 enum tree_code *rescode_ptr;
1586 tree op0 = *op0_ptr;
1587 tree op1 = *op1_ptr;
1588 int unsignedp0, unsignedp1;
1590 tree primop0, primop1;
1591 enum tree_code code = *rescode_ptr;
1593 /* Throw away any conversions to wider types
1594 already present in the operands. */
1596 primop0 = get_narrower (op0, &unsignedp0);
1597 primop1 = get_narrower (op1, &unsignedp1);
1599 /* Handle the case that OP0 does not *contain* a conversion
1600 but it *requires* conversion to FINAL_TYPE. */
1602 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1603 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1604 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1605 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1607 /* If one of the operands must be floated, we cannot optimize. */
1608 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1609 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1611 /* If first arg is constant, swap the args (changing operation
1612 so value is preserved), for canonicalization. Don't do this if
1613 the second arg is 0. */
1615 if (TREE_CONSTANT (primop0)
1616 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1618 register tree tem = primop0;
1619 register int temi = unsignedp0;
1627 unsignedp0 = unsignedp1;
1650 *rescode_ptr = code;
1653 /* If comparing an integer against a constant more bits wide,
1654 maybe we can deduce a value of 1 or 0 independent of the data.
1655 Or else truncate the constant now
1656 rather than extend the variable at run time.
1658 This is only interesting if the constant is the wider arg.
1659 Also, it is not safe if the constant is unsigned and the
1660 variable arg is signed, since in this case the variable
1661 would be sign-extended and then regarded as unsigned.
1662 Our technique fails in this case because the lowest/highest
1663 possible unsigned results don't follow naturally from the
1664 lowest/highest possible values of the variable operand.
1665 For just EQ_EXPR and NE_EXPR there is another technique that
1666 could be used: see if the constant can be faithfully represented
1667 in the other operand's type, by truncating it and reextending it
1668 and see if that preserves the constant's value. */
1670 if (!real1 && !real2
1671 && TREE_CODE (primop1) == INTEGER_CST
1672 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1674 int min_gt, max_gt, min_lt, max_lt;
1675 tree maxval, minval;
1676 /* 1 if comparison is nominally unsigned. */
1677 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1680 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1682 /* If TYPE is an enumeration, then we need to get its min/max
1683 values from it's underlying integral type, not the enumerated
1685 if (TREE_CODE (type) == ENUMERAL_TYPE)
1686 type = type_for_size (TYPE_PRECISION (type), unsignedp0);
1688 maxval = TYPE_MAX_VALUE (type);
1689 minval = TYPE_MIN_VALUE (type);
1691 if (unsignedp && !unsignedp0)
1692 *restype_ptr = signed_type (*restype_ptr);
1694 if (TREE_TYPE (primop1) != *restype_ptr)
1695 primop1 = convert (*restype_ptr, primop1);
1696 if (type != *restype_ptr)
1698 minval = convert (*restype_ptr, minval);
1699 maxval = convert (*restype_ptr, maxval);
1702 if (unsignedp && unsignedp0)
1704 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1705 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1706 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1707 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1711 min_gt = INT_CST_LT (primop1, minval);
1712 max_gt = INT_CST_LT (primop1, maxval);
1713 min_lt = INT_CST_LT (minval, primop1);
1714 max_lt = INT_CST_LT (maxval, primop1);
1718 /* This used to be a switch, but Genix compiler can't handle that. */
1719 if (code == NE_EXPR)
1721 if (max_lt || min_gt)
1722 val = boolean_true_node;
1724 else if (code == EQ_EXPR)
1726 if (max_lt || min_gt)
1727 val = boolean_false_node;
1729 else if (code == LT_EXPR)
1732 val = boolean_true_node;
1734 val = boolean_false_node;
1736 else if (code == GT_EXPR)
1739 val = boolean_true_node;
1741 val = boolean_false_node;
1743 else if (code == LE_EXPR)
1746 val = boolean_true_node;
1748 val = boolean_false_node;
1750 else if (code == GE_EXPR)
1753 val = boolean_true_node;
1755 val = boolean_false_node;
1758 /* If primop0 was sign-extended and unsigned comparison specd,
1759 we did a signed comparison above using the signed type bounds.
1760 But the comparison we output must be unsigned.
1762 Also, for inequalities, VAL is no good; but if the signed
1763 comparison had *any* fixed result, it follows that the
1764 unsigned comparison just tests the sign in reverse
1765 (positive values are LE, negative ones GE).
1766 So we can generate an unsigned comparison
1767 against an extreme value of the signed type. */
1769 if (unsignedp && !unsignedp0)
1776 primop1 = TYPE_MIN_VALUE (type);
1782 primop1 = TYPE_MAX_VALUE (type);
1789 type = unsigned_type (type);
1792 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1794 /* This is the case of (char)x >?< 0x80, which people used to use
1795 expecting old C compilers to change the 0x80 into -0x80. */
1796 if (val == boolean_false_node)
1797 warning ("comparison is always false due to limited range of data type");
1798 if (val == boolean_true_node)
1799 warning ("comparison is always true due to limited range of data type");
1802 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1804 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1805 if (val == boolean_false_node)
1806 warning ("comparison is always false due to limited range of data type");
1807 if (val == boolean_true_node)
1808 warning ("comparison is always true due to limited range of data type");
1813 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1814 if (TREE_SIDE_EFFECTS (primop0))
1815 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1819 /* Value is not predetermined, but do the comparison
1820 in the type of the operand that is not constant.
1821 TYPE is already properly set. */
1823 else if (real1 && real2
1824 && (TYPE_PRECISION (TREE_TYPE (primop0))
1825 == TYPE_PRECISION (TREE_TYPE (primop1))))
1826 type = TREE_TYPE (primop0);
1828 /* If args' natural types are both narrower than nominal type
1829 and both extend in the same manner, compare them
1830 in the type of the wider arg.
1831 Otherwise must actually extend both to the nominal
1832 common type lest different ways of extending
1834 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1836 else if (unsignedp0 == unsignedp1 && real1 == real2
1837 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1838 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1840 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1841 type = signed_or_unsigned_type (unsignedp0
1842 || TREE_UNSIGNED (*restype_ptr),
1844 /* Make sure shorter operand is extended the right way
1845 to match the longer operand. */
1846 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1848 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1853 /* Here we must do the comparison on the nominal type
1854 using the args exactly as we received them. */
1855 type = *restype_ptr;
1859 if (!real1 && !real2 && integer_zerop (primop1)
1860 && TREE_UNSIGNED (*restype_ptr))
1866 /* All unsigned values are >= 0, so we warn if extra warnings
1867 are requested. However, if OP0 is a constant that is
1868 >= 0, the signedness of the comparison isn't an issue,
1869 so suppress the warning. */
1870 if (extra_warnings && !in_system_header
1871 && ! (TREE_CODE (primop0) == INTEGER_CST
1872 && ! TREE_OVERFLOW (convert (signed_type (type),
1874 warning ("comparison of unsigned expression >= 0 is always true");
1875 value = boolean_true_node;
1879 if (extra_warnings && !in_system_header
1880 && ! (TREE_CODE (primop0) == INTEGER_CST
1881 && ! TREE_OVERFLOW (convert (signed_type (type),
1883 warning ("comparison of unsigned expression < 0 is always false");
1884 value = boolean_false_node;
1893 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1894 if (TREE_SIDE_EFFECTS (primop0))
1895 return build (COMPOUND_EXPR, TREE_TYPE (value),
1902 *op0_ptr = convert (type, primop0);
1903 *op1_ptr = convert (type, primop1);
1905 *restype_ptr = boolean_type_node;
1910 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1911 or validate its data type for an `if' or `while' statement or ?..: exp.
1913 This preparation consists of taking the ordinary
1914 representation of an expression expr and producing a valid tree
1915 boolean expression describing whether expr is nonzero. We could
1916 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1917 but we optimize comparisons, &&, ||, and !.
1919 The resulting type should always be `boolean_type_node'. */
1922 truthvalue_conversion (expr)
1925 if (TREE_CODE (expr) == ERROR_MARK)
1928 #if 0 /* This appears to be wrong for C++. */
1929 /* These really should return error_mark_node after 2.4 is stable.
1930 But not all callers handle ERROR_MARK properly. */
1931 switch (TREE_CODE (TREE_TYPE (expr)))
1934 error ("struct type value used where scalar is required");
1935 return boolean_false_node;
1938 error ("union type value used where scalar is required");
1939 return boolean_false_node;
1942 error ("array type value used where scalar is required");
1943 return boolean_false_node;
1950 switch (TREE_CODE (expr))
1953 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
1954 case TRUTH_ANDIF_EXPR:
1955 case TRUTH_ORIF_EXPR:
1956 case TRUTH_AND_EXPR:
1958 case TRUTH_XOR_EXPR:
1959 case TRUTH_NOT_EXPR:
1960 TREE_TYPE (expr) = boolean_type_node;
1967 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
1970 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
1973 /* If we are taking the address of a external decl, it might be zero
1974 if it is weak, so we cannot optimize. */
1975 if (DECL_P (TREE_OPERAND (expr, 0))
1976 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
1979 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
1980 return build (COMPOUND_EXPR, boolean_type_node,
1981 TREE_OPERAND (expr, 0), boolean_true_node);
1983 return boolean_true_node;
1986 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
1987 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
1988 truthvalue_conversion (TREE_OPERAND (expr, 0)),
1989 truthvalue_conversion (TREE_OPERAND (expr, 1)),
1996 /* These don't change whether an object is non-zero or zero. */
1997 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2001 /* These don't change whether an object is zero or non-zero, but
2002 we can't ignore them if their second arg has side-effects. */
2003 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2004 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2005 truthvalue_conversion (TREE_OPERAND (expr, 0)));
2007 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2010 /* Distribute the conversion into the arms of a COND_EXPR. */
2011 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2012 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2013 truthvalue_conversion (TREE_OPERAND (expr, 2))));
2016 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2017 since that affects how `default_conversion' will behave. */
2018 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2019 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2021 /* fall through... */
2023 /* If this is widening the argument, we can ignore it. */
2024 if (TYPE_PRECISION (TREE_TYPE (expr))
2025 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2026 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2030 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2032 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT
2033 && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE)
2035 /* fall through... */
2037 /* This and MINUS_EXPR can be changed into a comparison of the
2039 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2040 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2041 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2042 TREE_OPERAND (expr, 1), 1);
2043 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2044 fold (build1 (NOP_EXPR,
2045 TREE_TYPE (TREE_OPERAND (expr, 0)),
2046 TREE_OPERAND (expr, 1))), 1);
2049 if (integer_onep (TREE_OPERAND (expr, 1))
2050 && TREE_TYPE (expr) != boolean_type_node)
2051 /* Using convert here would cause infinite recursion. */
2052 return build1 (NOP_EXPR, boolean_type_node, expr);
2056 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2057 warning ("suggest parentheses around assignment used as truth value");
2064 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2066 tree tem = save_expr (expr);
2067 return (build_binary_op
2068 ((TREE_SIDE_EFFECTS (expr)
2069 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2070 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2071 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2075 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2078 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2079 int, enum built_in_class, int, int,
2082 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2083 down to the element type of an array. */
2086 c_build_qualified_type (type, type_quals)
2090 /* A restrict-qualified pointer type must be a pointer to object or
2091 incomplete type. Note that the use of POINTER_TYPE_P also allows
2092 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2093 the C++ front-end also use POINTER_TYPE for pointer-to-member
2094 values, so even though it should be illegal to use `restrict'
2095 with such an entity we don't flag that here. Thus, special case
2096 code for that case is required in the C++ front-end. */
2097 if ((type_quals & TYPE_QUAL_RESTRICT)
2098 && (!POINTER_TYPE_P (type)
2099 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2101 error ("invalid use of `restrict'");
2102 type_quals &= ~TYPE_QUAL_RESTRICT;
2105 if (TREE_CODE (type) == ARRAY_TYPE)
2106 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2108 TYPE_DOMAIN (type));
2109 return build_qualified_type (type, type_quals);
2112 /* Apply the TYPE_QUALS to the new DECL. */
2115 c_apply_type_quals_to_decl (type_quals, decl)
2119 if ((type_quals & TYPE_QUAL_CONST)
2120 || (TREE_TYPE (decl)
2121 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2122 TREE_READONLY (decl) = 1;
2123 if (type_quals & TYPE_QUAL_VOLATILE)
2125 TREE_SIDE_EFFECTS (decl) = 1;
2126 TREE_THIS_VOLATILE (decl) = 1;
2128 if (type_quals & TYPE_QUAL_RESTRICT)
2130 if (!TREE_TYPE (decl)
2131 || !POINTER_TYPE_P (TREE_TYPE (decl))
2132 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2133 error ("invalid use of `restrict'");
2134 else if (flag_strict_aliasing)
2136 /* No two restricted pointers can point at the same thing.
2137 However, a restricted pointer can point at the same thing
2138 as an unrestricted pointer, if that unrestricted pointer
2139 is based on the restricted pointer. So, we make the
2140 alias set for the restricted pointer a subset of the
2141 alias set for the type pointed to by the type of the
2144 HOST_WIDE_INT pointed_to_alias_set
2145 = get_alias_set (TREE_TYPE (TREE_TYPE (decl)));
2147 if (pointed_to_alias_set == 0)
2148 /* It's not legal to make a subset of alias set zero. */
2152 DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();
2153 record_alias_subset (pointed_to_alias_set,
2154 DECL_POINTER_ALIAS_SET (decl));
2161 /* Return the typed-based alias set for T, which may be an expression
2162 or a type. Return -1 if we don't do anything special. */
2165 lang_get_alias_set (t)
2170 /* We know nothing about vector types */
2171 if (TREE_CODE (t) == VECTOR_TYPE)
2174 /* Permit type-punning when accessing a union, provided the access
2175 is directly through the union. For example, this code does not
2176 permit taking the address of a union member and then storing
2177 through it. Even the type-punning allowed here is a GCC
2178 extension, albeit a common and useful one; the C standard says
2179 that such accesses have implementation-defined behavior. */
2181 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2182 u = TREE_OPERAND (u, 0))
2183 if (TREE_CODE (u) == COMPONENT_REF
2184 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2187 /* If this is a char *, the ANSI C standard says it can alias
2188 anything. Note that all references need do this. */
2189 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2190 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2191 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2194 /* That's all the expressions we handle specially. */
2198 /* The C standard specifically allows aliasing between signed and
2199 unsigned variants of the same type. We treat the signed
2200 variant as canonical. */
2201 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2203 tree t1 = signed_type (t);
2205 /* t1 == t can happen for boolean nodes which are always unsigned. */
2207 return get_alias_set (t1);
2209 else if (POINTER_TYPE_P (t))
2213 /* Unfortunately, there is no canonical form of a pointer type.
2214 In particular, if we have `typedef int I', then `int *', and
2215 `I *' are different types. So, we have to pick a canonical
2216 representative. We do this below.
2218 Technically, this approach is actually more conservative that
2219 it needs to be. In particular, `const int *' and `int *'
2220 chould be in different alias sets, according to the C and C++
2221 standard, since their types are not the same, and so,
2222 technically, an `int **' and `const int **' cannot point at
2225 But, the standard is wrong. In particular, this code is
2230 const int* const* cipp = &ipp;
2232 And, it doesn't make sense for that to be legal unless you
2233 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2234 the pointed-to types. This issue has been reported to the
2236 t1 = build_type_no_quals (t);
2238 return get_alias_set (t1);
2240 /* It's not yet safe to use alias sets for classes in C++ because
2241 the TYPE_FIELDs list for a class doesn't mention base classes. */
2242 else if (c_language == clk_cplusplus && AGGREGATE_TYPE_P (t))
2248 /* Implement the __alignof keyword: Return the minimum required
2249 alignment of TYPE, measured in bytes. */
2255 enum tree_code code = TREE_CODE (type);
2258 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2259 if (code == REFERENCE_TYPE)
2261 type = TREE_TYPE (type);
2262 code = TREE_CODE (type);
2265 if (code == FUNCTION_TYPE)
2266 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2267 else if (code == VOID_TYPE || code == ERROR_MARK)
2269 else if (!COMPLETE_TYPE_P (type))
2271 error ("__alignof__ applied to an incomplete type");
2275 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2277 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2280 /* Implement the __alignof keyword: Return the minimum required
2281 alignment of EXPR, measured in bytes. For VAR_DECL's and
2282 FIELD_DECL's return DECL_ALIGN (which can be set from an
2283 "aligned" __attribute__ specification). */
2286 c_alignof_expr (expr)
2291 if (TREE_CODE (expr) == VAR_DECL)
2292 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2294 else if (TREE_CODE (expr) == COMPONENT_REF
2295 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2297 error ("`__alignof' applied to a bit-field");
2300 else if (TREE_CODE (expr) == COMPONENT_REF
2301 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2302 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2304 else if (TREE_CODE (expr) == INDIRECT_REF)
2306 tree t = TREE_OPERAND (expr, 0);
2308 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2310 while (TREE_CODE (t) == NOP_EXPR
2311 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2315 t = TREE_OPERAND (t, 0);
2316 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2317 if (thisalign > bestalign)
2318 best = t, bestalign = thisalign;
2320 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2323 return c_alignof (TREE_TYPE (expr));
2325 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2328 /* Give the specifications for the format attributes, used by C and all
2331 static const struct attribute_spec c_format_attribute_table[] =
2333 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2334 { "format", 3, 3, false, true, true,
2335 handle_format_attribute },
2336 { "format_arg", 1, 1, false, true, true,
2337 handle_format_arg_attribute },
2338 { NULL, 0, 0, false, false, false, NULL }
2341 /* Build tree nodes and builtin functions common to both C and C++ language
2345 c_common_nodes_and_builtins ()
2349 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2350 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2351 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2352 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2353 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2354 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2355 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2356 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2357 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2358 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2359 #include "builtin-types.def"
2360 #undef DEF_PRIMITIVE_TYPE
2361 #undef DEF_FUNCTION_TYPE_0
2362 #undef DEF_FUNCTION_TYPE_1
2363 #undef DEF_FUNCTION_TYPE_2
2364 #undef DEF_FUNCTION_TYPE_3
2365 #undef DEF_FUNCTION_TYPE_4
2366 #undef DEF_FUNCTION_TYPE_VAR_0
2367 #undef DEF_FUNCTION_TYPE_VAR_1
2368 #undef DEF_FUNCTION_TYPE_VAR_2
2369 #undef DEF_POINTER_TYPE
2373 typedef enum builtin_type builtin_type;
2375 tree builtin_types[(int)BT_LAST];
2376 int wchar_type_size;
2377 tree array_domain_type;
2378 /* Either char* or void*. */
2379 tree traditional_ptr_type_node;
2380 /* Either const char* or const void*. */
2381 tree traditional_cptr_type_node;
2382 tree traditional_len_type_node;
2383 tree va_list_ref_type_node;
2384 tree va_list_arg_type_node;
2386 /* We must initialize this before any builtin functions (which might have
2387 attributes) are declared. (c_common_lang_init is too late.) */
2388 format_attribute_table = c_format_attribute_table;
2390 /* Define `int' and `char' first so that dbx will output them first. */
2391 record_builtin_type (RID_INT, NULL, integer_type_node);
2392 record_builtin_type (RID_CHAR, "char", char_type_node);
2394 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2395 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2396 but not C. Are the conditionals here needed? */
2397 if (c_language == clk_cplusplus)
2398 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2399 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2400 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2401 record_builtin_type (RID_MAX, "long unsigned int",
2402 long_unsigned_type_node);
2403 if (c_language == clk_cplusplus)
2404 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2405 record_builtin_type (RID_MAX, "long long int",
2406 long_long_integer_type_node);
2407 record_builtin_type (RID_MAX, "long long unsigned int",
2408 long_long_unsigned_type_node);
2409 if (c_language == clk_cplusplus)
2410 record_builtin_type (RID_MAX, "long long unsigned",
2411 long_long_unsigned_type_node);
2412 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2413 record_builtin_type (RID_MAX, "short unsigned int",
2414 short_unsigned_type_node);
2415 if (c_language == clk_cplusplus)
2416 record_builtin_type (RID_MAX, "unsigned short",
2417 short_unsigned_type_node);
2419 /* Define both `signed char' and `unsigned char'. */
2420 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2421 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2423 /* These are types that type_for_size and type_for_mode use. */
2424 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intQI_type_node));
2425 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intHI_type_node));
2426 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intSI_type_node));
2427 pushdecl (build_decl (TYPE_DECL, NULL_TREE, intDI_type_node));
2428 #if HOST_BITS_PER_WIDE_INT >= 64
2429 pushdecl (build_decl (TYPE_DECL, get_identifier ("__int128_t"), intTI_type_node));
2431 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intQI_type_node));
2432 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intHI_type_node));
2433 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intSI_type_node));
2434 pushdecl (build_decl (TYPE_DECL, NULL_TREE, unsigned_intDI_type_node));
2435 #if HOST_BITS_PER_WIDE_INT >= 64
2436 pushdecl (build_decl (TYPE_DECL, get_identifier ("__uint128_t"), unsigned_intTI_type_node));
2439 /* Create the widest literal types. */
2440 widest_integer_literal_type_node
2441 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2442 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2443 widest_integer_literal_type_node));
2445 widest_unsigned_literal_type_node
2446 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2447 pushdecl (build_decl (TYPE_DECL, NULL_TREE,
2448 widest_unsigned_literal_type_node));
2450 /* `unsigned long' is the standard type for sizeof.
2451 Note that stddef.h uses `unsigned long',
2452 and this must agree, even if long and int are the same size. */
2454 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2455 signed_size_type_node = signed_type (c_size_type_node);
2456 if (flag_traditional)
2457 c_size_type_node = signed_size_type_node;
2458 set_sizetype (c_size_type_node);
2460 build_common_tree_nodes_2 (flag_short_double);
2462 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2463 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2464 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2466 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),
2467 complex_integer_type_node));
2468 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
2469 complex_float_type_node));
2470 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),
2471 complex_double_type_node));
2472 pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2473 complex_long_double_type_node));
2475 record_builtin_type (RID_VOID, NULL, void_type_node);
2477 void_zero_node = build_int_2 (0, 0);
2478 TREE_TYPE (void_zero_node) = void_type_node;
2480 void_list_node = build_void_list_node ();
2482 /* Make a type to be the domain of a few array types
2483 whose domains don't really matter.
2484 200 is small enough that it always fits in size_t
2485 and large enough that it can hold most function names for the
2486 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2487 array_domain_type = build_index_type (size_int (200));
2489 /* Make a type for arrays of characters.
2490 With luck nothing will ever really depend on the length of this
2492 char_array_type_node
2493 = build_array_type (char_type_node, array_domain_type);
2495 /* Likewise for arrays of ints. */
2497 = build_array_type (integer_type_node, array_domain_type);
2499 string_type_node = build_pointer_type (char_type_node);
2500 const_string_type_node
2501 = build_pointer_type (build_qualified_type
2502 (char_type_node, TYPE_QUAL_CONST));
2504 traditional_ptr_type_node = ((flag_traditional &&
2505 c_language != clk_cplusplus)
2506 ? string_type_node : ptr_type_node);
2507 traditional_cptr_type_node = ((flag_traditional &&
2508 c_language != clk_cplusplus)
2509 ? const_string_type_node : const_ptr_type_node);
2511 (*targetm.init_builtins) ();
2513 /* This is special for C++ so functions can be overloaded. */
2514 wchar_type_node = get_identifier (flag_short_wchar
2515 ? "short unsigned int"
2517 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2518 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2519 if (c_language == clk_cplusplus)
2521 if (TREE_UNSIGNED (wchar_type_node))
2522 wchar_type_node = make_unsigned_type (wchar_type_size);
2524 wchar_type_node = make_signed_type (wchar_type_size);
2525 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2529 signed_wchar_type_node = signed_type (wchar_type_node);
2530 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2533 /* This is for wide string constants. */
2534 wchar_array_type_node
2535 = build_array_type (wchar_type_node, array_domain_type);
2538 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2541 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2543 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2545 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2547 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2548 unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2550 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2551 va_list_type_node));
2553 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2554 ptrdiff_type_node));
2556 pushdecl (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2559 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2561 va_list_arg_type_node = va_list_ref_type_node =
2562 build_pointer_type (TREE_TYPE (va_list_type_node));
2566 va_list_arg_type_node = va_list_type_node;
2567 va_list_ref_type_node = build_reference_type (va_list_type_node);
2570 traditional_len_type_node = ((flag_traditional &&
2571 c_language != clk_cplusplus)
2572 ? integer_type_node : sizetype);
2574 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2575 builtin_types[(int) ENUM] = VALUE;
2576 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2577 builtin_types[(int) ENUM] \
2578 = build_function_type (builtin_types[(int) RETURN], \
2580 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2581 builtin_types[(int) ENUM] \
2582 = build_function_type (builtin_types[(int) RETURN], \
2583 tree_cons (NULL_TREE, \
2584 builtin_types[(int) ARG1], \
2586 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2587 builtin_types[(int) ENUM] \
2588 = build_function_type \
2589 (builtin_types[(int) RETURN], \
2590 tree_cons (NULL_TREE, \
2591 builtin_types[(int) ARG1], \
2592 tree_cons (NULL_TREE, \
2593 builtin_types[(int) ARG2], \
2595 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2596 builtin_types[(int) ENUM] \
2597 = build_function_type \
2598 (builtin_types[(int) RETURN], \
2599 tree_cons (NULL_TREE, \
2600 builtin_types[(int) ARG1], \
2601 tree_cons (NULL_TREE, \
2602 builtin_types[(int) ARG2], \
2603 tree_cons (NULL_TREE, \
2604 builtin_types[(int) ARG3], \
2606 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2607 builtin_types[(int) ENUM] \
2608 = build_function_type \
2609 (builtin_types[(int) RETURN], \
2610 tree_cons (NULL_TREE, \
2611 builtin_types[(int) ARG1], \
2612 tree_cons (NULL_TREE, \
2613 builtin_types[(int) ARG2], \
2616 builtin_types[(int) ARG3], \
2617 tree_cons (NULL_TREE, \
2618 builtin_types[(int) ARG4], \
2619 void_list_node)))));
2620 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2621 builtin_types[(int) ENUM] \
2622 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2623 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2624 builtin_types[(int) ENUM] \
2625 = build_function_type (builtin_types[(int) RETURN], \
2626 tree_cons (NULL_TREE, \
2627 builtin_types[(int) ARG1], \
2630 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2631 builtin_types[(int) ENUM] \
2632 = build_function_type \
2633 (builtin_types[(int) RETURN], \
2634 tree_cons (NULL_TREE, \
2635 builtin_types[(int) ARG1], \
2636 tree_cons (NULL_TREE, \
2637 builtin_types[(int) ARG2], \
2639 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2640 builtin_types[(int) ENUM] \
2641 = build_pointer_type (builtin_types[(int) TYPE]);
2642 #include "builtin-types.def"
2643 #undef DEF_PRIMITIVE_TYPE
2644 #undef DEF_FUNCTION_TYPE_1
2645 #undef DEF_FUNCTION_TYPE_2
2646 #undef DEF_FUNCTION_TYPE_3
2647 #undef DEF_FUNCTION_TYPE_4
2648 #undef DEF_FUNCTION_TYPE_VAR_0
2649 #undef DEF_FUNCTION_TYPE_VAR_1
2650 #undef DEF_POINTER_TYPE
2652 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2653 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2658 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2662 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2665 ? (NAME + strlen ("__builtin_")) \
2668 decl = builtin_function_2 (NAME, \
2669 NAME + strlen ("__builtin_"), \
2670 builtin_types[TYPE], \
2671 builtin_types[LIBTYPE], \
2676 /*noreturn_p=*/0); \
2678 built_in_decls[(int) ENUM] = decl; \
2680 #include "builtins.def"
2683 /* Declare _exit and _Exit just to mark them as non-returning. */
2684 builtin_function_2 (NULL, "_exit", NULL_TREE,
2685 builtin_types[BT_FN_VOID_INT],
2686 0, NOT_BUILT_IN, 0, 1, 1);
2687 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2688 builtin_types[BT_FN_VOID_INT],
2689 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2691 /* Declare these functions non-returning
2692 to avoid spurious "control drops through" warnings. */
2693 builtin_function_2 (NULL, "abort",
2694 NULL_TREE, ((c_language == clk_cplusplus)
2695 ? builtin_types[BT_FN_VOID]
2696 : builtin_types[BT_FN_VOID_VAR]),
2697 0, NOT_BUILT_IN, 0, 0, 1);
2699 builtin_function_2 (NULL, "exit",
2700 NULL_TREE, ((c_language == clk_cplusplus)
2701 ? builtin_types[BT_FN_VOID_INT]
2702 : builtin_types[BT_FN_VOID_VAR]),
2703 0, NOT_BUILT_IN, 0, 0, 1);
2705 main_identifier_node = get_identifier ("main");
2707 /* ??? Perhaps there's a better place to do this. But it is related
2708 to __builtin_va_arg, so it isn't that off-the-wall. */
2709 lang_type_promotes_to = simple_type_promotes_to;
2713 build_va_arg (expr, type)
2716 return build1 (VA_ARG_EXPR, type, expr);
2720 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2721 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2722 of these may be NULL (though both being NULL is useless).
2723 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2724 TYPE is the type of the function with the ordinary name. These
2725 may differ if the ordinary name is declared with a looser type to avoid
2726 conflicts with headers. FUNCTION_CODE and CLASS are as for
2727 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2728 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2729 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2730 NORETURN_P is nonzero, the function is marked as non-returning.
2731 Returns the declaration of BUILTIN_NAME, if any, otherwise
2732 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2733 or if NONANSI_P and flag_no_nonansi_builtin. */
2736 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2737 class, library_name_p, nonansi_p, noreturn_p)
2738 const char *builtin_name;
2743 enum built_in_class class;
2748 tree bdecl = NULL_TREE;
2749 tree decl = NULL_TREE;
2750 if (builtin_name != 0)
2752 bdecl = builtin_function (builtin_name, builtin_type, function_code,
2753 class, library_name_p ? name : NULL);
2756 TREE_THIS_VOLATILE (bdecl) = 1;
2757 TREE_SIDE_EFFECTS (bdecl) = 1;
2760 if (name != 0 && !flag_no_builtin && !(nonansi_p && flag_no_nonansi_builtin))
2762 decl = builtin_function (name, type, function_code, class, NULL);
2764 DECL_BUILT_IN_NONANSI (decl) = 1;
2767 TREE_THIS_VOLATILE (decl) = 1;
2768 TREE_SIDE_EFFECTS (decl) = 1;
2771 return (bdecl != 0 ? bdecl : decl);
2774 /* Nonzero if the type T promotes to int. This is (nearly) the
2775 integral promotions defined in ISO C99 6.3.1.1/2. */
2778 c_promoting_integer_type_p (t)
2781 switch (TREE_CODE (t))
2784 return (TYPE_MAIN_VARIANT (t) == char_type_node
2785 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2786 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2787 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2788 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
2789 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
2792 /* ??? Technically all enumerations not larger than an int
2793 promote to an int. But this is used along code paths
2794 that only want to notice a size change. */
2795 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
2805 /* Given a type, apply default promotions wrt unnamed function arguments
2806 and return the new type. Return NULL_TREE if no change. */
2807 /* ??? There is a function of the same name in the C++ front end that
2808 does something similar, but is more thorough and does not return NULL
2809 if no change. We could perhaps share code, but it would make the
2810 self_promoting_type property harder to identify. */
2813 simple_type_promotes_to (type)
2816 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2817 return double_type_node;
2819 if (c_promoting_integer_type_p (type))
2821 /* Traditionally, unsignedness is preserved in default promotions.
2822 Also preserve unsignedness if not really getting any wider. */
2823 if (TREE_UNSIGNED (type)
2824 && (flag_traditional
2825 || TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
2826 return unsigned_type_node;
2827 return integer_type_node;
2833 /* Return 1 if PARMS specifies a fixed number of parameters
2834 and none of their types is affected by default promotions. */
2837 self_promoting_args_p (parms)
2841 for (t = parms; t; t = TREE_CHAIN (t))
2843 register tree type = TREE_VALUE (t);
2845 if (TREE_CHAIN (t) == 0 && type != void_type_node)
2851 if (TYPE_MAIN_VARIANT (type) == float_type_node)
2854 if (c_promoting_integer_type_p (type))
2860 /* Recursively examines the array elements of TYPE, until a non-array
2861 element type is found. */
2864 strip_array_types (type)
2867 while (TREE_CODE (type) == ARRAY_TYPE)
2868 type = TREE_TYPE (type);
2873 /* Recognize certain built-in functions so we can make tree-codes
2874 other than CALL_EXPR. We do this when it enables fold-const.c
2875 to do something useful. */
2876 /* ??? By rights this should go in builtins.c, but only C and C++
2877 implement build_{binary,unary}_op. Not exactly sure what bits
2878 of functionality are actually needed from those functions, or
2879 where the similar functionality exists in the other front ends. */
2882 expand_tree_builtin (function, params, coerced_params)
2883 tree function, params, coerced_params;
2885 enum tree_code code;
2887 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
2890 switch (DECL_FUNCTION_CODE (function))
2894 case BUILT_IN_LLABS:
2895 case BUILT_IN_IMAXABS:
2897 case BUILT_IN_FABSL:
2898 case BUILT_IN_FABSF:
2899 if (coerced_params == 0)
2900 return integer_zero_node;
2901 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
2904 case BUILT_IN_CONJF:
2905 case BUILT_IN_CONJL:
2906 if (coerced_params == 0)
2907 return integer_zero_node;
2908 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
2910 case BUILT_IN_CREAL:
2911 case BUILT_IN_CREALF:
2912 case BUILT_IN_CREALL:
2913 if (coerced_params == 0)
2914 return integer_zero_node;
2915 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
2917 case BUILT_IN_CIMAG:
2918 case BUILT_IN_CIMAGF:
2919 case BUILT_IN_CIMAGL:
2920 if (coerced_params == 0)
2921 return integer_zero_node;
2922 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
2924 case BUILT_IN_ISGREATER:
2925 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2931 case BUILT_IN_ISGREATEREQUAL:
2932 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2938 case BUILT_IN_ISLESS:
2939 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2945 case BUILT_IN_ISLESSEQUAL:
2946 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2952 case BUILT_IN_ISLESSGREATER:
2953 if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT)
2959 case BUILT_IN_ISUNORDERED:
2960 if (TARGET_FLOAT_FORMAT != IEEE_FLOAT_FORMAT)
2961 return integer_zero_node;
2962 code = UNORDERED_EXPR;
2970 || TREE_CHAIN (params) == 0)
2972 error ("too few arguments to function `%s'",
2973 IDENTIFIER_POINTER (DECL_NAME (function)));
2974 return error_mark_node;
2976 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
2978 error ("too many arguments to function `%s'",
2979 IDENTIFIER_POINTER (DECL_NAME (function)));
2980 return error_mark_node;
2983 arg0 = TREE_VALUE (params);
2984 arg1 = TREE_VALUE (TREE_CHAIN (params));
2985 arg0 = build_binary_op (code, arg0, arg1, 0);
2986 if (code != UNORDERED_EXPR)
2987 arg0 = build_unary_op (TRUTH_NOT_EXPR, arg0, 0);
2999 /* Returns non-zero if CODE is the code for a statement. */
3002 statement_code_p (code)
3003 enum tree_code code;
3026 if (lang_statement_code_p)
3027 return (*lang_statement_code_p) (code);
3032 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3033 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3034 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3035 value, the traversal is aborted, and the value returned by FUNC is
3036 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3037 the node being visited are not walked.
3039 We don't need a without_duplicates variant of this one because the
3040 statement tree is a tree, not a graph. */
3043 walk_stmt_tree (tp, func, data)
3048 enum tree_code code;
3053 #define WALK_SUBTREE(NODE) \
3056 result = walk_stmt_tree (&(NODE), func, data); \
3062 /* Skip empty subtrees. */
3066 /* Skip subtrees below non-statement nodes. */
3067 if (!statement_code_p (TREE_CODE (*tp)))
3070 /* Call the function. */
3072 result = (*func) (tp, &walk_subtrees, data);
3074 /* If we found something, return it. */
3078 /* FUNC may have modified the tree, recheck that we're looking at a
3080 code = TREE_CODE (*tp);
3081 if (!statement_code_p (code))
3084 /* Visit the subtrees unless FUNC decided that there was nothing
3085 interesting below this point in the tree. */
3088 /* Walk over all the sub-trees of this operand. Statement nodes
3089 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3090 len = TREE_CODE_LENGTH (code);
3092 /* Go through the subtrees. We need to do this in forward order so
3093 that the scope of a FOR_EXPR is handled properly. */
3094 for (i = 0; i < len; ++i)
3095 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3098 /* Finally visit the chain. This can be tail-recursion optimized if
3099 we write it this way. */
3100 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3105 /* Used to compare case labels. K1 and K2 are actually tree nodes
3106 representing case labels, or NULL_TREE for a `default' label.
3107 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3108 K2, and 0 if K1 and K2 are equal. */
3111 case_compare (k1, k2)
3115 /* Consider a NULL key (such as arises with a `default' label) to be
3116 smaller than anything else. */
3122 return tree_int_cst_compare ((tree) k1, (tree) k2);
3125 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3126 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3127 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3128 case label was declared using the usual C/C++ syntax, rather than
3129 the GNU case range extension. CASES is a tree containing all the
3130 case ranges processed so far; COND is the condition for the
3131 switch-statement itself. Returns the CASE_LABEL created, or
3132 ERROR_MARK_NODE if no CASE_LABEL is created. */
3135 c_add_case_label (cases, cond, low_value, high_value)
3144 splay_tree_node node;
3146 /* Create the LABEL_DECL itself. */
3147 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3148 DECL_CONTEXT (label) = current_function_decl;
3150 /* If there was an error processing the switch condition, bail now
3151 before we get more confused. */
3152 if (!cond || cond == error_mark_node)
3154 /* Add a label anyhow so that the back-end doesn't think that
3155 the beginning of the switch is unreachable. */
3157 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3158 return error_mark_node;
3161 if ((low_value && TREE_TYPE (low_value)
3162 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3163 || (high_value && TREE_TYPE (high_value)
3164 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3165 error ("pointers are not permitted as case values");
3167 /* Case ranges are a GNU extension. */
3168 if (high_value && pedantic)
3170 if (c_language == clk_cplusplus)
3171 pedwarn ("ISO C++ forbids range expressions in switch statements");
3173 pedwarn ("ISO C forbids range expressions in switch statements");
3176 type = TREE_TYPE (cond);
3179 low_value = check_case_value (low_value);
3180 low_value = convert_and_check (type, low_value);
3184 high_value = check_case_value (high_value);
3185 high_value = convert_and_check (type, high_value);
3188 /* If an error has occurred, bail out now. */
3189 if (low_value == error_mark_node || high_value == error_mark_node)
3192 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3193 return error_mark_node;
3196 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3197 really a case range, even though it was written that way. Remove
3198 the HIGH_VALUE to simplify later processing. */
3199 if (tree_int_cst_equal (low_value, high_value))
3200 high_value = NULL_TREE;
3201 if (low_value && high_value
3202 && !tree_int_cst_lt (low_value, high_value))
3203 warning ("empty range specified");
3205 /* Look up the LOW_VALUE in the table of case labels we already
3207 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3208 /* If there was not an exact match, check for overlapping ranges.
3209 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3210 that's a `default' label and the only overlap is an exact match. */
3211 if (!node && (low_value || high_value))
3213 splay_tree_node low_bound;
3214 splay_tree_node high_bound;
3216 /* Even though there wasn't an exact match, there might be an
3217 overlap between this case range and another case range.
3218 Since we've (inductively) not allowed any overlapping case
3219 ranges, we simply need to find the greatest low case label
3220 that is smaller that LOW_VALUE, and the smallest low case
3221 label that is greater than LOW_VALUE. If there is an overlap
3222 it will occur in one of these two ranges. */
3223 low_bound = splay_tree_predecessor (cases,
3224 (splay_tree_key) low_value);
3225 high_bound = splay_tree_successor (cases,
3226 (splay_tree_key) low_value);
3228 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3229 the LOW_VALUE, so there is no need to check unless the
3230 LOW_BOUND is in fact itself a case range. */
3232 && CASE_HIGH ((tree) low_bound->value)
3233 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3236 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3237 range is bigger than the low end of the current range, so we
3238 are only interested if the current range is a real range, and
3239 not an ordinary case label. */
3242 && (tree_int_cst_compare ((tree) high_bound->key,
3247 /* If there was an overlap, issue an error. */
3250 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3254 error ("duplicate (or overlapping) case value");
3255 error_with_decl (duplicate,
3256 "this is the first entry overlapping that value");
3260 error ("duplicate case value") ;
3261 error_with_decl (duplicate, "previously used here");
3265 error ("multiple default labels in one switch");
3266 error_with_decl (duplicate, "this is the first default label");
3269 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3272 /* Add a CASE_LABEL to the statement-tree. */
3273 case_label = add_stmt (build_case_label (low_value, high_value, label));
3274 /* Register this case label in the splay tree. */
3275 splay_tree_insert (cases,
3276 (splay_tree_key) low_value,
3277 (splay_tree_value) case_label);
3282 /* Finish an expression taking the address of LABEL. Returns an
3283 expression for the address. */
3286 finish_label_address_expr (label)
3293 if (c_language == clk_cplusplus)
3294 pedwarn ("ISO C++ forbids taking the address of a label");
3296 pedwarn ("ISO C forbids taking the address of a label");
3299 label = lookup_label (label);
3300 if (label == NULL_TREE)
3301 result = null_pointer_node;
3304 TREE_USED (label) = 1;
3305 result = build1 (ADDR_EXPR, ptr_type_node, label);
3306 TREE_CONSTANT (result) = 1;
3307 /* The current function in not necessarily uninlinable.
3308 Computed gotos are incompatible with inlining, but the value
3309 here could be used only in a diagnostic, for example. */
3315 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3316 parameter allows this function to be used as a GC-marking
3323 stmt_tree st = (stmt_tree) p;
3325 ggc_mark_tree (st->x_last_stmt);
3326 ggc_mark_tree (st->x_last_expr_type);
3329 /* Mark LD for GC. */
3332 c_mark_lang_decl (c)
3333 struct c_lang_decl *c;
3337 /* Mark F for GC. */
3340 mark_c_language_function (f)
3341 struct language_function *f;
3346 mark_stmt_tree (&f->x_stmt_tree);
3347 ggc_mark_tree (f->x_scope_stmt_stack);
3350 /* Hook used by expand_expr to expand language-specific tree codes. */
3353 c_expand_expr (exp, target, tmode, modifier)
3356 enum machine_mode tmode;
3357 enum expand_modifier modifier;
3359 switch (TREE_CODE (exp))
3366 /* Since expand_expr_stmt calls free_temp_slots after every
3367 expression statement, we must call push_temp_slots here.
3368 Otherwise, any temporaries in use now would be considered
3369 out-of-scope after the first EXPR_STMT from within the
3372 rtl_expr = expand_start_stmt_expr ();
3373 expand_stmt (STMT_EXPR_STMT (exp));
3374 expand_end_stmt_expr (rtl_expr);
3375 result = expand_expr (rtl_expr, target, tmode, modifier);
3383 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3384 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3386 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3387 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3388 == BUILT_IN_FRONTEND))
3389 return c_expand_builtin (exp, target, tmode, modifier);
3403 /* Hook used by safe_from_p to handle language-specific tree codes. */
3406 c_safe_from_p (target, exp)
3410 /* We can see statements here when processing the body of a
3411 statement-expression. For a declaration statement declaring a
3412 variable, look at the variable's initializer. */
3413 if (TREE_CODE (exp) == DECL_STMT)
3415 tree decl = DECL_STMT_DECL (exp);
3417 if (TREE_CODE (decl) == VAR_DECL
3418 && DECL_INITIAL (decl)
3419 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3423 /* For any statement, we must follow the statement-chain. */
3424 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3425 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3427 /* Assume everything else is safe. */
3431 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3434 c_unsafe_for_reeval (exp)
3437 /* Statement expressions may not be reevaluated. */
3438 if (TREE_CODE (exp) == STMT_EXPR)
3441 /* Walk all other expressions. */
3445 /* Tree code classes. */
3447 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3449 static const char c_tree_code_type[] = {
3451 #include "c-common.def"
3455 /* Table indexed by tree code giving number of expression
3456 operands beyond the fixed part of the node structure.
3457 Not used for types or decls. */
3459 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3461 static const int c_tree_code_length[] = {
3463 #include "c-common.def"
3467 /* Names of tree components.
3468 Used for printing out the tree and error messages. */
3469 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3471 static const char *const c_tree_code_name[] = {
3473 #include "c-common.def"
3477 /* Adds the tree codes specific to the C front end to the list of all
3483 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
3485 (int)LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
3486 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
3488 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
3489 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
3491 (LAST_C_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
3492 lang_unsafe_for_reeval = c_unsafe_for_reeval;
3495 #define CALLED_AS_BUILT_IN(NODE) \
3496 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3499 c_expand_builtin (exp, target, tmode, modifier)
3502 enum machine_mode tmode;
3503 enum expand_modifier modifier;
3505 tree type = TREE_TYPE (exp);
3506 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3507 tree arglist = TREE_OPERAND (exp, 1);
3508 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3509 enum tree_code code = TREE_CODE (exp);
3510 const int ignore = (target == const0_rtx
3511 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3512 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3513 || code == COND_EXPR)
3514 && TREE_CODE (type) == VOID_TYPE));
3516 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3517 return expand_call (exp, target, ignore);
3521 case BUILT_IN_PRINTF:
3522 target = c_expand_builtin_printf (arglist, target, tmode,
3528 case BUILT_IN_FPRINTF:
3529 target = c_expand_builtin_fprintf (arglist, target, tmode,
3535 default: /* just do library call, if unknown builtin */
3536 error ("built-in function `%s' not currently supported",
3537 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3540 /* The switch statement above can drop through to cause the function
3541 to be called normally. */
3542 return expand_call (exp, target, ignore);
3545 /* Check an arglist to *printf for problems. The arglist should start
3546 at the format specifier, with the remaining arguments immediately
3549 is_valid_printf_arglist (arglist)
3552 /* Save this value so we can restore it later. */
3553 const int SAVE_pedantic = pedantic;
3554 int diagnostic_occurred = 0;
3557 /* Set this to a known value so the user setting won't affect code
3560 /* Check to make sure there are no format specifier errors. */
3561 attrs = tree_cons (get_identifier ("format"),
3562 tree_cons (NULL_TREE,
3563 get_identifier ("printf"),
3564 tree_cons (NULL_TREE,
3566 tree_cons (NULL_TREE,
3570 check_function_format (&diagnostic_occurred, attrs, arglist);
3572 /* Restore the value of `pedantic'. */
3573 pedantic = SAVE_pedantic;
3575 /* If calling `check_function_format_ptr' produces a warning, we
3576 return false, otherwise we return true. */
3577 return ! diagnostic_occurred;
3580 /* If the arguments passed to printf are suitable for optimizations,
3581 we attempt to transform the call. */
3583 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore)
3586 enum machine_mode tmode;
3587 enum expand_modifier modifier;
3590 tree fn_putchar = built_in_decls[BUILT_IN_PUTCHAR],
3591 fn_puts = built_in_decls[BUILT_IN_PUTS];
3592 tree fn, format_arg, stripped_string;
3594 /* If the return value is used, or the replacement _DECL isn't
3595 initialized, don't do the transformation. */
3596 if (!ignore || !fn_putchar || !fn_puts)
3599 /* Verify the required arguments in the original call. */
3601 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3604 /* Check the specifier vs. the parameters. */
3605 if (!is_valid_printf_arglist (arglist))
3608 format_arg = TREE_VALUE (arglist);
3609 stripped_string = format_arg;
3610 STRIP_NOPS (stripped_string);
3611 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3612 stripped_string = TREE_OPERAND (stripped_string, 0);
3614 /* If the format specifier isn't a STRING_CST, punt. */
3615 if (TREE_CODE (stripped_string) != STRING_CST)
3618 /* OK! We can attempt optimization. */
3620 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3621 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3623 arglist = TREE_CHAIN (arglist);
3626 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3627 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3629 arglist = TREE_CHAIN (arglist);
3634 /* We can't handle anything else with % args or %% ... yet. */
3635 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3638 /* If the resulting constant string has a length of 1, call
3639 putchar. Note, TREE_STRING_LENGTH includes the terminating
3640 NULL in its count. */
3641 if (TREE_STRING_LENGTH (stripped_string) == 2)
3643 /* Given printf("c"), (where c is any one character,)
3644 convert "c"[0] to an int and pass that to the replacement
3646 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3647 arglist = build_tree_list (NULL_TREE, arglist);
3651 /* If the resulting constant was "string\n", call
3652 __builtin_puts("string"). Ensure "string" has at least one
3653 character besides the trailing \n. Note, TREE_STRING_LENGTH
3654 includes the terminating NULL in its count. */
3655 else if (TREE_STRING_LENGTH (stripped_string) > 2
3656 && TREE_STRING_POINTER (stripped_string)
3657 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3659 /* Create a NULL-terminated string that's one char shorter
3660 than the original, stripping off the trailing '\n'. */
3661 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3662 char *newstr = (char *) alloca (newlen);
3663 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3664 newstr[newlen - 1] = 0;
3666 arglist = combine_strings (build_string (newlen, newstr));
3667 arglist = build_tree_list (NULL_TREE, arglist);
3671 /* We'd like to arrange to call fputs(string) here, but we
3672 need stdout and don't have a way to get it ... yet. */
3676 return expand_expr (build_function_call (fn, arglist),
3677 (ignore ? const0_rtx : target),
3681 /* If the arguments passed to fprintf are suitable for optimizations,
3682 we attempt to transform the call. */
3684 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore)
3687 enum machine_mode tmode;
3688 enum expand_modifier modifier;
3691 tree fn_fputc = built_in_decls[BUILT_IN_FPUTC],
3692 fn_fputs = built_in_decls[BUILT_IN_FPUTS];
3693 tree fn, format_arg, stripped_string;
3695 /* If the return value is used, or the replacement _DECL isn't
3696 initialized, don't do the transformation. */
3697 if (!ignore || !fn_fputc || !fn_fputs)
3700 /* Verify the required arguments in the original call. */
3702 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3703 || (TREE_CHAIN (arglist) == 0)
3704 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3708 /* Check the specifier vs. the parameters. */
3709 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3712 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3713 stripped_string = format_arg;
3714 STRIP_NOPS (stripped_string);
3715 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3716 stripped_string = TREE_OPERAND (stripped_string, 0);
3718 /* If the format specifier isn't a STRING_CST, punt. */
3719 if (TREE_CODE (stripped_string) != STRING_CST)
3722 /* OK! We can attempt optimization. */
3724 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3725 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3727 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3728 arglist = tree_cons (NULL_TREE,
3729 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3733 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3734 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3736 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3737 arglist = tree_cons (NULL_TREE,
3738 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3744 /* We can't handle anything else with % args or %% ... yet. */
3745 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3748 /* When "string" doesn't contain %, replace all cases of
3749 fprintf(stream,string) with fputs(string,stream). The fputs
3750 builtin will take take of special cases like length==1. */
3751 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
3752 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
3756 return expand_expr (build_function_call (fn, arglist),
3757 (ignore ? const0_rtx : target),
3762 /* Given a boolean expression ARG, return a tree representing an increment
3763 or decrement (as indicated by CODE) of ARG. The front end must check for
3764 invalid cases (e.g., decrement in C++). */
3766 boolean_increment (code, arg)
3767 enum tree_code code;
3771 tree true_res = (c_language == clk_cplusplus
3773 : c_bool_true_node);
3774 arg = stabilize_reference (arg);
3777 case PREINCREMENT_EXPR:
3778 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3780 case POSTINCREMENT_EXPR:
3781 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
3782 arg = save_expr (arg);
3783 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3784 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3786 case PREDECREMENT_EXPR:
3787 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3789 case POSTDECREMENT_EXPR:
3790 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
3791 arg = save_expr (arg);
3792 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
3793 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
3798 TREE_SIDE_EFFECTS (val) = 1;
3802 /* Handle C and C++ default attributes. */
3804 enum built_in_attribute
3806 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3807 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3808 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3809 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3810 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3811 #include "builtin-attrs.def"
3812 #undef DEF_ATTR_NULL_TREE
3814 #undef DEF_ATTR_IDENT
3815 #undef DEF_ATTR_TREE_LIST
3820 static tree built_in_attributes[(int) ATTR_LAST];
3822 static bool c_attrs_initialized = false;
3824 static void c_init_attributes PARAMS ((void));
3826 /* Do the parts of lang_init common to C and C++. */
3828 c_common_lang_init ()
3830 /* If still "unspecified", make it match -fbounded-pointers. */
3831 if (flag_bounds_check < 0)
3832 flag_bounds_check = flag_bounded_pointers;
3834 lang_anon_aggr_type_p = anon_aggr_type_p;
3836 /* Special format checking options don't work without -Wformat; warn if
3838 if (warn_format_y2k && !warn_format)
3839 warning ("-Wformat-y2k ignored without -Wformat");
3840 if (warn_format_extra_args && !warn_format)
3841 warning ("-Wformat-extra-args ignored without -Wformat");
3842 if (warn_format_nonliteral && !warn_format)
3843 warning ("-Wformat-nonliteral ignored without -Wformat");
3844 if (warn_format_security && !warn_format)
3845 warning ("-Wformat-security ignored without -Wformat");
3846 if (warn_missing_format_attribute && !warn_format)
3847 warning ("-Wmissing-format-attribute ignored without -Wformat");
3849 if (!c_attrs_initialized)
3850 c_init_attributes ();
3854 c_init_attributes ()
3856 /* Fill in the built_in_attributes array. */
3857 #define DEF_ATTR_NULL_TREE(ENUM) \
3858 built_in_attributes[(int) ENUM] = NULL_TREE;
3859 #define DEF_ATTR_INT(ENUM, VALUE) \
3860 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3861 #define DEF_ATTR_IDENT(ENUM, STRING) \
3862 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3863 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3864 built_in_attributes[(int) ENUM] \
3865 = tree_cons (built_in_attributes[(int) PURPOSE], \
3866 built_in_attributes[(int) VALUE], \
3867 built_in_attributes[(int) CHAIN]);
3868 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
3869 #include "builtin-attrs.def"
3870 #undef DEF_ATTR_NULL_TREE
3872 #undef DEF_ATTR_IDENT
3873 #undef DEF_ATTR_TREE_LIST
3875 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
3876 c_attrs_initialized = true;
3879 /* Depending on the name of DECL, apply default attributes to it. */
3882 c_common_insert_default_attributes (decl)
3885 tree name = DECL_NAME (decl);
3887 if (!c_attrs_initialized)
3888 c_init_attributes ();
3890 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
3891 #define DEF_ATTR_INT(ENUM, VALUE)
3892 #define DEF_ATTR_IDENT(ENUM, STRING)
3893 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
3894 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
3895 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
3896 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
3897 ATTR_FLAG_BUILT_IN);
3898 #include "builtin-attrs.def"
3899 #undef DEF_ATTR_NULL_TREE
3901 #undef DEF_ATTR_IDENT
3902 #undef DEF_ATTR_TREE_LIST