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
) == VECTOR_CST
706 || TREE_CODE (value
) == COMPLEX_CST
)
707 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
708 pedwarn ("overflow in constant expression");
711 /* Print a warning if an expression had overflow in folding.
712 Invoke this function on every expression that
713 (1) appears in the source code, and
714 (2) might be a constant expression that overflowed, and
715 (3) is not already checked by convert_and_check;
716 however, do not invoke this function on operands of explicit casts. */
719 overflow_warning (value
)
722 if ((TREE_CODE (value
) == INTEGER_CST
723 || (TREE_CODE (value
) == COMPLEX_CST
724 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
725 && TREE_OVERFLOW (value
))
727 TREE_OVERFLOW (value
) = 0;
728 if (skip_evaluation
== 0)
729 warning ("integer overflow in expression");
731 else if ((TREE_CODE (value
) == REAL_CST
732 || (TREE_CODE (value
) == COMPLEX_CST
733 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
734 && TREE_OVERFLOW (value
))
736 TREE_OVERFLOW (value
) = 0;
737 if (skip_evaluation
== 0)
738 warning ("floating point overflow in expression");
740 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
742 TREE_OVERFLOW (value
) = 0;
743 if (skip_evaluation
== 0)
744 warning ("vector overflow in expression");
748 /* Print a warning if a large constant is truncated to unsigned,
749 or if -Wconversion is used and a constant < 0 is converted to unsigned.
750 Invoke this function on every expression that might be implicitly
751 converted to an unsigned type. */
754 unsigned_conversion_warning (result
, operand
)
755 tree result
, operand
;
757 if (TREE_CODE (operand
) == INTEGER_CST
758 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
759 && TREE_UNSIGNED (TREE_TYPE (result
))
760 && skip_evaluation
== 0
761 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
763 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
764 /* This detects cases like converting -129 or 256 to unsigned char. */
765 warning ("large integer implicitly truncated to unsigned type");
766 else if (warn_conversion
)
767 warning ("negative integer implicitly converted to unsigned type");
771 /* Nonzero if constant C has a value that is permissible
772 for type TYPE (an INTEGER_TYPE). */
775 constant_fits_type_p (c
, type
)
778 if (TREE_CODE (c
) == INTEGER_CST
)
779 return int_fits_type_p (c
, type
);
781 c
= convert (type
, c
);
782 return !TREE_OVERFLOW (c
);
785 /* Convert EXPR to TYPE, warning about conversion problems with constants.
786 Invoke this function on every expression that is converted implicitly,
787 i.e. because of language rules and not because of an explicit cast. */
790 convert_and_check (type
, expr
)
793 tree t
= convert (type
, expr
);
794 if (TREE_CODE (t
) == INTEGER_CST
)
796 if (TREE_OVERFLOW (t
))
798 TREE_OVERFLOW (t
) = 0;
800 /* Do not diagnose overflow in a constant expression merely
801 because a conversion overflowed. */
802 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
804 /* No warning for converting 0x80000000 to int. */
805 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
806 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
807 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
808 /* If EXPR fits in the unsigned version of TYPE,
809 don't warn unless pedantic. */
811 || TREE_UNSIGNED (type
)
812 || ! constant_fits_type_p (expr
, unsigned_type (type
)))
813 && skip_evaluation
== 0)
814 warning ("overflow in implicit constant conversion");
817 unsigned_conversion_warning (t
, expr
);
822 /* A node in a list that describes references to variables (EXPR), which are
823 either read accesses if WRITER is zero, or write accesses, in which case
824 WRITER is the parent of EXPR. */
831 /* Used to implement a cache the results of a call to verify_tree. We only
832 use this for SAVE_EXPRs. */
835 struct tlist_cache
*next
;
836 struct tlist
*cache_before_sp
;
837 struct tlist
*cache_after_sp
;
841 /* Obstack to use when allocating tlist structures, and corresponding
843 static struct obstack tlist_obstack
;
844 static char *tlist_firstobj
= 0;
846 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
848 static struct tlist
*warned_ids
;
849 /* SAVE_EXPRs need special treatment. We process them only once and then
850 cache the results. */
851 static struct tlist_cache
*save_expr_cache
;
853 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
854 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
855 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
856 static int warning_candidate_p
PARAMS ((tree
));
857 static void warn_for_collisions
PARAMS ((struct tlist
*));
858 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
859 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
860 static void verify_sequence_points
PARAMS ((tree
));
862 /* Create a new struct tlist and fill in its fields. */
863 static struct tlist
*
864 new_tlist (next
, t
, writer
)
870 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
877 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
878 is nonnull, we ignore any node we find which has a writer equal to it. */
881 add_tlist (to
, add
, exclude_writer
, copy
)
889 struct tlist
*next
= add
->next
;
892 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
893 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
898 /* Merge the nodes of ADD into TO. This merging process is done so that for
899 each variable that already exists in TO, no new node is added; however if
900 there is a write access recorded in ADD, and an occurrence on TO is only
901 a read access, then the occurrence in TO will be modified to record the
905 merge_tlist (to
, add
, copy
)
910 struct tlist
**end
= to
;
919 struct tlist
*next
= add
->next
;
921 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
922 if (tmp2
->expr
== add
->expr
)
926 tmp2
->writer
= add
->writer
;
930 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
938 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
939 references in list LIST conflict with it, excluding reads if ONLY writers
943 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
944 tree written
, writer
;
950 /* Avoid duplicate warnings. */
951 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
952 if (tmp
->expr
== written
)
957 if (list
->expr
== written
958 && list
->writer
!= writer
959 && (! only_writes
|| list
->writer
))
961 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
962 warning ("operation on `%s' may be undefined",
963 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
969 /* Given a list LIST of references to variables, find whether any of these
970 can cause conflicts due to missing sequence points. */
973 warn_for_collisions (list
)
978 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
981 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
985 /* Return nonzero if X is a tree that can be verified by the sequence point
988 warning_candidate_p (x
)
991 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
994 /* Walk the tree X, and record accesses to variables. If X is written by the
995 parent tree, WRITER is the parent.
996 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
997 expression or its only operand forces a sequence point, then everything up
998 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1000 Once we return, we will have emitted warnings if any subexpression before
1001 such a sequence point could be undefined. On a higher level, however, the
1002 sequence point may not be relevant, and we'll merge the two lists.
1004 Example: (b++, a) + b;
1005 The call that processes the COMPOUND_EXPR will store the increment of B
1006 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1007 processes the PLUS_EXPR will need to merge the two lists so that
1008 eventually, all accesses end up on the same list (and we'll warn about the
1009 unordered subexpressions b++ and b.
1011 A note on merging. If we modify the former example so that our expression
1014 care must be taken not simply to add all three expressions into the final
1015 PNO_SP list. The function merge_tlist takes care of that by merging the
1016 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1017 way, so that no more than one access to B is recorded. */
1020 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1022 struct tlist
**pbefore_sp
, **pno_sp
;
1025 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1026 enum tree_code code
;
1029 /* X may be NULL if it is the operand of an empty statement expression
1035 code
= TREE_CODE (x
);
1036 class = TREE_CODE_CLASS (code
);
1038 if (warning_candidate_p (x
))
1040 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1050 case TRUTH_ANDIF_EXPR
:
1051 case TRUTH_ORIF_EXPR
:
1052 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1053 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1054 warn_for_collisions (tmp_nosp
);
1055 merge_tlist (pbefore_sp
, tmp_before
, 0);
1056 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1057 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1058 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1062 tmp_before
= tmp_list2
= 0;
1063 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1064 warn_for_collisions (tmp_list2
);
1065 merge_tlist (pbefore_sp
, tmp_before
, 0);
1066 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1068 tmp_list3
= tmp_nosp
= 0;
1069 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1070 warn_for_collisions (tmp_nosp
);
1071 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1073 tmp_list3
= tmp_list2
= 0;
1074 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1075 warn_for_collisions (tmp_list2
);
1076 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1077 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1078 two first, to avoid warning for (a ? b++ : b++). */
1079 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1080 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1083 case PREDECREMENT_EXPR
:
1084 case PREINCREMENT_EXPR
:
1085 case POSTDECREMENT_EXPR
:
1086 case POSTINCREMENT_EXPR
:
1087 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1091 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1092 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1093 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1094 /* Expressions inside the LHS are not ordered wrt. the sequence points
1095 in the RHS. Example:
1097 Despite the fact that the modification of "a" is in the before_sp
1098 list (tmp_before), it conflicts with the use of "a" in the LHS.
1099 We can handle this by adding the contents of tmp_list3
1100 to those of tmp_before, and redoing the collision warnings for that
1102 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1103 warn_for_collisions (tmp_before
);
1104 /* Exclude the LHS itself here; we first have to merge it into the
1105 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1106 didn't exclude the LHS, we'd get it twice, once as a read and once
1108 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1109 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1111 merge_tlist (pbefore_sp
, tmp_before
, 0);
1112 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1113 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1114 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1118 /* We need to warn about conflicts among arguments and conflicts between
1119 args and the function address. Side effects of the function address,
1120 however, are not ordered by the sequence point of the call. */
1121 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1122 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1123 if (TREE_OPERAND (x
, 1))
1124 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1125 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1126 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1127 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1128 warn_for_collisions (tmp_before
);
1129 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1133 /* Scan all the list, e.g. indices of multi dimensional array. */
1136 tmp_before
= tmp_nosp
= 0;
1137 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1138 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1139 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1146 struct tlist_cache
*t
;
1147 for (t
= save_expr_cache
; t
; t
= t
->next
)
1153 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1155 t
->next
= save_expr_cache
;
1157 save_expr_cache
= t
;
1159 tmp_before
= tmp_nosp
= 0;
1160 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1161 warn_for_collisions (tmp_nosp
);
1166 struct tlist
*t
= tmp_nosp
;
1168 merge_tlist (&tmp_list3
, t
, 0);
1170 t
->cache_before_sp
= tmp_before
;
1171 t
->cache_after_sp
= tmp_list3
;
1173 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1174 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1183 if (first_rtl_op (code
) == 0)
1185 x
= TREE_OPERAND (x
, 0);
1201 int max
= first_rtl_op (TREE_CODE (x
));
1202 for (lp
= 0; lp
< max
; lp
++)
1204 tmp_before
= tmp_nosp
= 0;
1205 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1206 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1207 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1214 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1218 verify_sequence_points (expr
)
1221 struct tlist
*before_sp
= 0, *after_sp
= 0;
1224 save_expr_cache
= 0;
1225 if (tlist_firstobj
== 0)
1227 gcc_obstack_init (&tlist_obstack
);
1228 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1231 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1232 warn_for_collisions (after_sp
);
1233 obstack_free (&tlist_obstack
, tlist_firstobj
);
1237 c_expand_expr_stmt (expr
)
1240 /* Do default conversion if safe and possibly important,
1241 in case within ({...}). */
1242 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1243 && (flag_isoc99
|| lvalue_p (expr
)))
1244 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1245 expr
= default_conversion (expr
);
1247 if (warn_sequence_point
)
1248 verify_sequence_points (expr
);
1250 if (TREE_TYPE (expr
) != error_mark_node
1251 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1252 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1253 error ("expression statement has incomplete type");
1255 last_expr_type
= TREE_TYPE (expr
);
1256 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1259 /* Validate the expression after `case' and apply default promotions. */
1262 check_case_value (value
)
1265 if (value
== NULL_TREE
)
1268 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1269 STRIP_TYPE_NOPS (value
);
1270 /* In C++, the following is allowed:
1273 switch (...) { case i: ... }
1275 So, we try to reduce the VALUE to a constant that way. */
1276 if (c_language
== clk_cplusplus
)
1278 value
= decl_constant_value (value
);
1279 STRIP_TYPE_NOPS (value
);
1280 value
= fold (value
);
1283 if (TREE_CODE (value
) != INTEGER_CST
1284 && value
!= error_mark_node
)
1286 error ("case label does not reduce to an integer constant");
1287 value
= error_mark_node
;
1290 /* Promote char or short to int. */
1291 value
= default_conversion (value
);
1293 constant_expression_warning (value
);
1298 /* Return an integer type with BITS bits of precision,
1299 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1302 type_for_size (bits
, unsignedp
)
1306 if (bits
== TYPE_PRECISION (integer_type_node
))
1307 return unsignedp
? unsigned_type_node
: integer_type_node
;
1309 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1310 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1312 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1313 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1315 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1316 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1318 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1319 return (unsignedp
? long_long_unsigned_type_node
1320 : long_long_integer_type_node
);
1322 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1323 return (unsignedp
? widest_unsigned_literal_type_node
1324 : widest_integer_literal_type_node
);
1326 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1327 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1329 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1330 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1332 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1333 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1335 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1336 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1341 /* Return a data type that has machine mode MODE.
1342 If the mode is an integer,
1343 then UNSIGNEDP selects between signed and unsigned types. */
1346 type_for_mode (mode
, unsignedp
)
1347 enum machine_mode mode
;
1350 if (mode
== TYPE_MODE (integer_type_node
))
1351 return unsignedp
? unsigned_type_node
: integer_type_node
;
1353 if (mode
== TYPE_MODE (signed_char_type_node
))
1354 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1356 if (mode
== TYPE_MODE (short_integer_type_node
))
1357 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1359 if (mode
== TYPE_MODE (long_integer_type_node
))
1360 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1362 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1363 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1365 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1366 return unsignedp
? widest_unsigned_literal_type_node
1367 : widest_integer_literal_type_node
;
1370 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1373 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1376 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1379 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1381 #if HOST_BITS_PER_WIDE_INT >= 64
1382 if (mode
== TYPE_MODE (intTI_type_node
))
1383 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1386 if (mode
== TYPE_MODE (float_type_node
))
1387 return float_type_node
;
1389 if (mode
== TYPE_MODE (double_type_node
))
1390 return double_type_node
;
1392 if (mode
== TYPE_MODE (long_double_type_node
))
1393 return long_double_type_node
;
1395 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1396 return build_pointer_type (char_type_node
);
1398 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1399 return build_pointer_type (integer_type_node
);
1401 #ifdef VECTOR_MODE_SUPPORTED_P
1402 if (VECTOR_MODE_SUPPORTED_P (mode
))
1407 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
1409 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
1411 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
1413 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
1415 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
1417 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
1419 return V16SF_type_node
;
1421 return V4SF_type_node
;
1423 return V2SF_type_node
;
1433 /* Return an unsigned type the same as TYPE in other respects. */
1435 unsigned_type (type
)
1438 tree type1
= TYPE_MAIN_VARIANT (type
);
1439 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1440 return unsigned_char_type_node
;
1441 if (type1
== integer_type_node
)
1442 return unsigned_type_node
;
1443 if (type1
== short_integer_type_node
)
1444 return short_unsigned_type_node
;
1445 if (type1
== long_integer_type_node
)
1446 return long_unsigned_type_node
;
1447 if (type1
== long_long_integer_type_node
)
1448 return long_long_unsigned_type_node
;
1449 if (type1
== widest_integer_literal_type_node
)
1450 return widest_unsigned_literal_type_node
;
1451 #if HOST_BITS_PER_WIDE_INT >= 64
1452 if (type1
== intTI_type_node
)
1453 return unsigned_intTI_type_node
;
1455 if (type1
== intDI_type_node
)
1456 return unsigned_intDI_type_node
;
1457 if (type1
== intSI_type_node
)
1458 return unsigned_intSI_type_node
;
1459 if (type1
== intHI_type_node
)
1460 return unsigned_intHI_type_node
;
1461 if (type1
== intQI_type_node
)
1462 return unsigned_intQI_type_node
;
1464 return signed_or_unsigned_type (1, type
);
1467 /* Return a signed type the same as TYPE in other respects. */
1473 tree type1
= TYPE_MAIN_VARIANT (type
);
1474 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1475 return signed_char_type_node
;
1476 if (type1
== unsigned_type_node
)
1477 return integer_type_node
;
1478 if (type1
== short_unsigned_type_node
)
1479 return short_integer_type_node
;
1480 if (type1
== long_unsigned_type_node
)
1481 return long_integer_type_node
;
1482 if (type1
== long_long_unsigned_type_node
)
1483 return long_long_integer_type_node
;
1484 if (type1
== widest_unsigned_literal_type_node
)
1485 return widest_integer_literal_type_node
;
1486 #if HOST_BITS_PER_WIDE_INT >= 64
1487 if (type1
== unsigned_intTI_type_node
)
1488 return intTI_type_node
;
1490 if (type1
== unsigned_intDI_type_node
)
1491 return intDI_type_node
;
1492 if (type1
== unsigned_intSI_type_node
)
1493 return intSI_type_node
;
1494 if (type1
== unsigned_intHI_type_node
)
1495 return intHI_type_node
;
1496 if (type1
== unsigned_intQI_type_node
)
1497 return intQI_type_node
;
1499 return signed_or_unsigned_type (0, type
);
1502 /* Return a type the same as TYPE except unsigned or
1503 signed according to UNSIGNEDP. */
1506 signed_or_unsigned_type (unsignedp
, type
)
1510 if (! INTEGRAL_TYPE_P (type
)
1511 || TREE_UNSIGNED (type
) == unsignedp
)
1514 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1515 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1516 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1517 return unsignedp
? unsigned_type_node
: integer_type_node
;
1518 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1519 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1520 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1521 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1522 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1523 return (unsignedp
? long_long_unsigned_type_node
1524 : long_long_integer_type_node
);
1525 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1526 return (unsignedp
? widest_unsigned_literal_type_node
1527 : widest_integer_literal_type_node
);
1529 #if HOST_BITS_PER_WIDE_INT >= 64
1530 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
1531 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1533 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
1534 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1535 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
1536 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1537 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
1538 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1539 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
1540 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1545 /* Return the minimum number of bits needed to represent VALUE in a
1546 signed or unsigned type, UNSIGNEDP says which. */
1549 min_precision (value
, unsignedp
)
1555 /* If the value is negative, compute its negative minus 1. The latter
1556 adjustment is because the absolute value of the largest negative value
1557 is one larger than the largest positive value. This is equivalent to
1558 a bit-wise negation, so use that operation instead. */
1560 if (tree_int_cst_sgn (value
) < 0)
1561 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1563 /* Return the number of bits needed, taking into account the fact
1564 that we need one more bit for a signed than unsigned type. */
1566 if (integer_zerop (value
))
1569 log
= tree_floor_log2 (value
);
1571 return log
+ 1 + ! unsignedp
;
1574 /* Print an error message for invalid operands to arith operation CODE.
1575 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1578 binary_op_error (code
)
1579 enum tree_code code
;
1586 error ("invalid truth-value expression");
1590 opname
= "+"; break;
1592 opname
= "-"; break;
1594 opname
= "*"; break;
1596 opname
= "max"; break;
1598 opname
= "min"; break;
1600 opname
= "=="; break;
1602 opname
= "!="; break;
1604 opname
= "<="; break;
1606 opname
= ">="; break;
1608 opname
= "<"; break;
1610 opname
= ">"; break;
1612 opname
= "<<"; break;
1614 opname
= ">>"; break;
1615 case TRUNC_MOD_EXPR
:
1616 case FLOOR_MOD_EXPR
:
1617 opname
= "%"; break;
1618 case TRUNC_DIV_EXPR
:
1619 case FLOOR_DIV_EXPR
:
1620 opname
= "/"; break;
1622 opname
= "&"; break;
1624 opname
= "|"; break;
1625 case TRUTH_ANDIF_EXPR
:
1626 opname
= "&&"; break;
1627 case TRUTH_ORIF_EXPR
:
1628 opname
= "||"; break;
1630 opname
= "^"; break;
1633 opname
= "rotate"; break;
1635 opname
= "unknown"; break;
1637 error ("invalid operands to binary %s", opname
);
1640 /* Subroutine of build_binary_op, used for comparison operations.
1641 See if the operands have both been converted from subword integer types
1642 and, if so, perhaps change them both back to their original type.
1643 This function is also responsible for converting the two operands
1644 to the proper common type for comparison.
1646 The arguments of this function are all pointers to local variables
1647 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1648 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1650 If this function returns nonzero, it means that the comparison has
1651 a constant value. What this function returns is an expression for
1655 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1656 tree
*op0_ptr
, *op1_ptr
;
1658 enum tree_code
*rescode_ptr
;
1661 tree op0
= *op0_ptr
;
1662 tree op1
= *op1_ptr
;
1663 int unsignedp0
, unsignedp1
;
1665 tree primop0
, primop1
;
1666 enum tree_code code
= *rescode_ptr
;
1668 /* Throw away any conversions to wider types
1669 already present in the operands. */
1671 primop0
= get_narrower (op0
, &unsignedp0
);
1672 primop1
= get_narrower (op1
, &unsignedp1
);
1674 /* Handle the case that OP0 does not *contain* a conversion
1675 but it *requires* conversion to FINAL_TYPE. */
1677 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1678 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1679 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1680 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1682 /* If one of the operands must be floated, we cannot optimize. */
1683 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1684 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1686 /* If first arg is constant, swap the args (changing operation
1687 so value is preserved), for canonicalization. Don't do this if
1688 the second arg is 0. */
1690 if (TREE_CONSTANT (primop0
)
1691 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1694 int temi
= unsignedp0
;
1702 unsignedp0
= unsignedp1
;
1725 *rescode_ptr
= code
;
1728 /* If comparing an integer against a constant more bits wide,
1729 maybe we can deduce a value of 1 or 0 independent of the data.
1730 Or else truncate the constant now
1731 rather than extend the variable at run time.
1733 This is only interesting if the constant is the wider arg.
1734 Also, it is not safe if the constant is unsigned and the
1735 variable arg is signed, since in this case the variable
1736 would be sign-extended and then regarded as unsigned.
1737 Our technique fails in this case because the lowest/highest
1738 possible unsigned results don't follow naturally from the
1739 lowest/highest possible values of the variable operand.
1740 For just EQ_EXPR and NE_EXPR there is another technique that
1741 could be used: see if the constant can be faithfully represented
1742 in the other operand's type, by truncating it and reextending it
1743 and see if that preserves the constant's value. */
1745 if (!real1
&& !real2
1746 && TREE_CODE (primop1
) == INTEGER_CST
1747 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1749 int min_gt
, max_gt
, min_lt
, max_lt
;
1750 tree maxval
, minval
;
1751 /* 1 if comparison is nominally unsigned. */
1752 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1755 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1757 /* If TYPE is an enumeration, then we need to get its min/max
1758 values from it's underlying integral type, not the enumerated
1760 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1761 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
1763 maxval
= TYPE_MAX_VALUE (type
);
1764 minval
= TYPE_MIN_VALUE (type
);
1766 if (unsignedp
&& !unsignedp0
)
1767 *restype_ptr
= signed_type (*restype_ptr
);
1769 if (TREE_TYPE (primop1
) != *restype_ptr
)
1770 primop1
= convert (*restype_ptr
, primop1
);
1771 if (type
!= *restype_ptr
)
1773 minval
= convert (*restype_ptr
, minval
);
1774 maxval
= convert (*restype_ptr
, maxval
);
1777 if (unsignedp
&& unsignedp0
)
1779 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1780 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1781 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1782 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1786 min_gt
= INT_CST_LT (primop1
, minval
);
1787 max_gt
= INT_CST_LT (primop1
, maxval
);
1788 min_lt
= INT_CST_LT (minval
, primop1
);
1789 max_lt
= INT_CST_LT (maxval
, primop1
);
1793 /* This used to be a switch, but Genix compiler can't handle that. */
1794 if (code
== NE_EXPR
)
1796 if (max_lt
|| min_gt
)
1797 val
= boolean_true_node
;
1799 else if (code
== EQ_EXPR
)
1801 if (max_lt
|| min_gt
)
1802 val
= boolean_false_node
;
1804 else if (code
== LT_EXPR
)
1807 val
= boolean_true_node
;
1809 val
= boolean_false_node
;
1811 else if (code
== GT_EXPR
)
1814 val
= boolean_true_node
;
1816 val
= boolean_false_node
;
1818 else if (code
== LE_EXPR
)
1821 val
= boolean_true_node
;
1823 val
= boolean_false_node
;
1825 else if (code
== GE_EXPR
)
1828 val
= boolean_true_node
;
1830 val
= boolean_false_node
;
1833 /* If primop0 was sign-extended and unsigned comparison specd,
1834 we did a signed comparison above using the signed type bounds.
1835 But the comparison we output must be unsigned.
1837 Also, for inequalities, VAL is no good; but if the signed
1838 comparison had *any* fixed result, it follows that the
1839 unsigned comparison just tests the sign in reverse
1840 (positive values are LE, negative ones GE).
1841 So we can generate an unsigned comparison
1842 against an extreme value of the signed type. */
1844 if (unsignedp
&& !unsignedp0
)
1851 primop1
= TYPE_MIN_VALUE (type
);
1857 primop1
= TYPE_MAX_VALUE (type
);
1864 type
= unsigned_type (type
);
1867 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1869 /* This is the case of (char)x >?< 0x80, which people used to use
1870 expecting old C compilers to change the 0x80 into -0x80. */
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");
1877 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1879 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1880 if (val
== boolean_false_node
)
1881 warning ("comparison is always false due to limited range of data type");
1882 if (val
== boolean_true_node
)
1883 warning ("comparison is always true due to limited range of data type");
1888 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1889 if (TREE_SIDE_EFFECTS (primop0
))
1890 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1894 /* Value is not predetermined, but do the comparison
1895 in the type of the operand that is not constant.
1896 TYPE is already properly set. */
1898 else if (real1
&& real2
1899 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1900 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1901 type
= TREE_TYPE (primop0
);
1903 /* If args' natural types are both narrower than nominal type
1904 and both extend in the same manner, compare them
1905 in the type of the wider arg.
1906 Otherwise must actually extend both to the nominal
1907 common type lest different ways of extending
1909 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1911 else if (unsignedp0
== unsignedp1
&& real1
== real2
1912 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1913 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1915 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1916 type
= signed_or_unsigned_type (unsignedp0
1917 || TREE_UNSIGNED (*restype_ptr
),
1919 /* Make sure shorter operand is extended the right way
1920 to match the longer operand. */
1921 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1923 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1928 /* Here we must do the comparison on the nominal type
1929 using the args exactly as we received them. */
1930 type
= *restype_ptr
;
1934 if (!real1
&& !real2
&& integer_zerop (primop1
)
1935 && TREE_UNSIGNED (*restype_ptr
))
1941 /* All unsigned values are >= 0, so we warn if extra warnings
1942 are requested. However, if OP0 is a constant that is
1943 >= 0, the signedness of the comparison isn't an issue,
1944 so suppress the warning. */
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 true");
1950 value
= boolean_true_node
;
1954 if (extra_warnings
&& !in_system_header
1955 && ! (TREE_CODE (primop0
) == INTEGER_CST
1956 && ! TREE_OVERFLOW (convert (signed_type (type
),
1958 warning ("comparison of unsigned expression < 0 is always false");
1959 value
= boolean_false_node
;
1968 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1969 if (TREE_SIDE_EFFECTS (primop0
))
1970 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1977 *op0_ptr
= convert (type
, primop0
);
1978 *op1_ptr
= convert (type
, primop1
);
1980 *restype_ptr
= boolean_type_node
;
1985 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1986 or validate its data type for an `if' or `while' statement or ?..: exp.
1988 This preparation consists of taking the ordinary
1989 representation of an expression expr and producing a valid tree
1990 boolean expression describing whether expr is nonzero. We could
1991 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1992 but we optimize comparisons, &&, ||, and !.
1994 The resulting type should always be `boolean_type_node'. */
1997 truthvalue_conversion (expr
)
2000 if (TREE_CODE (expr
) == ERROR_MARK
)
2003 #if 0 /* This appears to be wrong for C++. */
2004 /* These really should return error_mark_node after 2.4 is stable.
2005 But not all callers handle ERROR_MARK properly. */
2006 switch (TREE_CODE (TREE_TYPE (expr
)))
2009 error ("struct type value used where scalar is required");
2010 return boolean_false_node
;
2013 error ("union type value used where scalar is required");
2014 return boolean_false_node
;
2017 error ("array type value used where scalar is required");
2018 return boolean_false_node
;
2025 switch (TREE_CODE (expr
))
2028 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2029 case TRUTH_ANDIF_EXPR
:
2030 case TRUTH_ORIF_EXPR
:
2031 case TRUTH_AND_EXPR
:
2033 case TRUTH_XOR_EXPR
:
2034 case TRUTH_NOT_EXPR
:
2035 TREE_TYPE (expr
) = boolean_type_node
;
2042 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2045 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2048 /* If we are taking the address of an external decl, it might be zero
2049 if it is weak, so we cannot optimize. */
2050 if (DECL_P (TREE_OPERAND (expr
, 0))
2051 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2054 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2055 return build (COMPOUND_EXPR
, boolean_type_node
,
2056 TREE_OPERAND (expr
, 0), boolean_true_node
);
2058 return boolean_true_node
;
2061 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2062 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2063 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2064 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2071 /* These don't change whether an object is non-zero or zero. */
2072 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2076 /* These don't change whether an object is zero or non-zero, but
2077 we can't ignore them if their second arg has side-effects. */
2078 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2079 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2080 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2082 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2085 /* Distribute the conversion into the arms of a COND_EXPR. */
2086 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2087 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2088 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2091 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2092 since that affects how `default_conversion' will behave. */
2093 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2094 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2096 /* fall through... */
2098 /* If this is widening the argument, we can ignore it. */
2099 if (TYPE_PRECISION (TREE_TYPE (expr
))
2100 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2101 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2105 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2107 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2108 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2110 /* fall through... */
2112 /* This and MINUS_EXPR can be changed into a comparison of the
2114 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2115 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2116 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2117 TREE_OPERAND (expr
, 1), 1);
2118 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2119 fold (build1 (NOP_EXPR
,
2120 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2121 TREE_OPERAND (expr
, 1))), 1);
2124 if (integer_onep (TREE_OPERAND (expr
, 1))
2125 && TREE_TYPE (expr
) != boolean_type_node
)
2126 /* Using convert here would cause infinite recursion. */
2127 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2131 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2132 warning ("suggest parentheses around assignment used as truth value");
2139 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2141 tree tem
= save_expr (expr
);
2142 return (build_binary_op
2143 ((TREE_SIDE_EFFECTS (expr
)
2144 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2145 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
2146 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
2150 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2153 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2154 int, enum built_in_class
, int, int,
2157 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2158 down to the element type of an array. */
2161 c_build_qualified_type (type
, type_quals
)
2165 /* A restrict-qualified pointer type must be a pointer to object or
2166 incomplete type. Note that the use of POINTER_TYPE_P also allows
2167 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2168 the C++ front-end also use POINTER_TYPE for pointer-to-member
2169 values, so even though it should be illegal to use `restrict'
2170 with such an entity we don't flag that here. Thus, special case
2171 code for that case is required in the C++ front-end. */
2172 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2173 && (!POINTER_TYPE_P (type
)
2174 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2176 error ("invalid use of `restrict'");
2177 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2180 if (TREE_CODE (type
) == ARRAY_TYPE
)
2181 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2183 TYPE_DOMAIN (type
));
2184 return build_qualified_type (type
, type_quals
);
2187 /* Apply the TYPE_QUALS to the new DECL. */
2190 c_apply_type_quals_to_decl (type_quals
, decl
)
2194 if ((type_quals
& TYPE_QUAL_CONST
)
2195 || (TREE_TYPE (decl
)
2196 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2197 TREE_READONLY (decl
) = 1;
2198 if (type_quals
& TYPE_QUAL_VOLATILE
)
2200 TREE_SIDE_EFFECTS (decl
) = 1;
2201 TREE_THIS_VOLATILE (decl
) = 1;
2203 if (type_quals
& TYPE_QUAL_RESTRICT
)
2205 if (!TREE_TYPE (decl
)
2206 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2207 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2208 error ("invalid use of `restrict'");
2209 else if (flag_strict_aliasing
)
2210 /* Indicate we need to make a unique alias set for this pointer.
2211 We can't do it here because it might be pointing to an
2213 DECL_POINTER_ALIAS_SET (decl
) = -2;
2218 /* Return the typed-based alias set for T, which may be an expression
2219 or a type. Return -1 if we don't do anything special. */
2222 c_common_get_alias_set (t
)
2227 /* We know nothing about vector types */
2228 if (TREE_CODE (t
) == VECTOR_TYPE
)
2231 /* Permit type-punning when accessing a union, provided the access
2232 is directly through the union. For example, this code does not
2233 permit taking the address of a union member and then storing
2234 through it. Even the type-punning allowed here is a GCC
2235 extension, albeit a common and useful one; the C standard says
2236 that such accesses have implementation-defined behavior. */
2238 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2239 u
= TREE_OPERAND (u
, 0))
2240 if (TREE_CODE (u
) == COMPONENT_REF
2241 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2244 /* If this is a char *, the ANSI C standard says it can alias
2245 anything. Note that all references need do this. */
2246 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2247 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2248 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2251 /* That's all the expressions we handle specially. */
2255 /* The C standard specifically allows aliasing between signed and
2256 unsigned variants of the same type. We treat the signed
2257 variant as canonical. */
2258 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2260 tree t1
= signed_type (t
);
2262 /* t1 == t can happen for boolean nodes which are always unsigned. */
2264 return get_alias_set (t1
);
2266 else if (POINTER_TYPE_P (t
))
2270 /* Unfortunately, there is no canonical form of a pointer type.
2271 In particular, if we have `typedef int I', then `int *', and
2272 `I *' are different types. So, we have to pick a canonical
2273 representative. We do this below.
2275 Technically, this approach is actually more conservative that
2276 it needs to be. In particular, `const int *' and `int *'
2277 should be in different alias sets, according to the C and C++
2278 standard, since their types are not the same, and so,
2279 technically, an `int **' and `const int **' cannot point at
2282 But, the standard is wrong. In particular, this code is
2287 const int* const* cipp = &ipp;
2289 And, it doesn't make sense for that to be legal unless you
2290 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2291 the pointed-to types. This issue has been reported to the
2293 t1
= build_type_no_quals (t
);
2295 return get_alias_set (t1
);
2301 /* Implement the __alignof keyword: Return the minimum required
2302 alignment of TYPE, measured in bytes. */
2308 enum tree_code code
= TREE_CODE (type
);
2311 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2312 if (code
== REFERENCE_TYPE
)
2314 type
= TREE_TYPE (type
);
2315 code
= TREE_CODE (type
);
2318 if (code
== FUNCTION_TYPE
)
2319 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2320 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
2322 else if (!COMPLETE_TYPE_P (type
))
2324 error ("__alignof__ applied to an incomplete type");
2328 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2330 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2333 /* Implement the __alignof keyword: Return the minimum required
2334 alignment of EXPR, measured in bytes. For VAR_DECL's and
2335 FIELD_DECL's return DECL_ALIGN (which can be set from an
2336 "aligned" __attribute__ specification). */
2339 c_alignof_expr (expr
)
2344 if (TREE_CODE (expr
) == VAR_DECL
)
2345 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2347 else if (TREE_CODE (expr
) == COMPONENT_REF
2348 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2350 error ("`__alignof' applied to a bit-field");
2353 else if (TREE_CODE (expr
) == COMPONENT_REF
2354 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2355 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2357 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2359 tree t
= TREE_OPERAND (expr
, 0);
2361 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2363 while (TREE_CODE (t
) == NOP_EXPR
2364 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2368 t
= TREE_OPERAND (t
, 0);
2369 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2370 if (thisalign
> bestalign
)
2371 best
= t
, bestalign
= thisalign
;
2373 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2376 return c_alignof (TREE_TYPE (expr
));
2378 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2381 /* Give the specifications for the format attributes, used by C and all
2384 static const struct attribute_spec c_format_attribute_table
[] =
2386 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2387 { "format", 3, 3, false, true, true,
2388 handle_format_attribute
},
2389 { "format_arg", 1, 1, false, true, true,
2390 handle_format_arg_attribute
},
2391 { NULL
, 0, 0, false, false, false, NULL
}
2394 /* Build tree nodes and builtin functions common to both C and C++ language
2398 c_common_nodes_and_builtins ()
2402 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2403 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2404 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2405 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2406 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2407 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2408 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2409 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2410 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2411 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2412 #include "builtin-types.def"
2413 #undef DEF_PRIMITIVE_TYPE
2414 #undef DEF_FUNCTION_TYPE_0
2415 #undef DEF_FUNCTION_TYPE_1
2416 #undef DEF_FUNCTION_TYPE_2
2417 #undef DEF_FUNCTION_TYPE_3
2418 #undef DEF_FUNCTION_TYPE_4
2419 #undef DEF_FUNCTION_TYPE_VAR_0
2420 #undef DEF_FUNCTION_TYPE_VAR_1
2421 #undef DEF_FUNCTION_TYPE_VAR_2
2422 #undef DEF_POINTER_TYPE
2426 typedef enum builtin_type builtin_type
;
2428 tree builtin_types
[(int) BT_LAST
];
2429 int wchar_type_size
;
2430 tree array_domain_type
;
2431 /* Either char* or void*. */
2432 tree traditional_ptr_type_node
;
2433 /* Either const char* or const void*. */
2434 tree traditional_cptr_type_node
;
2435 tree traditional_len_type_node
;
2436 tree va_list_ref_type_node
;
2437 tree va_list_arg_type_node
;
2439 /* We must initialize this before any builtin functions (which might have
2440 attributes) are declared. (c_common_init is too late.) */
2441 format_attribute_table
= c_format_attribute_table
;
2443 /* Define `int' and `char' first so that dbx will output them first. */
2444 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
2445 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2447 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2448 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2449 but not C. Are the conditionals here needed? */
2450 if (c_language
== clk_cplusplus
)
2451 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
2452 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2453 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2454 record_builtin_type (RID_MAX
, "long unsigned int",
2455 long_unsigned_type_node
);
2456 if (c_language
== clk_cplusplus
)
2457 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2458 record_builtin_type (RID_MAX
, "long long int",
2459 long_long_integer_type_node
);
2460 record_builtin_type (RID_MAX
, "long long unsigned int",
2461 long_long_unsigned_type_node
);
2462 if (c_language
== clk_cplusplus
)
2463 record_builtin_type (RID_MAX
, "long long unsigned",
2464 long_long_unsigned_type_node
);
2465 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2466 record_builtin_type (RID_MAX
, "short unsigned int",
2467 short_unsigned_type_node
);
2468 if (c_language
== clk_cplusplus
)
2469 record_builtin_type (RID_MAX
, "unsigned short",
2470 short_unsigned_type_node
);
2472 /* Define both `signed char' and `unsigned char'. */
2473 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2474 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2476 /* These are types that type_for_size and type_for_mode use. */
2477 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2478 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2479 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2480 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2481 #if HOST_BITS_PER_WIDE_INT >= 64
2482 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
2484 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2485 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2486 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2487 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2488 #if HOST_BITS_PER_WIDE_INT >= 64
2489 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
2492 /* Create the widest literal types. */
2493 widest_integer_literal_type_node
2494 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2495 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2496 widest_integer_literal_type_node
));
2498 widest_unsigned_literal_type_node
2499 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2500 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2501 widest_unsigned_literal_type_node
));
2503 /* `unsigned long' is the standard type for sizeof.
2504 Note that stddef.h uses `unsigned long',
2505 and this must agree, even if long and int are the same size. */
2507 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2508 signed_size_type_node
= signed_type (c_size_type_node
);
2509 if (flag_traditional
)
2510 c_size_type_node
= signed_size_type_node
;
2511 set_sizetype (c_size_type_node
);
2513 build_common_tree_nodes_2 (flag_short_double
);
2515 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
2516 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
2517 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2519 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2520 complex_integer_type_node
));
2521 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2522 complex_float_type_node
));
2523 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2524 complex_double_type_node
));
2525 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2526 complex_long_double_type_node
));
2528 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
2530 void_zero_node
= build_int_2 (0, 0);
2531 TREE_TYPE (void_zero_node
) = void_type_node
;
2533 void_list_node
= build_void_list_node ();
2535 /* Make a type to be the domain of a few array types
2536 whose domains don't really matter.
2537 200 is small enough that it always fits in size_t
2538 and large enough that it can hold most function names for the
2539 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2540 array_domain_type
= build_index_type (size_int (200));
2542 /* Make a type for arrays of characters.
2543 With luck nothing will ever really depend on the length of this
2545 char_array_type_node
2546 = build_array_type (char_type_node
, array_domain_type
);
2548 /* Likewise for arrays of ints. */
2550 = build_array_type (integer_type_node
, array_domain_type
);
2552 string_type_node
= build_pointer_type (char_type_node
);
2553 const_string_type_node
2554 = build_pointer_type (build_qualified_type
2555 (char_type_node
, TYPE_QUAL_CONST
));
2557 traditional_ptr_type_node
= ((flag_traditional
&&
2558 c_language
!= clk_cplusplus
)
2559 ? string_type_node
: ptr_type_node
);
2560 traditional_cptr_type_node
= ((flag_traditional
&&
2561 c_language
!= clk_cplusplus
)
2562 ? const_string_type_node
: const_ptr_type_node
);
2564 (*targetm
.init_builtins
) ();
2566 /* This is special for C++ so functions can be overloaded. */
2567 wchar_type_node
= get_identifier (flag_short_wchar
2568 ? "short unsigned int"
2570 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2571 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2572 if (c_language
== clk_cplusplus
)
2574 if (TREE_UNSIGNED (wchar_type_node
))
2575 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2577 wchar_type_node
= make_signed_type (wchar_type_size
);
2578 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2582 signed_wchar_type_node
= signed_type (wchar_type_node
);
2583 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2586 /* This is for wide string constants. */
2587 wchar_array_type_node
2588 = build_array_type (wchar_type_node
, array_domain_type
);
2591 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2594 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2596 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2598 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2600 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2601 unsigned_ptrdiff_type_node
= unsigned_type (ptrdiff_type_node
);
2603 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2604 va_list_type_node
));
2606 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2607 ptrdiff_type_node
));
2609 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2612 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2614 va_list_arg_type_node
= va_list_ref_type_node
=
2615 build_pointer_type (TREE_TYPE (va_list_type_node
));
2619 va_list_arg_type_node
= va_list_type_node
;
2620 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2623 traditional_len_type_node
= ((flag_traditional
&&
2624 c_language
!= clk_cplusplus
)
2625 ? integer_type_node
: sizetype
);
2627 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2628 builtin_types[(int) ENUM] = VALUE;
2629 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2630 builtin_types[(int) ENUM] \
2631 = build_function_type (builtin_types[(int) RETURN], \
2633 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2634 builtin_types[(int) ENUM] \
2635 = build_function_type (builtin_types[(int) RETURN], \
2636 tree_cons (NULL_TREE, \
2637 builtin_types[(int) ARG1], \
2639 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
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], \
2648 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2649 builtin_types[(int) ENUM] \
2650 = build_function_type \
2651 (builtin_types[(int) RETURN], \
2652 tree_cons (NULL_TREE, \
2653 builtin_types[(int) ARG1], \
2654 tree_cons (NULL_TREE, \
2655 builtin_types[(int) ARG2], \
2656 tree_cons (NULL_TREE, \
2657 builtin_types[(int) ARG3], \
2659 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2660 builtin_types[(int) ENUM] \
2661 = build_function_type \
2662 (builtin_types[(int) RETURN], \
2663 tree_cons (NULL_TREE, \
2664 builtin_types[(int) ARG1], \
2665 tree_cons (NULL_TREE, \
2666 builtin_types[(int) ARG2], \
2669 builtin_types[(int) ARG3], \
2670 tree_cons (NULL_TREE, \
2671 builtin_types[(int) ARG4], \
2672 void_list_node)))));
2673 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2674 builtin_types[(int) ENUM] \
2675 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2676 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2677 builtin_types[(int) ENUM] \
2678 = build_function_type (builtin_types[(int) RETURN], \
2679 tree_cons (NULL_TREE, \
2680 builtin_types[(int) ARG1], \
2683 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2684 builtin_types[(int) ENUM] \
2685 = build_function_type \
2686 (builtin_types[(int) RETURN], \
2687 tree_cons (NULL_TREE, \
2688 builtin_types[(int) ARG1], \
2689 tree_cons (NULL_TREE, \
2690 builtin_types[(int) ARG2], \
2692 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2693 builtin_types[(int) ENUM] \
2694 = build_pointer_type (builtin_types[(int) TYPE]);
2695 #include "builtin-types.def"
2696 #undef DEF_PRIMITIVE_TYPE
2697 #undef DEF_FUNCTION_TYPE_1
2698 #undef DEF_FUNCTION_TYPE_2
2699 #undef DEF_FUNCTION_TYPE_3
2700 #undef DEF_FUNCTION_TYPE_4
2701 #undef DEF_FUNCTION_TYPE_VAR_0
2702 #undef DEF_FUNCTION_TYPE_VAR_1
2703 #undef DEF_POINTER_TYPE
2705 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2706 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2711 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2715 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2718 ? (NAME + strlen ("__builtin_")) \
2721 decl = builtin_function_2 (NAME, \
2722 NAME + strlen ("__builtin_"), \
2723 builtin_types[TYPE], \
2724 builtin_types[LIBTYPE], \
2729 /*noreturn_p=*/0); \
2731 built_in_decls[(int) ENUM] = decl; \
2733 #include "builtins.def"
2736 /* Declare _exit and _Exit just to mark them as non-returning. */
2737 builtin_function_2 (NULL
, "_exit", NULL_TREE
,
2738 builtin_types
[BT_FN_VOID_INT
],
2739 0, NOT_BUILT_IN
, 0, 1, 1);
2740 builtin_function_2 (NULL
, "_Exit", NULL_TREE
,
2741 builtin_types
[BT_FN_VOID_INT
],
2742 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
2744 /* Declare these functions non-returning
2745 to avoid spurious "control drops through" warnings. */
2746 builtin_function_2 (NULL
, "abort",
2747 NULL_TREE
, ((c_language
== clk_cplusplus
)
2748 ? builtin_types
[BT_FN_VOID
]
2749 : builtin_types
[BT_FN_VOID_VAR
]),
2750 0, NOT_BUILT_IN
, 0, 0, 1);
2752 builtin_function_2 (NULL
, "exit",
2753 NULL_TREE
, ((c_language
== clk_cplusplus
)
2754 ? builtin_types
[BT_FN_VOID_INT
]
2755 : builtin_types
[BT_FN_VOID_VAR
]),
2756 0, NOT_BUILT_IN
, 0, 0, 1);
2758 main_identifier_node
= get_identifier ("main");
2760 /* ??? Perhaps there's a better place to do this. But it is related
2761 to __builtin_va_arg, so it isn't that off-the-wall. */
2762 lang_type_promotes_to
= simple_type_promotes_to
;
2766 build_va_arg (expr
, type
)
2769 return build1 (VA_ARG_EXPR
, type
, expr
);
2773 /* Linked list of disabled built-in functions. */
2775 typedef struct disabled_builtin
2778 struct disabled_builtin
*next
;
2780 static disabled_builtin
*disabled_builtins
= NULL
;
2782 static bool builtin_function_disabled_p
PARAMS ((const char *));
2784 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2785 begins with "__builtin_", give an error. */
2788 disable_builtin_function (name
)
2791 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
2792 error ("cannot disable built-in function `%s'", name
);
2795 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
2797 new->next
= disabled_builtins
;
2798 disabled_builtins
= new;
2803 /* Return true if the built-in function NAME has been disabled, false
2807 builtin_function_disabled_p (name
)
2810 disabled_builtin
*p
;
2811 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
2813 if (strcmp (name
, p
->name
) == 0)
2820 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2821 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2822 of these may be NULL (though both being NULL is useless).
2823 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2824 TYPE is the type of the function with the ordinary name. These
2825 may differ if the ordinary name is declared with a looser type to avoid
2826 conflicts with headers. FUNCTION_CODE and CLASS are as for
2827 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2828 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2829 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2830 NORETURN_P is nonzero, the function is marked as non-returning.
2831 Returns the declaration of BUILTIN_NAME, if any, otherwise
2832 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2833 or if NONANSI_P and flag_no_nonansi_builtin. */
2836 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
2837 class, library_name_p
, nonansi_p
, noreturn_p
)
2838 const char *builtin_name
;
2843 enum built_in_class
class;
2848 tree bdecl
= NULL_TREE
;
2849 tree decl
= NULL_TREE
;
2850 if (builtin_name
!= 0)
2852 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
2853 class, library_name_p
? name
: NULL
);
2856 TREE_THIS_VOLATILE (bdecl
) = 1;
2857 TREE_SIDE_EFFECTS (bdecl
) = 1;
2860 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
2861 && !(nonansi_p
&& flag_no_nonansi_builtin
))
2863 decl
= builtin_function (name
, type
, function_code
, class, NULL
);
2865 DECL_BUILT_IN_NONANSI (decl
) = 1;
2868 TREE_THIS_VOLATILE (decl
) = 1;
2869 TREE_SIDE_EFFECTS (decl
) = 1;
2872 return (bdecl
!= 0 ? bdecl
: decl
);
2875 /* Nonzero if the type T promotes to int. This is (nearly) the
2876 integral promotions defined in ISO C99 6.3.1.1/2. */
2879 c_promoting_integer_type_p (t
)
2882 switch (TREE_CODE (t
))
2885 return (TYPE_MAIN_VARIANT (t
) == char_type_node
2886 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
2887 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
2888 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
2889 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
2890 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
2893 /* ??? Technically all enumerations not larger than an int
2894 promote to an int. But this is used along code paths
2895 that only want to notice a size change. */
2896 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
2906 /* Given a type, apply default promotions wrt unnamed function arguments
2907 and return the new type. Return NULL_TREE if no change. */
2908 /* ??? There is a function of the same name in the C++ front end that
2909 does something similar, but is more thorough and does not return NULL
2910 if no change. We could perhaps share code, but it would make the
2911 self_promoting_type property harder to identify. */
2914 simple_type_promotes_to (type
)
2917 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2918 return double_type_node
;
2920 if (c_promoting_integer_type_p (type
))
2922 /* Traditionally, unsignedness is preserved in default promotions.
2923 Also preserve unsignedness if not really getting any wider. */
2924 if (TREE_UNSIGNED (type
)
2925 && (flag_traditional
2926 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
2927 return unsigned_type_node
;
2928 return integer_type_node
;
2934 /* Return 1 if PARMS specifies a fixed number of parameters
2935 and none of their types is affected by default promotions. */
2938 self_promoting_args_p (parms
)
2942 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
2944 tree type
= TREE_VALUE (t
);
2946 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
2952 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2955 if (c_promoting_integer_type_p (type
))
2961 /* Recursively examines the array elements of TYPE, until a non-array
2962 element type is found. */
2965 strip_array_types (type
)
2968 while (TREE_CODE (type
) == ARRAY_TYPE
)
2969 type
= TREE_TYPE (type
);
2974 /* Recognize certain built-in functions so we can make tree-codes
2975 other than CALL_EXPR. We do this when it enables fold-const.c
2976 to do something useful. */
2977 /* ??? By rights this should go in builtins.c, but only C and C++
2978 implement build_{binary,unary}_op. Not exactly sure what bits
2979 of functionality are actually needed from those functions, or
2980 where the similar functionality exists in the other front ends. */
2983 expand_tree_builtin (function
, params
, coerced_params
)
2984 tree function
, params
, coerced_params
;
2986 enum tree_code code
;
2988 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
2991 switch (DECL_FUNCTION_CODE (function
))
2995 case BUILT_IN_LLABS
:
2996 case BUILT_IN_IMAXABS
:
2998 case BUILT_IN_FABSL
:
2999 case BUILT_IN_FABSF
:
3000 if (coerced_params
== 0)
3001 return integer_zero_node
;
3002 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3005 case BUILT_IN_CONJF
:
3006 case BUILT_IN_CONJL
:
3007 if (coerced_params
== 0)
3008 return integer_zero_node
;
3009 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3011 case BUILT_IN_CREAL
:
3012 case BUILT_IN_CREALF
:
3013 case BUILT_IN_CREALL
:
3014 if (coerced_params
== 0)
3015 return integer_zero_node
;
3016 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3018 case BUILT_IN_CIMAG
:
3019 case BUILT_IN_CIMAGF
:
3020 case BUILT_IN_CIMAGL
:
3021 if (coerced_params
== 0)
3022 return integer_zero_node
;
3023 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3025 case BUILT_IN_ISGREATER
:
3026 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3032 case BUILT_IN_ISGREATEREQUAL
:
3033 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3039 case BUILT_IN_ISLESS
:
3040 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3046 case BUILT_IN_ISLESSEQUAL
:
3047 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3053 case BUILT_IN_ISLESSGREATER
:
3054 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3060 case BUILT_IN_ISUNORDERED
:
3061 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
3062 return integer_zero_node
;
3063 code
= UNORDERED_EXPR
;
3071 || TREE_CHAIN (params
) == 0)
3073 error ("too few arguments to function `%s'",
3074 IDENTIFIER_POINTER (DECL_NAME (function
)));
3075 return error_mark_node
;
3077 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3079 error ("too many arguments to function `%s'",
3080 IDENTIFIER_POINTER (DECL_NAME (function
)));
3081 return error_mark_node
;
3084 arg0
= TREE_VALUE (params
);
3085 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3086 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
3087 if (code
!= UNORDERED_EXPR
)
3088 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
3100 /* Returns non-zero if CODE is the code for a statement. */
3103 statement_code_p (code
)
3104 enum tree_code code
;
3128 if (lang_statement_code_p
)
3129 return (*lang_statement_code_p
) (code
);
3134 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3135 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3136 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3137 value, the traversal is aborted, and the value returned by FUNC is
3138 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3139 the node being visited are not walked.
3141 We don't need a without_duplicates variant of this one because the
3142 statement tree is a tree, not a graph. */
3145 walk_stmt_tree (tp
, func
, data
)
3150 enum tree_code code
;
3155 #define WALK_SUBTREE(NODE) \
3158 result = walk_stmt_tree (&(NODE), func, data); \
3164 /* Skip empty subtrees. */
3168 /* Skip subtrees below non-statement nodes. */
3169 if (!statement_code_p (TREE_CODE (*tp
)))
3172 /* Call the function. */
3174 result
= (*func
) (tp
, &walk_subtrees
, data
);
3176 /* If we found something, return it. */
3180 /* FUNC may have modified the tree, recheck that we're looking at a
3182 code
= TREE_CODE (*tp
);
3183 if (!statement_code_p (code
))
3186 /* Visit the subtrees unless FUNC decided that there was nothing
3187 interesting below this point in the tree. */
3190 /* Walk over all the sub-trees of this operand. Statement nodes
3191 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3192 len
= TREE_CODE_LENGTH (code
);
3194 /* Go through the subtrees. We need to do this in forward order so
3195 that the scope of a FOR_EXPR is handled properly. */
3196 for (i
= 0; i
< len
; ++i
)
3197 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3200 /* Finally visit the chain. This can be tail-recursion optimized if
3201 we write it this way. */
3202 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3207 /* Used to compare case labels. K1 and K2 are actually tree nodes
3208 representing case labels, or NULL_TREE for a `default' label.
3209 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3210 K2, and 0 if K1 and K2 are equal. */
3213 case_compare (k1
, k2
)
3217 /* Consider a NULL key (such as arises with a `default' label) to be
3218 smaller than anything else. */
3224 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3227 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3228 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3229 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3230 case label was declared using the usual C/C++ syntax, rather than
3231 the GNU case range extension. CASES is a tree containing all the
3232 case ranges processed so far; COND is the condition for the
3233 switch-statement itself. Returns the CASE_LABEL created, or
3234 ERROR_MARK_NODE if no CASE_LABEL is created. */
3237 c_add_case_label (cases
, cond
, low_value
, high_value
)
3246 splay_tree_node node
;
3248 /* Create the LABEL_DECL itself. */
3249 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3250 DECL_CONTEXT (label
) = current_function_decl
;
3252 /* If there was an error processing the switch condition, bail now
3253 before we get more confused. */
3254 if (!cond
|| cond
== error_mark_node
)
3256 /* Add a label anyhow so that the back-end doesn't think that
3257 the beginning of the switch is unreachable. */
3259 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3260 return error_mark_node
;
3263 if ((low_value
&& TREE_TYPE (low_value
)
3264 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3265 || (high_value
&& TREE_TYPE (high_value
)
3266 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3267 error ("pointers are not permitted as case values");
3269 /* Case ranges are a GNU extension. */
3270 if (high_value
&& pedantic
)
3272 if (c_language
== clk_cplusplus
)
3273 pedwarn ("ISO C++ forbids range expressions in switch statements");
3275 pedwarn ("ISO C forbids range expressions in switch statements");
3278 type
= TREE_TYPE (cond
);
3281 low_value
= check_case_value (low_value
);
3282 low_value
= convert_and_check (type
, low_value
);
3286 high_value
= check_case_value (high_value
);
3287 high_value
= convert_and_check (type
, high_value
);
3290 /* If an error has occurred, bail out now. */
3291 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3294 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3295 return error_mark_node
;
3298 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3299 really a case range, even though it was written that way. Remove
3300 the HIGH_VALUE to simplify later processing. */
3301 if (tree_int_cst_equal (low_value
, high_value
))
3302 high_value
= NULL_TREE
;
3303 if (low_value
&& high_value
3304 && !tree_int_cst_lt (low_value
, high_value
))
3305 warning ("empty range specified");
3307 /* Look up the LOW_VALUE in the table of case labels we already
3309 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3310 /* If there was not an exact match, check for overlapping ranges.
3311 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3312 that's a `default' label and the only overlap is an exact match. */
3313 if (!node
&& (low_value
|| high_value
))
3315 splay_tree_node low_bound
;
3316 splay_tree_node high_bound
;
3318 /* Even though there wasn't an exact match, there might be an
3319 overlap between this case range and another case range.
3320 Since we've (inductively) not allowed any overlapping case
3321 ranges, we simply need to find the greatest low case label
3322 that is smaller that LOW_VALUE, and the smallest low case
3323 label that is greater than LOW_VALUE. If there is an overlap
3324 it will occur in one of these two ranges. */
3325 low_bound
= splay_tree_predecessor (cases
,
3326 (splay_tree_key
) low_value
);
3327 high_bound
= splay_tree_successor (cases
,
3328 (splay_tree_key
) low_value
);
3330 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3331 the LOW_VALUE, so there is no need to check unless the
3332 LOW_BOUND is in fact itself a case range. */
3334 && CASE_HIGH ((tree
) low_bound
->value
)
3335 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3338 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3339 range is bigger than the low end of the current range, so we
3340 are only interested if the current range is a real range, and
3341 not an ordinary case label. */
3344 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3349 /* If there was an overlap, issue an error. */
3352 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3356 error ("duplicate (or overlapping) case value");
3357 error_with_decl (duplicate
,
3358 "this is the first entry overlapping that value");
3362 error ("duplicate case value") ;
3363 error_with_decl (duplicate
, "previously used here");
3367 error ("multiple default labels in one switch");
3368 error_with_decl (duplicate
, "this is the first default label");
3371 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3374 /* Add a CASE_LABEL to the statement-tree. */
3375 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3376 /* Register this case label in the splay tree. */
3377 splay_tree_insert (cases
,
3378 (splay_tree_key
) low_value
,
3379 (splay_tree_value
) case_label
);
3384 /* Finish an expression taking the address of LABEL. Returns an
3385 expression for the address. */
3388 finish_label_address_expr (label
)
3395 if (c_language
== clk_cplusplus
)
3396 pedwarn ("ISO C++ forbids taking the address of a label");
3398 pedwarn ("ISO C forbids taking the address of a label");
3401 label
= lookup_label (label
);
3402 if (label
== NULL_TREE
)
3403 result
= null_pointer_node
;
3406 TREE_USED (label
) = 1;
3407 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3408 TREE_CONSTANT (result
) = 1;
3409 /* The current function in not necessarily uninlinable.
3410 Computed gotos are incompatible with inlining, but the value
3411 here could be used only in a diagnostic, for example. */
3417 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3418 parameter allows this function to be used as a GC-marking
3425 stmt_tree st
= (stmt_tree
) p
;
3427 ggc_mark_tree (st
->x_last_stmt
);
3428 ggc_mark_tree (st
->x_last_expr_type
);
3431 /* Mark LD for GC. */
3434 c_mark_lang_decl (c
)
3435 struct c_lang_decl
*c ATTRIBUTE_UNUSED
;
3439 /* Mark F for GC. */
3442 mark_c_language_function (f
)
3443 struct language_function
*f
;
3448 mark_stmt_tree (&f
->x_stmt_tree
);
3449 ggc_mark_tree (f
->x_scope_stmt_stack
);
3452 /* Hook used by expand_expr to expand language-specific tree codes. */
3455 c_expand_expr (exp
, target
, tmode
, modifier
)
3458 enum machine_mode tmode
;
3459 enum expand_modifier modifier
;
3461 switch (TREE_CODE (exp
))
3468 /* Since expand_expr_stmt calls free_temp_slots after every
3469 expression statement, we must call push_temp_slots here.
3470 Otherwise, any temporaries in use now would be considered
3471 out-of-scope after the first EXPR_STMT from within the
3474 rtl_expr
= expand_start_stmt_expr ();
3476 /* If we want the result of this expression, find the last
3477 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3478 if (target
!= const0_rtx
3479 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
3480 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
3482 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
3483 tree last
= TREE_CHAIN (expr
);
3485 while (TREE_CHAIN (last
))
3488 last
= TREE_CHAIN (last
);
3491 if (TREE_CODE (last
) == SCOPE_STMT
3492 && TREE_CODE (expr
) == EXPR_STMT
)
3493 TREE_ADDRESSABLE (expr
) = 1;
3496 expand_stmt (STMT_EXPR_STMT (exp
));
3497 expand_end_stmt_expr (rtl_expr
);
3498 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
3506 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3507 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3509 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3510 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3511 == BUILT_IN_FRONTEND
))
3512 return c_expand_builtin (exp
, target
, tmode
, modifier
);
3518 case COMPOUND_LITERAL_EXPR
:
3520 /* Initialize the anonymous variable declared in the compound
3521 literal, then return the variable. */
3522 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
3523 emit_local_var (decl
);
3524 return expand_expr (decl
, target
, tmode
, modifier
);
3535 /* Hook used by safe_from_p to handle language-specific tree codes. */
3538 c_safe_from_p (target
, exp
)
3542 /* We can see statements here when processing the body of a
3543 statement-expression. For a declaration statement declaring a
3544 variable, look at the variable's initializer. */
3545 if (TREE_CODE (exp
) == DECL_STMT
)
3547 tree decl
= DECL_STMT_DECL (exp
);
3549 if (TREE_CODE (decl
) == VAR_DECL
3550 && DECL_INITIAL (decl
)
3551 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
3555 /* For any statement, we must follow the statement-chain. */
3556 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
3557 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
3559 /* Assume everything else is safe. */
3563 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3566 c_unsafe_for_reeval (exp
)
3569 /* Statement expressions may not be reevaluated, likewise compound
3571 if (TREE_CODE (exp
) == STMT_EXPR
3572 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
3575 /* Walk all other expressions. */
3579 /* Hook used by staticp to handle language-specific tree codes. */
3585 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
3586 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
3591 /* Tree code classes. */
3593 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3595 static const char c_tree_code_type
[] = {
3597 #include "c-common.def"
3601 /* Table indexed by tree code giving number of expression
3602 operands beyond the fixed part of the node structure.
3603 Not used for types or decls. */
3605 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3607 static const int c_tree_code_length
[] = {
3609 #include "c-common.def"
3613 /* Names of tree components.
3614 Used for printing out the tree and error messages. */
3615 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3617 static const char *const c_tree_code_name
[] = {
3619 #include "c-common.def"
3623 /* Adds the tree codes specific to the C front end to the list of all
3629 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3631 (int) LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
);
3632 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3634 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
3635 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3637 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
3638 lang_unsafe_for_reeval
= c_unsafe_for_reeval
;
3641 #define CALLED_AS_BUILT_IN(NODE) \
3642 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3645 c_expand_builtin (exp
, target
, tmode
, modifier
)
3648 enum machine_mode tmode
;
3649 enum expand_modifier modifier
;
3651 tree type
= TREE_TYPE (exp
);
3652 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3653 tree arglist
= TREE_OPERAND (exp
, 1);
3654 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3655 enum tree_code code
= TREE_CODE (exp
);
3656 const int ignore
= (target
== const0_rtx
3657 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
3658 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
3659 || code
== COND_EXPR
)
3660 && TREE_CODE (type
) == VOID_TYPE
));
3662 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
3663 return expand_call (exp
, target
, ignore
);
3667 case BUILT_IN_PRINTF
:
3668 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3669 modifier
, ignore
, /*unlocked=*/ 0);
3674 case BUILT_IN_PRINTF_UNLOCKED
:
3675 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3676 modifier
, ignore
, /*unlocked=*/ 1);
3681 case BUILT_IN_FPRINTF
:
3682 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3683 modifier
, ignore
, /*unlocked=*/ 0);
3688 case BUILT_IN_FPRINTF_UNLOCKED
:
3689 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3690 modifier
, ignore
, /*unlocked=*/ 1);
3695 default: /* just do library call, if unknown builtin */
3696 error ("built-in function `%s' not currently supported",
3697 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3700 /* The switch statement above can drop through to cause the function
3701 to be called normally. */
3702 return expand_call (exp
, target
, ignore
);
3705 /* Check an arglist to *printf for problems. The arglist should start
3706 at the format specifier, with the remaining arguments immediately
3709 is_valid_printf_arglist (arglist
)
3712 /* Save this value so we can restore it later. */
3713 const int SAVE_pedantic
= pedantic
;
3714 int diagnostic_occurred
= 0;
3717 /* Set this to a known value so the user setting won't affect code
3720 /* Check to make sure there are no format specifier errors. */
3721 attrs
= tree_cons (get_identifier ("format"),
3722 tree_cons (NULL_TREE
,
3723 get_identifier ("printf"),
3724 tree_cons (NULL_TREE
,
3726 tree_cons (NULL_TREE
,
3730 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
3732 /* Restore the value of `pedantic'. */
3733 pedantic
= SAVE_pedantic
;
3735 /* If calling `check_function_format_ptr' produces a warning, we
3736 return false, otherwise we return true. */
3737 return ! diagnostic_occurred
;
3740 /* If the arguments passed to printf are suitable for optimizations,
3741 we attempt to transform the call. */
3743 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3746 enum machine_mode tmode
;
3747 enum expand_modifier modifier
;
3751 tree fn_putchar
= unlocked
?
3752 built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTCHAR
];
3753 tree fn_puts
= unlocked
?
3754 built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTS
];
3755 tree fn
, format_arg
, stripped_string
;
3757 /* If the return value is used, or the replacement _DECL isn't
3758 initialized, don't do the transformation. */
3759 if (!ignore
|| !fn_putchar
|| !fn_puts
)
3762 /* Verify the required arguments in the original call. */
3764 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
3767 /* Check the specifier vs. the parameters. */
3768 if (!is_valid_printf_arglist (arglist
))
3771 format_arg
= TREE_VALUE (arglist
);
3772 stripped_string
= format_arg
;
3773 STRIP_NOPS (stripped_string
);
3774 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3775 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3777 /* If the format specifier isn't a STRING_CST, punt. */
3778 if (TREE_CODE (stripped_string
) != STRING_CST
)
3781 /* OK! We can attempt optimization. */
3783 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3784 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
3786 arglist
= TREE_CHAIN (arglist
);
3789 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3790 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3792 arglist
= TREE_CHAIN (arglist
);
3797 /* We can't handle anything else with % args or %% ... yet. */
3798 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3801 /* If the resulting constant string has a length of 1, call
3802 putchar. Note, TREE_STRING_LENGTH includes the terminating
3803 NULL in its count. */
3804 if (TREE_STRING_LENGTH (stripped_string
) == 2)
3806 /* Given printf("c"), (where c is any one character,)
3807 convert "c"[0] to an int and pass that to the replacement
3809 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
3810 arglist
= build_tree_list (NULL_TREE
, arglist
);
3814 /* If the resulting constant was "string\n", call
3815 __builtin_puts("string"). Ensure "string" has at least one
3816 character besides the trailing \n. Note, TREE_STRING_LENGTH
3817 includes the terminating NULL in its count. */
3818 else if (TREE_STRING_LENGTH (stripped_string
) > 2
3819 && TREE_STRING_POINTER (stripped_string
)
3820 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
3822 /* Create a NULL-terminated string that's one char shorter
3823 than the original, stripping off the trailing '\n'. */
3824 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
3825 char *newstr
= (char *) alloca (newlen
);
3826 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
3827 newstr
[newlen
- 1] = 0;
3829 arglist
= combine_strings (build_string (newlen
, newstr
));
3830 arglist
= build_tree_list (NULL_TREE
, arglist
);
3834 /* We'd like to arrange to call fputs(string) here, but we
3835 need stdout and don't have a way to get it ... yet. */
3839 return expand_expr (build_function_call (fn
, arglist
),
3840 (ignore
? const0_rtx
: target
),
3844 /* If the arguments passed to fprintf are suitable for optimizations,
3845 we attempt to transform the call. */
3847 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3850 enum machine_mode tmode
;
3851 enum expand_modifier modifier
;
3855 tree fn_fputc
= unlocked
?
3856 built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTC
];
3857 tree fn_fputs
= unlocked
?
3858 built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTS
];
3859 tree fn
, format_arg
, stripped_string
;
3861 /* If the return value is used, or the replacement _DECL isn't
3862 initialized, don't do the transformation. */
3863 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
3866 /* Verify the required arguments in the original call. */
3868 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
3869 || (TREE_CHAIN (arglist
) == 0)
3870 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
3874 /* Check the specifier vs. the parameters. */
3875 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
3878 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
3879 stripped_string
= format_arg
;
3880 STRIP_NOPS (stripped_string
);
3881 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3882 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3884 /* If the format specifier isn't a STRING_CST, punt. */
3885 if (TREE_CODE (stripped_string
) != STRING_CST
)
3888 /* OK! We can attempt optimization. */
3890 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3891 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
3893 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3894 arglist
= tree_cons (NULL_TREE
,
3895 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3899 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3900 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3902 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3903 arglist
= tree_cons (NULL_TREE
,
3904 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3910 /* We can't handle anything else with % args or %% ... yet. */
3911 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3914 /* When "string" doesn't contain %, replace all cases of
3915 fprintf(stream,string) with fputs(string,stream). The fputs
3916 builtin will take take of special cases like length==1. */
3917 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
3918 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
3922 return expand_expr (build_function_call (fn
, arglist
),
3923 (ignore
? const0_rtx
: target
),
3928 /* Given a boolean expression ARG, return a tree representing an increment
3929 or decrement (as indicated by CODE) of ARG. The front end must check for
3930 invalid cases (e.g., decrement in C++). */
3932 boolean_increment (code
, arg
)
3933 enum tree_code code
;
3937 tree true_res
= (c_language
== clk_cplusplus
3939 : c_bool_true_node
);
3940 arg
= stabilize_reference (arg
);
3943 case PREINCREMENT_EXPR
:
3944 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3946 case POSTINCREMENT_EXPR
:
3947 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3948 arg
= save_expr (arg
);
3949 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3950 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3952 case PREDECREMENT_EXPR
:
3953 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3955 case POSTDECREMENT_EXPR
:
3956 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3957 arg
= save_expr (arg
);
3958 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3959 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3964 TREE_SIDE_EFFECTS (val
) = 1;
3968 /* Handle C and C++ default attributes. */
3970 enum built_in_attribute
3972 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3973 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3974 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3975 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3976 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3977 #include "builtin-attrs.def"
3978 #undef DEF_ATTR_NULL_TREE
3980 #undef DEF_ATTR_IDENT
3981 #undef DEF_ATTR_TREE_LIST
3986 static tree built_in_attributes
[(int) ATTR_LAST
];
3988 static bool c_attrs_initialized
= false;
3990 static void c_init_attributes
PARAMS ((void));
3992 /* Common initialization before parsing options. */
3994 c_common_init_options (lang
)
3995 enum c_language_kind lang
;
3998 parse_in
= cpp_create_reader (lang
== clk_c
? CLK_GNUC89
:
3999 lang
== clk_cplusplus
? CLK_GNUCXX
: CLK_OBJC
);
4001 /* Mark as "unspecified" (see c_common_post_options). */
4002 flag_bounds_check
= -1;
4005 /* Post-switch processing. */
4007 c_common_post_options ()
4009 cpp_post_options (parse_in
);
4011 /* Use tree inlining if possible. Function instrumentation is only
4012 done in the RTL level, so we disable tree inlining. */
4013 if (! flag_instrument_function_entry_exit
)
4015 if (!flag_no_inline
)
4017 flag_inline_trees
= 1;
4020 if (flag_inline_functions
)
4022 flag_inline_trees
= 2;
4023 flag_inline_functions
= 0;
4027 /* If still "unspecified", make it match -fbounded-pointers. */
4028 if (flag_bounds_check
== -1)
4029 flag_bounds_check
= flag_bounded_pointers
;
4031 /* Special format checking options don't work without -Wformat; warn if
4033 if (warn_format_y2k
&& !warn_format
)
4034 warning ("-Wformat-y2k ignored without -Wformat");
4035 if (warn_format_extra_args
&& !warn_format
)
4036 warning ("-Wformat-extra-args ignored without -Wformat");
4037 if (warn_format_nonliteral
&& !warn_format
)
4038 warning ("-Wformat-nonliteral ignored without -Wformat");
4039 if (warn_format_security
&& !warn_format
)
4040 warning ("-Wformat-security ignored without -Wformat");
4041 if (warn_missing_format_attribute
&& !warn_format
)
4042 warning ("-Wmissing-format-attribute ignored without -Wformat");
4045 /* Front end initialization common to C, ObjC and C++. */
4047 c_common_init (filename
)
4048 const char *filename
;
4050 /* Do this before initializing pragmas, as then cpplib's hash table
4052 filename
= init_c_lex (filename
);
4056 if (!c_attrs_initialized
)
4057 c_init_attributes ();
4062 /* Common finish hook for the C, ObjC and C++ front ends. */
4066 cpp_finish (parse_in
);
4068 /* For performance, avoid tearing down cpplib's internal structures.
4069 Call cpp_errors () instead of cpp_destroy (). */
4070 errorcount
+= cpp_errors (parse_in
);
4074 c_init_attributes ()
4076 /* Fill in the built_in_attributes array. */
4077 #define DEF_ATTR_NULL_TREE(ENUM) \
4078 built_in_attributes[(int) ENUM] = NULL_TREE;
4079 #define DEF_ATTR_INT(ENUM, VALUE) \
4080 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4081 #define DEF_ATTR_IDENT(ENUM, STRING) \
4082 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4083 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4084 built_in_attributes[(int) ENUM] \
4085 = tree_cons (built_in_attributes[(int) PURPOSE], \
4086 built_in_attributes[(int) VALUE], \
4087 built_in_attributes[(int) CHAIN]);
4088 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4089 #include "builtin-attrs.def"
4090 #undef DEF_ATTR_NULL_TREE
4092 #undef DEF_ATTR_IDENT
4093 #undef DEF_ATTR_TREE_LIST
4095 ggc_add_tree_root (built_in_attributes
, (int) ATTR_LAST
);
4096 c_attrs_initialized
= true;
4099 /* Depending on the name of DECL, apply default attributes to it. */
4102 c_common_insert_default_attributes (decl
)
4105 tree name
= DECL_NAME (decl
);
4107 if (!c_attrs_initialized
)
4108 c_init_attributes ();
4110 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4111 #define DEF_ATTR_INT(ENUM, VALUE)
4112 #define DEF_ATTR_IDENT(ENUM, STRING)
4113 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4114 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4115 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4116 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4117 ATTR_FLAG_BUILT_IN);
4118 #include "builtin-attrs.def"
4119 #undef DEF_ATTR_NULL_TREE
4121 #undef DEF_ATTR_IDENT
4122 #undef DEF_ATTR_TREE_LIST
4126 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4127 additionally give the location of the previous declaration DECL. */
4129 shadow_warning (msgid
, name
, decl
)
4133 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
4134 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4135 DECL_SOURCE_LINE (decl
),
4136 "shadowed declaration is here");