1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
33 #include "tree-inline.h"
34 #include "diagnostic.h"
40 cpp_reader
*parse_in
; /* Declared in c-lex.h. */
42 #undef WCHAR_TYPE_SIZE
43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
45 /* We let tm.h override the types used here, to handle trivial differences
46 such as the choice of unsigned int or long unsigned int for size_t.
47 When machines start needing nontrivial differences in the size type,
48 it would be best to do something here to figure out automatically
49 from other information what type to use. */
52 #define SIZE_TYPE "long unsigned int"
56 #define WCHAR_TYPE "int"
60 #define PTRDIFF_TYPE "long int"
64 #define WINT_TYPE "unsigned int"
68 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
70 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
78 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 ? "long unsigned int" \
80 : "long long unsigned int"))
83 /* The variant of the C language being processed. */
85 enum c_language_kind c_language
;
87 /* The following symbols are subsumed in the c_global_trees array, and
88 listed here individually for documentation purposes.
90 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
92 tree short_integer_type_node;
93 tree long_integer_type_node;
94 tree long_long_integer_type_node;
96 tree short_unsigned_type_node;
97 tree long_unsigned_type_node;
98 tree long_long_unsigned_type_node;
100 tree boolean_type_node;
101 tree boolean_false_node;
102 tree boolean_true_node;
104 tree ptrdiff_type_node;
106 tree unsigned_char_type_node;
107 tree signed_char_type_node;
108 tree wchar_type_node;
109 tree signed_wchar_type_node;
110 tree unsigned_wchar_type_node;
112 tree float_type_node;
113 tree double_type_node;
114 tree long_double_type_node;
116 tree complex_integer_type_node;
117 tree complex_float_type_node;
118 tree complex_double_type_node;
119 tree complex_long_double_type_node;
121 tree intQI_type_node;
122 tree intHI_type_node;
123 tree intSI_type_node;
124 tree intDI_type_node;
125 tree intTI_type_node;
127 tree unsigned_intQI_type_node;
128 tree unsigned_intHI_type_node;
129 tree unsigned_intSI_type_node;
130 tree unsigned_intDI_type_node;
131 tree unsigned_intTI_type_node;
133 tree widest_integer_literal_type_node;
134 tree widest_unsigned_literal_type_node;
136 Nodes for types `void *' and `const void *'.
138 tree ptr_type_node, const_ptr_type_node;
140 Nodes for types `char *' and `const char *'.
142 tree string_type_node, const_string_type_node;
144 Type `char[SOMENUMBER]'.
145 Used when an array of char is needed and the size is irrelevant.
147 tree char_array_type_node;
149 Type `int[SOMENUMBER]' or something like it.
150 Used when an array of int needed and the size is irrelevant.
152 tree int_array_type_node;
154 Type `wchar_t[SOMENUMBER]' or something like it.
155 Used when a wide string literal is created.
157 tree wchar_array_type_node;
159 Type `int ()' -- used for implicit declaration of functions.
161 tree default_function_type;
163 A VOID_TYPE node, packaged in a TREE_LIST.
167 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
168 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
169 VAR_DECLS, but C++ does.)
171 tree function_name_decl_node;
172 tree pretty_function_name_decl_node;
173 tree c99_function_name_decl_node;
175 Stack of nested function name VAR_DECLs.
177 tree saved_function_name_decls;
181 tree c_global_trees
[CTI_MAX
];
183 /* Nonzero means don't recognize the non-ANSI builtin functions. */
187 /* Nonzero means don't recognize the non-ANSI builtin functions.
190 int flag_no_nonansi_builtin
;
192 /* Nonzero means give `double' the same size as `float'. */
194 int flag_short_double
;
196 /* Nonzero means give `wchar_t' the same size as `short'. */
198 int flag_short_wchar
;
200 /* Nonzero means warn about possible violations of sequence point rules. */
202 int warn_sequence_point
;
204 /* Nonzero means to warn about compile-time division by zero. */
205 int warn_div_by_zero
= 1;
207 /* The elements of `ridpointers' are identifier nodes for the reserved
208 type names and storage classes. It is indexed by a RID_... value. */
211 tree (*make_fname_decl
) PARAMS ((tree
, int));
213 /* If non-NULL, the address of a language-specific function that
214 returns 1 for language-specific statement codes. */
215 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
217 /* If non-NULL, the address of a language-specific function that takes
218 any action required right before expand_function_end is called. */
219 void (*lang_expand_function_end
) PARAMS ((void));
221 /* Nonzero means the expression being parsed will never be evaluated.
222 This is a count, since unevaluated expressions can nest. */
225 /* Information about how a function name is generated. */
228 tree
*const decl
; /* pointer to the VAR_DECL. */
229 const unsigned rid
; /* RID number for the identifier. */
230 const int pretty
; /* How pretty is it? */
233 /* The three ways of getting then name of the current function. */
235 const struct fname_var_t fname_vars
[] =
237 /* C99 compliant __func__, must be first. */
238 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
239 /* GCC __FUNCTION__ compliant. */
240 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
241 /* GCC __PRETTY_FUNCTION__ compliant. */
242 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
246 static int constant_fits_type_p
PARAMS ((tree
, tree
));
248 /* Keep a stack of if statements. We record the number of compound
249 statements seen up to the if keyword, as well as the line number
250 and file of the if. If a potentially ambiguous else is seen, that
251 fact is recorded; the warning is issued when we can be sure that
252 the enclosing if statement does not have an else branch. */
262 static if_elt
*if_stack
;
264 /* Amount of space in the if statement stack. */
265 static int if_stack_space
= 0;
268 static int if_stack_pointer
= 0;
270 /* Record the start of an if-then, and record the start of it
271 for ambiguous else detection.
273 COND is the condition for the if-then statement.
275 IF_STMT is the statement node that has already been created for
276 this if-then statement. It is created before parsing the
277 condition to keep line number information accurate. */
280 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
285 /* Make sure there is enough space on the stack. */
286 if (if_stack_space
== 0)
289 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
291 else if (if_stack_space
== if_stack_pointer
)
293 if_stack_space
+= 10;
294 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
297 IF_COND (if_stmt
) = cond
;
300 /* Record this if statement. */
301 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
302 if_stack
[if_stack_pointer
].file
= input_filename
;
303 if_stack
[if_stack_pointer
].line
= lineno
;
304 if_stack
[if_stack_pointer
].needs_warning
= 0;
305 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
309 /* Called after the then-clause for an if-statement is processed. */
314 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
315 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
318 /* Record the end of an if-then. Optionally warn if a nested
319 if statement had an ambiguous else clause. */
325 if (if_stack
[if_stack_pointer
].needs_warning
)
326 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
327 if_stack
[if_stack_pointer
].line
,
328 "suggest explicit braces to avoid ambiguous `else'");
329 last_expr_type
= NULL_TREE
;
332 /* Called between the then-clause and the else-clause
333 of an if-then-else. */
336 c_expand_start_else ()
338 /* An ambiguous else warning must be generated for the enclosing if
339 statement, unless we see an else branch for that one, too. */
341 && if_stack_pointer
> 1
342 && (if_stack
[if_stack_pointer
- 1].compstmt_count
343 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
344 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
346 /* Even if a nested if statement had an else branch, it can't be
347 ambiguous if this one also has an else. So don't warn in that
348 case. Also don't warn for any if statements nested in this else. */
349 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
350 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
353 /* Called after the else-clause for an if-statement is processed. */
358 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
359 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
362 /* Begin an if-statement. Returns a newly created IF_STMT if
365 Unlike the C++ front-end, we do not call add_stmt here; it is
366 probably safe to do so, but I am not very familiar with this
367 code so I am being extra careful not to change its behavior
368 beyond what is strictly necessary for correctness. */
374 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
378 /* Begin a while statement. Returns a newly created WHILE_STMT if
381 Unlike the C++ front-end, we do not call add_stmt here; it is
382 probably safe to do so, but I am not very familiar with this
383 code so I am being extra careful not to change its behavior
384 beyond what is strictly necessary for correctness. */
387 c_begin_while_stmt ()
390 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
395 c_finish_while_stmt_cond (cond
, while_stmt
)
399 WHILE_COND (while_stmt
) = cond
;
402 /* Push current bindings for the function name VAR_DECLS. */
408 tree saved
= NULL_TREE
;
410 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
412 tree decl
= *fname_vars
[ix
].decl
;
416 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
417 *fname_vars
[ix
].decl
= NULL_TREE
;
420 if (saved
|| saved_function_name_decls
)
421 /* Normally they'll have been NULL, so only push if we've got a
422 stack, or they are non-NULL. */
423 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
424 saved_function_name_decls
);
427 /* Finish up the current bindings, adding them into the
428 current function's statement tree. This is done by wrapping the
429 function's body in a COMPOUND_STMT containing these decls too. This
430 must be done _before_ finish_stmt_tree is called. If there is no
431 current function, we must be at file scope and no statements are
432 involved. Pop the previous bindings. */
435 finish_fname_decls ()
438 tree body
= NULL_TREE
;
439 tree stack
= saved_function_name_decls
;
441 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
442 body
= chainon (TREE_VALUE (stack
), body
);
446 /* They were called into existence, so add to statement tree. */
447 body
= chainon (body
,
448 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)));
449 body
= build_stmt (COMPOUND_STMT
, body
);
451 COMPOUND_STMT_NO_SCOPE (body
) = 1;
452 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)) = body
;
455 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
456 *fname_vars
[ix
].decl
= NULL_TREE
;
460 /* We had saved values, restore them. */
463 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
465 tree decl
= TREE_PURPOSE (saved
);
466 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
468 *fname_vars
[ix
].decl
= decl
;
470 stack
= TREE_CHAIN (stack
);
472 saved_function_name_decls
= stack
;
475 /* Return the text name of the current function, suitable prettified
479 fname_as_string (pretty_p
)
482 const char *name
= NULL
;
485 name
= (current_function_decl
486 ? (*decl_printable_name
) (current_function_decl
, 2)
488 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
489 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
495 /* Return the text name of the current function, formatted as
496 required by the supplied RID value. */
504 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
505 if (fname_vars
[ix
].rid
== rid
)
507 return fname_as_string (fname_vars
[ix
].pretty
);
510 /* Return the VAR_DECL for a const char array naming the current
511 function. If the VAR_DECL has not yet been created, create it
512 now. RID indicates how it should be formatted and IDENTIFIER_NODE
513 ID is its name (unfortunately C and C++ hold the RID values of
514 keywords in different places, so we can't derive RID from ID in
515 this language independent code. */
523 tree decl
= NULL_TREE
;
525 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
526 if (fname_vars
[ix
].rid
== rid
)
529 decl
= *fname_vars
[ix
].decl
;
532 tree saved_last_tree
= last_tree
;
534 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
535 if (last_tree
!= saved_last_tree
)
537 /* We created some statement tree for the decl. This belongs
538 at the start of the function, so remove it now and reinsert
539 it after the function is complete. */
540 tree stmts
= TREE_CHAIN (saved_last_tree
);
542 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
543 last_tree
= saved_last_tree
;
544 saved_function_name_decls
= tree_cons (decl
, stmts
,
545 saved_function_name_decls
);
547 *fname_vars
[ix
].decl
= decl
;
549 if (!ix
&& !current_function_decl
)
550 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
555 /* Given a chain of STRING_CST nodes,
556 concatenate them into one STRING_CST
557 and give it a suitable array-of-chars data type. */
560 combine_strings (strings
)
567 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
569 const int nchars_max
= flag_isoc99
? 4095 : 509;
571 if (TREE_CHAIN (strings
))
573 /* More than one in the chain, so concatenate. */
576 /* Don't include the \0 at the end of each substring,
577 except for the last one.
578 Count wide strings and ordinary strings separately. */
579 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
581 if (TREE_TYPE (t
) == wchar_array_type_node
)
583 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
588 length
+= (TREE_STRING_LENGTH (t
) - 1);
589 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
590 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
594 /* If anything is wide, the non-wides will be converted,
595 which makes them take more space. */
597 length
= length
* wchar_bytes
+ wide_length
;
601 /* Copy the individual strings into the new combined string.
602 If the combined string is wide, convert the chars to ints
603 for any individual strings that are not wide. */
606 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
608 int len
= (TREE_STRING_LENGTH (t
)
609 - ((TREE_TYPE (t
) == wchar_array_type_node
)
611 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
613 memcpy (q
, TREE_STRING_POINTER (t
), len
);
619 for (i
= 0; i
< len
; i
++)
621 if (BYTES_BIG_ENDIAN
)
623 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
625 *q
++ = TREE_STRING_POINTER (t
)[i
];
629 *q
++ = TREE_STRING_POINTER (t
)[i
];
630 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
639 for (i
= 0; i
< wchar_bytes
; i
++)
645 value
= build_string (length
, p
);
650 length
= TREE_STRING_LENGTH (value
);
651 if (TREE_TYPE (value
) == wchar_array_type_node
)
655 /* Compute the number of elements, for the array type. */
656 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
658 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
659 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
660 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
662 /* Create the array type for the string constant.
663 -Wwrite-strings says make the string constant an array of const char
664 so that copying it to a non-const pointer will get a warning.
665 For C++, this is the standard behavior. */
666 if (flag_const_strings
667 && (! flag_traditional
&& ! flag_writable_strings
))
670 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
673 = build_array_type (elements
,
674 build_index_type (build_int_2 (nchars
- 1, 0)));
678 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
679 build_index_type (build_int_2 (nchars
- 1, 0)));
681 TREE_CONSTANT (value
) = 1;
682 TREE_READONLY (value
) = ! flag_writable_strings
;
683 TREE_STATIC (value
) = 1;
687 static int is_valid_printf_arglist
PARAMS ((tree
));
688 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
689 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
690 enum expand_modifier
, int, int));
691 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
692 enum expand_modifier
, int, int));
694 /* Print a warning if a constant expression had overflow in folding.
695 Invoke this function on every expression that the language
696 requires to be a constant expression.
697 Note the ANSI C standard says it is erroneous for a
698 constant expression to overflow. */
701 constant_expression_warning (value
)
704 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
705 || TREE_CODE (value
) == COMPLEX_CST
)
706 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
707 pedwarn ("overflow in constant expression");
710 /* Print a warning if an expression had overflow in folding.
711 Invoke this function on every expression that
712 (1) appears in the source code, and
713 (2) might be a constant expression that overflowed, and
714 (3) is not already checked by convert_and_check;
715 however, do not invoke this function on operands of explicit casts. */
718 overflow_warning (value
)
721 if ((TREE_CODE (value
) == INTEGER_CST
722 || (TREE_CODE (value
) == COMPLEX_CST
723 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
724 && TREE_OVERFLOW (value
))
726 TREE_OVERFLOW (value
) = 0;
727 if (skip_evaluation
== 0)
728 warning ("integer overflow in expression");
730 else if ((TREE_CODE (value
) == REAL_CST
731 || (TREE_CODE (value
) == COMPLEX_CST
732 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
733 && TREE_OVERFLOW (value
))
735 TREE_OVERFLOW (value
) = 0;
736 if (skip_evaluation
== 0)
737 warning ("floating point overflow in expression");
741 /* Print a warning if a large constant is truncated to unsigned,
742 or if -Wconversion is used and a constant < 0 is converted to unsigned.
743 Invoke this function on every expression that might be implicitly
744 converted to an unsigned type. */
747 unsigned_conversion_warning (result
, operand
)
748 tree result
, operand
;
750 if (TREE_CODE (operand
) == INTEGER_CST
751 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
752 && TREE_UNSIGNED (TREE_TYPE (result
))
753 && skip_evaluation
== 0
754 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
756 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
757 /* This detects cases like converting -129 or 256 to unsigned char. */
758 warning ("large integer implicitly truncated to unsigned type");
759 else if (warn_conversion
)
760 warning ("negative integer implicitly converted to unsigned type");
764 /* Nonzero if constant C has a value that is permissible
765 for type TYPE (an INTEGER_TYPE). */
768 constant_fits_type_p (c
, type
)
771 if (TREE_CODE (c
) == INTEGER_CST
)
772 return int_fits_type_p (c
, type
);
774 c
= convert (type
, c
);
775 return !TREE_OVERFLOW (c
);
778 /* Convert EXPR to TYPE, warning about conversion problems with constants.
779 Invoke this function on every expression that is converted implicitly,
780 i.e. because of language rules and not because of an explicit cast. */
783 convert_and_check (type
, expr
)
786 tree t
= convert (type
, expr
);
787 if (TREE_CODE (t
) == INTEGER_CST
)
789 if (TREE_OVERFLOW (t
))
791 TREE_OVERFLOW (t
) = 0;
793 /* Do not diagnose overflow in a constant expression merely
794 because a conversion overflowed. */
795 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
797 /* No warning for converting 0x80000000 to int. */
798 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
799 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
800 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
801 /* If EXPR fits in the unsigned version of TYPE,
802 don't warn unless pedantic. */
804 || TREE_UNSIGNED (type
)
805 || ! constant_fits_type_p (expr
, unsigned_type (type
)))
806 && skip_evaluation
== 0)
807 warning ("overflow in implicit constant conversion");
810 unsigned_conversion_warning (t
, expr
);
815 /* A node in a list that describes references to variables (EXPR), which are
816 either read accesses if WRITER is zero, or write accesses, in which case
817 WRITER is the parent of EXPR. */
824 /* Used to implement a cache the results of a call to verify_tree. We only
825 use this for SAVE_EXPRs. */
828 struct tlist_cache
*next
;
829 struct tlist
*cache_before_sp
;
830 struct tlist
*cache_after_sp
;
834 /* Obstack to use when allocating tlist structures, and corresponding
836 static struct obstack tlist_obstack
;
837 static char *tlist_firstobj
= 0;
839 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
841 static struct tlist
*warned_ids
;
842 /* SAVE_EXPRs need special treatment. We process them only once and then
843 cache the results. */
844 static struct tlist_cache
*save_expr_cache
;
846 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
847 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
848 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
849 static int warning_candidate_p
PARAMS ((tree
));
850 static void warn_for_collisions
PARAMS ((struct tlist
*));
851 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
852 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
853 static void verify_sequence_points
PARAMS ((tree
));
855 /* Create a new struct tlist and fill in its fields. */
856 static struct tlist
*
857 new_tlist (next
, t
, writer
)
863 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
870 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
871 is nonnull, we ignore any node we find which has a writer equal to it. */
874 add_tlist (to
, add
, exclude_writer
, copy
)
882 struct tlist
*next
= add
->next
;
885 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
886 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
891 /* Merge the nodes of ADD into TO. This merging process is done so that for
892 each variable that already exists in TO, no new node is added; however if
893 there is a write access recorded in ADD, and an occurrence on TO is only
894 a read access, then the occurrence in TO will be modified to record the
898 merge_tlist (to
, add
, copy
)
903 struct tlist
**end
= to
;
912 struct tlist
*next
= add
->next
;
914 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
915 if (tmp2
->expr
== add
->expr
)
919 tmp2
->writer
= add
->writer
;
923 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
931 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
932 references in list LIST conflict with it, excluding reads if ONLY writers
936 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
937 tree written
, writer
;
943 /* Avoid duplicate warnings. */
944 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
945 if (tmp
->expr
== written
)
950 if (list
->expr
== written
951 && list
->writer
!= writer
952 && (! only_writes
|| list
->writer
))
954 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
955 warning ("operation on `%s' may be undefined",
956 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
962 /* Given a list LIST of references to variables, find whether any of these
963 can cause conflicts due to missing sequence points. */
966 warn_for_collisions (list
)
971 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
974 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
978 /* Return nonzero if X is a tree that can be verified by the sequence point
981 warning_candidate_p (x
)
984 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
987 /* Walk the tree X, and record accesses to variables. If X is written by the
988 parent tree, WRITER is the parent.
989 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
990 expression or its only operand forces a sequence point, then everything up
991 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
993 Once we return, we will have emitted warnings if any subexpression before
994 such a sequence point could be undefined. On a higher level, however, the
995 sequence point may not be relevant, and we'll merge the two lists.
997 Example: (b++, a) + b;
998 The call that processes the COMPOUND_EXPR will store the increment of B
999 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1000 processes the PLUS_EXPR will need to merge the two lists so that
1001 eventually, all accesses end up on the same list (and we'll warn about the
1002 unordered subexpressions b++ and b.
1004 A note on merging. If we modify the former example so that our expression
1007 care must be taken not simply to add all three expressions into the final
1008 PNO_SP list. The function merge_tlist takes care of that by merging the
1009 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1010 way, so that no more than one access to B is recorded. */
1013 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1015 struct tlist
**pbefore_sp
, **pno_sp
;
1018 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1019 enum tree_code code
;
1022 /* X may be NULL if it is the operand of an empty statement expression
1028 code
= TREE_CODE (x
);
1029 class = TREE_CODE_CLASS (code
);
1031 if (warning_candidate_p (x
))
1033 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1043 case TRUTH_ANDIF_EXPR
:
1044 case TRUTH_ORIF_EXPR
:
1045 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1046 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1047 warn_for_collisions (tmp_nosp
);
1048 merge_tlist (pbefore_sp
, tmp_before
, 0);
1049 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1050 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1051 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1055 tmp_before
= tmp_list2
= 0;
1056 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1057 warn_for_collisions (tmp_list2
);
1058 merge_tlist (pbefore_sp
, tmp_before
, 0);
1059 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1061 tmp_list3
= tmp_nosp
= 0;
1062 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1063 warn_for_collisions (tmp_nosp
);
1064 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1066 tmp_list3
= tmp_list2
= 0;
1067 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1068 warn_for_collisions (tmp_list2
);
1069 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1070 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1071 two first, to avoid warning for (a ? b++ : b++). */
1072 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1073 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1076 case PREDECREMENT_EXPR
:
1077 case PREINCREMENT_EXPR
:
1078 case POSTDECREMENT_EXPR
:
1079 case POSTINCREMENT_EXPR
:
1080 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1084 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1085 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1086 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1087 /* Expressions inside the LHS are not ordered wrt. the sequence points
1088 in the RHS. Example:
1090 Despite the fact that the modification of "a" is in the before_sp
1091 list (tmp_before), it conflicts with the use of "a" in the LHS.
1092 We can handle this by adding the contents of tmp_list3
1093 to those of tmp_before, and redoing the collision warnings for that
1095 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1096 warn_for_collisions (tmp_before
);
1097 /* Exclude the LHS itself here; we first have to merge it into the
1098 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1099 didn't exclude the LHS, we'd get it twice, once as a read and once
1101 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1102 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1104 merge_tlist (pbefore_sp
, tmp_before
, 0);
1105 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1106 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1107 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1111 /* We need to warn about conflicts among arguments and conflicts between
1112 args and the function address. Side effects of the function address,
1113 however, are not ordered by the sequence point of the call. */
1114 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1115 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1116 if (TREE_OPERAND (x
, 1))
1117 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1118 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1119 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1120 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1121 warn_for_collisions (tmp_before
);
1122 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1126 /* Scan all the list, e.g. indices of multi dimensional array. */
1129 tmp_before
= tmp_nosp
= 0;
1130 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1131 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1132 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1139 struct tlist_cache
*t
;
1140 for (t
= save_expr_cache
; t
; t
= t
->next
)
1146 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1148 t
->next
= save_expr_cache
;
1150 save_expr_cache
= t
;
1152 tmp_before
= tmp_nosp
= 0;
1153 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1154 warn_for_collisions (tmp_nosp
);
1159 struct tlist
*t
= tmp_nosp
;
1161 merge_tlist (&tmp_list3
, t
, 0);
1163 t
->cache_before_sp
= tmp_before
;
1164 t
->cache_after_sp
= tmp_list3
;
1166 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1167 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1176 if (first_rtl_op (code
) == 0)
1178 x
= TREE_OPERAND (x
, 0);
1194 int max
= first_rtl_op (TREE_CODE (x
));
1195 for (lp
= 0; lp
< max
; lp
++)
1197 tmp_before
= tmp_nosp
= 0;
1198 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1199 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1200 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1207 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1211 verify_sequence_points (expr
)
1214 struct tlist
*before_sp
= 0, *after_sp
= 0;
1217 save_expr_cache
= 0;
1218 if (tlist_firstobj
== 0)
1220 gcc_obstack_init (&tlist_obstack
);
1221 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1224 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1225 warn_for_collisions (after_sp
);
1226 obstack_free (&tlist_obstack
, tlist_firstobj
);
1230 c_expand_expr_stmt (expr
)
1233 /* Do default conversion if safe and possibly important,
1234 in case within ({...}). */
1235 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1236 && (flag_isoc99
|| lvalue_p (expr
)))
1237 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1238 expr
= default_conversion (expr
);
1240 if (warn_sequence_point
)
1241 verify_sequence_points (expr
);
1243 if (TREE_TYPE (expr
) != error_mark_node
1244 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1245 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1246 error ("expression statement has incomplete type");
1248 last_expr_type
= TREE_TYPE (expr
);
1249 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1252 /* Validate the expression after `case' and apply default promotions. */
1255 check_case_value (value
)
1258 if (value
== NULL_TREE
)
1261 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1262 STRIP_TYPE_NOPS (value
);
1263 /* In C++, the following is allowed:
1266 switch (...) { case i: ... }
1268 So, we try to reduce the VALUE to a constant that way. */
1269 if (c_language
== clk_cplusplus
)
1271 value
= decl_constant_value (value
);
1272 STRIP_TYPE_NOPS (value
);
1273 value
= fold (value
);
1276 if (TREE_CODE (value
) != INTEGER_CST
1277 && value
!= error_mark_node
)
1279 error ("case label does not reduce to an integer constant");
1280 value
= error_mark_node
;
1283 /* Promote char or short to int. */
1284 value
= default_conversion (value
);
1286 constant_expression_warning (value
);
1291 /* Return an integer type with BITS bits of precision,
1292 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1295 type_for_size (bits
, unsignedp
)
1299 if (bits
== TYPE_PRECISION (integer_type_node
))
1300 return unsignedp
? unsigned_type_node
: integer_type_node
;
1302 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1303 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1305 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1306 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1308 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1309 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1311 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1312 return (unsignedp
? long_long_unsigned_type_node
1313 : long_long_integer_type_node
);
1315 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1316 return (unsignedp
? widest_unsigned_literal_type_node
1317 : widest_integer_literal_type_node
);
1319 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1320 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1322 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1323 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1325 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1326 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1328 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1329 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1334 /* Return a data type that has machine mode MODE.
1335 If the mode is an integer,
1336 then UNSIGNEDP selects between signed and unsigned types. */
1339 type_for_mode (mode
, unsignedp
)
1340 enum machine_mode mode
;
1343 if (mode
== TYPE_MODE (integer_type_node
))
1344 return unsignedp
? unsigned_type_node
: integer_type_node
;
1346 if (mode
== TYPE_MODE (signed_char_type_node
))
1347 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1349 if (mode
== TYPE_MODE (short_integer_type_node
))
1350 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1352 if (mode
== TYPE_MODE (long_integer_type_node
))
1353 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1355 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1356 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1358 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1359 return unsignedp
? widest_unsigned_literal_type_node
1360 : widest_integer_literal_type_node
;
1363 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1366 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1369 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1372 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1374 #if HOST_BITS_PER_WIDE_INT >= 64
1375 if (mode
== TYPE_MODE (intTI_type_node
))
1376 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1379 if (mode
== TYPE_MODE (float_type_node
))
1380 return float_type_node
;
1382 if (mode
== TYPE_MODE (double_type_node
))
1383 return double_type_node
;
1385 if (mode
== TYPE_MODE (long_double_type_node
))
1386 return long_double_type_node
;
1388 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1389 return build_pointer_type (char_type_node
);
1391 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1392 return build_pointer_type (integer_type_node
);
1394 #ifdef VECTOR_MODE_SUPPORTED_P
1395 if (VECTOR_MODE_SUPPORTED_P (mode
))
1400 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
1402 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
1404 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
1406 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
1408 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
1410 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
1412 return V16SF_type_node
;
1414 return V4SF_type_node
;
1416 return V2SF_type_node
;
1426 /* Return an unsigned type the same as TYPE in other respects. */
1428 unsigned_type (type
)
1431 tree type1
= TYPE_MAIN_VARIANT (type
);
1432 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1433 return unsigned_char_type_node
;
1434 if (type1
== integer_type_node
)
1435 return unsigned_type_node
;
1436 if (type1
== short_integer_type_node
)
1437 return short_unsigned_type_node
;
1438 if (type1
== long_integer_type_node
)
1439 return long_unsigned_type_node
;
1440 if (type1
== long_long_integer_type_node
)
1441 return long_long_unsigned_type_node
;
1442 if (type1
== widest_integer_literal_type_node
)
1443 return widest_unsigned_literal_type_node
;
1444 #if HOST_BITS_PER_WIDE_INT >= 64
1445 if (type1
== intTI_type_node
)
1446 return unsigned_intTI_type_node
;
1448 if (type1
== intDI_type_node
)
1449 return unsigned_intDI_type_node
;
1450 if (type1
== intSI_type_node
)
1451 return unsigned_intSI_type_node
;
1452 if (type1
== intHI_type_node
)
1453 return unsigned_intHI_type_node
;
1454 if (type1
== intQI_type_node
)
1455 return unsigned_intQI_type_node
;
1457 return signed_or_unsigned_type (1, type
);
1460 /* Return a signed type the same as TYPE in other respects. */
1466 tree type1
= TYPE_MAIN_VARIANT (type
);
1467 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1468 return signed_char_type_node
;
1469 if (type1
== unsigned_type_node
)
1470 return integer_type_node
;
1471 if (type1
== short_unsigned_type_node
)
1472 return short_integer_type_node
;
1473 if (type1
== long_unsigned_type_node
)
1474 return long_integer_type_node
;
1475 if (type1
== long_long_unsigned_type_node
)
1476 return long_long_integer_type_node
;
1477 if (type1
== widest_unsigned_literal_type_node
)
1478 return widest_integer_literal_type_node
;
1479 #if HOST_BITS_PER_WIDE_INT >= 64
1480 if (type1
== unsigned_intTI_type_node
)
1481 return intTI_type_node
;
1483 if (type1
== unsigned_intDI_type_node
)
1484 return intDI_type_node
;
1485 if (type1
== unsigned_intSI_type_node
)
1486 return intSI_type_node
;
1487 if (type1
== unsigned_intHI_type_node
)
1488 return intHI_type_node
;
1489 if (type1
== unsigned_intQI_type_node
)
1490 return intQI_type_node
;
1492 return signed_or_unsigned_type (0, type
);
1495 /* Return a type the same as TYPE except unsigned or
1496 signed according to UNSIGNEDP. */
1499 signed_or_unsigned_type (unsignedp
, type
)
1503 if (! INTEGRAL_TYPE_P (type
)
1504 || TREE_UNSIGNED (type
) == unsignedp
)
1507 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1508 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1509 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1510 return unsignedp
? unsigned_type_node
: integer_type_node
;
1511 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1512 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1513 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1514 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1515 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1516 return (unsignedp
? long_long_unsigned_type_node
1517 : long_long_integer_type_node
);
1518 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1519 return (unsignedp
? widest_unsigned_literal_type_node
1520 : widest_integer_literal_type_node
);
1522 #if HOST_BITS_PER_WIDE_INT >= 64
1523 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
1524 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1526 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
1527 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1528 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
1529 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1530 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
1531 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1532 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
1533 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1538 /* Return the minimum number of bits needed to represent VALUE in a
1539 signed or unsigned type, UNSIGNEDP says which. */
1542 min_precision (value
, unsignedp
)
1548 /* If the value is negative, compute its negative minus 1. The latter
1549 adjustment is because the absolute value of the largest negative value
1550 is one larger than the largest positive value. This is equivalent to
1551 a bit-wise negation, so use that operation instead. */
1553 if (tree_int_cst_sgn (value
) < 0)
1554 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1556 /* Return the number of bits needed, taking into account the fact
1557 that we need one more bit for a signed than unsigned type. */
1559 if (integer_zerop (value
))
1562 log
= tree_floor_log2 (value
);
1564 return log
+ 1 + ! unsignedp
;
1567 /* Print an error message for invalid operands to arith operation CODE.
1568 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1571 binary_op_error (code
)
1572 enum tree_code code
;
1579 error ("invalid truth-value expression");
1583 opname
= "+"; break;
1585 opname
= "-"; break;
1587 opname
= "*"; break;
1589 opname
= "max"; break;
1591 opname
= "min"; break;
1593 opname
= "=="; break;
1595 opname
= "!="; break;
1597 opname
= "<="; break;
1599 opname
= ">="; break;
1601 opname
= "<"; break;
1603 opname
= ">"; break;
1605 opname
= "<<"; break;
1607 opname
= ">>"; break;
1608 case TRUNC_MOD_EXPR
:
1609 case FLOOR_MOD_EXPR
:
1610 opname
= "%"; break;
1611 case TRUNC_DIV_EXPR
:
1612 case FLOOR_DIV_EXPR
:
1613 opname
= "/"; break;
1615 opname
= "&"; break;
1617 opname
= "|"; break;
1618 case TRUTH_ANDIF_EXPR
:
1619 opname
= "&&"; break;
1620 case TRUTH_ORIF_EXPR
:
1621 opname
= "||"; break;
1623 opname
= "^"; break;
1626 opname
= "rotate"; break;
1628 opname
= "unknown"; break;
1630 error ("invalid operands to binary %s", opname
);
1633 /* Subroutine of build_binary_op, used for comparison operations.
1634 See if the operands have both been converted from subword integer types
1635 and, if so, perhaps change them both back to their original type.
1636 This function is also responsible for converting the two operands
1637 to the proper common type for comparison.
1639 The arguments of this function are all pointers to local variables
1640 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1641 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1643 If this function returns nonzero, it means that the comparison has
1644 a constant value. What this function returns is an expression for
1648 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1649 tree
*op0_ptr
, *op1_ptr
;
1651 enum tree_code
*rescode_ptr
;
1654 tree op0
= *op0_ptr
;
1655 tree op1
= *op1_ptr
;
1656 int unsignedp0
, unsignedp1
;
1658 tree primop0
, primop1
;
1659 enum tree_code code
= *rescode_ptr
;
1661 /* Throw away any conversions to wider types
1662 already present in the operands. */
1664 primop0
= get_narrower (op0
, &unsignedp0
);
1665 primop1
= get_narrower (op1
, &unsignedp1
);
1667 /* Handle the case that OP0 does not *contain* a conversion
1668 but it *requires* conversion to FINAL_TYPE. */
1670 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1671 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1672 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1673 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1675 /* If one of the operands must be floated, we cannot optimize. */
1676 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1677 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1679 /* If first arg is constant, swap the args (changing operation
1680 so value is preserved), for canonicalization. Don't do this if
1681 the second arg is 0. */
1683 if (TREE_CONSTANT (primop0
)
1684 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1687 int temi
= unsignedp0
;
1695 unsignedp0
= unsignedp1
;
1718 *rescode_ptr
= code
;
1721 /* If comparing an integer against a constant more bits wide,
1722 maybe we can deduce a value of 1 or 0 independent of the data.
1723 Or else truncate the constant now
1724 rather than extend the variable at run time.
1726 This is only interesting if the constant is the wider arg.
1727 Also, it is not safe if the constant is unsigned and the
1728 variable arg is signed, since in this case the variable
1729 would be sign-extended and then regarded as unsigned.
1730 Our technique fails in this case because the lowest/highest
1731 possible unsigned results don't follow naturally from the
1732 lowest/highest possible values of the variable operand.
1733 For just EQ_EXPR and NE_EXPR there is another technique that
1734 could be used: see if the constant can be faithfully represented
1735 in the other operand's type, by truncating it and reextending it
1736 and see if that preserves the constant's value. */
1738 if (!real1
&& !real2
1739 && TREE_CODE (primop1
) == INTEGER_CST
1740 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1742 int min_gt
, max_gt
, min_lt
, max_lt
;
1743 tree maxval
, minval
;
1744 /* 1 if comparison is nominally unsigned. */
1745 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1748 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1750 /* If TYPE is an enumeration, then we need to get its min/max
1751 values from it's underlying integral type, not the enumerated
1753 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1754 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
1756 maxval
= TYPE_MAX_VALUE (type
);
1757 minval
= TYPE_MIN_VALUE (type
);
1759 if (unsignedp
&& !unsignedp0
)
1760 *restype_ptr
= signed_type (*restype_ptr
);
1762 if (TREE_TYPE (primop1
) != *restype_ptr
)
1763 primop1
= convert (*restype_ptr
, primop1
);
1764 if (type
!= *restype_ptr
)
1766 minval
= convert (*restype_ptr
, minval
);
1767 maxval
= convert (*restype_ptr
, maxval
);
1770 if (unsignedp
&& unsignedp0
)
1772 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1773 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1774 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1775 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1779 min_gt
= INT_CST_LT (primop1
, minval
);
1780 max_gt
= INT_CST_LT (primop1
, maxval
);
1781 min_lt
= INT_CST_LT (minval
, primop1
);
1782 max_lt
= INT_CST_LT (maxval
, primop1
);
1786 /* This used to be a switch, but Genix compiler can't handle that. */
1787 if (code
== NE_EXPR
)
1789 if (max_lt
|| min_gt
)
1790 val
= boolean_true_node
;
1792 else if (code
== EQ_EXPR
)
1794 if (max_lt
|| min_gt
)
1795 val
= boolean_false_node
;
1797 else if (code
== LT_EXPR
)
1800 val
= boolean_true_node
;
1802 val
= boolean_false_node
;
1804 else if (code
== GT_EXPR
)
1807 val
= boolean_true_node
;
1809 val
= boolean_false_node
;
1811 else if (code
== LE_EXPR
)
1814 val
= boolean_true_node
;
1816 val
= boolean_false_node
;
1818 else if (code
== GE_EXPR
)
1821 val
= boolean_true_node
;
1823 val
= boolean_false_node
;
1826 /* If primop0 was sign-extended and unsigned comparison specd,
1827 we did a signed comparison above using the signed type bounds.
1828 But the comparison we output must be unsigned.
1830 Also, for inequalities, VAL is no good; but if the signed
1831 comparison had *any* fixed result, it follows that the
1832 unsigned comparison just tests the sign in reverse
1833 (positive values are LE, negative ones GE).
1834 So we can generate an unsigned comparison
1835 against an extreme value of the signed type. */
1837 if (unsignedp
&& !unsignedp0
)
1844 primop1
= TYPE_MIN_VALUE (type
);
1850 primop1
= TYPE_MAX_VALUE (type
);
1857 type
= unsigned_type (type
);
1860 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1862 /* This is the case of (char)x >?< 0x80, which people used to use
1863 expecting old C compilers to change the 0x80 into -0x80. */
1864 if (val
== boolean_false_node
)
1865 warning ("comparison is always false due to limited range of data type");
1866 if (val
== boolean_true_node
)
1867 warning ("comparison is always true due to limited range of data type");
1870 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1872 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1873 if (val
== boolean_false_node
)
1874 warning ("comparison is always false due to limited range of data type");
1875 if (val
== boolean_true_node
)
1876 warning ("comparison is always true due to limited range of data type");
1881 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1882 if (TREE_SIDE_EFFECTS (primop0
))
1883 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1887 /* Value is not predetermined, but do the comparison
1888 in the type of the operand that is not constant.
1889 TYPE is already properly set. */
1891 else if (real1
&& real2
1892 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1893 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1894 type
= TREE_TYPE (primop0
);
1896 /* If args' natural types are both narrower than nominal type
1897 and both extend in the same manner, compare them
1898 in the type of the wider arg.
1899 Otherwise must actually extend both to the nominal
1900 common type lest different ways of extending
1902 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1904 else if (unsignedp0
== unsignedp1
&& real1
== real2
1905 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1906 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1908 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1909 type
= signed_or_unsigned_type (unsignedp0
1910 || TREE_UNSIGNED (*restype_ptr
),
1912 /* Make sure shorter operand is extended the right way
1913 to match the longer operand. */
1914 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1916 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1921 /* Here we must do the comparison on the nominal type
1922 using the args exactly as we received them. */
1923 type
= *restype_ptr
;
1927 if (!real1
&& !real2
&& integer_zerop (primop1
)
1928 && TREE_UNSIGNED (*restype_ptr
))
1934 /* All unsigned values are >= 0, so we warn if extra warnings
1935 are requested. However, if OP0 is a constant that is
1936 >= 0, the signedness of the comparison isn't an issue,
1937 so suppress the warning. */
1938 if (extra_warnings
&& !in_system_header
1939 && ! (TREE_CODE (primop0
) == INTEGER_CST
1940 && ! TREE_OVERFLOW (convert (signed_type (type
),
1942 warning ("comparison of unsigned expression >= 0 is always true");
1943 value
= boolean_true_node
;
1947 if (extra_warnings
&& !in_system_header
1948 && ! (TREE_CODE (primop0
) == INTEGER_CST
1949 && ! TREE_OVERFLOW (convert (signed_type (type
),
1951 warning ("comparison of unsigned expression < 0 is always false");
1952 value
= boolean_false_node
;
1961 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1962 if (TREE_SIDE_EFFECTS (primop0
))
1963 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1970 *op0_ptr
= convert (type
, primop0
);
1971 *op1_ptr
= convert (type
, primop1
);
1973 *restype_ptr
= boolean_type_node
;
1978 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1979 or validate its data type for an `if' or `while' statement or ?..: exp.
1981 This preparation consists of taking the ordinary
1982 representation of an expression expr and producing a valid tree
1983 boolean expression describing whether expr is nonzero. We could
1984 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1985 but we optimize comparisons, &&, ||, and !.
1987 The resulting type should always be `boolean_type_node'. */
1990 truthvalue_conversion (expr
)
1993 if (TREE_CODE (expr
) == ERROR_MARK
)
1996 #if 0 /* This appears to be wrong for C++. */
1997 /* These really should return error_mark_node after 2.4 is stable.
1998 But not all callers handle ERROR_MARK properly. */
1999 switch (TREE_CODE (TREE_TYPE (expr
)))
2002 error ("struct type value used where scalar is required");
2003 return boolean_false_node
;
2006 error ("union type value used where scalar is required");
2007 return boolean_false_node
;
2010 error ("array type value used where scalar is required");
2011 return boolean_false_node
;
2018 switch (TREE_CODE (expr
))
2021 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2022 case TRUTH_ANDIF_EXPR
:
2023 case TRUTH_ORIF_EXPR
:
2024 case TRUTH_AND_EXPR
:
2026 case TRUTH_XOR_EXPR
:
2027 case TRUTH_NOT_EXPR
:
2028 TREE_TYPE (expr
) = boolean_type_node
;
2035 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2038 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2041 /* If we are taking the address of an external decl, it might be zero
2042 if it is weak, so we cannot optimize. */
2043 if (DECL_P (TREE_OPERAND (expr
, 0))
2044 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2047 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2048 return build (COMPOUND_EXPR
, boolean_type_node
,
2049 TREE_OPERAND (expr
, 0), boolean_true_node
);
2051 return boolean_true_node
;
2054 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2055 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2056 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2057 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2064 /* These don't change whether an object is non-zero or zero. */
2065 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2069 /* These don't change whether an object is zero or non-zero, but
2070 we can't ignore them if their second arg has side-effects. */
2071 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2072 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2073 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2075 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2078 /* Distribute the conversion into the arms of a COND_EXPR. */
2079 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2080 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2081 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2084 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2085 since that affects how `default_conversion' will behave. */
2086 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2087 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2089 /* fall through... */
2091 /* If this is widening the argument, we can ignore it. */
2092 if (TYPE_PRECISION (TREE_TYPE (expr
))
2093 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2094 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2098 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2100 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2101 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2103 /* fall through... */
2105 /* This and MINUS_EXPR can be changed into a comparison of the
2107 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2108 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2109 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2110 TREE_OPERAND (expr
, 1), 1);
2111 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2112 fold (build1 (NOP_EXPR
,
2113 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2114 TREE_OPERAND (expr
, 1))), 1);
2117 if (integer_onep (TREE_OPERAND (expr
, 1))
2118 && TREE_TYPE (expr
) != boolean_type_node
)
2119 /* Using convert here would cause infinite recursion. */
2120 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2124 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2125 warning ("suggest parentheses around assignment used as truth value");
2132 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2134 tree tem
= save_expr (expr
);
2135 return (build_binary_op
2136 ((TREE_SIDE_EFFECTS (expr
)
2137 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2138 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
2139 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
2143 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2146 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2147 int, enum built_in_class
, int, int,
2150 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2151 down to the element type of an array. */
2154 c_build_qualified_type (type
, type_quals
)
2158 /* A restrict-qualified pointer type must be a pointer to object or
2159 incomplete type. Note that the use of POINTER_TYPE_P also allows
2160 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2161 the C++ front-end also use POINTER_TYPE for pointer-to-member
2162 values, so even though it should be illegal to use `restrict'
2163 with such an entity we don't flag that here. Thus, special case
2164 code for that case is required in the C++ front-end. */
2165 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2166 && (!POINTER_TYPE_P (type
)
2167 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2169 error ("invalid use of `restrict'");
2170 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2173 if (TREE_CODE (type
) == ARRAY_TYPE
)
2174 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2176 TYPE_DOMAIN (type
));
2177 return build_qualified_type (type
, type_quals
);
2180 /* Apply the TYPE_QUALS to the new DECL. */
2183 c_apply_type_quals_to_decl (type_quals
, decl
)
2187 if ((type_quals
& TYPE_QUAL_CONST
)
2188 || (TREE_TYPE (decl
)
2189 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2190 TREE_READONLY (decl
) = 1;
2191 if (type_quals
& TYPE_QUAL_VOLATILE
)
2193 TREE_SIDE_EFFECTS (decl
) = 1;
2194 TREE_THIS_VOLATILE (decl
) = 1;
2196 if (type_quals
& TYPE_QUAL_RESTRICT
)
2198 if (!TREE_TYPE (decl
)
2199 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2200 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2201 error ("invalid use of `restrict'");
2202 else if (flag_strict_aliasing
)
2203 /* Indicate we need to make a unique alias set for this pointer.
2204 We can't do it here because it might be pointing to an
2206 DECL_POINTER_ALIAS_SET (decl
) = -2;
2211 /* Return the typed-based alias set for T, which may be an expression
2212 or a type. Return -1 if we don't do anything special. */
2215 c_common_get_alias_set (t
)
2220 /* We know nothing about vector types */
2221 if (TREE_CODE (t
) == VECTOR_TYPE
)
2224 /* Permit type-punning when accessing a union, provided the access
2225 is directly through the union. For example, this code does not
2226 permit taking the address of a union member and then storing
2227 through it. Even the type-punning allowed here is a GCC
2228 extension, albeit a common and useful one; the C standard says
2229 that such accesses have implementation-defined behavior. */
2231 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2232 u
= TREE_OPERAND (u
, 0))
2233 if (TREE_CODE (u
) == COMPONENT_REF
2234 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2237 /* If this is a char *, the ANSI C standard says it can alias
2238 anything. Note that all references need do this. */
2239 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2240 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2241 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2244 /* That's all the expressions we handle specially. */
2248 /* The C standard specifically allows aliasing between signed and
2249 unsigned variants of the same type. We treat the signed
2250 variant as canonical. */
2251 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2253 tree t1
= signed_type (t
);
2255 /* t1 == t can happen for boolean nodes which are always unsigned. */
2257 return get_alias_set (t1
);
2259 else if (POINTER_TYPE_P (t
))
2263 /* Unfortunately, there is no canonical form of a pointer type.
2264 In particular, if we have `typedef int I', then `int *', and
2265 `I *' are different types. So, we have to pick a canonical
2266 representative. We do this below.
2268 Technically, this approach is actually more conservative that
2269 it needs to be. In particular, `const int *' and `int *'
2270 should be in different alias sets, according to the C and C++
2271 standard, since their types are not the same, and so,
2272 technically, an `int **' and `const int **' cannot point at
2275 But, the standard is wrong. In particular, this code is
2280 const int* const* cipp = &ipp;
2282 And, it doesn't make sense for that to be legal unless you
2283 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2284 the pointed-to types. This issue has been reported to the
2286 t1
= build_type_no_quals (t
);
2288 return get_alias_set (t1
);
2294 /* Implement the __alignof keyword: Return the minimum required
2295 alignment of TYPE, measured in bytes. */
2301 enum tree_code code
= TREE_CODE (type
);
2304 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2305 if (code
== REFERENCE_TYPE
)
2307 type
= TREE_TYPE (type
);
2308 code
= TREE_CODE (type
);
2311 if (code
== FUNCTION_TYPE
)
2312 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2313 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
2315 else if (!COMPLETE_TYPE_P (type
))
2317 error ("__alignof__ applied to an incomplete type");
2321 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2323 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2326 /* Implement the __alignof keyword: Return the minimum required
2327 alignment of EXPR, measured in bytes. For VAR_DECL's and
2328 FIELD_DECL's return DECL_ALIGN (which can be set from an
2329 "aligned" __attribute__ specification). */
2332 c_alignof_expr (expr
)
2337 if (TREE_CODE (expr
) == VAR_DECL
)
2338 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2340 else if (TREE_CODE (expr
) == COMPONENT_REF
2341 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2343 error ("`__alignof' applied to a bit-field");
2346 else if (TREE_CODE (expr
) == COMPONENT_REF
2347 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2348 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2350 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2352 tree t
= TREE_OPERAND (expr
, 0);
2354 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2356 while (TREE_CODE (t
) == NOP_EXPR
2357 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2361 t
= TREE_OPERAND (t
, 0);
2362 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2363 if (thisalign
> bestalign
)
2364 best
= t
, bestalign
= thisalign
;
2366 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2369 return c_alignof (TREE_TYPE (expr
));
2371 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2374 /* Give the specifications for the format attributes, used by C and all
2377 static const struct attribute_spec c_format_attribute_table
[] =
2379 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2380 { "format", 3, 3, false, true, true,
2381 handle_format_attribute
},
2382 { "format_arg", 1, 1, false, true, true,
2383 handle_format_arg_attribute
},
2384 { NULL
, 0, 0, false, false, false, NULL
}
2387 /* Build tree nodes and builtin functions common to both C and C++ language
2391 c_common_nodes_and_builtins ()
2395 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2396 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2397 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2398 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2399 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2400 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2401 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2402 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2403 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2404 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2405 #include "builtin-types.def"
2406 #undef DEF_PRIMITIVE_TYPE
2407 #undef DEF_FUNCTION_TYPE_0
2408 #undef DEF_FUNCTION_TYPE_1
2409 #undef DEF_FUNCTION_TYPE_2
2410 #undef DEF_FUNCTION_TYPE_3
2411 #undef DEF_FUNCTION_TYPE_4
2412 #undef DEF_FUNCTION_TYPE_VAR_0
2413 #undef DEF_FUNCTION_TYPE_VAR_1
2414 #undef DEF_FUNCTION_TYPE_VAR_2
2415 #undef DEF_POINTER_TYPE
2419 typedef enum builtin_type builtin_type
;
2421 tree builtin_types
[(int) BT_LAST
];
2422 int wchar_type_size
;
2423 tree array_domain_type
;
2424 /* Either char* or void*. */
2425 tree traditional_ptr_type_node
;
2426 /* Either const char* or const void*. */
2427 tree traditional_cptr_type_node
;
2428 tree traditional_len_type_node
;
2429 tree va_list_ref_type_node
;
2430 tree va_list_arg_type_node
;
2432 /* We must initialize this before any builtin functions (which might have
2433 attributes) are declared. (c_common_init is too late.) */
2434 format_attribute_table
= c_format_attribute_table
;
2436 /* Define `int' and `char' first so that dbx will output them first. */
2437 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
2438 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2440 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2441 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2442 but not C. Are the conditionals here needed? */
2443 if (c_language
== clk_cplusplus
)
2444 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
2445 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2446 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2447 record_builtin_type (RID_MAX
, "long unsigned int",
2448 long_unsigned_type_node
);
2449 if (c_language
== clk_cplusplus
)
2450 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2451 record_builtin_type (RID_MAX
, "long long int",
2452 long_long_integer_type_node
);
2453 record_builtin_type (RID_MAX
, "long long unsigned int",
2454 long_long_unsigned_type_node
);
2455 if (c_language
== clk_cplusplus
)
2456 record_builtin_type (RID_MAX
, "long long unsigned",
2457 long_long_unsigned_type_node
);
2458 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2459 record_builtin_type (RID_MAX
, "short unsigned int",
2460 short_unsigned_type_node
);
2461 if (c_language
== clk_cplusplus
)
2462 record_builtin_type (RID_MAX
, "unsigned short",
2463 short_unsigned_type_node
);
2465 /* Define both `signed char' and `unsigned char'. */
2466 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2467 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2469 /* These are types that type_for_size and type_for_mode use. */
2470 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2471 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2472 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2473 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2474 #if HOST_BITS_PER_WIDE_INT >= 64
2475 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
2477 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2478 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2479 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2480 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2481 #if HOST_BITS_PER_WIDE_INT >= 64
2482 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
2485 /* Create the widest literal types. */
2486 widest_integer_literal_type_node
2487 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2488 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2489 widest_integer_literal_type_node
));
2491 widest_unsigned_literal_type_node
2492 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2493 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2494 widest_unsigned_literal_type_node
));
2496 /* `unsigned long' is the standard type for sizeof.
2497 Note that stddef.h uses `unsigned long',
2498 and this must agree, even if long and int are the same size. */
2500 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2501 signed_size_type_node
= signed_type (c_size_type_node
);
2502 if (flag_traditional
)
2503 c_size_type_node
= signed_size_type_node
;
2504 set_sizetype (c_size_type_node
);
2506 build_common_tree_nodes_2 (flag_short_double
);
2508 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
2509 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
2510 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2512 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2513 complex_integer_type_node
));
2514 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2515 complex_float_type_node
));
2516 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2517 complex_double_type_node
));
2518 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2519 complex_long_double_type_node
));
2521 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
2523 void_zero_node
= build_int_2 (0, 0);
2524 TREE_TYPE (void_zero_node
) = void_type_node
;
2526 void_list_node
= build_void_list_node ();
2528 /* Make a type to be the domain of a few array types
2529 whose domains don't really matter.
2530 200 is small enough that it always fits in size_t
2531 and large enough that it can hold most function names for the
2532 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2533 array_domain_type
= build_index_type (size_int (200));
2535 /* Make a type for arrays of characters.
2536 With luck nothing will ever really depend on the length of this
2538 char_array_type_node
2539 = build_array_type (char_type_node
, array_domain_type
);
2541 /* Likewise for arrays of ints. */
2543 = build_array_type (integer_type_node
, array_domain_type
);
2545 string_type_node
= build_pointer_type (char_type_node
);
2546 const_string_type_node
2547 = build_pointer_type (build_qualified_type
2548 (char_type_node
, TYPE_QUAL_CONST
));
2550 traditional_ptr_type_node
= ((flag_traditional
&&
2551 c_language
!= clk_cplusplus
)
2552 ? string_type_node
: ptr_type_node
);
2553 traditional_cptr_type_node
= ((flag_traditional
&&
2554 c_language
!= clk_cplusplus
)
2555 ? const_string_type_node
: const_ptr_type_node
);
2557 (*targetm
.init_builtins
) ();
2559 /* This is special for C++ so functions can be overloaded. */
2560 wchar_type_node
= get_identifier (flag_short_wchar
2561 ? "short unsigned int"
2563 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2564 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2565 if (c_language
== clk_cplusplus
)
2567 if (TREE_UNSIGNED (wchar_type_node
))
2568 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2570 wchar_type_node
= make_signed_type (wchar_type_size
);
2571 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2575 signed_wchar_type_node
= signed_type (wchar_type_node
);
2576 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2579 /* This is for wide string constants. */
2580 wchar_array_type_node
2581 = build_array_type (wchar_type_node
, array_domain_type
);
2584 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2587 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2589 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2591 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2593 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2594 unsigned_ptrdiff_type_node
= unsigned_type (ptrdiff_type_node
);
2596 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2597 va_list_type_node
));
2599 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2600 ptrdiff_type_node
));
2602 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2605 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2607 va_list_arg_type_node
= va_list_ref_type_node
=
2608 build_pointer_type (TREE_TYPE (va_list_type_node
));
2612 va_list_arg_type_node
= va_list_type_node
;
2613 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2616 traditional_len_type_node
= ((flag_traditional
&&
2617 c_language
!= clk_cplusplus
)
2618 ? integer_type_node
: sizetype
);
2620 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2621 builtin_types[(int) ENUM] = VALUE;
2622 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2623 builtin_types[(int) ENUM] \
2624 = build_function_type (builtin_types[(int) RETURN], \
2626 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2627 builtin_types[(int) ENUM] \
2628 = build_function_type (builtin_types[(int) RETURN], \
2629 tree_cons (NULL_TREE, \
2630 builtin_types[(int) ARG1], \
2632 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2633 builtin_types[(int) ENUM] \
2634 = build_function_type \
2635 (builtin_types[(int) RETURN], \
2636 tree_cons (NULL_TREE, \
2637 builtin_types[(int) ARG1], \
2638 tree_cons (NULL_TREE, \
2639 builtin_types[(int) ARG2], \
2641 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2642 builtin_types[(int) ENUM] \
2643 = build_function_type \
2644 (builtin_types[(int) RETURN], \
2645 tree_cons (NULL_TREE, \
2646 builtin_types[(int) ARG1], \
2647 tree_cons (NULL_TREE, \
2648 builtin_types[(int) ARG2], \
2649 tree_cons (NULL_TREE, \
2650 builtin_types[(int) ARG3], \
2652 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2653 builtin_types[(int) ENUM] \
2654 = build_function_type \
2655 (builtin_types[(int) RETURN], \
2656 tree_cons (NULL_TREE, \
2657 builtin_types[(int) ARG1], \
2658 tree_cons (NULL_TREE, \
2659 builtin_types[(int) ARG2], \
2662 builtin_types[(int) ARG3], \
2663 tree_cons (NULL_TREE, \
2664 builtin_types[(int) ARG4], \
2665 void_list_node)))));
2666 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2667 builtin_types[(int) ENUM] \
2668 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2669 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2670 builtin_types[(int) ENUM] \
2671 = build_function_type (builtin_types[(int) RETURN], \
2672 tree_cons (NULL_TREE, \
2673 builtin_types[(int) ARG1], \
2676 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2677 builtin_types[(int) ENUM] \
2678 = build_function_type \
2679 (builtin_types[(int) RETURN], \
2680 tree_cons (NULL_TREE, \
2681 builtin_types[(int) ARG1], \
2682 tree_cons (NULL_TREE, \
2683 builtin_types[(int) ARG2], \
2685 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2686 builtin_types[(int) ENUM] \
2687 = build_pointer_type (builtin_types[(int) TYPE]);
2688 #include "builtin-types.def"
2689 #undef DEF_PRIMITIVE_TYPE
2690 #undef DEF_FUNCTION_TYPE_1
2691 #undef DEF_FUNCTION_TYPE_2
2692 #undef DEF_FUNCTION_TYPE_3
2693 #undef DEF_FUNCTION_TYPE_4
2694 #undef DEF_FUNCTION_TYPE_VAR_0
2695 #undef DEF_FUNCTION_TYPE_VAR_1
2696 #undef DEF_POINTER_TYPE
2698 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2699 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2704 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2708 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2711 ? (NAME + strlen ("__builtin_")) \
2714 decl = builtin_function_2 (NAME, \
2715 NAME + strlen ("__builtin_"), \
2716 builtin_types[TYPE], \
2717 builtin_types[LIBTYPE], \
2722 /*noreturn_p=*/0); \
2724 built_in_decls[(int) ENUM] = decl; \
2726 #include "builtins.def"
2729 /* Declare _exit and _Exit just to mark them as non-returning. */
2730 builtin_function_2 (NULL
, "_exit", NULL_TREE
,
2731 builtin_types
[BT_FN_VOID_INT
],
2732 0, NOT_BUILT_IN
, 0, 1, 1);
2733 builtin_function_2 (NULL
, "_Exit", NULL_TREE
,
2734 builtin_types
[BT_FN_VOID_INT
],
2735 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
2737 /* Declare these functions non-returning
2738 to avoid spurious "control drops through" warnings. */
2739 builtin_function_2 (NULL
, "abort",
2740 NULL_TREE
, ((c_language
== clk_cplusplus
)
2741 ? builtin_types
[BT_FN_VOID
]
2742 : builtin_types
[BT_FN_VOID_VAR
]),
2743 0, NOT_BUILT_IN
, 0, 0, 1);
2745 builtin_function_2 (NULL
, "exit",
2746 NULL_TREE
, ((c_language
== clk_cplusplus
)
2747 ? builtin_types
[BT_FN_VOID_INT
]
2748 : builtin_types
[BT_FN_VOID_VAR
]),
2749 0, NOT_BUILT_IN
, 0, 0, 1);
2751 main_identifier_node
= get_identifier ("main");
2753 /* ??? Perhaps there's a better place to do this. But it is related
2754 to __builtin_va_arg, so it isn't that off-the-wall. */
2755 lang_type_promotes_to
= simple_type_promotes_to
;
2759 build_va_arg (expr
, type
)
2762 return build1 (VA_ARG_EXPR
, type
, expr
);
2766 /* Linked list of disabled built-in functions. */
2768 typedef struct disabled_builtin
2771 struct disabled_builtin
*next
;
2773 static disabled_builtin
*disabled_builtins
= NULL
;
2775 static bool builtin_function_disabled_p
PARAMS ((const char *));
2777 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2778 begins with "__builtin_", give an error. */
2781 disable_builtin_function (name
)
2784 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
2785 error ("cannot disable built-in function `%s'", name
);
2788 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
2790 new->next
= disabled_builtins
;
2791 disabled_builtins
= new;
2796 /* Return true if the built-in function NAME has been disabled, false
2800 builtin_function_disabled_p (name
)
2803 disabled_builtin
*p
;
2804 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
2806 if (strcmp (name
, p
->name
) == 0)
2813 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2814 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2815 of these may be NULL (though both being NULL is useless).
2816 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2817 TYPE is the type of the function with the ordinary name. These
2818 may differ if the ordinary name is declared with a looser type to avoid
2819 conflicts with headers. FUNCTION_CODE and CLASS are as for
2820 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2821 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2822 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2823 NORETURN_P is nonzero, the function is marked as non-returning.
2824 Returns the declaration of BUILTIN_NAME, if any, otherwise
2825 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2826 or if NONANSI_P and flag_no_nonansi_builtin. */
2829 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
2830 class, library_name_p
, nonansi_p
, noreturn_p
)
2831 const char *builtin_name
;
2836 enum built_in_class
class;
2841 tree bdecl
= NULL_TREE
;
2842 tree decl
= NULL_TREE
;
2843 if (builtin_name
!= 0)
2845 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
2846 class, library_name_p
? name
: NULL
);
2849 TREE_THIS_VOLATILE (bdecl
) = 1;
2850 TREE_SIDE_EFFECTS (bdecl
) = 1;
2853 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
2854 && !(nonansi_p
&& flag_no_nonansi_builtin
))
2856 decl
= builtin_function (name
, type
, function_code
, class, NULL
);
2858 DECL_BUILT_IN_NONANSI (decl
) = 1;
2861 TREE_THIS_VOLATILE (decl
) = 1;
2862 TREE_SIDE_EFFECTS (decl
) = 1;
2865 return (bdecl
!= 0 ? bdecl
: decl
);
2868 /* Nonzero if the type T promotes to int. This is (nearly) the
2869 integral promotions defined in ISO C99 6.3.1.1/2. */
2872 c_promoting_integer_type_p (t
)
2875 switch (TREE_CODE (t
))
2878 return (TYPE_MAIN_VARIANT (t
) == char_type_node
2879 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
2880 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
2881 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
2882 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
2883 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
2886 /* ??? Technically all enumerations not larger than an int
2887 promote to an int. But this is used along code paths
2888 that only want to notice a size change. */
2889 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
2899 /* Given a type, apply default promotions wrt unnamed function arguments
2900 and return the new type. Return NULL_TREE if no change. */
2901 /* ??? There is a function of the same name in the C++ front end that
2902 does something similar, but is more thorough and does not return NULL
2903 if no change. We could perhaps share code, but it would make the
2904 self_promoting_type property harder to identify. */
2907 simple_type_promotes_to (type
)
2910 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2911 return double_type_node
;
2913 if (c_promoting_integer_type_p (type
))
2915 /* Traditionally, unsignedness is preserved in default promotions.
2916 Also preserve unsignedness if not really getting any wider. */
2917 if (TREE_UNSIGNED (type
)
2918 && (flag_traditional
2919 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
2920 return unsigned_type_node
;
2921 return integer_type_node
;
2927 /* Return 1 if PARMS specifies a fixed number of parameters
2928 and none of their types is affected by default promotions. */
2931 self_promoting_args_p (parms
)
2935 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
2937 tree type
= TREE_VALUE (t
);
2939 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
2945 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2948 if (c_promoting_integer_type_p (type
))
2954 /* Recursively examines the array elements of TYPE, until a non-array
2955 element type is found. */
2958 strip_array_types (type
)
2961 while (TREE_CODE (type
) == ARRAY_TYPE
)
2962 type
= TREE_TYPE (type
);
2967 /* Recognize certain built-in functions so we can make tree-codes
2968 other than CALL_EXPR. We do this when it enables fold-const.c
2969 to do something useful. */
2970 /* ??? By rights this should go in builtins.c, but only C and C++
2971 implement build_{binary,unary}_op. Not exactly sure what bits
2972 of functionality are actually needed from those functions, or
2973 where the similar functionality exists in the other front ends. */
2976 expand_tree_builtin (function
, params
, coerced_params
)
2977 tree function
, params
, coerced_params
;
2979 enum tree_code code
;
2981 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
2984 switch (DECL_FUNCTION_CODE (function
))
2988 case BUILT_IN_LLABS
:
2989 case BUILT_IN_IMAXABS
:
2991 case BUILT_IN_FABSL
:
2992 case BUILT_IN_FABSF
:
2993 if (coerced_params
== 0)
2994 return integer_zero_node
;
2995 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2998 case BUILT_IN_CONJF
:
2999 case BUILT_IN_CONJL
:
3000 if (coerced_params
== 0)
3001 return integer_zero_node
;
3002 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3004 case BUILT_IN_CREAL
:
3005 case BUILT_IN_CREALF
:
3006 case BUILT_IN_CREALL
:
3007 if (coerced_params
== 0)
3008 return integer_zero_node
;
3009 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3011 case BUILT_IN_CIMAG
:
3012 case BUILT_IN_CIMAGF
:
3013 case BUILT_IN_CIMAGL
:
3014 if (coerced_params
== 0)
3015 return integer_zero_node
;
3016 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3018 case BUILT_IN_ISGREATER
:
3019 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3025 case BUILT_IN_ISGREATEREQUAL
:
3026 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3032 case BUILT_IN_ISLESS
:
3033 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3039 case BUILT_IN_ISLESSEQUAL
:
3040 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3046 case BUILT_IN_ISLESSGREATER
:
3047 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3053 case BUILT_IN_ISUNORDERED
:
3054 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
3055 return integer_zero_node
;
3056 code
= UNORDERED_EXPR
;
3064 || TREE_CHAIN (params
) == 0)
3066 error ("too few arguments to function `%s'",
3067 IDENTIFIER_POINTER (DECL_NAME (function
)));
3068 return error_mark_node
;
3070 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3072 error ("too many arguments to function `%s'",
3073 IDENTIFIER_POINTER (DECL_NAME (function
)));
3074 return error_mark_node
;
3077 arg0
= TREE_VALUE (params
);
3078 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3079 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
3080 if (code
!= UNORDERED_EXPR
)
3081 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
3093 /* Returns non-zero if CODE is the code for a statement. */
3096 statement_code_p (code
)
3097 enum tree_code code
;
3121 if (lang_statement_code_p
)
3122 return (*lang_statement_code_p
) (code
);
3127 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3128 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3129 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3130 value, the traversal is aborted, and the value returned by FUNC is
3131 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3132 the node being visited are not walked.
3134 We don't need a without_duplicates variant of this one because the
3135 statement tree is a tree, not a graph. */
3138 walk_stmt_tree (tp
, func
, data
)
3143 enum tree_code code
;
3148 #define WALK_SUBTREE(NODE) \
3151 result = walk_stmt_tree (&(NODE), func, data); \
3157 /* Skip empty subtrees. */
3161 /* Skip subtrees below non-statement nodes. */
3162 if (!statement_code_p (TREE_CODE (*tp
)))
3165 /* Call the function. */
3167 result
= (*func
) (tp
, &walk_subtrees
, data
);
3169 /* If we found something, return it. */
3173 /* FUNC may have modified the tree, recheck that we're looking at a
3175 code
= TREE_CODE (*tp
);
3176 if (!statement_code_p (code
))
3179 /* Visit the subtrees unless FUNC decided that there was nothing
3180 interesting below this point in the tree. */
3183 /* Walk over all the sub-trees of this operand. Statement nodes
3184 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3185 len
= TREE_CODE_LENGTH (code
);
3187 /* Go through the subtrees. We need to do this in forward order so
3188 that the scope of a FOR_EXPR is handled properly. */
3189 for (i
= 0; i
< len
; ++i
)
3190 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3193 /* Finally visit the chain. This can be tail-recursion optimized if
3194 we write it this way. */
3195 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3200 /* Used to compare case labels. K1 and K2 are actually tree nodes
3201 representing case labels, or NULL_TREE for a `default' label.
3202 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3203 K2, and 0 if K1 and K2 are equal. */
3206 case_compare (k1
, k2
)
3210 /* Consider a NULL key (such as arises with a `default' label) to be
3211 smaller than anything else. */
3217 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3220 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3221 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3222 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3223 case label was declared using the usual C/C++ syntax, rather than
3224 the GNU case range extension. CASES is a tree containing all the
3225 case ranges processed so far; COND is the condition for the
3226 switch-statement itself. Returns the CASE_LABEL created, or
3227 ERROR_MARK_NODE if no CASE_LABEL is created. */
3230 c_add_case_label (cases
, cond
, low_value
, high_value
)
3239 splay_tree_node node
;
3241 /* Create the LABEL_DECL itself. */
3242 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3243 DECL_CONTEXT (label
) = current_function_decl
;
3245 /* If there was an error processing the switch condition, bail now
3246 before we get more confused. */
3247 if (!cond
|| cond
== error_mark_node
)
3249 /* Add a label anyhow so that the back-end doesn't think that
3250 the beginning of the switch is unreachable. */
3252 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3253 return error_mark_node
;
3256 if ((low_value
&& TREE_TYPE (low_value
)
3257 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3258 || (high_value
&& TREE_TYPE (high_value
)
3259 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3260 error ("pointers are not permitted as case values");
3262 /* Case ranges are a GNU extension. */
3263 if (high_value
&& pedantic
)
3265 if (c_language
== clk_cplusplus
)
3266 pedwarn ("ISO C++ forbids range expressions in switch statements");
3268 pedwarn ("ISO C forbids range expressions in switch statements");
3271 type
= TREE_TYPE (cond
);
3274 low_value
= check_case_value (low_value
);
3275 low_value
= convert_and_check (type
, low_value
);
3279 high_value
= check_case_value (high_value
);
3280 high_value
= convert_and_check (type
, high_value
);
3283 /* If an error has occurred, bail out now. */
3284 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3287 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3288 return error_mark_node
;
3291 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3292 really a case range, even though it was written that way. Remove
3293 the HIGH_VALUE to simplify later processing. */
3294 if (tree_int_cst_equal (low_value
, high_value
))
3295 high_value
= NULL_TREE
;
3296 if (low_value
&& high_value
3297 && !tree_int_cst_lt (low_value
, high_value
))
3298 warning ("empty range specified");
3300 /* Look up the LOW_VALUE in the table of case labels we already
3302 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3303 /* If there was not an exact match, check for overlapping ranges.
3304 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3305 that's a `default' label and the only overlap is an exact match. */
3306 if (!node
&& (low_value
|| high_value
))
3308 splay_tree_node low_bound
;
3309 splay_tree_node high_bound
;
3311 /* Even though there wasn't an exact match, there might be an
3312 overlap between this case range and another case range.
3313 Since we've (inductively) not allowed any overlapping case
3314 ranges, we simply need to find the greatest low case label
3315 that is smaller that LOW_VALUE, and the smallest low case
3316 label that is greater than LOW_VALUE. If there is an overlap
3317 it will occur in one of these two ranges. */
3318 low_bound
= splay_tree_predecessor (cases
,
3319 (splay_tree_key
) low_value
);
3320 high_bound
= splay_tree_successor (cases
,
3321 (splay_tree_key
) low_value
);
3323 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3324 the LOW_VALUE, so there is no need to check unless the
3325 LOW_BOUND is in fact itself a case range. */
3327 && CASE_HIGH ((tree
) low_bound
->value
)
3328 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3331 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3332 range is bigger than the low end of the current range, so we
3333 are only interested if the current range is a real range, and
3334 not an ordinary case label. */
3337 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3342 /* If there was an overlap, issue an error. */
3345 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3349 error ("duplicate (or overlapping) case value");
3350 error_with_decl (duplicate
,
3351 "this is the first entry overlapping that value");
3355 error ("duplicate case value") ;
3356 error_with_decl (duplicate
, "previously used here");
3360 error ("multiple default labels in one switch");
3361 error_with_decl (duplicate
, "this is the first default label");
3364 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3367 /* Add a CASE_LABEL to the statement-tree. */
3368 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3369 /* Register this case label in the splay tree. */
3370 splay_tree_insert (cases
,
3371 (splay_tree_key
) low_value
,
3372 (splay_tree_value
) case_label
);
3377 /* Finish an expression taking the address of LABEL. Returns an
3378 expression for the address. */
3381 finish_label_address_expr (label
)
3388 if (c_language
== clk_cplusplus
)
3389 pedwarn ("ISO C++ forbids taking the address of a label");
3391 pedwarn ("ISO C forbids taking the address of a label");
3394 label
= lookup_label (label
);
3395 if (label
== NULL_TREE
)
3396 result
= null_pointer_node
;
3399 TREE_USED (label
) = 1;
3400 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3401 TREE_CONSTANT (result
) = 1;
3402 /* The current function in not necessarily uninlinable.
3403 Computed gotos are incompatible with inlining, but the value
3404 here could be used only in a diagnostic, for example. */
3410 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3411 parameter allows this function to be used as a GC-marking
3418 stmt_tree st
= (stmt_tree
) p
;
3420 ggc_mark_tree (st
->x_last_stmt
);
3421 ggc_mark_tree (st
->x_last_expr_type
);
3424 /* Mark LD for GC. */
3427 c_mark_lang_decl (c
)
3428 struct c_lang_decl
*c ATTRIBUTE_UNUSED
;
3432 /* Mark F for GC. */
3435 mark_c_language_function (f
)
3436 struct language_function
*f
;
3441 mark_stmt_tree (&f
->x_stmt_tree
);
3442 ggc_mark_tree (f
->x_scope_stmt_stack
);
3445 /* Hook used by expand_expr to expand language-specific tree codes. */
3448 c_expand_expr (exp
, target
, tmode
, modifier
)
3451 enum machine_mode tmode
;
3452 enum expand_modifier modifier
;
3454 switch (TREE_CODE (exp
))
3461 /* Since expand_expr_stmt calls free_temp_slots after every
3462 expression statement, we must call push_temp_slots here.
3463 Otherwise, any temporaries in use now would be considered
3464 out-of-scope after the first EXPR_STMT from within the
3467 rtl_expr
= expand_start_stmt_expr ();
3469 /* If we want the result of this expression, find the last
3470 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3471 if (target
!= const0_rtx
3472 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
3473 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
3475 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
3476 tree last
= TREE_CHAIN (expr
);
3478 while (TREE_CHAIN (last
))
3481 last
= TREE_CHAIN (last
);
3484 if (TREE_CODE (last
) == SCOPE_STMT
3485 && TREE_CODE (expr
) == EXPR_STMT
)
3486 TREE_ADDRESSABLE (expr
) = 1;
3489 expand_stmt (STMT_EXPR_STMT (exp
));
3490 expand_end_stmt_expr (rtl_expr
);
3491 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
3499 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3500 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3502 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3503 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3504 == BUILT_IN_FRONTEND
))
3505 return c_expand_builtin (exp
, target
, tmode
, modifier
);
3511 case COMPOUND_LITERAL_EXPR
:
3513 /* Initialize the anonymous variable declared in the compound
3514 literal, then return the variable. */
3515 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
3516 emit_local_var (decl
);
3517 return expand_expr (decl
, target
, tmode
, modifier
);
3528 /* Hook used by safe_from_p to handle language-specific tree codes. */
3531 c_safe_from_p (target
, exp
)
3535 /* We can see statements here when processing the body of a
3536 statement-expression. For a declaration statement declaring a
3537 variable, look at the variable's initializer. */
3538 if (TREE_CODE (exp
) == DECL_STMT
)
3540 tree decl
= DECL_STMT_DECL (exp
);
3542 if (TREE_CODE (decl
) == VAR_DECL
3543 && DECL_INITIAL (decl
)
3544 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
3548 /* For any statement, we must follow the statement-chain. */
3549 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
3550 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
3552 /* Assume everything else is safe. */
3556 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3559 c_unsafe_for_reeval (exp
)
3562 /* Statement expressions may not be reevaluated, likewise compound
3564 if (TREE_CODE (exp
) == STMT_EXPR
3565 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
3568 /* Walk all other expressions. */
3572 /* Hook used by staticp to handle language-specific tree codes. */
3578 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
3579 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
3584 /* Tree code classes. */
3586 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3588 static const char c_tree_code_type
[] = {
3590 #include "c-common.def"
3594 /* Table indexed by tree code giving number of expression
3595 operands beyond the fixed part of the node structure.
3596 Not used for types or decls. */
3598 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3600 static const int c_tree_code_length
[] = {
3602 #include "c-common.def"
3606 /* Names of tree components.
3607 Used for printing out the tree and error messages. */
3608 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3610 static const char *const c_tree_code_name
[] = {
3612 #include "c-common.def"
3616 /* Adds the tree codes specific to the C front end to the list of all
3622 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3624 (int) LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
);
3625 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3627 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
3628 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3630 (LAST_C_TREE_CODE
- (int) LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
3631 lang_unsafe_for_reeval
= c_unsafe_for_reeval
;
3634 #define CALLED_AS_BUILT_IN(NODE) \
3635 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3638 c_expand_builtin (exp
, target
, tmode
, modifier
)
3641 enum machine_mode tmode
;
3642 enum expand_modifier modifier
;
3644 tree type
= TREE_TYPE (exp
);
3645 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3646 tree arglist
= TREE_OPERAND (exp
, 1);
3647 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3648 enum tree_code code
= TREE_CODE (exp
);
3649 const int ignore
= (target
== const0_rtx
3650 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
3651 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
3652 || code
== COND_EXPR
)
3653 && TREE_CODE (type
) == VOID_TYPE
));
3655 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
3656 return expand_call (exp
, target
, ignore
);
3660 case BUILT_IN_PRINTF
:
3661 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3662 modifier
, ignore
, /*unlocked=*/ 0);
3667 case BUILT_IN_PRINTF_UNLOCKED
:
3668 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3669 modifier
, ignore
, /*unlocked=*/ 1);
3674 case BUILT_IN_FPRINTF
:
3675 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3676 modifier
, ignore
, /*unlocked=*/ 0);
3681 case BUILT_IN_FPRINTF_UNLOCKED
:
3682 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3683 modifier
, ignore
, /*unlocked=*/ 1);
3688 default: /* just do library call, if unknown builtin */
3689 error ("built-in function `%s' not currently supported",
3690 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3693 /* The switch statement above can drop through to cause the function
3694 to be called normally. */
3695 return expand_call (exp
, target
, ignore
);
3698 /* Check an arglist to *printf for problems. The arglist should start
3699 at the format specifier, with the remaining arguments immediately
3702 is_valid_printf_arglist (arglist
)
3705 /* Save this value so we can restore it later. */
3706 const int SAVE_pedantic
= pedantic
;
3707 int diagnostic_occurred
= 0;
3710 /* Set this to a known value so the user setting won't affect code
3713 /* Check to make sure there are no format specifier errors. */
3714 attrs
= tree_cons (get_identifier ("format"),
3715 tree_cons (NULL_TREE
,
3716 get_identifier ("printf"),
3717 tree_cons (NULL_TREE
,
3719 tree_cons (NULL_TREE
,
3723 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
3725 /* Restore the value of `pedantic'. */
3726 pedantic
= SAVE_pedantic
;
3728 /* If calling `check_function_format_ptr' produces a warning, we
3729 return false, otherwise we return true. */
3730 return ! diagnostic_occurred
;
3733 /* If the arguments passed to printf are suitable for optimizations,
3734 we attempt to transform the call. */
3736 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3739 enum machine_mode tmode
;
3740 enum expand_modifier modifier
;
3744 tree fn_putchar
= unlocked
?
3745 built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTCHAR
];
3746 tree fn_puts
= unlocked
?
3747 built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTS
];
3748 tree fn
, format_arg
, stripped_string
;
3750 /* If the return value is used, or the replacement _DECL isn't
3751 initialized, don't do the transformation. */
3752 if (!ignore
|| !fn_putchar
|| !fn_puts
)
3755 /* Verify the required arguments in the original call. */
3757 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
3760 /* Check the specifier vs. the parameters. */
3761 if (!is_valid_printf_arglist (arglist
))
3764 format_arg
= TREE_VALUE (arglist
);
3765 stripped_string
= format_arg
;
3766 STRIP_NOPS (stripped_string
);
3767 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3768 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3770 /* If the format specifier isn't a STRING_CST, punt. */
3771 if (TREE_CODE (stripped_string
) != STRING_CST
)
3774 /* OK! We can attempt optimization. */
3776 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3777 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
3779 arglist
= TREE_CHAIN (arglist
);
3782 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3783 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3785 arglist
= TREE_CHAIN (arglist
);
3790 /* We can't handle anything else with % args or %% ... yet. */
3791 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3794 /* If the resulting constant string has a length of 1, call
3795 putchar. Note, TREE_STRING_LENGTH includes the terminating
3796 NULL in its count. */
3797 if (TREE_STRING_LENGTH (stripped_string
) == 2)
3799 /* Given printf("c"), (where c is any one character,)
3800 convert "c"[0] to an int and pass that to the replacement
3802 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
3803 arglist
= build_tree_list (NULL_TREE
, arglist
);
3807 /* If the resulting constant was "string\n", call
3808 __builtin_puts("string"). Ensure "string" has at least one
3809 character besides the trailing \n. Note, TREE_STRING_LENGTH
3810 includes the terminating NULL in its count. */
3811 else if (TREE_STRING_LENGTH (stripped_string
) > 2
3812 && TREE_STRING_POINTER (stripped_string
)
3813 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
3815 /* Create a NULL-terminated string that's one char shorter
3816 than the original, stripping off the trailing '\n'. */
3817 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
3818 char *newstr
= (char *) alloca (newlen
);
3819 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
3820 newstr
[newlen
- 1] = 0;
3822 arglist
= combine_strings (build_string (newlen
, newstr
));
3823 arglist
= build_tree_list (NULL_TREE
, arglist
);
3827 /* We'd like to arrange to call fputs(string) here, but we
3828 need stdout and don't have a way to get it ... yet. */
3832 return expand_expr (build_function_call (fn
, arglist
),
3833 (ignore
? const0_rtx
: target
),
3837 /* If the arguments passed to fprintf are suitable for optimizations,
3838 we attempt to transform the call. */
3840 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
3843 enum machine_mode tmode
;
3844 enum expand_modifier modifier
;
3848 tree fn_fputc
= unlocked
?
3849 built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTC
];
3850 tree fn_fputs
= unlocked
?
3851 built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTS
];
3852 tree fn
, format_arg
, stripped_string
;
3854 /* If the return value is used, or the replacement _DECL isn't
3855 initialized, don't do the transformation. */
3856 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
3859 /* Verify the required arguments in the original call. */
3861 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
3862 || (TREE_CHAIN (arglist
) == 0)
3863 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
3867 /* Check the specifier vs. the parameters. */
3868 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
3871 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
3872 stripped_string
= format_arg
;
3873 STRIP_NOPS (stripped_string
);
3874 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3875 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3877 /* If the format specifier isn't a STRING_CST, punt. */
3878 if (TREE_CODE (stripped_string
) != STRING_CST
)
3881 /* OK! We can attempt optimization. */
3883 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3884 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
3886 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3887 arglist
= tree_cons (NULL_TREE
,
3888 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3892 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3893 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3895 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3896 arglist
= tree_cons (NULL_TREE
,
3897 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3903 /* We can't handle anything else with % args or %% ... yet. */
3904 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3907 /* When "string" doesn't contain %, replace all cases of
3908 fprintf(stream,string) with fputs(string,stream). The fputs
3909 builtin will take take of special cases like length==1. */
3910 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
3911 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
3915 return expand_expr (build_function_call (fn
, arglist
),
3916 (ignore
? const0_rtx
: target
),
3921 /* Given a boolean expression ARG, return a tree representing an increment
3922 or decrement (as indicated by CODE) of ARG. The front end must check for
3923 invalid cases (e.g., decrement in C++). */
3925 boolean_increment (code
, arg
)
3926 enum tree_code code
;
3930 tree true_res
= (c_language
== clk_cplusplus
3932 : c_bool_true_node
);
3933 arg
= stabilize_reference (arg
);
3936 case PREINCREMENT_EXPR
:
3937 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3939 case POSTINCREMENT_EXPR
:
3940 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3941 arg
= save_expr (arg
);
3942 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3943 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3945 case PREDECREMENT_EXPR
:
3946 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3948 case POSTDECREMENT_EXPR
:
3949 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3950 arg
= save_expr (arg
);
3951 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3952 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3957 TREE_SIDE_EFFECTS (val
) = 1;
3961 /* Handle C and C++ default attributes. */
3963 enum built_in_attribute
3965 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3966 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3967 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3968 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3969 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3970 #include "builtin-attrs.def"
3971 #undef DEF_ATTR_NULL_TREE
3973 #undef DEF_ATTR_IDENT
3974 #undef DEF_ATTR_TREE_LIST
3979 static tree built_in_attributes
[(int) ATTR_LAST
];
3981 static bool c_attrs_initialized
= false;
3983 static void c_init_attributes
PARAMS ((void));
3985 /* Common initialization before parsing options. */
3987 c_common_init_options (lang
)
3988 enum c_language_kind lang
;
3991 parse_in
= cpp_create_reader (lang
== clk_c
? CLK_GNUC89
:
3992 lang
== clk_cplusplus
? CLK_GNUCXX
: CLK_OBJC
);
3994 /* Mark as "unspecified" (see c_common_post_options). */
3995 flag_bounds_check
= -1;
3998 /* Post-switch processing. */
4000 c_common_post_options ()
4002 cpp_post_options (parse_in
);
4004 /* Use tree inlining if possible. Function instrumentation is only
4005 done in the RTL level, so we disable tree inlining. */
4006 if (! flag_instrument_function_entry_exit
)
4008 if (!flag_no_inline
)
4010 flag_inline_trees
= 1;
4013 if (flag_inline_functions
)
4015 flag_inline_trees
= 2;
4016 flag_inline_functions
= 0;
4020 /* If still "unspecified", make it match -fbounded-pointers. */
4021 if (flag_bounds_check
== -1)
4022 flag_bounds_check
= flag_bounded_pointers
;
4024 /* Special format checking options don't work without -Wformat; warn if
4026 if (warn_format_y2k
&& !warn_format
)
4027 warning ("-Wformat-y2k ignored without -Wformat");
4028 if (warn_format_extra_args
&& !warn_format
)
4029 warning ("-Wformat-extra-args ignored without -Wformat");
4030 if (warn_format_nonliteral
&& !warn_format
)
4031 warning ("-Wformat-nonliteral ignored without -Wformat");
4032 if (warn_format_security
&& !warn_format
)
4033 warning ("-Wformat-security ignored without -Wformat");
4034 if (warn_missing_format_attribute
&& !warn_format
)
4035 warning ("-Wmissing-format-attribute ignored without -Wformat");
4038 /* Front end initialization common to C, ObjC and C++. */
4040 c_common_init (filename
)
4041 const char *filename
;
4043 /* Do this before initializing pragmas, as then cpplib's hash table
4045 filename
= init_c_lex (filename
);
4049 if (!c_attrs_initialized
)
4050 c_init_attributes ();
4055 /* Common finish hook for the C, ObjC and C++ front ends. */
4059 cpp_finish (parse_in
);
4061 /* For performance, avoid tearing down cpplib's internal structures.
4062 Call cpp_errors () instead of cpp_destroy (). */
4063 errorcount
+= cpp_errors (parse_in
);
4067 c_init_attributes ()
4069 /* Fill in the built_in_attributes array. */
4070 #define DEF_ATTR_NULL_TREE(ENUM) \
4071 built_in_attributes[(int) ENUM] = NULL_TREE;
4072 #define DEF_ATTR_INT(ENUM, VALUE) \
4073 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4074 #define DEF_ATTR_IDENT(ENUM, STRING) \
4075 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4076 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4077 built_in_attributes[(int) ENUM] \
4078 = tree_cons (built_in_attributes[(int) PURPOSE], \
4079 built_in_attributes[(int) VALUE], \
4080 built_in_attributes[(int) CHAIN]);
4081 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4082 #include "builtin-attrs.def"
4083 #undef DEF_ATTR_NULL_TREE
4085 #undef DEF_ATTR_IDENT
4086 #undef DEF_ATTR_TREE_LIST
4088 ggc_add_tree_root (built_in_attributes
, (int) ATTR_LAST
);
4089 c_attrs_initialized
= true;
4092 /* Depending on the name of DECL, apply default attributes to it. */
4095 c_common_insert_default_attributes (decl
)
4098 tree name
= DECL_NAME (decl
);
4100 if (!c_attrs_initialized
)
4101 c_init_attributes ();
4103 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4104 #define DEF_ATTR_INT(ENUM, VALUE)
4105 #define DEF_ATTR_IDENT(ENUM, STRING)
4106 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4107 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4108 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4109 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4110 ATTR_FLAG_BUILT_IN);
4111 #include "builtin-attrs.def"
4112 #undef DEF_ATTR_NULL_TREE
4114 #undef DEF_ATTR_IDENT
4115 #undef DEF_ATTR_TREE_LIST
4119 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4120 additionally give the location of the previous declaration DECL. */
4122 shadow_warning (msgid
, name
, decl
)
4126 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
4127 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4128 DECL_SOURCE_LINE (decl
),
4129 "shadowed declaration is here");