1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
33 #include "tree-inline.h"
34 #include "diagnostic.h"
40 cpp_reader
*parse_in
; /* Declared in c-lex.h. */
42 #undef WCHAR_TYPE_SIZE
43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
45 /* We let tm.h override the types used here, to handle trivial differences
46 such as the choice of unsigned int or long unsigned int for size_t.
47 When machines start needing nontrivial differences in the size type,
48 it would be best to do something here to figure out automatically
49 from other information what type to use. */
52 #define SIZE_TYPE "long unsigned int"
56 #define WCHAR_TYPE "int"
60 #define PTRDIFF_TYPE "long int"
64 #define WINT_TYPE "unsigned int"
68 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
70 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
78 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 ? "long unsigned int" \
80 : "long long unsigned int"))
83 /* The variant of the C language being processed. */
85 enum c_language_kind c_language
;
87 /* The following symbols are subsumed in the c_global_trees array, and
88 listed here individually for documentation purposes.
90 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
92 tree short_integer_type_node;
93 tree long_integer_type_node;
94 tree long_long_integer_type_node;
96 tree short_unsigned_type_node;
97 tree long_unsigned_type_node;
98 tree long_long_unsigned_type_node;
100 tree boolean_type_node;
101 tree boolean_false_node;
102 tree boolean_true_node;
104 tree ptrdiff_type_node;
106 tree unsigned_char_type_node;
107 tree signed_char_type_node;
108 tree wchar_type_node;
109 tree signed_wchar_type_node;
110 tree unsigned_wchar_type_node;
112 tree float_type_node;
113 tree double_type_node;
114 tree long_double_type_node;
116 tree complex_integer_type_node;
117 tree complex_float_type_node;
118 tree complex_double_type_node;
119 tree complex_long_double_type_node;
121 tree intQI_type_node;
122 tree intHI_type_node;
123 tree intSI_type_node;
124 tree intDI_type_node;
125 tree intTI_type_node;
127 tree unsigned_intQI_type_node;
128 tree unsigned_intHI_type_node;
129 tree unsigned_intSI_type_node;
130 tree unsigned_intDI_type_node;
131 tree unsigned_intTI_type_node;
133 tree widest_integer_literal_type_node;
134 tree widest_unsigned_literal_type_node;
136 Nodes for types `void *' and `const void *'.
138 tree ptr_type_node, const_ptr_type_node;
140 Nodes for types `char *' and `const char *'.
142 tree string_type_node, const_string_type_node;
144 Type `char[SOMENUMBER]'.
145 Used when an array of char is needed and the size is irrelevant.
147 tree char_array_type_node;
149 Type `int[SOMENUMBER]' or something like it.
150 Used when an array of int needed and the size is irrelevant.
152 tree int_array_type_node;
154 Type `wchar_t[SOMENUMBER]' or something like it.
155 Used when a wide string literal is created.
157 tree wchar_array_type_node;
159 Type `int ()' -- used for implicit declaration of functions.
161 tree default_function_type;
163 A VOID_TYPE node, packaged in a TREE_LIST.
167 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
168 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
169 VAR_DECLS, but C++ does.)
171 tree function_name_decl_node;
172 tree pretty_function_name_decl_node;
173 tree c99_function_name_decl_node;
175 Stack of nested function name VAR_DECLs.
177 tree saved_function_name_decls;
181 tree c_global_trees
[CTI_MAX
];
183 /* Nonzero means don't recognize the non-ANSI builtin functions. */
187 /* Nonzero means don't recognize the non-ANSI builtin functions.
190 int flag_no_nonansi_builtin
;
192 /* Nonzero means give `double' the same size as `float'. */
194 int flag_short_double
;
196 /* Nonzero means give `wchar_t' the same size as `short'. */
198 int flag_short_wchar
;
200 /* Nonzero means warn about possible violations of sequence point rules. */
202 int warn_sequence_point
;
204 /* Nonzero means to warn about compile-time division by zero. */
205 int warn_div_by_zero
= 1;
207 /* The elements of `ridpointers' are identifier nodes for the reserved
208 type names and storage classes. It is indexed by a RID_... value. */
211 tree (*make_fname_decl
) PARAMS ((tree
, int));
213 /* If non-NULL, the address of a language-specific function that
214 returns 1 for language-specific statement codes. */
215 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
217 /* If non-NULL, the address of a language-specific function that takes
218 any action required right before expand_function_end is called. */
219 void (*lang_expand_function_end
) PARAMS ((void));
221 /* Nonzero means the expression being parsed will never be evaluated.
222 This is a count, since unevaluated expressions can nest. */
225 /* Information about how a function name is generated. */
228 tree
*const decl
; /* pointer to the VAR_DECL. */
229 const unsigned rid
; /* RID number for the identifier. */
230 const int pretty
; /* How pretty is it? */
233 /* The three ways of getting then name of the current function. */
235 const struct fname_var_t fname_vars
[] =
237 /* C99 compliant __func__, must be first. */
238 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
239 /* GCC __FUNCTION__ compliant. */
240 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
241 /* GCC __PRETTY_FUNCTION__ compliant. */
242 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
246 static int constant_fits_type_p
PARAMS ((tree
, tree
));
248 /* Keep a stack of if statements. We record the number of compound
249 statements seen up to the if keyword, as well as the line number
250 and file of the if. If a potentially ambiguous else is seen, that
251 fact is recorded; the warning is issued when we can be sure that
252 the enclosing if statement does not have an else branch. */
262 static if_elt
*if_stack
;
264 /* Amount of space in the if statement stack. */
265 static int if_stack_space
= 0;
268 static int if_stack_pointer
= 0;
270 /* Record the start of an if-then, and record the start of it
271 for ambiguous else detection.
273 COND is the condition for the if-then statement.
275 IF_STMT is the statement node that has already been created for
276 this if-then statement. It is created before parsing the
277 condition to keep line number information accurate. */
280 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
285 /* Make sure there is enough space on the stack. */
286 if (if_stack_space
== 0)
289 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
291 else if (if_stack_space
== if_stack_pointer
)
293 if_stack_space
+= 10;
294 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
297 IF_COND (if_stmt
) = cond
;
300 /* Record this if statement. */
301 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
302 if_stack
[if_stack_pointer
].file
= input_filename
;
303 if_stack
[if_stack_pointer
].line
= lineno
;
304 if_stack
[if_stack_pointer
].needs_warning
= 0;
305 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
309 /* Called after the then-clause for an if-statement is processed. */
314 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
315 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
318 /* Record the end of an if-then. Optionally warn if a nested
319 if statement had an ambiguous else clause. */
325 if (if_stack
[if_stack_pointer
].needs_warning
)
326 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
327 if_stack
[if_stack_pointer
].line
,
328 "suggest explicit braces to avoid ambiguous `else'");
329 last_expr_type
= NULL_TREE
;
332 /* Called between the then-clause and the else-clause
333 of an if-then-else. */
336 c_expand_start_else ()
338 /* An ambiguous else warning must be generated for the enclosing if
339 statement, unless we see an else branch for that one, too. */
341 && if_stack_pointer
> 1
342 && (if_stack
[if_stack_pointer
- 1].compstmt_count
343 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
344 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
346 /* Even if a nested if statement had an else branch, it can't be
347 ambiguous if this one also has an else. So don't warn in that
348 case. Also don't warn for any if statements nested in this else. */
349 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
350 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
353 /* Called after the else-clause for an if-statement is processed. */
358 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
359 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
362 /* Begin an if-statement. Returns a newly created IF_STMT if
365 Unlike the C++ front-end, we do not call add_stmt here; it is
366 probably safe to do so, but I am not very familiar with this
367 code so I am being extra careful not to change its behavior
368 beyond what is strictly necessary for correctness. */
374 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
378 /* Begin a while statement. Returns a newly created WHILE_STMT if
381 Unlike the C++ front-end, we do not call add_stmt here; it is
382 probably safe to do so, but I am not very familiar with this
383 code so I am being extra careful not to change its behavior
384 beyond what is strictly necessary for correctness. */
387 c_begin_while_stmt ()
390 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
395 c_finish_while_stmt_cond (cond
, while_stmt
)
399 WHILE_COND (while_stmt
) = cond
;
402 /* Push current bindings for the function name VAR_DECLS. */
408 tree saved
= NULL_TREE
;
410 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
412 tree decl
= *fname_vars
[ix
].decl
;
416 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
417 *fname_vars
[ix
].decl
= NULL_TREE
;
420 if (saved
|| saved_function_name_decls
)
421 /* Normally they'll have been NULL, so only push if we've got a
422 stack, or they are non-NULL. */
423 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
424 saved_function_name_decls
);
427 /* Finish up the current bindings, adding them into the
428 current function's statement tree. This is done by wrapping the
429 function's body in a COMPOUND_STMT containing these decls too. This
430 must be done _before_ finish_stmt_tree is called. If there is no
431 current function, we must be at file scope and no statements are
432 involved. Pop the previous bindings. */
435 finish_fname_decls ()
438 tree body
= NULL_TREE
;
439 tree stack
= saved_function_name_decls
;
441 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
442 body
= chainon (TREE_VALUE (stack
), body
);
446 /* They were called into existence, so add to statement tree. */
447 body
= chainon (body
,
448 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)));
449 body
= build_stmt (COMPOUND_STMT
, body
);
451 COMPOUND_STMT_NO_SCOPE (body
) = 1;
452 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)) = body
;
455 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
456 *fname_vars
[ix
].decl
= NULL_TREE
;
460 /* We had saved values, restore them. */
463 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
465 tree decl
= TREE_PURPOSE (saved
);
466 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
468 *fname_vars
[ix
].decl
= decl
;
470 stack
= TREE_CHAIN (stack
);
472 saved_function_name_decls
= stack
;
475 /* Return the text name of the current function, suitable prettified
479 fname_as_string (pretty_p
)
482 const char *name
= NULL
;
485 name
= (current_function_decl
486 ? (*decl_printable_name
) (current_function_decl
, 2)
488 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
489 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
495 /* Return the text name of the current function, formatted as
496 required by the supplied RID value. */
504 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
505 if (fname_vars
[ix
].rid
== rid
)
507 return fname_as_string (fname_vars
[ix
].pretty
);
510 /* Return the VAR_DECL for a const char array naming the current
511 function. If the VAR_DECL has not yet been created, create it
512 now. RID indicates how it should be formatted and IDENTIFIER_NODE
513 ID is its name (unfortunately C and C++ hold the RID values of
514 keywords in different places, so we can't derive RID from ID in
515 this language independent code. */
523 tree decl
= NULL_TREE
;
525 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
526 if (fname_vars
[ix
].rid
== rid
)
529 decl
= *fname_vars
[ix
].decl
;
532 tree saved_last_tree
= last_tree
;
534 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
535 if (last_tree
!= saved_last_tree
)
537 /* We created some statement tree for the decl. This belongs
538 at the start of the function, so remove it now and reinsert
539 it after the function is complete. */
540 tree stmts
= TREE_CHAIN (saved_last_tree
);
542 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
543 last_tree
= saved_last_tree
;
544 saved_function_name_decls
= tree_cons (decl
, stmts
,
545 saved_function_name_decls
);
547 *fname_vars
[ix
].decl
= decl
;
549 if (!ix
&& !current_function_decl
)
550 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
555 /* Given a chain of STRING_CST nodes,
556 concatenate them into one STRING_CST
557 and give it a suitable array-of-chars data type. */
560 combine_strings (strings
)
567 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
569 const int nchars_max
= flag_isoc99
? 4095 : 509;
571 if (TREE_CHAIN (strings
))
573 /* More than one in the chain, so concatenate. */
576 /* Don't include the \0 at the end of each substring,
577 except for the last one.
578 Count wide strings and ordinary strings separately. */
579 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
581 if (TREE_TYPE (t
) == wchar_array_type_node
)
583 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
588 length
+= (TREE_STRING_LENGTH (t
) - 1);
589 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
590 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
594 /* If anything is wide, the non-wides will be converted,
595 which makes them take more space. */
597 length
= length
* wchar_bytes
+ wide_length
;
601 /* Copy the individual strings into the new combined string.
602 If the combined string is wide, convert the chars to ints
603 for any individual strings that are not wide. */
606 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
608 int len
= (TREE_STRING_LENGTH (t
)
609 - ((TREE_TYPE (t
) == wchar_array_type_node
)
611 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
613 memcpy (q
, TREE_STRING_POINTER (t
), len
);
619 for (i
= 0; i
< len
; i
++)
621 if (BYTES_BIG_ENDIAN
)
623 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
625 *q
++ = TREE_STRING_POINTER (t
)[i
];
629 *q
++ = TREE_STRING_POINTER (t
)[i
];
630 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
639 for (i
= 0; i
< wchar_bytes
; i
++)
645 value
= build_string (length
, p
);
650 length
= TREE_STRING_LENGTH (value
);
651 if (TREE_TYPE (value
) == wchar_array_type_node
)
655 /* Compute the number of elements, for the array type. */
656 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
658 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
659 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
660 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
662 /* Create the array type for the string constant.
663 -Wwrite-strings says make the string constant an array of const char
664 so that copying it to a non-const pointer will get a warning.
665 For C++, this is the standard behavior. */
666 if (flag_const_strings
667 && (! flag_traditional
&& ! flag_writable_strings
))
670 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
673 = build_array_type (elements
,
674 build_index_type (build_int_2 (nchars
- 1, 0)));
678 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
679 build_index_type (build_int_2 (nchars
- 1, 0)));
681 TREE_CONSTANT (value
) = 1;
682 TREE_READONLY (value
) = ! flag_writable_strings
;
683 TREE_STATIC (value
) = 1;
687 static int is_valid_printf_arglist
PARAMS ((tree
));
688 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
689 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
690 enum expand_modifier
, int, int));
691 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
692 enum expand_modifier
, int, int));
694 /* Print a warning if a constant expression had overflow in folding.
695 Invoke this function on every expression that the language
696 requires to be a constant expression.
697 Note the ANSI C standard says it is erroneous for a
698 constant expression to overflow. */
701 constant_expression_warning (value
)
704 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
705 || TREE_CODE (value
) == COMPLEX_CST
)
706 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
707 pedwarn ("overflow in constant expression");
710 /* Print a warning if an expression had overflow in folding.
711 Invoke this function on every expression that
712 (1) appears in the source code, and
713 (2) might be a constant expression that overflowed, and
714 (3) is not already checked by convert_and_check;
715 however, do not invoke this function on operands of explicit casts. */
718 overflow_warning (value
)
721 if ((TREE_CODE (value
) == INTEGER_CST
722 || (TREE_CODE (value
) == COMPLEX_CST
723 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
724 && TREE_OVERFLOW (value
))
726 TREE_OVERFLOW (value
) = 0;
727 if (skip_evaluation
== 0)
728 warning ("integer overflow in expression");
730 else if ((TREE_CODE (value
) == REAL_CST
731 || (TREE_CODE (value
) == COMPLEX_CST
732 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
733 && TREE_OVERFLOW (value
))
735 TREE_OVERFLOW (value
) = 0;
736 if (skip_evaluation
== 0)
737 warning ("floating point overflow in expression");
741 /* Print a warning if a large constant is truncated to unsigned,
742 or if -Wconversion is used and a constant < 0 is converted to unsigned.
743 Invoke this function on every expression that might be implicitly
744 converted to an unsigned type. */
747 unsigned_conversion_warning (result
, operand
)
748 tree result
, operand
;
750 if (TREE_CODE (operand
) == INTEGER_CST
751 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
752 && TREE_UNSIGNED (TREE_TYPE (result
))
753 && skip_evaluation
== 0
754 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
756 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
757 /* This detects cases like converting -129 or 256 to unsigned char. */
758 warning ("large integer implicitly truncated to unsigned type");
759 else if (warn_conversion
)
760 warning ("negative integer implicitly converted to unsigned type");
764 /* Nonzero if constant C has a value that is permissible
765 for type TYPE (an INTEGER_TYPE). */
768 constant_fits_type_p (c
, type
)
771 if (TREE_CODE (c
) == INTEGER_CST
)
772 return int_fits_type_p (c
, type
);
774 c
= convert (type
, c
);
775 return !TREE_OVERFLOW (c
);
778 /* Convert EXPR to TYPE, warning about conversion problems with constants.
779 Invoke this function on every expression that is converted implicitly,
780 i.e. because of language rules and not because of an explicit cast. */
783 convert_and_check (type
, expr
)
786 tree t
= convert (type
, expr
);
787 if (TREE_CODE (t
) == INTEGER_CST
)
789 if (TREE_OVERFLOW (t
))
791 TREE_OVERFLOW (t
) = 0;
793 /* Do not diagnose overflow in a constant expression merely
794 because a conversion overflowed. */
795 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
797 /* No warning for converting 0x80000000 to int. */
798 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
799 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
800 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
801 /* If EXPR fits in the unsigned version of TYPE,
802 don't warn unless pedantic. */
804 || TREE_UNSIGNED (type
)
805 || ! constant_fits_type_p (expr
, unsigned_type (type
)))
806 && skip_evaluation
== 0)
807 warning ("overflow in implicit constant conversion");
810 unsigned_conversion_warning (t
, expr
);
815 /* A node in a list that describes references to variables (EXPR), which are
816 either read accesses if WRITER is zero, or write accesses, in which case
817 WRITER is the parent of EXPR. */
824 /* Used to implement a cache the results of a call to verify_tree. We only
825 use this for SAVE_EXPRs. */
828 struct tlist_cache
*next
;
829 struct tlist
*cache_before_sp
;
830 struct tlist
*cache_after_sp
;
834 /* Obstack to use when allocating tlist structures, and corresponding
836 static struct obstack tlist_obstack
;
837 static char *tlist_firstobj
= 0;
839 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
841 static struct tlist
*warned_ids
;
842 /* SAVE_EXPRs need special treatment. We process them only once and then
843 cache the results. */
844 static struct tlist_cache
*save_expr_cache
;
846 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
847 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
848 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
849 static int warning_candidate_p
PARAMS ((tree
));
850 static void warn_for_collisions
PARAMS ((struct tlist
*));
851 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
852 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
853 static void verify_sequence_points
PARAMS ((tree
));
855 /* Create a new struct tlist and fill in its fields. */
856 static struct tlist
*
857 new_tlist (next
, t
, writer
)
863 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
870 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
871 is nonnull, we ignore any node we find which has a writer equal to it. */
874 add_tlist (to
, add
, exclude_writer
, copy
)
882 struct tlist
*next
= add
->next
;
885 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
886 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
891 /* Merge the nodes of ADD into TO. This merging process is done so that for
892 each variable that already exists in TO, no new node is added; however if
893 there is a write access recorded in ADD, and an occurrence on TO is only
894 a read access, then the occurrence in TO will be modified to record the
898 merge_tlist (to
, add
, copy
)
903 struct tlist
**end
= to
;
912 struct tlist
*next
= add
->next
;
914 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
915 if (tmp2
->expr
== add
->expr
)
919 tmp2
->writer
= add
->writer
;
923 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
931 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
932 references in list LIST conflict with it, excluding reads if ONLY writers
936 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
937 tree written
, writer
;
943 /* Avoid duplicate warnings. */
944 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
945 if (tmp
->expr
== written
)
950 if (list
->expr
== written
951 && list
->writer
!= writer
952 && (! only_writes
|| list
->writer
))
954 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
955 warning ("operation on `%s' may be undefined",
956 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
962 /* Given a list LIST of references to variables, find whether any of these
963 can cause conflicts due to missing sequence points. */
966 warn_for_collisions (list
)
971 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
974 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
978 /* Return nonzero if X is a tree that can be verified by the sequence point
981 warning_candidate_p (x
)
984 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
987 /* Walk the tree X, and record accesses to variables. If X is written by the
988 parent tree, WRITER is the parent.
989 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
990 expression or its only operand forces a sequence point, then everything up
991 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
993 Once we return, we will have emitted warnings if any subexpression before
994 such a sequence point could be undefined. On a higher level, however, the
995 sequence point may not be relevant, and we'll merge the two lists.
997 Example: (b++, a) + b;
998 The call that processes the COMPOUND_EXPR will store the increment of B
999 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1000 processes the PLUS_EXPR will need to merge the two lists so that
1001 eventually, all accesses end up on the same list (and we'll warn about the
1002 unordered subexpressions b++ and b.
1004 A note on merging. If we modify the former example so that our expression
1007 care must be taken not simply to add all three expressions into the final
1008 PNO_SP list. The function merge_tlist takes care of that by merging the
1009 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1010 way, so that no more than one access to B is recorded. */
1013 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1015 struct tlist
**pbefore_sp
, **pno_sp
;
1018 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1019 enum tree_code code
;
1022 /* X may be NULL if it is the operand of an empty statement expression
1028 code
= TREE_CODE (x
);
1029 class = TREE_CODE_CLASS (code
);
1031 if (warning_candidate_p (x
))
1033 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1043 case TRUTH_ANDIF_EXPR
:
1044 case TRUTH_ORIF_EXPR
:
1045 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1046 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1047 warn_for_collisions (tmp_nosp
);
1048 merge_tlist (pbefore_sp
, tmp_before
, 0);
1049 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1050 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1051 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1055 tmp_before
= tmp_list2
= 0;
1056 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1057 warn_for_collisions (tmp_list2
);
1058 merge_tlist (pbefore_sp
, tmp_before
, 0);
1059 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1061 tmp_list3
= tmp_nosp
= 0;
1062 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1063 warn_for_collisions (tmp_nosp
);
1064 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1066 tmp_list3
= tmp_list2
= 0;
1067 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1068 warn_for_collisions (tmp_list2
);
1069 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1070 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1071 two first, to avoid warning for (a ? b++ : b++). */
1072 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1073 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1076 case PREDECREMENT_EXPR
:
1077 case PREINCREMENT_EXPR
:
1078 case POSTDECREMENT_EXPR
:
1079 case POSTINCREMENT_EXPR
:
1080 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1084 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1085 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1086 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1087 /* Expressions inside the LHS are not ordered wrt. the sequence points
1088 in the RHS. Example:
1090 Despite the fact that the modification of "a" is in the before_sp
1091 list (tmp_before), it conflicts with the use of "a" in the LHS.
1092 We can handle this by adding the contents of tmp_list3
1093 to those of tmp_before, and redoing the collision warnings for that
1095 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1096 warn_for_collisions (tmp_before
);
1097 /* Exclude the LHS itself here; we first have to merge it into the
1098 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1099 didn't exclude the LHS, we'd get it twice, once as a read and once
1101 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1102 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1104 merge_tlist (pbefore_sp
, tmp_before
, 0);
1105 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1106 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1107 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1111 /* We need to warn about conflicts among arguments and conflicts between
1112 args and the function address. Side effects of the function address,
1113 however, are not ordered by the sequence point of the call. */
1114 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1115 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1116 if (TREE_OPERAND (x
, 1))
1117 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1118 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1119 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1120 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1121 warn_for_collisions (tmp_before
);
1122 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1126 /* Scan all the list, e.g. indices of multi dimensional array. */
1129 tmp_before
= tmp_nosp
= 0;
1130 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1131 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1132 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1139 struct tlist_cache
*t
;
1140 for (t
= save_expr_cache
; t
; t
= t
->next
)
1146 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1148 t
->next
= save_expr_cache
;
1150 save_expr_cache
= t
;
1152 tmp_before
= tmp_nosp
= 0;
1153 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1154 warn_for_collisions (tmp_nosp
);
1159 struct tlist
*t
= tmp_nosp
;
1161 merge_tlist (&tmp_list3
, t
, 0);
1163 t
->cache_before_sp
= tmp_before
;
1164 t
->cache_after_sp
= tmp_list3
;
1166 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1167 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1176 if (first_rtl_op (code
) == 0)
1178 x
= TREE_OPERAND (x
, 0);
1194 int max
= first_rtl_op (TREE_CODE (x
));
1195 for (lp
= 0; lp
< max
; lp
++)
1197 tmp_before
= tmp_nosp
= 0;
1198 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1199 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1200 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1207 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1211 verify_sequence_points (expr
)
1214 struct tlist
*before_sp
= 0, *after_sp
= 0;
1217 save_expr_cache
= 0;
1218 if (tlist_firstobj
== 0)
1220 gcc_obstack_init (&tlist_obstack
);
1221 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1224 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1225 warn_for_collisions (after_sp
);
1226 obstack_free (&tlist_obstack
, tlist_firstobj
);
1230 c_expand_expr_stmt (expr
)
1233 /* Do default conversion if safe and possibly important,
1234 in case within ({...}). */
1235 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1236 && (flag_isoc99
|| lvalue_p (expr
)))
1237 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1238 expr
= default_conversion (expr
);
1240 if (warn_sequence_point
)
1241 verify_sequence_points (expr
);
1243 if (TREE_TYPE (expr
) != error_mark_node
1244 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1245 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1246 error ("expression statement has incomplete type");
1248 last_expr_type
= TREE_TYPE (expr
);
1249 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1252 /* Validate the expression after `case' and apply default promotions. */
1255 check_case_value (value
)
1258 if (value
== NULL_TREE
)
1261 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1262 STRIP_TYPE_NOPS (value
);
1263 /* In C++, the following is allowed:
1266 switch (...) { case i: ... }
1268 So, we try to reduce the VALUE to a constant that way. */
1269 if (c_language
== clk_cplusplus
)
1271 value
= decl_constant_value (value
);
1272 STRIP_TYPE_NOPS (value
);
1273 value
= fold (value
);
1276 if (TREE_CODE (value
) != INTEGER_CST
1277 && value
!= error_mark_node
)
1279 error ("case label does not reduce to an integer constant");
1280 value
= error_mark_node
;
1283 /* Promote char or short to int. */
1284 value
= default_conversion (value
);
1286 constant_expression_warning (value
);
1291 /* Return an integer type with BITS bits of precision,
1292 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1295 type_for_size (bits
, unsignedp
)
1299 if (bits
== TYPE_PRECISION (integer_type_node
))
1300 return unsignedp
? unsigned_type_node
: integer_type_node
;
1302 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1303 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1305 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1306 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1308 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1309 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1311 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1312 return (unsignedp
? long_long_unsigned_type_node
1313 : long_long_integer_type_node
);
1315 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1316 return (unsignedp
? widest_unsigned_literal_type_node
1317 : widest_integer_literal_type_node
);
1319 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1320 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1322 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1323 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1325 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1326 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1328 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1329 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1334 /* Return a data type that has machine mode MODE.
1335 If the mode is an integer,
1336 then UNSIGNEDP selects between signed and unsigned types. */
1339 type_for_mode (mode
, unsignedp
)
1340 enum machine_mode mode
;
1343 if (mode
== TYPE_MODE (integer_type_node
))
1344 return unsignedp
? unsigned_type_node
: integer_type_node
;
1346 if (mode
== TYPE_MODE (signed_char_type_node
))
1347 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1349 if (mode
== TYPE_MODE (short_integer_type_node
))
1350 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1352 if (mode
== TYPE_MODE (long_integer_type_node
))
1353 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1355 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1356 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1358 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1359 return unsignedp
? widest_unsigned_literal_type_node
1360 : widest_integer_literal_type_node
;
1363 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1366 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1369 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1372 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1374 #if HOST_BITS_PER_WIDE_INT >= 64
1375 if (mode
== TYPE_MODE (intTI_type_node
))
1376 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1379 if (mode
== TYPE_MODE (float_type_node
))
1380 return float_type_node
;
1382 if (mode
== TYPE_MODE (double_type_node
))
1383 return double_type_node
;
1385 if (mode
== TYPE_MODE (long_double_type_node
))
1386 return long_double_type_node
;
1388 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1389 return build_pointer_type (char_type_node
);
1391 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1392 return build_pointer_type (integer_type_node
);
1394 #ifdef VECTOR_MODE_SUPPORTED_P
1395 if (VECTOR_MODE_SUPPORTED_P (mode
))
1400 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
1402 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
1404 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
1406 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
1408 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
1410 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
1412 return V4SF_type_node
;
1414 return V2SF_type_node
;
1424 /* Return an unsigned type the same as TYPE in other respects. */
1426 unsigned_type (type
)
1429 tree type1
= TYPE_MAIN_VARIANT (type
);
1430 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1431 return unsigned_char_type_node
;
1432 if (type1
== integer_type_node
)
1433 return unsigned_type_node
;
1434 if (type1
== short_integer_type_node
)
1435 return short_unsigned_type_node
;
1436 if (type1
== long_integer_type_node
)
1437 return long_unsigned_type_node
;
1438 if (type1
== long_long_integer_type_node
)
1439 return long_long_unsigned_type_node
;
1440 if (type1
== widest_integer_literal_type_node
)
1441 return widest_unsigned_literal_type_node
;
1442 #if HOST_BITS_PER_WIDE_INT >= 64
1443 if (type1
== intTI_type_node
)
1444 return unsigned_intTI_type_node
;
1446 if (type1
== intDI_type_node
)
1447 return unsigned_intDI_type_node
;
1448 if (type1
== intSI_type_node
)
1449 return unsigned_intSI_type_node
;
1450 if (type1
== intHI_type_node
)
1451 return unsigned_intHI_type_node
;
1452 if (type1
== intQI_type_node
)
1453 return unsigned_intQI_type_node
;
1455 return signed_or_unsigned_type (1, type
);
1458 /* Return a signed type the same as TYPE in other respects. */
1464 tree type1
= TYPE_MAIN_VARIANT (type
);
1465 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1466 return signed_char_type_node
;
1467 if (type1
== unsigned_type_node
)
1468 return integer_type_node
;
1469 if (type1
== short_unsigned_type_node
)
1470 return short_integer_type_node
;
1471 if (type1
== long_unsigned_type_node
)
1472 return long_integer_type_node
;
1473 if (type1
== long_long_unsigned_type_node
)
1474 return long_long_integer_type_node
;
1475 if (type1
== widest_unsigned_literal_type_node
)
1476 return widest_integer_literal_type_node
;
1477 #if HOST_BITS_PER_WIDE_INT >= 64
1478 if (type1
== unsigned_intTI_type_node
)
1479 return intTI_type_node
;
1481 if (type1
== unsigned_intDI_type_node
)
1482 return intDI_type_node
;
1483 if (type1
== unsigned_intSI_type_node
)
1484 return intSI_type_node
;
1485 if (type1
== unsigned_intHI_type_node
)
1486 return intHI_type_node
;
1487 if (type1
== unsigned_intQI_type_node
)
1488 return intQI_type_node
;
1490 return signed_or_unsigned_type (0, type
);
1493 /* Return a type the same as TYPE except unsigned or
1494 signed according to UNSIGNEDP. */
1497 signed_or_unsigned_type (unsignedp
, type
)
1501 if (! INTEGRAL_TYPE_P (type
)
1502 || TREE_UNSIGNED (type
) == unsignedp
)
1505 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1506 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1507 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1508 return unsignedp
? unsigned_type_node
: integer_type_node
;
1509 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1510 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1511 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1512 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1513 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1514 return (unsignedp
? long_long_unsigned_type_node
1515 : long_long_integer_type_node
);
1516 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1517 return (unsignedp
? widest_unsigned_literal_type_node
1518 : widest_integer_literal_type_node
);
1520 #if HOST_BITS_PER_WIDE_INT >= 64
1521 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
1522 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1524 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
1525 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1526 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
1527 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1528 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
1529 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1530 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
1531 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1536 /* Return the minimum number of bits needed to represent VALUE in a
1537 signed or unsigned type, UNSIGNEDP says which. */
1540 min_precision (value
, unsignedp
)
1546 /* If the value is negative, compute its negative minus 1. The latter
1547 adjustment is because the absolute value of the largest negative value
1548 is one larger than the largest positive value. This is equivalent to
1549 a bit-wise negation, so use that operation instead. */
1551 if (tree_int_cst_sgn (value
) < 0)
1552 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1554 /* Return the number of bits needed, taking into account the fact
1555 that we need one more bit for a signed than unsigned type. */
1557 if (integer_zerop (value
))
1560 log
= tree_floor_log2 (value
);
1562 return log
+ 1 + ! unsignedp
;
1565 /* Print an error message for invalid operands to arith operation CODE.
1566 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1569 binary_op_error (code
)
1570 enum tree_code code
;
1577 error ("invalid truth-value expression");
1581 opname
= "+"; break;
1583 opname
= "-"; break;
1585 opname
= "*"; break;
1587 opname
= "max"; break;
1589 opname
= "min"; break;
1591 opname
= "=="; break;
1593 opname
= "!="; break;
1595 opname
= "<="; break;
1597 opname
= ">="; break;
1599 opname
= "<"; break;
1601 opname
= ">"; break;
1603 opname
= "<<"; break;
1605 opname
= ">>"; break;
1606 case TRUNC_MOD_EXPR
:
1607 case FLOOR_MOD_EXPR
:
1608 opname
= "%"; break;
1609 case TRUNC_DIV_EXPR
:
1610 case FLOOR_DIV_EXPR
:
1611 opname
= "/"; break;
1613 opname
= "&"; break;
1615 opname
= "|"; break;
1616 case TRUTH_ANDIF_EXPR
:
1617 opname
= "&&"; break;
1618 case TRUTH_ORIF_EXPR
:
1619 opname
= "||"; break;
1621 opname
= "^"; break;
1624 opname
= "rotate"; break;
1626 opname
= "unknown"; break;
1628 error ("invalid operands to binary %s", opname
);
1631 /* Subroutine of build_binary_op, used for comparison operations.
1632 See if the operands have both been converted from subword integer types
1633 and, if so, perhaps change them both back to their original type.
1634 This function is also responsible for converting the two operands
1635 to the proper common type for comparison.
1637 The arguments of this function are all pointers to local variables
1638 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1639 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1641 If this function returns nonzero, it means that the comparison has
1642 a constant value. What this function returns is an expression for
1646 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1647 tree
*op0_ptr
, *op1_ptr
;
1649 enum tree_code
*rescode_ptr
;
1652 tree op0
= *op0_ptr
;
1653 tree op1
= *op1_ptr
;
1654 int unsignedp0
, unsignedp1
;
1656 tree primop0
, primop1
;
1657 enum tree_code code
= *rescode_ptr
;
1659 /* Throw away any conversions to wider types
1660 already present in the operands. */
1662 primop0
= get_narrower (op0
, &unsignedp0
);
1663 primop1
= get_narrower (op1
, &unsignedp1
);
1665 /* Handle the case that OP0 does not *contain* a conversion
1666 but it *requires* conversion to FINAL_TYPE. */
1668 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1669 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1670 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1671 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1673 /* If one of the operands must be floated, we cannot optimize. */
1674 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1675 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1677 /* If first arg is constant, swap the args (changing operation
1678 so value is preserved), for canonicalization. Don't do this if
1679 the second arg is 0. */
1681 if (TREE_CONSTANT (primop0
)
1682 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1685 int temi
= unsignedp0
;
1693 unsignedp0
= unsignedp1
;
1716 *rescode_ptr
= code
;
1719 /* If comparing an integer against a constant more bits wide,
1720 maybe we can deduce a value of 1 or 0 independent of the data.
1721 Or else truncate the constant now
1722 rather than extend the variable at run time.
1724 This is only interesting if the constant is the wider arg.
1725 Also, it is not safe if the constant is unsigned and the
1726 variable arg is signed, since in this case the variable
1727 would be sign-extended and then regarded as unsigned.
1728 Our technique fails in this case because the lowest/highest
1729 possible unsigned results don't follow naturally from the
1730 lowest/highest possible values of the variable operand.
1731 For just EQ_EXPR and NE_EXPR there is another technique that
1732 could be used: see if the constant can be faithfully represented
1733 in the other operand's type, by truncating it and reextending it
1734 and see if that preserves the constant's value. */
1736 if (!real1
&& !real2
1737 && TREE_CODE (primop1
) == INTEGER_CST
1738 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1740 int min_gt
, max_gt
, min_lt
, max_lt
;
1741 tree maxval
, minval
;
1742 /* 1 if comparison is nominally unsigned. */
1743 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1746 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1748 /* If TYPE is an enumeration, then we need to get its min/max
1749 values from it's underlying integral type, not the enumerated
1751 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1752 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
1754 maxval
= TYPE_MAX_VALUE (type
);
1755 minval
= TYPE_MIN_VALUE (type
);
1757 if (unsignedp
&& !unsignedp0
)
1758 *restype_ptr
= signed_type (*restype_ptr
);
1760 if (TREE_TYPE (primop1
) != *restype_ptr
)
1761 primop1
= convert (*restype_ptr
, primop1
);
1762 if (type
!= *restype_ptr
)
1764 minval
= convert (*restype_ptr
, minval
);
1765 maxval
= convert (*restype_ptr
, maxval
);
1768 if (unsignedp
&& unsignedp0
)
1770 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1771 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1772 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1773 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1777 min_gt
= INT_CST_LT (primop1
, minval
);
1778 max_gt
= INT_CST_LT (primop1
, maxval
);
1779 min_lt
= INT_CST_LT (minval
, primop1
);
1780 max_lt
= INT_CST_LT (maxval
, primop1
);
1784 /* This used to be a switch, but Genix compiler can't handle that. */
1785 if (code
== NE_EXPR
)
1787 if (max_lt
|| min_gt
)
1788 val
= boolean_true_node
;
1790 else if (code
== EQ_EXPR
)
1792 if (max_lt
|| min_gt
)
1793 val
= boolean_false_node
;
1795 else if (code
== LT_EXPR
)
1798 val
= boolean_true_node
;
1800 val
= boolean_false_node
;
1802 else if (code
== GT_EXPR
)
1805 val
= boolean_true_node
;
1807 val
= boolean_false_node
;
1809 else if (code
== LE_EXPR
)
1812 val
= boolean_true_node
;
1814 val
= boolean_false_node
;
1816 else if (code
== GE_EXPR
)
1819 val
= boolean_true_node
;
1821 val
= boolean_false_node
;
1824 /* If primop0 was sign-extended and unsigned comparison specd,
1825 we did a signed comparison above using the signed type bounds.
1826 But the comparison we output must be unsigned.
1828 Also, for inequalities, VAL is no good; but if the signed
1829 comparison had *any* fixed result, it follows that the
1830 unsigned comparison just tests the sign in reverse
1831 (positive values are LE, negative ones GE).
1832 So we can generate an unsigned comparison
1833 against an extreme value of the signed type. */
1835 if (unsignedp
&& !unsignedp0
)
1842 primop1
= TYPE_MIN_VALUE (type
);
1848 primop1
= TYPE_MAX_VALUE (type
);
1855 type
= unsigned_type (type
);
1858 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1860 /* This is the case of (char)x >?< 0x80, which people used to use
1861 expecting old C compilers to change the 0x80 into -0x80. */
1862 if (val
== boolean_false_node
)
1863 warning ("comparison is always false due to limited range of data type");
1864 if (val
== boolean_true_node
)
1865 warning ("comparison is always true due to limited range of data type");
1868 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1870 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1871 if (val
== boolean_false_node
)
1872 warning ("comparison is always false due to limited range of data type");
1873 if (val
== boolean_true_node
)
1874 warning ("comparison is always true due to limited range of data type");
1879 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1880 if (TREE_SIDE_EFFECTS (primop0
))
1881 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1885 /* Value is not predetermined, but do the comparison
1886 in the type of the operand that is not constant.
1887 TYPE is already properly set. */
1889 else if (real1
&& real2
1890 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1891 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1892 type
= TREE_TYPE (primop0
);
1894 /* If args' natural types are both narrower than nominal type
1895 and both extend in the same manner, compare them
1896 in the type of the wider arg.
1897 Otherwise must actually extend both to the nominal
1898 common type lest different ways of extending
1900 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1902 else if (unsignedp0
== unsignedp1
&& real1
== real2
1903 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1904 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1906 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1907 type
= signed_or_unsigned_type (unsignedp0
1908 || TREE_UNSIGNED (*restype_ptr
),
1910 /* Make sure shorter operand is extended the right way
1911 to match the longer operand. */
1912 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1914 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1919 /* Here we must do the comparison on the nominal type
1920 using the args exactly as we received them. */
1921 type
= *restype_ptr
;
1925 if (!real1
&& !real2
&& integer_zerop (primop1
)
1926 && TREE_UNSIGNED (*restype_ptr
))
1932 /* All unsigned values are >= 0, so we warn if extra warnings
1933 are requested. However, if OP0 is a constant that is
1934 >= 0, the signedness of the comparison isn't an issue,
1935 so suppress the warning. */
1936 if (extra_warnings
&& !in_system_header
1937 && ! (TREE_CODE (primop0
) == INTEGER_CST
1938 && ! TREE_OVERFLOW (convert (signed_type (type
),
1940 warning ("comparison of unsigned expression >= 0 is always true");
1941 value
= boolean_true_node
;
1945 if (extra_warnings
&& !in_system_header
1946 && ! (TREE_CODE (primop0
) == INTEGER_CST
1947 && ! TREE_OVERFLOW (convert (signed_type (type
),
1949 warning ("comparison of unsigned expression < 0 is always false");
1950 value
= boolean_false_node
;
1959 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1960 if (TREE_SIDE_EFFECTS (primop0
))
1961 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1968 *op0_ptr
= convert (type
, primop0
);
1969 *op1_ptr
= convert (type
, primop1
);
1971 *restype_ptr
= boolean_type_node
;
1976 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1977 or validate its data type for an `if' or `while' statement or ?..: exp.
1979 This preparation consists of taking the ordinary
1980 representation of an expression expr and producing a valid tree
1981 boolean expression describing whether expr is nonzero. We could
1982 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1983 but we optimize comparisons, &&, ||, and !.
1985 The resulting type should always be `boolean_type_node'. */
1988 truthvalue_conversion (expr
)
1991 if (TREE_CODE (expr
) == ERROR_MARK
)
1994 #if 0 /* This appears to be wrong for C++. */
1995 /* These really should return error_mark_node after 2.4 is stable.
1996 But not all callers handle ERROR_MARK properly. */
1997 switch (TREE_CODE (TREE_TYPE (expr
)))
2000 error ("struct type value used where scalar is required");
2001 return boolean_false_node
;
2004 error ("union type value used where scalar is required");
2005 return boolean_false_node
;
2008 error ("array type value used where scalar is required");
2009 return boolean_false_node
;
2016 switch (TREE_CODE (expr
))
2019 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2020 case TRUTH_ANDIF_EXPR
:
2021 case TRUTH_ORIF_EXPR
:
2022 case TRUTH_AND_EXPR
:
2024 case TRUTH_XOR_EXPR
:
2025 case TRUTH_NOT_EXPR
:
2026 TREE_TYPE (expr
) = boolean_type_node
;
2033 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2036 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2039 /* If we are taking the address of an external decl, it might be zero
2040 if it is weak, so we cannot optimize. */
2041 if (DECL_P (TREE_OPERAND (expr
, 0))
2042 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2045 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2046 return build (COMPOUND_EXPR
, boolean_type_node
,
2047 TREE_OPERAND (expr
, 0), boolean_true_node
);
2049 return boolean_true_node
;
2052 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2053 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2054 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2055 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2062 /* These don't change whether an object is non-zero or zero. */
2063 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2067 /* These don't change whether an object is zero or non-zero, but
2068 we can't ignore them if their second arg has side-effects. */
2069 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2070 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2071 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2073 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2076 /* Distribute the conversion into the arms of a COND_EXPR. */
2077 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2078 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2079 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2082 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2083 since that affects how `default_conversion' will behave. */
2084 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2085 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2087 /* fall through... */
2089 /* If this is widening the argument, we can ignore it. */
2090 if (TYPE_PRECISION (TREE_TYPE (expr
))
2091 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2092 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2096 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2098 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2099 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2101 /* fall through... */
2103 /* This and MINUS_EXPR can be changed into a comparison of the
2105 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2106 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2107 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2108 TREE_OPERAND (expr
, 1), 1);
2109 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2110 fold (build1 (NOP_EXPR
,
2111 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2112 TREE_OPERAND (expr
, 1))), 1);
2115 if (integer_onep (TREE_OPERAND (expr
, 1))
2116 && TREE_TYPE (expr
) != boolean_type_node
)
2117 /* Using convert here would cause infinite recursion. */
2118 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2122 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2123 warning ("suggest parentheses around assignment used as truth value");
2130 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2132 tree tem
= save_expr (expr
);
2133 return (build_binary_op
2134 ((TREE_SIDE_EFFECTS (expr
)
2135 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2136 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
2137 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
2141 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2144 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2145 int, enum built_in_class
, int, int,
2148 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2149 down to the element type of an array. */
2152 c_build_qualified_type (type
, type_quals
)
2156 /* A restrict-qualified pointer type must be a pointer to object or
2157 incomplete type. Note that the use of POINTER_TYPE_P also allows
2158 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2159 the C++ front-end also use POINTER_TYPE for pointer-to-member
2160 values, so even though it should be illegal to use `restrict'
2161 with such an entity we don't flag that here. Thus, special case
2162 code for that case is required in the C++ front-end. */
2163 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2164 && (!POINTER_TYPE_P (type
)
2165 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2167 error ("invalid use of `restrict'");
2168 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2171 if (TREE_CODE (type
) == ARRAY_TYPE
)
2172 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2174 TYPE_DOMAIN (type
));
2175 return build_qualified_type (type
, type_quals
);
2178 /* Apply the TYPE_QUALS to the new DECL. */
2181 c_apply_type_quals_to_decl (type_quals
, decl
)
2185 if ((type_quals
& TYPE_QUAL_CONST
)
2186 || (TREE_TYPE (decl
)
2187 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2188 TREE_READONLY (decl
) = 1;
2189 if (type_quals
& TYPE_QUAL_VOLATILE
)
2191 TREE_SIDE_EFFECTS (decl
) = 1;
2192 TREE_THIS_VOLATILE (decl
) = 1;
2194 if (type_quals
& TYPE_QUAL_RESTRICT
)
2196 if (!TREE_TYPE (decl
)
2197 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2198 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2199 error ("invalid use of `restrict'");
2200 else if (flag_strict_aliasing
)
2201 /* Indicate we need to make a unique alias set for this pointer.
2202 We can't do it here because it might be pointing to an
2204 DECL_POINTER_ALIAS_SET (decl
) = -2;
2209 /* Return the typed-based alias set for T, which may be an expression
2210 or a type. Return -1 if we don't do anything special. */
2213 c_common_get_alias_set (t
)
2218 /* We know nothing about vector types */
2219 if (TREE_CODE (t
) == VECTOR_TYPE
)
2222 /* Permit type-punning when accessing a union, provided the access
2223 is directly through the union. For example, this code does not
2224 permit taking the address of a union member and then storing
2225 through it. Even the type-punning allowed here is a GCC
2226 extension, albeit a common and useful one; the C standard says
2227 that such accesses have implementation-defined behavior. */
2229 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2230 u
= TREE_OPERAND (u
, 0))
2231 if (TREE_CODE (u
) == COMPONENT_REF
2232 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2235 /* If this is a char *, the ANSI C standard says it can alias
2236 anything. Note that all references need do this. */
2237 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2238 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2239 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2242 /* That's all the expressions we handle specially. */
2246 /* The C standard specifically allows aliasing between signed and
2247 unsigned variants of the same type. We treat the signed
2248 variant as canonical. */
2249 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2251 tree t1
= signed_type (t
);
2253 /* t1 == t can happen for boolean nodes which are always unsigned. */
2255 return get_alias_set (t1
);
2257 else if (POINTER_TYPE_P (t
))
2261 /* Unfortunately, there is no canonical form of a pointer type.
2262 In particular, if we have `typedef int I', then `int *', and
2263 `I *' are different types. So, we have to pick a canonical
2264 representative. We do this below.
2266 Technically, this approach is actually more conservative that
2267 it needs to be. In particular, `const int *' and `int *'
2268 should be in different alias sets, according to the C and C++
2269 standard, since their types are not the same, and so,
2270 technically, an `int **' and `const int **' cannot point at
2273 But, the standard is wrong. In particular, this code is
2278 const int* const* cipp = &ipp;
2280 And, it doesn't make sense for that to be legal unless you
2281 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2282 the pointed-to types. This issue has been reported to the
2284 t1
= build_type_no_quals (t
);
2286 return get_alias_set (t1
);
2292 /* Implement the __alignof keyword: Return the minimum required
2293 alignment of TYPE, measured in bytes. */
2299 enum tree_code code
= TREE_CODE (type
);
2302 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2303 if (code
== REFERENCE_TYPE
)
2305 type
= TREE_TYPE (type
);
2306 code
= TREE_CODE (type
);
2309 if (code
== FUNCTION_TYPE
)
2310 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2311 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
2313 else if (!COMPLETE_TYPE_P (type
))
2315 error ("__alignof__ applied to an incomplete type");
2319 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2321 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2324 /* Implement the __alignof keyword: Return the minimum required
2325 alignment of EXPR, measured in bytes. For VAR_DECL's and
2326 FIELD_DECL's return DECL_ALIGN (which can be set from an
2327 "aligned" __attribute__ specification). */
2330 c_alignof_expr (expr
)
2335 if (TREE_CODE (expr
) == VAR_DECL
)
2336 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2338 else if (TREE_CODE (expr
) == COMPONENT_REF
2339 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2341 error ("`__alignof' applied to a bit-field");
2344 else if (TREE_CODE (expr
) == COMPONENT_REF
2345 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2346 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2348 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2350 tree t
= TREE_OPERAND (expr
, 0);
2352 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2354 while (TREE_CODE (t
) == NOP_EXPR
2355 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2359 t
= TREE_OPERAND (t
, 0);
2360 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2361 if (thisalign
> bestalign
)
2362 best
= t
, bestalign
= thisalign
;
2364 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2367 return c_alignof (TREE_TYPE (expr
));
2369 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2372 /* Give the specifications for the format attributes, used by C and all
2375 static const struct attribute_spec c_format_attribute_table
[] =
2377 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2378 { "format", 3, 3, false, true, true,
2379 handle_format_attribute
},
2380 { "format_arg", 1, 1, false, true, true,
2381 handle_format_arg_attribute
},
2382 { NULL
, 0, 0, false, false, false, NULL
}
2385 /* Build tree nodes and builtin functions common to both C and C++ language
2389 c_common_nodes_and_builtins ()
2393 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2394 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2395 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2396 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2397 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2398 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2399 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2400 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2401 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2402 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2403 #include "builtin-types.def"
2404 #undef DEF_PRIMITIVE_TYPE
2405 #undef DEF_FUNCTION_TYPE_0
2406 #undef DEF_FUNCTION_TYPE_1
2407 #undef DEF_FUNCTION_TYPE_2
2408 #undef DEF_FUNCTION_TYPE_3
2409 #undef DEF_FUNCTION_TYPE_4
2410 #undef DEF_FUNCTION_TYPE_VAR_0
2411 #undef DEF_FUNCTION_TYPE_VAR_1
2412 #undef DEF_FUNCTION_TYPE_VAR_2
2413 #undef DEF_POINTER_TYPE
2417 typedef enum builtin_type builtin_type
;
2419 tree builtin_types
[(int) BT_LAST
];
2420 int wchar_type_size
;
2421 tree array_domain_type
;
2422 /* Either char* or void*. */
2423 tree traditional_ptr_type_node
;
2424 /* Either const char* or const void*. */
2425 tree traditional_cptr_type_node
;
2426 tree traditional_len_type_node
;
2427 tree va_list_ref_type_node
;
2428 tree va_list_arg_type_node
;
2430 /* We must initialize this before any builtin functions (which might have
2431 attributes) are declared. (c_common_init is too late.) */
2432 format_attribute_table
= c_format_attribute_table
;
2434 /* Define `int' and `char' first so that dbx will output them first. */
2435 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
2436 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2438 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2439 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2440 but not C. Are the conditionals here needed? */
2441 if (c_language
== clk_cplusplus
)
2442 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
2443 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2444 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2445 record_builtin_type (RID_MAX
, "long unsigned int",
2446 long_unsigned_type_node
);
2447 if (c_language
== clk_cplusplus
)
2448 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2449 record_builtin_type (RID_MAX
, "long long int",
2450 long_long_integer_type_node
);
2451 record_builtin_type (RID_MAX
, "long long unsigned int",
2452 long_long_unsigned_type_node
);
2453 if (c_language
== clk_cplusplus
)
2454 record_builtin_type (RID_MAX
, "long long unsigned",
2455 long_long_unsigned_type_node
);
2456 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2457 record_builtin_type (RID_MAX
, "short unsigned int",
2458 short_unsigned_type_node
);
2459 if (c_language
== clk_cplusplus
)
2460 record_builtin_type (RID_MAX
, "unsigned short",
2461 short_unsigned_type_node
);
2463 /* Define both `signed char' and `unsigned char'. */
2464 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2465 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2467 /* These are types that type_for_size and type_for_mode use. */
2468 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2469 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2470 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2471 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2472 #if HOST_BITS_PER_WIDE_INT >= 64
2473 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
2475 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2476 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2477 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2478 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2479 #if HOST_BITS_PER_WIDE_INT >= 64
2480 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
2483 /* Create the widest literal types. */
2484 widest_integer_literal_type_node
2485 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2486 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2487 widest_integer_literal_type_node
));
2489 widest_unsigned_literal_type_node
2490 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2491 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2492 widest_unsigned_literal_type_node
));
2494 /* `unsigned long' is the standard type for sizeof.
2495 Note that stddef.h uses `unsigned long',
2496 and this must agree, even if long and int are the same size. */
2498 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2499 signed_size_type_node
= signed_type (c_size_type_node
);
2500 if (flag_traditional
)
2501 c_size_type_node
= signed_size_type_node
;
2502 set_sizetype (c_size_type_node
);
2504 build_common_tree_nodes_2 (flag_short_double
);
2506 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
2507 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
2508 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2510 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2511 complex_integer_type_node
));
2512 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2513 complex_float_type_node
));
2514 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2515 complex_double_type_node
));
2516 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2517 complex_long_double_type_node
));
2519 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
2521 void_zero_node
= build_int_2 (0, 0);
2522 TREE_TYPE (void_zero_node
) = void_type_node
;
2524 void_list_node
= build_void_list_node ();
2526 /* Make a type to be the domain of a few array types
2527 whose domains don't really matter.
2528 200 is small enough that it always fits in size_t
2529 and large enough that it can hold most function names for the
2530 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2531 array_domain_type
= build_index_type (size_int (200));
2533 /* Make a type for arrays of characters.
2534 With luck nothing will ever really depend on the length of this
2536 char_array_type_node
2537 = build_array_type (char_type_node
, array_domain_type
);
2539 /* Likewise for arrays of ints. */
2541 = build_array_type (integer_type_node
, array_domain_type
);
2543 string_type_node
= build_pointer_type (char_type_node
);
2544 const_string_type_node
2545 = build_pointer_type (build_qualified_type
2546 (char_type_node
, TYPE_QUAL_CONST
));
2548 traditional_ptr_type_node
= ((flag_traditional
&&
2549 c_language
!= clk_cplusplus
)
2550 ? string_type_node
: ptr_type_node
);
2551 traditional_cptr_type_node
= ((flag_traditional
&&
2552 c_language
!= clk_cplusplus
)
2553 ? const_string_type_node
: const_ptr_type_node
);
2555 (*targetm
.init_builtins
) ();
2557 /* This is special for C++ so functions can be overloaded. */
2558 wchar_type_node
= get_identifier (flag_short_wchar
2559 ? "short unsigned int"
2561 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2562 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2563 if (c_language
== clk_cplusplus
)
2565 if (TREE_UNSIGNED (wchar_type_node
))
2566 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2568 wchar_type_node
= make_signed_type (wchar_type_size
);
2569 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2573 signed_wchar_type_node
= signed_type (wchar_type_node
);
2574 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2577 /* This is for wide string constants. */
2578 wchar_array_type_node
2579 = build_array_type (wchar_type_node
, array_domain_type
);
2582 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2585 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2587 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2589 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2591 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2592 unsigned_ptrdiff_type_node
= unsigned_type (ptrdiff_type_node
);
2594 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2595 va_list_type_node
));
2597 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2598 ptrdiff_type_node
));
2600 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2603 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2605 va_list_arg_type_node
= va_list_ref_type_node
=
2606 build_pointer_type (TREE_TYPE (va_list_type_node
));
2610 va_list_arg_type_node
= va_list_type_node
;
2611 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2614 traditional_len_type_node
= ((flag_traditional
&&
2615 c_language
!= clk_cplusplus
)
2616 ? integer_type_node
: sizetype
);
2618 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2619 builtin_types[(int) ENUM] = VALUE;
2620 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2621 builtin_types[(int) ENUM] \
2622 = build_function_type (builtin_types[(int) RETURN], \
2624 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2625 builtin_types[(int) ENUM] \
2626 = build_function_type (builtin_types[(int) RETURN], \
2627 tree_cons (NULL_TREE, \
2628 builtin_types[(int) ARG1], \
2630 #define DEF_FUNCTION_TYPE_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_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2640 builtin_types[(int) ENUM] \
2641 = build_function_type \
2642 (builtin_types[(int) RETURN], \
2643 tree_cons (NULL_TREE, \
2644 builtin_types[(int) ARG1], \
2645 tree_cons (NULL_TREE, \
2646 builtin_types[(int) ARG2], \
2647 tree_cons (NULL_TREE, \
2648 builtin_types[(int) ARG3], \
2650 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2651 builtin_types[(int) ENUM] \
2652 = build_function_type \
2653 (builtin_types[(int) RETURN], \
2654 tree_cons (NULL_TREE, \
2655 builtin_types[(int) ARG1], \
2656 tree_cons (NULL_TREE, \
2657 builtin_types[(int) ARG2], \
2660 builtin_types[(int) ARG3], \
2661 tree_cons (NULL_TREE, \
2662 builtin_types[(int) ARG4], \
2663 void_list_node)))));
2664 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2665 builtin_types[(int) ENUM] \
2666 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2667 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2668 builtin_types[(int) ENUM] \
2669 = build_function_type (builtin_types[(int) RETURN], \
2670 tree_cons (NULL_TREE, \
2671 builtin_types[(int) ARG1], \
2674 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2675 builtin_types[(int) ENUM] \
2676 = build_function_type \
2677 (builtin_types[(int) RETURN], \
2678 tree_cons (NULL_TREE, \
2679 builtin_types[(int) ARG1], \
2680 tree_cons (NULL_TREE, \
2681 builtin_types[(int) ARG2], \
2683 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2684 builtin_types[(int) ENUM] \
2685 = build_pointer_type (builtin_types[(int) TYPE]);
2686 #include "builtin-types.def"
2687 #undef DEF_PRIMITIVE_TYPE
2688 #undef DEF_FUNCTION_TYPE_1
2689 #undef DEF_FUNCTION_TYPE_2
2690 #undef DEF_FUNCTION_TYPE_3
2691 #undef DEF_FUNCTION_TYPE_4
2692 #undef DEF_FUNCTION_TYPE_VAR_0
2693 #undef DEF_FUNCTION_TYPE_VAR_1
2694 #undef DEF_POINTER_TYPE
2696 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2697 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2702 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2706 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2709 ? (NAME + strlen ("__builtin_")) \
2712 decl = builtin_function_2 (NAME, \
2713 NAME + strlen ("__builtin_"), \
2714 builtin_types[TYPE], \
2715 builtin_types[LIBTYPE], \
2720 /*noreturn_p=*/0); \
2722 built_in_decls[(int) ENUM] = decl; \
2724 #include "builtins.def"
2727 /* Declare _exit and _Exit just to mark them as non-returning. */
2728 builtin_function_2 (NULL
, "_exit", NULL_TREE
,
2729 builtin_types
[BT_FN_VOID_INT
],
2730 0, NOT_BUILT_IN
, 0, 1, 1);
2731 builtin_function_2 (NULL
, "_Exit", NULL_TREE
,
2732 builtin_types
[BT_FN_VOID_INT
],
2733 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
2735 /* Declare these functions non-returning
2736 to avoid spurious "control drops through" warnings. */
2737 builtin_function_2 (NULL
, "abort",
2738 NULL_TREE
, ((c_language
== clk_cplusplus
)
2739 ? builtin_types
[BT_FN_VOID
]
2740 : builtin_types
[BT_FN_VOID_VAR
]),
2741 0, NOT_BUILT_IN
, 0, 0, 1);
2743 builtin_function_2 (NULL
, "exit",
2744 NULL_TREE
, ((c_language
== clk_cplusplus
)
2745 ? builtin_types
[BT_FN_VOID_INT
]
2746 : builtin_types
[BT_FN_VOID_VAR
]),
2747 0, NOT_BUILT_IN
, 0, 0, 1);
2749 main_identifier_node
= get_identifier ("main");
2751 /* ??? Perhaps there's a better place to do this. But it is related
2752 to __builtin_va_arg, so it isn't that off-the-wall. */
2753 lang_type_promotes_to
= simple_type_promotes_to
;
2757 build_va_arg (expr
, type
)
2760 return build1 (VA_ARG_EXPR
, type
, expr
);
2764 /* Linked list of disabled built-in functions. */
2766 typedef struct disabled_builtin
2769 struct disabled_builtin
*next
;
2771 static disabled_builtin
*disabled_builtins
= NULL
;
2773 static bool builtin_function_disabled_p
PARAMS ((const char *));
2775 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2776 begins with "__builtin_", give an error. */
2779 disable_builtin_function (name
)
2782 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
2783 error ("cannot disable built-in function `%s'", name
);
2786 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
2788 new->next
= disabled_builtins
;
2789 disabled_builtins
= new;
2794 /* Return true if the built-in function NAME has been disabled, false
2798 builtin_function_disabled_p (name
)
2801 disabled_builtin
*p
;
2802 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
2804 if (strcmp (name
, p
->name
) == 0)
2811 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2812 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2813 of these may be NULL (though both being NULL is useless).
2814 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2815 TYPE is the type of the function with the ordinary name. These
2816 may differ if the ordinary name is declared with a looser type to avoid
2817 conflicts with headers. FUNCTION_CODE and CLASS are as for
2818 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2819 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2820 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2821 NORETURN_P is nonzero, the function is marked as non-returning.
2822 Returns the declaration of BUILTIN_NAME, if any, otherwise
2823 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2824 or if NONANSI_P and flag_no_nonansi_builtin. */
2827 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
2828 class, library_name_p
, nonansi_p
, noreturn_p
)
2829 const char *builtin_name
;
2834 enum built_in_class
class;
2839 tree bdecl
= NULL_TREE
;
2840 tree decl
= NULL_TREE
;
2841 if (builtin_name
!= 0)
2843 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
2844 class, library_name_p
? name
: NULL
);
2847 TREE_THIS_VOLATILE (bdecl
) = 1;
2848 TREE_SIDE_EFFECTS (bdecl
) = 1;
2851 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
2852 && !(nonansi_p
&& flag_no_nonansi_builtin
))
2854 decl
= builtin_function (name
, type
, function_code
, class, NULL
);
2856 DECL_BUILT_IN_NONANSI (decl
) = 1;
2859 TREE_THIS_VOLATILE (decl
) = 1;
2860 TREE_SIDE_EFFECTS (decl
) = 1;
2863 return (bdecl
!= 0 ? bdecl
: decl
);
2866 /* Nonzero if the type T promotes to int. This is (nearly) the
2867 integral promotions defined in ISO C99 6.3.1.1/2. */
2870 c_promoting_integer_type_p (t
)
2873 switch (TREE_CODE (t
))
2876 return (TYPE_MAIN_VARIANT (t
) == char_type_node
2877 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
2878 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
2879 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
2880 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
2881 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
2884 /* ??? Technically all enumerations not larger than an int
2885 promote to an int. But this is used along code paths
2886 that only want to notice a size change. */
2887 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
2897 /* Given a type, apply default promotions wrt unnamed function arguments
2898 and return the new type. Return NULL_TREE if no change. */
2899 /* ??? There is a function of the same name in the C++ front end that
2900 does something similar, but is more thorough and does not return NULL
2901 if no change. We could perhaps share code, but it would make the
2902 self_promoting_type property harder to identify. */
2905 simple_type_promotes_to (type
)
2908 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2909 return double_type_node
;
2911 if (c_promoting_integer_type_p (type
))
2913 /* Traditionally, unsignedness is preserved in default promotions.
2914 Also preserve unsignedness if not really getting any wider. */
2915 if (TREE_UNSIGNED (type
)
2916 && (flag_traditional
2917 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
2918 return unsigned_type_node
;
2919 return integer_type_node
;
2925 /* Return 1 if PARMS specifies a fixed number of parameters
2926 and none of their types is affected by default promotions. */
2929 self_promoting_args_p (parms
)
2933 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
2935 tree type
= TREE_VALUE (t
);
2937 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
2943 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2946 if (c_promoting_integer_type_p (type
))
2952 /* Recursively examines the array elements of TYPE, until a non-array
2953 element type is found. */
2956 strip_array_types (type
)
2959 while (TREE_CODE (type
) == ARRAY_TYPE
)
2960 type
= TREE_TYPE (type
);
2965 /* Recognize certain built-in functions so we can make tree-codes
2966 other than CALL_EXPR. We do this when it enables fold-const.c
2967 to do something useful. */
2968 /* ??? By rights this should go in builtins.c, but only C and C++
2969 implement build_{binary,unary}_op. Not exactly sure what bits
2970 of functionality are actually needed from those functions, or
2971 where the similar functionality exists in the other front ends. */
2974 expand_tree_builtin (function
, params
, coerced_params
)
2975 tree function
, params
, coerced_params
;
2977 enum tree_code code
;
2979 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
2982 switch (DECL_FUNCTION_CODE (function
))
2986 case BUILT_IN_LLABS
:
2987 case BUILT_IN_IMAXABS
:
2989 case BUILT_IN_FABSL
:
2990 case BUILT_IN_FABSF
:
2991 if (coerced_params
== 0)
2992 return integer_zero_node
;
2993 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2996 case BUILT_IN_CONJF
:
2997 case BUILT_IN_CONJL
:
2998 if (coerced_params
== 0)
2999 return integer_zero_node
;
3000 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3002 case BUILT_IN_CREAL
:
3003 case BUILT_IN_CREALF
:
3004 case BUILT_IN_CREALL
:
3005 if (coerced_params
== 0)
3006 return integer_zero_node
;
3007 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3009 case BUILT_IN_CIMAG
:
3010 case BUILT_IN_CIMAGF
:
3011 case BUILT_IN_CIMAGL
:
3012 if (coerced_params
== 0)
3013 return integer_zero_node
;
3014 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3016 case BUILT_IN_ISGREATER
:
3017 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3023 case BUILT_IN_ISGREATEREQUAL
:
3024 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3030 case BUILT_IN_ISLESS
:
3031 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3037 case BUILT_IN_ISLESSEQUAL
:
3038 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3044 case BUILT_IN_ISLESSGREATER
:
3045 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3051 case BUILT_IN_ISUNORDERED
:
3052 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
3053 return integer_zero_node
;
3054 code
= UNORDERED_EXPR
;
3062 || TREE_CHAIN (params
) == 0)
3064 error ("too few arguments to function `%s'",
3065 IDENTIFIER_POINTER (DECL_NAME (function
)));
3066 return error_mark_node
;
3068 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3070 error ("too many arguments to function `%s'",
3071 IDENTIFIER_POINTER (DECL_NAME (function
)));
3072 return error_mark_node
;
3075 arg0
= TREE_VALUE (params
);
3076 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3077 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
3078 if (code
!= UNORDERED_EXPR
)
3079 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
3091 /* Returns non-zero if CODE is the code for a statement. */
3094 statement_code_p (code
)
3095 enum tree_code code
;
3118 if (lang_statement_code_p
)
3119 return (*lang_statement_code_p
) (code
);
3124 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3125 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3126 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3127 value, the traversal is aborted, and the value returned by FUNC is
3128 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3129 the node being visited are not walked.
3131 We don't need a without_duplicates variant of this one because the
3132 statement tree is a tree, not a graph. */
3135 walk_stmt_tree (tp
, func
, data
)
3140 enum tree_code code
;
3145 #define WALK_SUBTREE(NODE) \
3148 result = walk_stmt_tree (&(NODE), func, data); \
3154 /* Skip empty subtrees. */
3158 /* Skip subtrees below non-statement nodes. */
3159 if (!statement_code_p (TREE_CODE (*tp
)))
3162 /* Call the function. */
3164 result
= (*func
) (tp
, &walk_subtrees
, data
);
3166 /* If we found something, return it. */
3170 /* FUNC may have modified the tree, recheck that we're looking at a
3172 code
= TREE_CODE (*tp
);
3173 if (!statement_code_p (code
))
3176 /* Visit the subtrees unless FUNC decided that there was nothing
3177 interesting below this point in the tree. */
3180 /* Walk over all the sub-trees of this operand. Statement nodes
3181 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3182 len
= TREE_CODE_LENGTH (code
);
3184 /* Go through the subtrees. We need to do this in forward order so
3185 that the scope of a FOR_EXPR is handled properly. */
3186 for (i
= 0; i
< len
; ++i
)
3187 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3190 /* Finally visit the chain. This can be tail-recursion optimized if
3191 we write it this way. */
3192 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3197 /* Used to compare case labels. K1 and K2 are actually tree nodes
3198 representing case labels, or NULL_TREE for a `default' label.
3199 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3200 K2, and 0 if K1 and K2 are equal. */
3203 case_compare (k1
, k2
)
3207 /* Consider a NULL key (such as arises with a `default' label) to be
3208 smaller than anything else. */
3214 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3217 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3218 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3219 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3220 case label was declared using the usual C/C++ syntax, rather than
3221 the GNU case range extension. CASES is a tree containing all the
3222 case ranges processed so far; COND is the condition for the
3223 switch-statement itself. Returns the CASE_LABEL created, or
3224 ERROR_MARK_NODE if no CASE_LABEL is created. */
3227 c_add_case_label (cases
, cond
, low_value
, high_value
)
3236 splay_tree_node node
;
3238 /* Create the LABEL_DECL itself. */
3239 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3240 DECL_CONTEXT (label
) = current_function_decl
;
3242 /* If there was an error processing the switch condition, bail now
3243 before we get more confused. */
3244 if (!cond
|| cond
== error_mark_node
)
3246 /* Add a label anyhow so that the back-end doesn't think that
3247 the beginning of the switch is unreachable. */
3249 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3250 return error_mark_node
;
3253 if ((low_value
&& TREE_TYPE (low_value
)
3254 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3255 || (high_value
&& TREE_TYPE (high_value
)
3256 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3257 error ("pointers are not permitted as case values");
3259 /* Case ranges are a GNU extension. */
3260 if (high_value
&& pedantic
)
3262 if (c_language
== clk_cplusplus
)
3263 pedwarn ("ISO C++ forbids range expressions in switch statements");
3265 pedwarn ("ISO C forbids range expressions in switch statements");
3268 type
= TREE_TYPE (cond
);
3271 low_value
= check_case_value (low_value
);
3272 low_value
= convert_and_check (type
, low_value
);
3276 high_value
= check_case_value (high_value
);
3277 high_value
= convert_and_check (type
, high_value
);
3280 /* If an error has occurred, bail out now. */
3281 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3284 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3285 return error_mark_node
;
3288 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3289 really a case range, even though it was written that way. Remove
3290 the HIGH_VALUE to simplify later processing. */
3291 if (tree_int_cst_equal (low_value
, high_value
))
3292 high_value
= NULL_TREE
;
3293 if (low_value
&& high_value
3294 && !tree_int_cst_lt (low_value
, high_value
))
3295 warning ("empty range specified");
3297 /* Look up the LOW_VALUE in the table of case labels we already
3299 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3300 /* If there was not an exact match, check for overlapping ranges.
3301 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3302 that's a `default' label and the only overlap is an exact match. */
3303 if (!node
&& (low_value
|| high_value
))
3305 splay_tree_node low_bound
;
3306 splay_tree_node high_bound
;
3308 /* Even though there wasn't an exact match, there might be an
3309 overlap between this case range and another case range.
3310 Since we've (inductively) not allowed any overlapping case
3311 ranges, we simply need to find the greatest low case label
3312 that is smaller that LOW_VALUE, and the smallest low case
3313 label that is greater than LOW_VALUE. If there is an overlap
3314 it will occur in one of these two ranges. */
3315 low_bound
= splay_tree_predecessor (cases
,
3316 (splay_tree_key
) low_value
);
3317 high_bound
= splay_tree_successor (cases
,
3318 (splay_tree_key
) low_value
);
3320 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3321 the LOW_VALUE, so there is no need to check unless the
3322 LOW_BOUND is in fact itself a case range. */
3324 && CASE_HIGH ((tree
) low_bound
->value
)
3325 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3328 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3329 range is bigger than the low end of the current range, so we
3330 are only interested if the current range is a real range, and
3331 not an ordinary case label. */
3334 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3339 /* If there was an overlap, issue an error. */
3342 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3346 error ("duplicate (or overlapping) case value");
3347 error_with_decl (duplicate
,
3348 "this is the first entry overlapping that value");
3352 error ("duplicate case value") ;
3353 error_with_decl (duplicate
, "previously used here");
3357 error ("multiple default labels in one switch");
3358 error_with_decl (duplicate
, "this is the first default label");
3361 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3364 /* Add a CASE_LABEL to the statement-tree. */
3365 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3366 /* Register this case label in the splay tree. */
3367 splay_tree_insert (cases
,
3368 (splay_tree_key
) low_value
,
3369 (splay_tree_value
) case_label
);
3374 /* Finish an expression taking the address of LABEL. Returns an
3375 expression for the address. */
3378 finish_label_address_expr (label
)
3385 if (c_language
== clk_cplusplus
)
3386 pedwarn ("ISO C++ forbids taking the address of a label");
3388 pedwarn ("ISO C forbids taking the address of a label");
3391 label
= lookup_label (label
);
3392 if (label
== NULL_TREE
)
3393 result
= null_pointer_node
;
3396 TREE_USED (label
) = 1;
3397 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3398 TREE_CONSTANT (result
) = 1;
3399 /* The current function in not necessarily uninlinable.
3400 Computed gotos are incompatible with inlining, but the value
3401 here could be used only in a diagnostic, for example. */
3407 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3408 parameter allows this function to be used as a GC-marking
3415 stmt_tree st
= (stmt_tree
) p
;
3417 ggc_mark_tree (st
->x_last_stmt
);
3418 ggc_mark_tree (st
->x_last_expr_type
);
3421 /* Mark LD for GC. */
3424 c_mark_lang_decl (c
)
3425 struct c_lang_decl
*c ATTRIBUTE_UNUSED
;
3429 /* Mark F for GC. */
3432 mark_c_language_function (f
)
3433 struct language_function
*f
;
3438 mark_stmt_tree (&f
->x_stmt_tree
);
3439 ggc_mark_tree (f
->x_scope_stmt_stack
);
3442 /* Hook used by expand_expr to expand language-specific tree codes. */
3445 c_expand_expr (exp
, target
, tmode
, modifier
)
3448 enum machine_mode tmode
;
3449 enum expand_modifier modifier
;
3451 switch (TREE_CODE (exp
))
3458 /* Since expand_expr_stmt calls free_temp_slots after every
3459 expression statement, we must call push_temp_slots here.
3460 Otherwise, any temporaries in use now would be considered
3461 out-of-scope after the first EXPR_STMT from within the
3464 rtl_expr
= expand_start_stmt_expr ();
3466 /* If we want the result of this expression, find the last
3467 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3468 if (target
!= const0_rtx
3469 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
3470 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
3472 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
3473 tree last
= TREE_CHAIN (expr
);
3475 while (TREE_CHAIN (last
))
3478 last
= TREE_CHAIN (last
);
3481 if (TREE_CODE (last
) == SCOPE_STMT
3482 && TREE_CODE (expr
) == EXPR_STMT
)
3483 TREE_ADDRESSABLE (expr
) = 1;
3486 expand_stmt (STMT_EXPR_STMT (exp
));
3487 expand_end_stmt_expr (rtl_expr
);
3488 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
3496 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3497 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3499 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3500 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3501 == BUILT_IN_FRONTEND
))
3502 return c_expand_builtin (exp
, target
, tmode
, modifier
);
3508 case COMPOUND_LITERAL_EXPR
:
3510 /* Initialize the anonymous variable declared in the compound
3511 literal, then return the variable. */
3512 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
3513 emit_local_var (decl
);
3514 return expand_expr (decl
, target
, tmode
, modifier
);
3525 /* Hook used by safe_from_p to handle language-specific tree codes. */
3528 c_safe_from_p (target
, exp
)
3532 /* We can see statements here when processing the body of a
3533 statement-expression. For a declaration statement declaring a
3534 variable, look at the variable's initializer. */
3535 if (TREE_CODE (exp
) == DECL_STMT
)
3537 tree decl
= DECL_STMT_DECL (exp
);
3539 if (TREE_CODE (decl
) == VAR_DECL
3540 && DECL_INITIAL (decl
)
3541 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
3545 /* For any statement, we must follow the statement-chain. */
3546 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
3547 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
3549 /* Assume everything else is safe. */
3553 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3556 c_unsafe_for_reeval (exp
)
3559 /* Statement expressions may not be reevaluated. */
3560 if (TREE_CODE (exp
) == STMT_EXPR
)
3563 /* Walk all other expressions. */
3567 /* Hook used by staticp to handle language-specific tree codes. */
3573 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
3574 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
3579 /* Tree code classes. */
3581 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3583 static const char c_tree_code_type
[] = {
3585 #include "c-common.def"
3589 /* Table indexed by tree code giving number of expression
3590 operands beyond the fixed part of the node structure.
3591 Not used for types or decls. */
3593 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3595 static const int c_tree_code_length
[] = {
3597 #include "c-common.def"
3601 /* Names of tree components.
3602 Used for printing out the tree and error messages. */
3603 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3605 static const char *const c_tree_code_name
[] = {
3607 #include "c-common.def"
3611 /* Adds the tree codes specific to the C front end to the list of all
3617 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3619 (int) LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
);
3620 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3622 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
3623 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3625 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
3626 lang_unsafe_for_reeval
= c_unsafe_for_reeval
;
3629 #define CALLED_AS_BUILT_IN(NODE) \
3630 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3633 c_expand_builtin (exp
, target
, tmode
, modifier
)
3636 enum machine_mode tmode
;
3637 enum expand_modifier modifier
;
3639 tree type
= TREE_TYPE (exp
);
3640 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3641 tree arglist
= TREE_OPERAND (exp
, 1);
3642 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3643 enum tree_code code
= TREE_CODE (exp
);
3644 const int ignore
= (target
== const0_rtx
3645 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
3646 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
3647 || code
== COND_EXPR
)
3648 && TREE_CODE (type
) == VOID_TYPE
));
3650 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
3651 return expand_call (exp
, target
, ignore
);
3655 case BUILT_IN_PRINTF
:
3656 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3657 modifier
, ignore
, /*unlocked=*/ 0);
3662 case BUILT_IN_PRINTF_UNLOCKED
:
3663 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3664 modifier
, ignore
, /*unlocked=*/ 1);
3669 case BUILT_IN_FPRINTF
:
3670 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3671 modifier
, ignore
, /*unlocked=*/ 0);
3676 case BUILT_IN_FPRINTF_UNLOCKED
:
3677 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3678 modifier
, ignore
, /*unlocked=*/ 1);
3683 default: /* just do library call, if unknown builtin */
3684 error ("built-in function `%s' not currently supported",
3685 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3688 /* The switch statement above can drop through to cause the function
3689 to be called normally. */
3690 return expand_call (exp
, target
, ignore
);
3693 /* Check an arglist to *printf for problems. The arglist should start
3694 at the format specifier, with the remaining arguments immediately
3697 is_valid_printf_arglist (arglist
)
3700 /* Save this value so we can restore it later. */
3701 const int SAVE_pedantic
= pedantic
;
3702 int diagnostic_occurred
= 0;
3705 /* Set this to a known value so the user setting won't affect code
3708 /* Check to make sure there are no format specifier errors. */
3709 attrs
= tree_cons (get_identifier ("format"),
3710 tree_cons (NULL_TREE
,
3711 get_identifier ("printf"),
3712 tree_cons (NULL_TREE
,
3714 tree_cons (NULL_TREE
,
3718 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
3720 /* Restore the value of `pedantic'. */
3721 pedantic
= SAVE_pedantic
;
3723 /* If calling `check_function_format_ptr' produces a warning, we
3724 return false, otherwise we return true. */
3725 return ! diagnostic_occurred
;
3728 /* If the arguments passed to printf are suitable for optimizations,
3729 we attempt to transform the call. */
3731 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3734 enum machine_mode tmode
;
3735 enum expand_modifier modifier
;
3739 tree fn_putchar
= unlocked
?
3740 built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTCHAR
];
3741 tree fn_puts
= unlocked
?
3742 built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTS
];
3743 tree fn
, format_arg
, stripped_string
;
3745 /* If the return value is used, or the replacement _DECL isn't
3746 initialized, don't do the transformation. */
3747 if (!ignore
|| !fn_putchar
|| !fn_puts
)
3750 /* Verify the required arguments in the original call. */
3752 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
3755 /* Check the specifier vs. the parameters. */
3756 if (!is_valid_printf_arglist (arglist
))
3759 format_arg
= TREE_VALUE (arglist
);
3760 stripped_string
= format_arg
;
3761 STRIP_NOPS (stripped_string
);
3762 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3763 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3765 /* If the format specifier isn't a STRING_CST, punt. */
3766 if (TREE_CODE (stripped_string
) != STRING_CST
)
3769 /* OK! We can attempt optimization. */
3771 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3772 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
3774 arglist
= TREE_CHAIN (arglist
);
3777 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3778 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3780 arglist
= TREE_CHAIN (arglist
);
3785 /* We can't handle anything else with % args or %% ... yet. */
3786 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3789 /* If the resulting constant string has a length of 1, call
3790 putchar. Note, TREE_STRING_LENGTH includes the terminating
3791 NULL in its count. */
3792 if (TREE_STRING_LENGTH (stripped_string
) == 2)
3794 /* Given printf("c"), (where c is any one character,)
3795 convert "c"[0] to an int and pass that to the replacement
3797 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
3798 arglist
= build_tree_list (NULL_TREE
, arglist
);
3802 /* If the resulting constant was "string\n", call
3803 __builtin_puts("string"). Ensure "string" has at least one
3804 character besides the trailing \n. Note, TREE_STRING_LENGTH
3805 includes the terminating NULL in its count. */
3806 else if (TREE_STRING_LENGTH (stripped_string
) > 2
3807 && TREE_STRING_POINTER (stripped_string
)
3808 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
3810 /* Create a NULL-terminated string that's one char shorter
3811 than the original, stripping off the trailing '\n'. */
3812 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
3813 char *newstr
= (char *) alloca (newlen
);
3814 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
3815 newstr
[newlen
- 1] = 0;
3817 arglist
= combine_strings (build_string (newlen
, newstr
));
3818 arglist
= build_tree_list (NULL_TREE
, arglist
);
3822 /* We'd like to arrange to call fputs(string) here, but we
3823 need stdout and don't have a way to get it ... yet. */
3827 return expand_expr (build_function_call (fn
, arglist
),
3828 (ignore
? const0_rtx
: target
),
3832 /* If the arguments passed to fprintf are suitable for optimizations,
3833 we attempt to transform the call. */
3835 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3838 enum machine_mode tmode
;
3839 enum expand_modifier modifier
;
3843 tree fn_fputc
= unlocked
?
3844 built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTC
];
3845 tree fn_fputs
= unlocked
?
3846 built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTS
];
3847 tree fn
, format_arg
, stripped_string
;
3849 /* If the return value is used, or the replacement _DECL isn't
3850 initialized, don't do the transformation. */
3851 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
3854 /* Verify the required arguments in the original call. */
3856 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
3857 || (TREE_CHAIN (arglist
) == 0)
3858 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
3862 /* Check the specifier vs. the parameters. */
3863 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
3866 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
3867 stripped_string
= format_arg
;
3868 STRIP_NOPS (stripped_string
);
3869 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3870 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3872 /* If the format specifier isn't a STRING_CST, punt. */
3873 if (TREE_CODE (stripped_string
) != STRING_CST
)
3876 /* OK! We can attempt optimization. */
3878 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3879 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
3881 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3882 arglist
= tree_cons (NULL_TREE
,
3883 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3887 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3888 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3890 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3891 arglist
= tree_cons (NULL_TREE
,
3892 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3898 /* We can't handle anything else with % args or %% ... yet. */
3899 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3902 /* When "string" doesn't contain %, replace all cases of
3903 fprintf(stream,string) with fputs(string,stream). The fputs
3904 builtin will take take of special cases like length==1. */
3905 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
3906 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
3910 return expand_expr (build_function_call (fn
, arglist
),
3911 (ignore
? const0_rtx
: target
),
3916 /* Given a boolean expression ARG, return a tree representing an increment
3917 or decrement (as indicated by CODE) of ARG. The front end must check for
3918 invalid cases (e.g., decrement in C++). */
3920 boolean_increment (code
, arg
)
3921 enum tree_code code
;
3925 tree true_res
= (c_language
== clk_cplusplus
3927 : c_bool_true_node
);
3928 arg
= stabilize_reference (arg
);
3931 case PREINCREMENT_EXPR
:
3932 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3934 case POSTINCREMENT_EXPR
:
3935 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3936 arg
= save_expr (arg
);
3937 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3938 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3940 case PREDECREMENT_EXPR
:
3941 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3943 case POSTDECREMENT_EXPR
:
3944 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3945 arg
= save_expr (arg
);
3946 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3947 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3952 TREE_SIDE_EFFECTS (val
) = 1;
3956 /* Handle C and C++ default attributes. */
3958 enum built_in_attribute
3960 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3961 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3962 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3963 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3964 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3965 #include "builtin-attrs.def"
3966 #undef DEF_ATTR_NULL_TREE
3968 #undef DEF_ATTR_IDENT
3969 #undef DEF_ATTR_TREE_LIST
3974 static tree built_in_attributes
[(int) ATTR_LAST
];
3976 static bool c_attrs_initialized
= false;
3978 static void c_init_attributes
PARAMS ((void));
3980 /* Common initialization before parsing options. */
3982 c_common_init_options (lang
)
3983 enum c_language_kind lang
;
3986 parse_in
= cpp_create_reader (lang
== clk_c
? CLK_GNUC89
:
3987 lang
== clk_cplusplus
? CLK_GNUCXX
: CLK_OBJC
);
3989 /* Mark as "unspecified" (see c_common_post_options). */
3990 flag_bounds_check
= -1;
3993 /* Post-switch processing. */
3995 c_common_post_options ()
3997 cpp_post_options (parse_in
);
3999 /* Use tree inlining if possible. Function instrumentation is only
4000 done in the RTL level, so we disable tree inlining. */
4001 if (! flag_instrument_function_entry_exit
)
4003 if (!flag_no_inline
)
4005 flag_inline_trees
= 1;
4008 if (flag_inline_functions
)
4010 flag_inline_trees
= 2;
4011 flag_inline_functions
= 0;
4015 /* If still "unspecified", make it match -fbounded-pointers. */
4016 if (flag_bounds_check
== -1)
4017 flag_bounds_check
= flag_bounded_pointers
;
4019 /* Special format checking options don't work without -Wformat; warn if
4021 if (warn_format_y2k
&& !warn_format
)
4022 warning ("-Wformat-y2k ignored without -Wformat");
4023 if (warn_format_extra_args
&& !warn_format
)
4024 warning ("-Wformat-extra-args ignored without -Wformat");
4025 if (warn_format_nonliteral
&& !warn_format
)
4026 warning ("-Wformat-nonliteral ignored without -Wformat");
4027 if (warn_format_security
&& !warn_format
)
4028 warning ("-Wformat-security ignored without -Wformat");
4029 if (warn_missing_format_attribute
&& !warn_format
)
4030 warning ("-Wmissing-format-attribute ignored without -Wformat");
4033 /* Front end initialization common to C, ObjC and C++. */
4035 c_common_init (filename
)
4036 const char *filename
;
4038 /* Do this before initializing pragmas, as then cpplib's hash table
4040 filename
= init_c_lex (filename
);
4044 if (!c_attrs_initialized
)
4045 c_init_attributes ();
4050 /* Common finish hook for the C, ObjC and C++ front ends. */
4054 cpp_finish (parse_in
);
4056 /* For performance, avoid tearing down cpplib's internal structures.
4057 Call cpp_errors () instead of cpp_destroy (). */
4058 errorcount
+= cpp_errors (parse_in
);
4062 c_init_attributes ()
4064 /* Fill in the built_in_attributes array. */
4065 #define DEF_ATTR_NULL_TREE(ENUM) \
4066 built_in_attributes[(int) ENUM] = NULL_TREE;
4067 #define DEF_ATTR_INT(ENUM, VALUE) \
4068 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4069 #define DEF_ATTR_IDENT(ENUM, STRING) \
4070 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4071 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4072 built_in_attributes[(int) ENUM] \
4073 = tree_cons (built_in_attributes[(int) PURPOSE], \
4074 built_in_attributes[(int) VALUE], \
4075 built_in_attributes[(int) CHAIN]);
4076 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4077 #include "builtin-attrs.def"
4078 #undef DEF_ATTR_NULL_TREE
4080 #undef DEF_ATTR_IDENT
4081 #undef DEF_ATTR_TREE_LIST
4083 ggc_add_tree_root (built_in_attributes
, (int) ATTR_LAST
);
4084 c_attrs_initialized
= true;
4087 /* Depending on the name of DECL, apply default attributes to it. */
4090 c_common_insert_default_attributes (decl
)
4093 tree name
= DECL_NAME (decl
);
4095 if (!c_attrs_initialized
)
4096 c_init_attributes ();
4098 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4099 #define DEF_ATTR_INT(ENUM, VALUE)
4100 #define DEF_ATTR_IDENT(ENUM, STRING)
4101 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4102 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4103 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4104 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4105 ATTR_FLAG_BUILT_IN);
4106 #include "builtin-attrs.def"
4107 #undef DEF_ATTR_NULL_TREE
4109 #undef DEF_ATTR_IDENT
4110 #undef DEF_ATTR_TREE_LIST
4114 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4115 additionally give the location of the previous declaration DECL. */
4117 shadow_warning (msgid
, name
, decl
)
4121 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
4122 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4123 DECL_SOURCE_LINE (decl
),
4124 "shadowed declaration is here");