1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
37 cpp_reader
*parse_in
; /* Declared in c-lex.h. */
39 #undef WCHAR_TYPE_SIZE
40 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
42 /* We let tm.h override the types used here, to handle trivial differences
43 such as the choice of unsigned int or long unsigned int for size_t.
44 When machines start needing nontrivial differences in the size type,
45 it would be best to do something here to figure out automatically
46 from other information what type to use. */
49 #define SIZE_TYPE "long unsigned int"
53 #define WCHAR_TYPE "int"
57 #define PTRDIFF_TYPE "long int"
61 #define WINT_TYPE "unsigned int"
65 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
67 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
73 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
75 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
76 ? "long unsigned int" \
77 : "long long unsigned int"))
80 /* The following symbols are subsumed in the c_global_trees array, and
81 listed here individually for documentation purposes.
83 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
85 tree short_integer_type_node;
86 tree long_integer_type_node;
87 tree long_long_integer_type_node;
89 tree short_unsigned_type_node;
90 tree long_unsigned_type_node;
91 tree long_long_unsigned_type_node;
93 tree boolean_type_node;
94 tree boolean_false_node;
95 tree boolean_true_node;
97 tree ptrdiff_type_node;
99 tree unsigned_char_type_node;
100 tree signed_char_type_node;
101 tree wchar_type_node;
102 tree signed_wchar_type_node;
103 tree unsigned_wchar_type_node;
105 tree float_type_node;
106 tree double_type_node;
107 tree long_double_type_node;
109 tree complex_integer_type_node;
110 tree complex_float_type_node;
111 tree complex_double_type_node;
112 tree complex_long_double_type_node;
114 tree intQI_type_node;
115 tree intHI_type_node;
116 tree intSI_type_node;
117 tree intDI_type_node;
118 tree intTI_type_node;
120 tree unsigned_intQI_type_node;
121 tree unsigned_intHI_type_node;
122 tree unsigned_intSI_type_node;
123 tree unsigned_intDI_type_node;
124 tree unsigned_intTI_type_node;
126 tree widest_integer_literal_type_node;
127 tree widest_unsigned_literal_type_node;
129 Nodes for types `void *' and `const void *'.
131 tree ptr_type_node, const_ptr_type_node;
133 Nodes for types `char *' and `const char *'.
135 tree string_type_node, const_string_type_node;
137 Type `char[SOMENUMBER]'.
138 Used when an array of char is needed and the size is irrelevant.
140 tree char_array_type_node;
142 Type `int[SOMENUMBER]' or something like it.
143 Used when an array of int needed and the size is irrelevant.
145 tree int_array_type_node;
147 Type `wchar_t[SOMENUMBER]' or something like it.
148 Used when a wide string literal is created.
150 tree wchar_array_type_node;
152 Type `int ()' -- used for implicit declaration of functions.
154 tree default_function_type;
156 A VOID_TYPE node, packaged in a TREE_LIST.
160 The lazily created VAR_DECLS for __FUNCTION__, __PRETTY_FUNCTION__,
161 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
162 VAR_DECLS, but C++ does.)
164 tree function_name_decl_node;
165 tree pretty_function_name_declnode;
166 tree c99_function_name_decl_node;
168 Stack of nested function name VAR_DECLs.
170 tree saved_function_name_decls;
174 tree c_global_trees
[CTI_MAX
];
176 /* Nonzero means don't recognize the non-ANSI builtin functions. */
180 /* Nonzero means don't recognize the non-ANSI builtin functions.
183 int flag_no_nonansi_builtin
;
185 /* Nonzero means give `double' the same size as `float'. */
187 int flag_short_double
;
189 /* Nonzero means give `wchar_t' the same size as `short'. */
191 int flag_short_wchar
;
193 /* Nonzero means warn about possible violations of sequence point rules. */
195 int warn_sequence_point
;
197 /* Nonzero means to warn about compile-time division by zero. */
198 int warn_div_by_zero
= 1;
200 /* The elements of `ridpointers' are identifier nodes for the reserved
201 type names and storage classes. It is indexed by a RID_... value. */
204 tree (*make_fname_decl
) PARAMS ((tree
, int));
206 /* If non-NULL, the address of a language-specific function that
207 returns 1 for language-specific statement codes. */
208 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
210 /* If non-NULL, the address of a language-specific function that takes
211 any action required right before expand_function_end is called. */
212 void (*lang_expand_function_end
) PARAMS ((void));
214 /* If this variable is defined to a non-NULL value, it will be called
215 after the file has been completely parsed. */
216 void (*back_end_hook
) PARAMS ((tree
));
218 /* Nonzero means the expression being parsed will never be evaluated.
219 This is a count, since unevaluated expressions can nest. */
222 /* Information about how a function name is generated. */
225 tree
*const decl
; /* pointer to the VAR_DECL. */
226 const unsigned rid
; /* RID number for the identifier. */
227 const int pretty
; /* How pretty is it? */
230 /* The three ways of getting then name of the current function. */
232 const struct fname_var_t fname_vars
[] =
234 /* C99 compliant __func__, must be first. */
235 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
236 /* GCC __FUNCTION__ compliant. */
237 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
238 /* GCC __PRETTY_FUNCTION__ compliant. */
239 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
243 static int constant_fits_type_p
PARAMS ((tree
, tree
));
245 /* Keep a stack of if statements. We record the number of compound
246 statements seen up to the if keyword, as well as the line number
247 and file of the if. If a potentially ambiguous else is seen, that
248 fact is recorded; the warning is issued when we can be sure that
249 the enclosing if statement does not have an else branch. */
259 static if_elt
*if_stack
;
261 /* Amount of space in the if statement stack. */
262 static int if_stack_space
= 0;
265 static int if_stack_pointer
= 0;
267 /* Record the start of an if-then, and record the start of it
268 for ambiguous else detection. */
271 c_expand_start_cond (cond
, compstmt_count
)
277 /* Make sure there is enough space on the stack. */
278 if (if_stack_space
== 0)
281 if_stack
= (if_elt
*)xmalloc (10 * sizeof (if_elt
));
283 else if (if_stack_space
== if_stack_pointer
)
285 if_stack_space
+= 10;
286 if_stack
= (if_elt
*)xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
289 if_stmt
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
290 IF_COND (if_stmt
) = cond
;
293 /* Record this if statement. */
294 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
295 if_stack
[if_stack_pointer
].file
= input_filename
;
296 if_stack
[if_stack_pointer
].line
= lineno
;
297 if_stack
[if_stack_pointer
].needs_warning
= 0;
298 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
302 /* Called after the then-clause for an if-statement is processed. */
307 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
308 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
311 /* Record the end of an if-then. Optionally warn if a nested
312 if statement had an ambiguous else clause. */
318 if (if_stack
[if_stack_pointer
].needs_warning
)
319 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
320 if_stack
[if_stack_pointer
].line
,
321 "suggest explicit braces to avoid ambiguous `else'");
322 last_expr_type
= NULL_TREE
;
325 /* Called between the then-clause and the else-clause
326 of an if-then-else. */
329 c_expand_start_else ()
331 /* An ambiguous else warning must be generated for the enclosing if
332 statement, unless we see an else branch for that one, too. */
334 && if_stack_pointer
> 1
335 && (if_stack
[if_stack_pointer
- 1].compstmt_count
336 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
337 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
339 /* Even if a nested if statement had an else branch, it can't be
340 ambiguous if this one also has an else. So don't warn in that
341 case. Also don't warn for any if statements nested in this else. */
342 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
343 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
346 /* Called after the else-clause for an if-statement is processed. */
351 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
352 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
355 /* Push current bindings for the function name VAR_DECLS. */
361 tree saved
= NULL_TREE
;
363 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
365 tree decl
= *fname_vars
[ix
].decl
;
369 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
370 *fname_vars
[ix
].decl
= NULL_TREE
;
373 if (saved
|| saved_function_name_decls
)
374 /* Normally they'll have been NULL, so only push if we've got a
375 stack, or they are non-NULL. */
376 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
377 saved_function_name_decls
);
380 /* Finish up the current bindings, adding them into the
381 current function's statement tree. This is done by wrapping the
382 function's body in a COMPOUND_STMT containing these decls too. This
383 must be done _before_ finish_stmt_tree is called. If there is no
384 current function, we must be at file scope and no statements are
385 involved. Pop the previous bindings. */
388 finish_fname_decls ()
391 tree body
= NULL_TREE
;
392 tree stack
= saved_function_name_decls
;
394 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
395 body
= chainon (TREE_VALUE (stack
), body
);
399 /* They were called into existance, so add to statement tree. */
400 body
= chainon (body
,
401 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)));
402 body
= build_stmt (COMPOUND_STMT
, body
);
404 COMPOUND_STMT_NO_SCOPE (body
) = 1;
405 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)) = body
;
408 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
409 *fname_vars
[ix
].decl
= NULL_TREE
;
413 /* We had saved values, restore them. */
416 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
418 tree decl
= TREE_PURPOSE (saved
);
419 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
421 *fname_vars
[ix
].decl
= decl
;
423 stack
= TREE_CHAIN (stack
);
425 saved_function_name_decls
= stack
;
428 /* Return the text name of the current function, suitable prettified
432 fname_as_string (pretty_p
)
435 const char *name
= NULL
;
438 name
= (current_function_decl
439 ? (*decl_printable_name
) (current_function_decl
, 2)
441 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
442 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
448 /* Return the text name of the current function, formatted as
449 required by the supplied RID value. */
457 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
458 if (fname_vars
[ix
].rid
== rid
)
460 return fname_as_string (fname_vars
[ix
].pretty
);
463 /* Return the VAR_DECL for a const char array naming the current
464 function. If the VAR_DECL has not yet been created, create it
465 now. RID indicates how it should be formatted and IDENTIFIER_NODE
466 ID is its name (unfortunately C and C++ hold the RID values of
467 keywords in different places, so we can't derive RID from ID in
468 this language independant code. */
476 tree decl
= NULL_TREE
;
478 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
479 if (fname_vars
[ix
].rid
== rid
)
482 decl
= *fname_vars
[ix
].decl
;
485 tree saved_last_tree
= last_tree
;
487 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
488 if (last_tree
!= saved_last_tree
)
490 /* We created some statement tree for the decl. This belongs
491 at the start of the function, so remove it now and reinsert
492 it after the function is complete. */
493 tree stmts
= TREE_CHAIN (saved_last_tree
);
495 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
496 last_tree
= saved_last_tree
;
497 saved_function_name_decls
= tree_cons (decl
, stmts
,
498 saved_function_name_decls
);
500 *fname_vars
[ix
].decl
= decl
;
502 if (!ix
&& !current_function_decl
)
503 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
508 /* Given a chain of STRING_CST nodes,
509 concatenate them into one STRING_CST
510 and give it a suitable array-of-chars data type. */
513 combine_strings (strings
)
520 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
522 const int nchars_max
= flag_isoc99
? 4095 : 509;
524 if (TREE_CHAIN (strings
))
526 /* More than one in the chain, so concatenate. */
529 /* Don't include the \0 at the end of each substring,
530 except for the last one.
531 Count wide strings and ordinary strings separately. */
532 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
534 if (TREE_TYPE (t
) == wchar_array_type_node
)
536 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
540 length
+= (TREE_STRING_LENGTH (t
) - 1);
543 /* If anything is wide, the non-wides will be converted,
544 which makes them take more space. */
546 length
= length
* wchar_bytes
+ wide_length
;
550 /* Copy the individual strings into the new combined string.
551 If the combined string is wide, convert the chars to ints
552 for any individual strings that are not wide. */
555 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
557 int len
= (TREE_STRING_LENGTH (t
)
558 - ((TREE_TYPE (t
) == wchar_array_type_node
)
560 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
562 memcpy (q
, TREE_STRING_POINTER (t
), len
);
568 for (i
= 0; i
< len
; i
++)
570 if (BYTES_BIG_ENDIAN
)
572 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
574 *q
++ = TREE_STRING_POINTER (t
)[i
];
578 *q
++ = TREE_STRING_POINTER (t
)[i
];
579 for (j
=0; j
<(WCHAR_TYPE_SIZE
/ BITS_PER_UNIT
)-1; j
++)
588 for (i
= 0; i
< wchar_bytes
; i
++)
594 value
= build_string (length
, p
);
599 length
= TREE_STRING_LENGTH (value
);
600 if (TREE_TYPE (value
) == wchar_array_type_node
)
604 /* Compute the number of elements, for the array type. */
605 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
607 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
608 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
609 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
611 /* Create the array type for the string constant.
612 -Wwrite-strings says make the string constant an array of const char
613 so that copying it to a non-const pointer will get a warning.
614 For C++, this is the standard behavior. */
615 if (flag_const_strings
616 && (! flag_traditional
&& ! flag_writable_strings
))
619 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
622 = build_array_type (elements
,
623 build_index_type (build_int_2 (nchars
- 1, 0)));
627 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
628 build_index_type (build_int_2 (nchars
- 1, 0)));
630 TREE_CONSTANT (value
) = 1;
631 TREE_READONLY (value
) = ! flag_writable_strings
;
632 TREE_STATIC (value
) = 1;
636 static int is_valid_printf_arglist
PARAMS ((tree
));
637 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
638 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
639 enum expand_modifier
, int));
640 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
641 enum expand_modifier
, int));
643 /* Print a warning if a constant expression had overflow in folding.
644 Invoke this function on every expression that the language
645 requires to be a constant expression.
646 Note the ANSI C standard says it is erroneous for a
647 constant expression to overflow. */
650 constant_expression_warning (value
)
653 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
654 || TREE_CODE (value
) == COMPLEX_CST
)
655 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
656 pedwarn ("overflow in constant expression");
659 /* Print a warning if an expression had overflow in folding.
660 Invoke this function on every expression that
661 (1) appears in the source code, and
662 (2) might be a constant expression that overflowed, and
663 (3) is not already checked by convert_and_check;
664 however, do not invoke this function on operands of explicit casts. */
667 overflow_warning (value
)
670 if ((TREE_CODE (value
) == INTEGER_CST
671 || (TREE_CODE (value
) == COMPLEX_CST
672 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
673 && TREE_OVERFLOW (value
))
675 TREE_OVERFLOW (value
) = 0;
676 if (skip_evaluation
== 0)
677 warning ("integer overflow in expression");
679 else if ((TREE_CODE (value
) == REAL_CST
680 || (TREE_CODE (value
) == COMPLEX_CST
681 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
682 && TREE_OVERFLOW (value
))
684 TREE_OVERFLOW (value
) = 0;
685 if (skip_evaluation
== 0)
686 warning ("floating point overflow in expression");
690 /* Print a warning if a large constant is truncated to unsigned,
691 or if -Wconversion is used and a constant < 0 is converted to unsigned.
692 Invoke this function on every expression that might be implicitly
693 converted to an unsigned type. */
696 unsigned_conversion_warning (result
, operand
)
697 tree result
, operand
;
699 if (TREE_CODE (operand
) == INTEGER_CST
700 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
701 && TREE_UNSIGNED (TREE_TYPE (result
))
702 && skip_evaluation
== 0
703 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
705 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
706 /* This detects cases like converting -129 or 256 to unsigned char. */
707 warning ("large integer implicitly truncated to unsigned type");
708 else if (warn_conversion
)
709 warning ("negative integer implicitly converted to unsigned type");
713 /* Nonzero if constant C has a value that is permissible
714 for type TYPE (an INTEGER_TYPE). */
717 constant_fits_type_p (c
, type
)
720 if (TREE_CODE (c
) == INTEGER_CST
)
721 return int_fits_type_p (c
, type
);
723 c
= convert (type
, c
);
724 return !TREE_OVERFLOW (c
);
727 /* Convert EXPR to TYPE, warning about conversion problems with constants.
728 Invoke this function on every expression that is converted implicitly,
729 i.e. because of language rules and not because of an explicit cast. */
732 convert_and_check (type
, expr
)
735 tree t
= convert (type
, expr
);
736 if (TREE_CODE (t
) == INTEGER_CST
)
738 if (TREE_OVERFLOW (t
))
740 TREE_OVERFLOW (t
) = 0;
742 /* Do not diagnose overflow in a constant expression merely
743 because a conversion overflowed. */
744 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
746 /* No warning for converting 0x80000000 to int. */
747 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
748 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
749 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
750 /* If EXPR fits in the unsigned version of TYPE,
751 don't warn unless pedantic. */
753 || TREE_UNSIGNED (type
)
754 || ! constant_fits_type_p (expr
, unsigned_type (type
)))
755 && skip_evaluation
== 0)
756 warning ("overflow in implicit constant conversion");
759 unsigned_conversion_warning (t
, expr
);
764 /* A node in a list that describes references to variables (EXPR), which are
765 either read accesses if WRITER is zero, or write accesses, in which case
766 WRITER is the parent of EXPR. */
773 /* Used to implement a cache the results of a call to verify_tree. We only
774 use this for SAVE_EXPRs. */
777 struct tlist_cache
*next
;
778 struct tlist
*cache_before_sp
;
779 struct tlist
*cache_after_sp
;
783 /* Obstack to use when allocating tlist structures, and corresponding
785 static struct obstack tlist_obstack
;
786 static char *tlist_firstobj
= 0;
788 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
790 static struct tlist
*warned_ids
;
791 /* SAVE_EXPRs need special treatment. We process them only once and then
792 cache the results. */
793 static struct tlist_cache
*save_expr_cache
;
795 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
796 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
797 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
798 static int warning_candidate_p
PARAMS ((tree
));
799 static void warn_for_collisions
PARAMS ((struct tlist
*));
800 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
801 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
802 static void verify_sequence_points
PARAMS ((tree
));
804 /* Create a new struct tlist and fill in its fields. */
805 static struct tlist
*
806 new_tlist (next
, t
, writer
)
812 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
819 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
820 is nonnull, we ignore any node we find which has a writer equal to it. */
823 add_tlist (to
, add
, exclude_writer
, copy
)
831 struct tlist
*next
= add
->next
;
834 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
835 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
840 /* Merge the nodes of ADD into TO. This merging process is done so that for
841 each variable that already exists in TO, no new node is added; however if
842 there is a write access recorded in ADD, and an occurrence on TO is only
843 a read access, then the occurrence in TO will be modified to record the
847 merge_tlist (to
, add
, copy
)
852 struct tlist
**end
= to
;
861 struct tlist
*next
= add
->next
;
863 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
864 if (tmp2
->expr
== add
->expr
)
868 tmp2
->writer
= add
->writer
;
872 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
880 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
881 references in list LIST conflict with it, excluding reads if ONLY writers
885 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
886 tree written
, writer
;
892 /* Avoid duplicate warnings. */
893 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
894 if (tmp
->expr
== written
)
899 if (list
->expr
== written
900 && list
->writer
!= writer
901 && (! only_writes
|| list
->writer
))
903 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
904 warning ("operation on `%s' may be undefined",
905 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
911 /* Given a list LIST of references to variables, find whether any of these
912 can cause conflicts due to missing sequence points. */
915 warn_for_collisions (list
)
920 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
923 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
927 /* Return nonzero if X is a tree that can be verified by the sequence poitn
930 warning_candidate_p (x
)
933 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
936 /* Walk the tree X, and record accesses to variables. If X is written by the
937 parent tree, WRITER is the parent.
938 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
939 expression or its only operand forces a sequence point, then everything up
940 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
942 Once we return, we will have emitted warnings if any subexpression before
943 such a sequence point could be undefined. On a higher level, however, the
944 sequence point may not be relevant, and we'll merge the two lists.
946 Example: (b++, a) + b;
947 The call that processes the COMPOUND_EXPR will store the increment of B
948 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
949 processes the PLUS_EXPR will need to merge the two lists so that
950 eventually, all accesses end up on the same list (and we'll warn about the
951 unordered subexpressions b++ and b.
953 A note on merging. If we modify the former example so that our expression
956 care must be taken not simply to add all three expressions into the final
957 PNO_SP list. The function merge_tlist takes care of that by merging the
958 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
959 way, so that no more than one access to B is recorded. */
962 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
964 struct tlist
**pbefore_sp
, **pno_sp
;
967 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
971 /* X may be NULL if it is the operand of an empty statement expression
977 code
= TREE_CODE (x
);
978 class = TREE_CODE_CLASS (code
);
980 if (warning_candidate_p (x
))
982 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
992 case TRUTH_ANDIF_EXPR
:
993 case TRUTH_ORIF_EXPR
:
994 tmp_before
= tmp_nosp
= tmp_list3
= 0;
995 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
996 warn_for_collisions (tmp_nosp
);
997 merge_tlist (pbefore_sp
, tmp_before
, 0);
998 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
999 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1000 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1004 tmp_before
= tmp_list2
= 0;
1005 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1006 warn_for_collisions (tmp_list2
);
1007 merge_tlist (pbefore_sp
, tmp_before
, 0);
1008 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1010 tmp_list3
= tmp_nosp
= 0;
1011 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1012 warn_for_collisions (tmp_nosp
);
1013 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1015 tmp_list3
= tmp_list2
= 0;
1016 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1017 warn_for_collisions (tmp_list2
);
1018 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1019 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1020 two first, to avoid warning for (a ? b++ : b++). */
1021 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1022 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1025 case PREDECREMENT_EXPR
:
1026 case PREINCREMENT_EXPR
:
1027 case POSTDECREMENT_EXPR
:
1028 case POSTINCREMENT_EXPR
:
1029 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1033 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1034 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1035 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1036 /* Expressions inside the LHS are not ordered wrt. the sequence points
1037 in the RHS. Example:
1039 Despite the fact that the modification of "a" is in the before_sp
1040 list (tmp_before), it conflicts with the use of "a" in the LHS.
1041 We can handle this by adding the contents of tmp_list3
1042 to those of tmp_before, and redoing the collision warnings for that
1044 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1045 warn_for_collisions (tmp_before
);
1046 /* Exclude the LHS itself here; we first have to merge it into the
1047 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1048 didn't exclude the LHS, we'd get it twice, once as a read and once
1050 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1051 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1053 merge_tlist (pbefore_sp
, tmp_before
, 0);
1054 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1055 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1056 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1060 /* We need to warn about conflicts among arguments and conflicts between
1061 args and the function address. Side effects of the function address,
1062 however, are not ordered by the sequence point of the call. */
1063 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1064 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1065 if (TREE_OPERAND (x
, 1))
1066 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1067 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1068 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1069 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1070 warn_for_collisions (tmp_before
);
1071 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1075 /* Scan all the list, e.g. indices of multi dimensional array. */
1078 tmp_before
= tmp_nosp
= 0;
1079 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1080 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1081 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1088 struct tlist_cache
*t
;
1089 for (t
= save_expr_cache
; t
; t
= t
->next
)
1095 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1097 t
->next
= save_expr_cache
;
1099 save_expr_cache
= t
;
1101 tmp_before
= tmp_nosp
= 0;
1102 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1103 warn_for_collisions (tmp_nosp
);
1108 struct tlist
*t
= tmp_nosp
;
1110 merge_tlist (&tmp_list3
, t
, 0);
1112 t
->cache_before_sp
= tmp_before
;
1113 t
->cache_after_sp
= tmp_list3
;
1115 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1116 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1125 if (first_rtl_op (code
) == 0)
1127 x
= TREE_OPERAND (x
, 0);
1143 int max
= first_rtl_op (TREE_CODE (x
));
1144 for (lp
= 0; lp
< max
; lp
++)
1146 tmp_before
= tmp_nosp
= 0;
1147 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1148 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1149 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1156 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1160 verify_sequence_points (expr
)
1163 struct tlist
*before_sp
= 0, *after_sp
= 0;
1166 save_expr_cache
= 0;
1167 if (tlist_firstobj
== 0)
1169 gcc_obstack_init (&tlist_obstack
);
1170 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1173 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1174 warn_for_collisions (after_sp
);
1175 obstack_free (&tlist_obstack
, tlist_firstobj
);
1179 c_expand_expr_stmt (expr
)
1182 /* Do default conversion if safe and possibly important,
1183 in case within ({...}). */
1184 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1185 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1186 expr
= default_conversion (expr
);
1188 if (warn_sequence_point
)
1189 verify_sequence_points (expr
);
1191 if (TREE_TYPE (expr
) != error_mark_node
1192 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1193 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1194 error ("expression statement has incomplete type");
1196 last_expr_type
= TREE_TYPE (expr
);
1197 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1200 /* Validate the expression after `case' and apply default promotions. */
1203 check_case_value (value
)
1206 if (value
== NULL_TREE
)
1209 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1210 STRIP_TYPE_NOPS (value
);
1211 /* In C++, the following is allowed:
1214 switch (...) { case i: ... }
1216 So, we try to reduce the VALUE to a constant that way. */
1217 if (c_language
== clk_cplusplus
)
1219 value
= decl_constant_value (value
);
1220 STRIP_TYPE_NOPS (value
);
1221 value
= fold (value
);
1224 if (TREE_CODE (value
) != INTEGER_CST
1225 && value
!= error_mark_node
)
1227 error ("case label does not reduce to an integer constant");
1228 value
= error_mark_node
;
1231 /* Promote char or short to int. */
1232 value
= default_conversion (value
);
1234 constant_expression_warning (value
);
1239 /* Return an integer type with BITS bits of precision,
1240 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1243 type_for_size (bits
, unsignedp
)
1247 if (bits
== TYPE_PRECISION (integer_type_node
))
1248 return unsignedp
? unsigned_type_node
: integer_type_node
;
1250 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1251 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1253 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1254 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1256 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1257 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1259 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1260 return (unsignedp
? long_long_unsigned_type_node
1261 : long_long_integer_type_node
);
1263 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1264 return (unsignedp
? widest_unsigned_literal_type_node
1265 : widest_integer_literal_type_node
);
1267 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1268 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1270 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1271 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1273 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1274 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1276 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1277 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1282 /* Return a data type that has machine mode MODE.
1283 If the mode is an integer,
1284 then UNSIGNEDP selects between signed and unsigned types. */
1287 type_for_mode (mode
, unsignedp
)
1288 enum machine_mode mode
;
1291 if (mode
== TYPE_MODE (integer_type_node
))
1292 return unsignedp
? unsigned_type_node
: integer_type_node
;
1294 if (mode
== TYPE_MODE (signed_char_type_node
))
1295 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1297 if (mode
== TYPE_MODE (short_integer_type_node
))
1298 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1300 if (mode
== TYPE_MODE (long_integer_type_node
))
1301 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1303 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1304 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1306 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1307 return unsignedp
? widest_unsigned_literal_type_node
1308 : widest_integer_literal_type_node
;
1310 if (mode
== TYPE_MODE (intQI_type_node
))
1311 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1313 if (mode
== TYPE_MODE (intHI_type_node
))
1314 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1316 if (mode
== TYPE_MODE (intSI_type_node
))
1317 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1319 if (mode
== TYPE_MODE (intDI_type_node
))
1320 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1322 #if HOST_BITS_PER_WIDE_INT >= 64
1323 if (mode
== TYPE_MODE (intTI_type_node
))
1324 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1327 if (mode
== TYPE_MODE (float_type_node
))
1328 return float_type_node
;
1330 if (mode
== TYPE_MODE (double_type_node
))
1331 return double_type_node
;
1333 if (mode
== TYPE_MODE (long_double_type_node
))
1334 return long_double_type_node
;
1336 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1337 return build_pointer_type (char_type_node
);
1339 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1340 return build_pointer_type (integer_type_node
);
1342 #ifdef VECTOR_MODE_SUPPORTED_P
1343 if (mode
== TYPE_MODE (V4SF_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1344 return V4SF_type_node
;
1345 if (mode
== TYPE_MODE (V4SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1346 return V4SI_type_node
;
1347 if (mode
== TYPE_MODE (V2SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1348 return V2SI_type_node
;
1349 if (mode
== TYPE_MODE (V4HI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1350 return V4HI_type_node
;
1351 if (mode
== TYPE_MODE (V8QI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1352 return V8QI_type_node
;
1353 if (mode
== TYPE_MODE (V2SF_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1354 return V2SF_type_node
;
1360 /* Return an unsigned type the same as TYPE in other respects. */
1362 unsigned_type (type
)
1365 tree type1
= TYPE_MAIN_VARIANT (type
);
1366 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1367 return unsigned_char_type_node
;
1368 if (type1
== integer_type_node
)
1369 return unsigned_type_node
;
1370 if (type1
== short_integer_type_node
)
1371 return short_unsigned_type_node
;
1372 if (type1
== long_integer_type_node
)
1373 return long_unsigned_type_node
;
1374 if (type1
== long_long_integer_type_node
)
1375 return long_long_unsigned_type_node
;
1376 if (type1
== widest_integer_literal_type_node
)
1377 return widest_unsigned_literal_type_node
;
1378 #if HOST_BITS_PER_WIDE_INT >= 64
1379 if (type1
== intTI_type_node
)
1380 return unsigned_intTI_type_node
;
1382 if (type1
== intDI_type_node
)
1383 return unsigned_intDI_type_node
;
1384 if (type1
== intSI_type_node
)
1385 return unsigned_intSI_type_node
;
1386 if (type1
== intHI_type_node
)
1387 return unsigned_intHI_type_node
;
1388 if (type1
== intQI_type_node
)
1389 return unsigned_intQI_type_node
;
1391 return signed_or_unsigned_type (1, type
);
1394 /* Return a signed type the same as TYPE in other respects. */
1400 tree type1
= TYPE_MAIN_VARIANT (type
);
1401 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1402 return signed_char_type_node
;
1403 if (type1
== unsigned_type_node
)
1404 return integer_type_node
;
1405 if (type1
== short_unsigned_type_node
)
1406 return short_integer_type_node
;
1407 if (type1
== long_unsigned_type_node
)
1408 return long_integer_type_node
;
1409 if (type1
== long_long_unsigned_type_node
)
1410 return long_long_integer_type_node
;
1411 if (type1
== widest_unsigned_literal_type_node
)
1412 return widest_integer_literal_type_node
;
1413 #if HOST_BITS_PER_WIDE_INT >= 64
1414 if (type1
== unsigned_intTI_type_node
)
1415 return intTI_type_node
;
1417 if (type1
== unsigned_intDI_type_node
)
1418 return intDI_type_node
;
1419 if (type1
== unsigned_intSI_type_node
)
1420 return intSI_type_node
;
1421 if (type1
== unsigned_intHI_type_node
)
1422 return intHI_type_node
;
1423 if (type1
== unsigned_intQI_type_node
)
1424 return intQI_type_node
;
1426 return signed_or_unsigned_type (0, type
);
1429 /* Return a type the same as TYPE except unsigned or
1430 signed according to UNSIGNEDP. */
1433 signed_or_unsigned_type (unsignedp
, type
)
1437 if (! INTEGRAL_TYPE_P (type
)
1438 || TREE_UNSIGNED (type
) == unsignedp
)
1441 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1442 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1443 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1444 return unsignedp
? unsigned_type_node
: integer_type_node
;
1445 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1446 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1447 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1448 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1449 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1450 return (unsignedp
? long_long_unsigned_type_node
1451 : long_long_integer_type_node
);
1452 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1453 return (unsignedp
? widest_unsigned_literal_type_node
1454 : widest_integer_literal_type_node
);
1456 #if HOST_BITS_PER_WIDE_INT >= 64
1457 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
1458 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1460 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
1461 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1462 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
1463 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1464 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
1465 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1466 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
1467 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1472 /* Return the minimum number of bits needed to represent VALUE in a
1473 signed or unsigned type, UNSIGNEDP says which. */
1476 min_precision (value
, unsignedp
)
1482 /* If the value is negative, compute its negative minus 1. The latter
1483 adjustment is because the absolute value of the largest negative value
1484 is one larger than the largest positive value. This is equivalent to
1485 a bit-wise negation, so use that operation instead. */
1487 if (tree_int_cst_sgn (value
) < 0)
1488 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1490 /* Return the number of bits needed, taking into account the fact
1491 that we need one more bit for a signed than unsigned type. */
1493 if (integer_zerop (value
))
1496 log
= tree_floor_log2 (value
);
1498 return log
+ 1 + ! unsignedp
;
1501 /* Print an error message for invalid operands to arith operation CODE.
1502 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1505 binary_op_error (code
)
1506 enum tree_code code
;
1513 error ("invalid truth-value expression");
1517 opname
= "+"; break;
1519 opname
= "-"; break;
1521 opname
= "*"; break;
1523 opname
= "max"; break;
1525 opname
= "min"; break;
1527 opname
= "=="; break;
1529 opname
= "!="; break;
1531 opname
= "<="; break;
1533 opname
= ">="; break;
1535 opname
= "<"; break;
1537 opname
= ">"; break;
1539 opname
= "<<"; break;
1541 opname
= ">>"; break;
1542 case TRUNC_MOD_EXPR
:
1543 case FLOOR_MOD_EXPR
:
1544 opname
= "%"; break;
1545 case TRUNC_DIV_EXPR
:
1546 case FLOOR_DIV_EXPR
:
1547 opname
= "/"; break;
1549 opname
= "&"; break;
1551 opname
= "|"; break;
1552 case TRUTH_ANDIF_EXPR
:
1553 opname
= "&&"; break;
1554 case TRUTH_ORIF_EXPR
:
1555 opname
= "||"; break;
1557 opname
= "^"; break;
1560 opname
= "rotate"; break;
1562 opname
= "unknown"; break;
1564 error ("invalid operands to binary %s", opname
);
1567 /* Subroutine of build_binary_op, used for comparison operations.
1568 See if the operands have both been converted from subword integer types
1569 and, if so, perhaps change them both back to their original type.
1570 This function is also responsible for converting the two operands
1571 to the proper common type for comparison.
1573 The arguments of this function are all pointers to local variables
1574 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1575 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1577 If this function returns nonzero, it means that the comparison has
1578 a constant value. What this function returns is an expression for
1582 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1583 tree
*op0_ptr
, *op1_ptr
;
1585 enum tree_code
*rescode_ptr
;
1588 tree op0
= *op0_ptr
;
1589 tree op1
= *op1_ptr
;
1590 int unsignedp0
, unsignedp1
;
1592 tree primop0
, primop1
;
1593 enum tree_code code
= *rescode_ptr
;
1595 /* Throw away any conversions to wider types
1596 already present in the operands. */
1598 primop0
= get_narrower (op0
, &unsignedp0
);
1599 primop1
= get_narrower (op1
, &unsignedp1
);
1601 /* Handle the case that OP0 does not *contain* a conversion
1602 but it *requires* conversion to FINAL_TYPE. */
1604 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1605 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1606 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1607 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1609 /* If one of the operands must be floated, we cannot optimize. */
1610 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1611 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1613 /* If first arg is constant, swap the args (changing operation
1614 so value is preserved), for canonicalization. Don't do this if
1615 the second arg is 0. */
1617 if (TREE_CONSTANT (primop0
)
1618 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1621 int temi
= unsignedp0
;
1629 unsignedp0
= unsignedp1
;
1652 *rescode_ptr
= code
;
1655 /* If comparing an integer against a constant more bits wide,
1656 maybe we can deduce a value of 1 or 0 independent of the data.
1657 Or else truncate the constant now
1658 rather than extend the variable at run time.
1660 This is only interesting if the constant is the wider arg.
1661 Also, it is not safe if the constant is unsigned and the
1662 variable arg is signed, since in this case the variable
1663 would be sign-extended and then regarded as unsigned.
1664 Our technique fails in this case because the lowest/highest
1665 possible unsigned results don't follow naturally from the
1666 lowest/highest possible values of the variable operand.
1667 For just EQ_EXPR and NE_EXPR there is another technique that
1668 could be used: see if the constant can be faithfully represented
1669 in the other operand's type, by truncating it and reextending it
1670 and see if that preserves the constant's value. */
1672 if (!real1
&& !real2
1673 && TREE_CODE (primop1
) == INTEGER_CST
1674 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1676 int min_gt
, max_gt
, min_lt
, max_lt
;
1677 tree maxval
, minval
;
1678 /* 1 if comparison is nominally unsigned. */
1679 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1682 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1684 /* If TYPE is an enumeration, then we need to get its min/max
1685 values from it's underlying integral type, not the enumerated
1687 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1688 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
1690 maxval
= TYPE_MAX_VALUE (type
);
1691 minval
= TYPE_MIN_VALUE (type
);
1693 if (unsignedp
&& !unsignedp0
)
1694 *restype_ptr
= signed_type (*restype_ptr
);
1696 if (TREE_TYPE (primop1
) != *restype_ptr
)
1697 primop1
= convert (*restype_ptr
, primop1
);
1698 if (type
!= *restype_ptr
)
1700 minval
= convert (*restype_ptr
, minval
);
1701 maxval
= convert (*restype_ptr
, maxval
);
1704 if (unsignedp
&& unsignedp0
)
1706 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1707 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1708 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1709 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1713 min_gt
= INT_CST_LT (primop1
, minval
);
1714 max_gt
= INT_CST_LT (primop1
, maxval
);
1715 min_lt
= INT_CST_LT (minval
, primop1
);
1716 max_lt
= INT_CST_LT (maxval
, primop1
);
1720 /* This used to be a switch, but Genix compiler can't handle that. */
1721 if (code
== NE_EXPR
)
1723 if (max_lt
|| min_gt
)
1724 val
= boolean_true_node
;
1726 else if (code
== EQ_EXPR
)
1728 if (max_lt
|| min_gt
)
1729 val
= boolean_false_node
;
1731 else if (code
== LT_EXPR
)
1734 val
= boolean_true_node
;
1736 val
= boolean_false_node
;
1738 else if (code
== GT_EXPR
)
1741 val
= boolean_true_node
;
1743 val
= boolean_false_node
;
1745 else if (code
== LE_EXPR
)
1748 val
= boolean_true_node
;
1750 val
= boolean_false_node
;
1752 else if (code
== GE_EXPR
)
1755 val
= boolean_true_node
;
1757 val
= boolean_false_node
;
1760 /* If primop0 was sign-extended and unsigned comparison specd,
1761 we did a signed comparison above using the signed type bounds.
1762 But the comparison we output must be unsigned.
1764 Also, for inequalities, VAL is no good; but if the signed
1765 comparison had *any* fixed result, it follows that the
1766 unsigned comparison just tests the sign in reverse
1767 (positive values are LE, negative ones GE).
1768 So we can generate an unsigned comparison
1769 against an extreme value of the signed type. */
1771 if (unsignedp
&& !unsignedp0
)
1778 primop1
= TYPE_MIN_VALUE (type
);
1784 primop1
= TYPE_MAX_VALUE (type
);
1791 type
= unsigned_type (type
);
1794 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1796 /* This is the case of (char)x >?< 0x80, which people used to use
1797 expecting old C compilers to change the 0x80 into -0x80. */
1798 if (val
== boolean_false_node
)
1799 warning ("comparison is always false due to limited range of data type");
1800 if (val
== boolean_true_node
)
1801 warning ("comparison is always true due to limited range of data type");
1804 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1806 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1807 if (val
== boolean_false_node
)
1808 warning ("comparison is always false due to limited range of data type");
1809 if (val
== boolean_true_node
)
1810 warning ("comparison is always true due to limited range of data type");
1815 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1816 if (TREE_SIDE_EFFECTS (primop0
))
1817 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1821 /* Value is not predetermined, but do the comparison
1822 in the type of the operand that is not constant.
1823 TYPE is already properly set. */
1825 else if (real1
&& real2
1826 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1827 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1828 type
= TREE_TYPE (primop0
);
1830 /* If args' natural types are both narrower than nominal type
1831 and both extend in the same manner, compare them
1832 in the type of the wider arg.
1833 Otherwise must actually extend both to the nominal
1834 common type lest different ways of extending
1836 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1838 else if (unsignedp0
== unsignedp1
&& real1
== real2
1839 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1840 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1842 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1843 type
= signed_or_unsigned_type (unsignedp0
1844 || TREE_UNSIGNED (*restype_ptr
),
1846 /* Make sure shorter operand is extended the right way
1847 to match the longer operand. */
1848 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1850 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1855 /* Here we must do the comparison on the nominal type
1856 using the args exactly as we received them. */
1857 type
= *restype_ptr
;
1861 if (!real1
&& !real2
&& integer_zerop (primop1
)
1862 && TREE_UNSIGNED (*restype_ptr
))
1868 /* All unsigned values are >= 0, so we warn if extra warnings
1869 are requested. However, if OP0 is a constant that is
1870 >= 0, the signedness of the comparison isn't an issue,
1871 so suppress the warning. */
1872 if (extra_warnings
&& !in_system_header
1873 && ! (TREE_CODE (primop0
) == INTEGER_CST
1874 && ! TREE_OVERFLOW (convert (signed_type (type
),
1876 warning ("comparison of unsigned expression >= 0 is always true");
1877 value
= boolean_true_node
;
1881 if (extra_warnings
&& !in_system_header
1882 && ! (TREE_CODE (primop0
) == INTEGER_CST
1883 && ! TREE_OVERFLOW (convert (signed_type (type
),
1885 warning ("comparison of unsigned expression < 0 is always false");
1886 value
= boolean_false_node
;
1895 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1896 if (TREE_SIDE_EFFECTS (primop0
))
1897 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1904 *op0_ptr
= convert (type
, primop0
);
1905 *op1_ptr
= convert (type
, primop1
);
1907 *restype_ptr
= boolean_type_node
;
1912 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1913 or validate its data type for an `if' or `while' statement or ?..: exp.
1915 This preparation consists of taking the ordinary
1916 representation of an expression expr and producing a valid tree
1917 boolean expression describing whether expr is nonzero. We could
1918 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1919 but we optimize comparisons, &&, ||, and !.
1921 The resulting type should always be `boolean_type_node'. */
1924 truthvalue_conversion (expr
)
1927 if (TREE_CODE (expr
) == ERROR_MARK
)
1930 #if 0 /* This appears to be wrong for C++. */
1931 /* These really should return error_mark_node after 2.4 is stable.
1932 But not all callers handle ERROR_MARK properly. */
1933 switch (TREE_CODE (TREE_TYPE (expr
)))
1936 error ("struct type value used where scalar is required");
1937 return boolean_false_node
;
1940 error ("union type value used where scalar is required");
1941 return boolean_false_node
;
1944 error ("array type value used where scalar is required");
1945 return boolean_false_node
;
1952 switch (TREE_CODE (expr
))
1955 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
1956 case TRUTH_ANDIF_EXPR
:
1957 case TRUTH_ORIF_EXPR
:
1958 case TRUTH_AND_EXPR
:
1960 case TRUTH_XOR_EXPR
:
1961 case TRUTH_NOT_EXPR
:
1962 TREE_TYPE (expr
) = boolean_type_node
;
1969 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
1972 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
1975 /* If we are taking the address of an external decl, it might be zero
1976 if it is weak, so we cannot optimize. */
1977 if (DECL_P (TREE_OPERAND (expr
, 0))
1978 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
1981 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
1982 return build (COMPOUND_EXPR
, boolean_type_node
,
1983 TREE_OPERAND (expr
, 0), boolean_true_node
);
1985 return boolean_true_node
;
1988 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
1989 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
1990 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
1991 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
1998 /* These don't change whether an object is non-zero or zero. */
1999 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2003 /* These don't change whether an object is zero or non-zero, but
2004 we can't ignore them if their second arg has side-effects. */
2005 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2006 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2007 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2009 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2012 /* Distribute the conversion into the arms of a COND_EXPR. */
2013 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2014 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2015 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2018 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2019 since that affects how `default_conversion' will behave. */
2020 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2021 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2023 /* fall through... */
2025 /* If this is widening the argument, we can ignore it. */
2026 if (TYPE_PRECISION (TREE_TYPE (expr
))
2027 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2028 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2032 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2034 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2035 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2037 /* fall through... */
2039 /* This and MINUS_EXPR can be changed into a comparison of the
2041 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2042 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2043 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2044 TREE_OPERAND (expr
, 1), 1);
2045 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2046 fold (build1 (NOP_EXPR
,
2047 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2048 TREE_OPERAND (expr
, 1))), 1);
2051 if (integer_onep (TREE_OPERAND (expr
, 1))
2052 && TREE_TYPE (expr
) != boolean_type_node
)
2053 /* Using convert here would cause infinite recursion. */
2054 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2058 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2059 warning ("suggest parentheses around assignment used as truth value");
2066 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2068 tree tem
= save_expr (expr
);
2069 return (build_binary_op
2070 ((TREE_SIDE_EFFECTS (expr
)
2071 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2072 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
2073 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
2077 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2080 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2081 int, enum built_in_class
, int, int,
2084 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2085 down to the element type of an array. */
2088 c_build_qualified_type (type
, type_quals
)
2092 /* A restrict-qualified pointer type must be a pointer to object or
2093 incomplete type. Note that the use of POINTER_TYPE_P also allows
2094 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2095 the C++ front-end also use POINTER_TYPE for pointer-to-member
2096 values, so even though it should be illegal to use `restrict'
2097 with such an entity we don't flag that here. Thus, special case
2098 code for that case is required in the C++ front-end. */
2099 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2100 && (!POINTER_TYPE_P (type
)
2101 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2103 error ("invalid use of `restrict'");
2104 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2107 if (TREE_CODE (type
) == ARRAY_TYPE
)
2108 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2110 TYPE_DOMAIN (type
));
2111 return build_qualified_type (type
, type_quals
);
2114 /* Apply the TYPE_QUALS to the new DECL. */
2117 c_apply_type_quals_to_decl (type_quals
, decl
)
2121 if ((type_quals
& TYPE_QUAL_CONST
)
2122 || (TREE_TYPE (decl
)
2123 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2124 TREE_READONLY (decl
) = 1;
2125 if (type_quals
& TYPE_QUAL_VOLATILE
)
2127 TREE_SIDE_EFFECTS (decl
) = 1;
2128 TREE_THIS_VOLATILE (decl
) = 1;
2130 if (type_quals
& TYPE_QUAL_RESTRICT
)
2132 if (!TREE_TYPE (decl
)
2133 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2134 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2135 error ("invalid use of `restrict'");
2136 else if (flag_strict_aliasing
)
2137 /* Indicate we need to make a unique alias set for this pointer.
2138 We can't do it here because it might be pointing to an
2140 DECL_POINTER_ALIAS_SET (decl
) = -2;
2145 /* Return the typed-based alias set for T, which may be an expression
2146 or a type. Return -1 if we don't do anything special. */
2149 c_common_get_alias_set (t
)
2154 /* We know nothing about vector types */
2155 if (TREE_CODE (t
) == VECTOR_TYPE
)
2158 /* Permit type-punning when accessing a union, provided the access
2159 is directly through the union. For example, this code does not
2160 permit taking the address of a union member and then storing
2161 through it. Even the type-punning allowed here is a GCC
2162 extension, albeit a common and useful one; the C standard says
2163 that such accesses have implementation-defined behavior. */
2165 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2166 u
= TREE_OPERAND (u
, 0))
2167 if (TREE_CODE (u
) == COMPONENT_REF
2168 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2171 /* If this is a char *, the ANSI C standard says it can alias
2172 anything. Note that all references need do this. */
2173 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2174 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2175 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2178 /* That's all the expressions we handle specially. */
2182 /* The C standard specifically allows aliasing between signed and
2183 unsigned variants of the same type. We treat the signed
2184 variant as canonical. */
2185 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2187 tree t1
= signed_type (t
);
2189 /* t1 == t can happen for boolean nodes which are always unsigned. */
2191 return get_alias_set (t1
);
2193 else if (POINTER_TYPE_P (t
))
2197 /* Unfortunately, there is no canonical form of a pointer type.
2198 In particular, if we have `typedef int I', then `int *', and
2199 `I *' are different types. So, we have to pick a canonical
2200 representative. We do this below.
2202 Technically, this approach is actually more conservative that
2203 it needs to be. In particular, `const int *' and `int *'
2204 chould be in different alias sets, according to the C and C++
2205 standard, since their types are not the same, and so,
2206 technically, an `int **' and `const int **' cannot point at
2209 But, the standard is wrong. In particular, this code is
2214 const int* const* cipp = &ipp;
2216 And, it doesn't make sense for that to be legal unless you
2217 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2218 the pointed-to types. This issue has been reported to the
2220 t1
= build_type_no_quals (t
);
2222 return get_alias_set (t1
);
2228 /* Implement the __alignof keyword: Return the minimum required
2229 alignment of TYPE, measured in bytes. */
2235 enum tree_code code
= TREE_CODE (type
);
2238 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2239 if (code
== REFERENCE_TYPE
)
2241 type
= TREE_TYPE (type
);
2242 code
= TREE_CODE (type
);
2245 if (code
== FUNCTION_TYPE
)
2246 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2247 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
2249 else if (!COMPLETE_TYPE_P (type
))
2251 error ("__alignof__ applied to an incomplete type");
2255 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2257 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2260 /* Implement the __alignof keyword: Return the minimum required
2261 alignment of EXPR, measured in bytes. For VAR_DECL's and
2262 FIELD_DECL's return DECL_ALIGN (which can be set from an
2263 "aligned" __attribute__ specification). */
2266 c_alignof_expr (expr
)
2271 if (TREE_CODE (expr
) == VAR_DECL
)
2272 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2274 else if (TREE_CODE (expr
) == COMPONENT_REF
2275 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2277 error ("`__alignof' applied to a bit-field");
2280 else if (TREE_CODE (expr
) == COMPONENT_REF
2281 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2282 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2284 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2286 tree t
= TREE_OPERAND (expr
, 0);
2288 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2290 while (TREE_CODE (t
) == NOP_EXPR
2291 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2295 t
= TREE_OPERAND (t
, 0);
2296 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2297 if (thisalign
> bestalign
)
2298 best
= t
, bestalign
= thisalign
;
2300 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2303 return c_alignof (TREE_TYPE (expr
));
2305 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2308 /* Give the specifications for the format attributes, used by C and all
2311 static const struct attribute_spec c_format_attribute_table
[] =
2313 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2314 { "format", 3, 3, false, true, true,
2315 handle_format_attribute
},
2316 { "format_arg", 1, 1, false, true, true,
2317 handle_format_arg_attribute
},
2318 { NULL
, 0, 0, false, false, false, NULL
}
2321 /* Build tree nodes and builtin functions common to both C and C++ language
2325 c_common_nodes_and_builtins ()
2329 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2330 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2331 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2332 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2333 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2334 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2335 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2336 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2337 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2338 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2339 #include "builtin-types.def"
2340 #undef DEF_PRIMITIVE_TYPE
2341 #undef DEF_FUNCTION_TYPE_0
2342 #undef DEF_FUNCTION_TYPE_1
2343 #undef DEF_FUNCTION_TYPE_2
2344 #undef DEF_FUNCTION_TYPE_3
2345 #undef DEF_FUNCTION_TYPE_4
2346 #undef DEF_FUNCTION_TYPE_VAR_0
2347 #undef DEF_FUNCTION_TYPE_VAR_1
2348 #undef DEF_FUNCTION_TYPE_VAR_2
2349 #undef DEF_POINTER_TYPE
2353 typedef enum builtin_type builtin_type
;
2355 tree builtin_types
[(int)BT_LAST
];
2356 int wchar_type_size
;
2357 tree array_domain_type
;
2358 /* Either char* or void*. */
2359 tree traditional_ptr_type_node
;
2360 /* Either const char* or const void*. */
2361 tree traditional_cptr_type_node
;
2362 tree traditional_len_type_node
;
2363 tree va_list_ref_type_node
;
2364 tree va_list_arg_type_node
;
2366 /* We must initialize this before any builtin functions (which might have
2367 attributes) are declared. (c_common_lang_init is too late.) */
2368 format_attribute_table
= c_format_attribute_table
;
2370 /* Define `int' and `char' first so that dbx will output them first. */
2371 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
2372 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2374 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2375 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2376 but not C. Are the conditionals here needed? */
2377 if (c_language
== clk_cplusplus
)
2378 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
2379 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2380 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2381 record_builtin_type (RID_MAX
, "long unsigned int",
2382 long_unsigned_type_node
);
2383 if (c_language
== clk_cplusplus
)
2384 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2385 record_builtin_type (RID_MAX
, "long long int",
2386 long_long_integer_type_node
);
2387 record_builtin_type (RID_MAX
, "long long unsigned int",
2388 long_long_unsigned_type_node
);
2389 if (c_language
== clk_cplusplus
)
2390 record_builtin_type (RID_MAX
, "long long unsigned",
2391 long_long_unsigned_type_node
);
2392 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2393 record_builtin_type (RID_MAX
, "short unsigned int",
2394 short_unsigned_type_node
);
2395 if (c_language
== clk_cplusplus
)
2396 record_builtin_type (RID_MAX
, "unsigned short",
2397 short_unsigned_type_node
);
2399 /* Define both `signed char' and `unsigned char'. */
2400 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2401 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2403 /* These are types that type_for_size and type_for_mode use. */
2404 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2405 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2406 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2407 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2408 #if HOST_BITS_PER_WIDE_INT >= 64
2409 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
2411 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2412 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2413 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2414 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2415 #if HOST_BITS_PER_WIDE_INT >= 64
2416 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
2419 /* Create the widest literal types. */
2420 widest_integer_literal_type_node
2421 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2422 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2423 widest_integer_literal_type_node
));
2425 widest_unsigned_literal_type_node
2426 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2427 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2428 widest_unsigned_literal_type_node
));
2430 /* `unsigned long' is the standard type for sizeof.
2431 Note that stddef.h uses `unsigned long',
2432 and this must agree, even if long and int are the same size. */
2434 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2435 signed_size_type_node
= signed_type (c_size_type_node
);
2436 if (flag_traditional
)
2437 c_size_type_node
= signed_size_type_node
;
2438 set_sizetype (c_size_type_node
);
2440 build_common_tree_nodes_2 (flag_short_double
);
2442 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
2443 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
2444 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2446 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2447 complex_integer_type_node
));
2448 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2449 complex_float_type_node
));
2450 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2451 complex_double_type_node
));
2452 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2453 complex_long_double_type_node
));
2455 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
2457 void_zero_node
= build_int_2 (0, 0);
2458 TREE_TYPE (void_zero_node
) = void_type_node
;
2460 void_list_node
= build_void_list_node ();
2462 /* Make a type to be the domain of a few array types
2463 whose domains don't really matter.
2464 200 is small enough that it always fits in size_t
2465 and large enough that it can hold most function names for the
2466 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2467 array_domain_type
= build_index_type (size_int (200));
2469 /* Make a type for arrays of characters.
2470 With luck nothing will ever really depend on the length of this
2472 char_array_type_node
2473 = build_array_type (char_type_node
, array_domain_type
);
2475 /* Likewise for arrays of ints. */
2477 = build_array_type (integer_type_node
, array_domain_type
);
2479 string_type_node
= build_pointer_type (char_type_node
);
2480 const_string_type_node
2481 = build_pointer_type (build_qualified_type
2482 (char_type_node
, TYPE_QUAL_CONST
));
2484 traditional_ptr_type_node
= ((flag_traditional
&&
2485 c_language
!= clk_cplusplus
)
2486 ? string_type_node
: ptr_type_node
);
2487 traditional_cptr_type_node
= ((flag_traditional
&&
2488 c_language
!= clk_cplusplus
)
2489 ? const_string_type_node
: const_ptr_type_node
);
2491 (*targetm
.init_builtins
) ();
2493 /* This is special for C++ so functions can be overloaded. */
2494 wchar_type_node
= get_identifier (flag_short_wchar
2495 ? "short unsigned int"
2497 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2498 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2499 if (c_language
== clk_cplusplus
)
2501 if (TREE_UNSIGNED (wchar_type_node
))
2502 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2504 wchar_type_node
= make_signed_type (wchar_type_size
);
2505 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2509 signed_wchar_type_node
= signed_type (wchar_type_node
);
2510 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2513 /* This is for wide string constants. */
2514 wchar_array_type_node
2515 = build_array_type (wchar_type_node
, array_domain_type
);
2518 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2521 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2523 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2525 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2527 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2528 unsigned_ptrdiff_type_node
= unsigned_type (ptrdiff_type_node
);
2530 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2531 va_list_type_node
));
2533 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2534 ptrdiff_type_node
));
2536 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2539 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2541 va_list_arg_type_node
= va_list_ref_type_node
=
2542 build_pointer_type (TREE_TYPE (va_list_type_node
));
2546 va_list_arg_type_node
= va_list_type_node
;
2547 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2550 traditional_len_type_node
= ((flag_traditional
&&
2551 c_language
!= clk_cplusplus
)
2552 ? integer_type_node
: sizetype
);
2554 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2555 builtin_types[(int) ENUM] = VALUE;
2556 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2557 builtin_types[(int) ENUM] \
2558 = build_function_type (builtin_types[(int) RETURN], \
2560 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2561 builtin_types[(int) ENUM] \
2562 = build_function_type (builtin_types[(int) RETURN], \
2563 tree_cons (NULL_TREE, \
2564 builtin_types[(int) ARG1], \
2566 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2567 builtin_types[(int) ENUM] \
2568 = build_function_type \
2569 (builtin_types[(int) RETURN], \
2570 tree_cons (NULL_TREE, \
2571 builtin_types[(int) ARG1], \
2572 tree_cons (NULL_TREE, \
2573 builtin_types[(int) ARG2], \
2575 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2576 builtin_types[(int) ENUM] \
2577 = build_function_type \
2578 (builtin_types[(int) RETURN], \
2579 tree_cons (NULL_TREE, \
2580 builtin_types[(int) ARG1], \
2581 tree_cons (NULL_TREE, \
2582 builtin_types[(int) ARG2], \
2583 tree_cons (NULL_TREE, \
2584 builtin_types[(int) ARG3], \
2586 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2587 builtin_types[(int) ENUM] \
2588 = build_function_type \
2589 (builtin_types[(int) RETURN], \
2590 tree_cons (NULL_TREE, \
2591 builtin_types[(int) ARG1], \
2592 tree_cons (NULL_TREE, \
2593 builtin_types[(int) ARG2], \
2596 builtin_types[(int) ARG3], \
2597 tree_cons (NULL_TREE, \
2598 builtin_types[(int) ARG4], \
2599 void_list_node)))));
2600 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2601 builtin_types[(int) ENUM] \
2602 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2603 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2604 builtin_types[(int) ENUM] \
2605 = build_function_type (builtin_types[(int) RETURN], \
2606 tree_cons (NULL_TREE, \
2607 builtin_types[(int) ARG1], \
2610 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2611 builtin_types[(int) ENUM] \
2612 = build_function_type \
2613 (builtin_types[(int) RETURN], \
2614 tree_cons (NULL_TREE, \
2615 builtin_types[(int) ARG1], \
2616 tree_cons (NULL_TREE, \
2617 builtin_types[(int) ARG2], \
2619 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2620 builtin_types[(int) ENUM] \
2621 = build_pointer_type (builtin_types[(int) TYPE]);
2622 #include "builtin-types.def"
2623 #undef DEF_PRIMITIVE_TYPE
2624 #undef DEF_FUNCTION_TYPE_1
2625 #undef DEF_FUNCTION_TYPE_2
2626 #undef DEF_FUNCTION_TYPE_3
2627 #undef DEF_FUNCTION_TYPE_4
2628 #undef DEF_FUNCTION_TYPE_VAR_0
2629 #undef DEF_FUNCTION_TYPE_VAR_1
2630 #undef DEF_POINTER_TYPE
2632 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2633 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2638 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2642 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2645 ? (NAME + strlen ("__builtin_")) \
2648 decl = builtin_function_2 (NAME, \
2649 NAME + strlen ("__builtin_"), \
2650 builtin_types[TYPE], \
2651 builtin_types[LIBTYPE], \
2656 /*noreturn_p=*/0); \
2658 built_in_decls[(int) ENUM] = decl; \
2660 #include "builtins.def"
2663 /* Declare _exit and _Exit just to mark them as non-returning. */
2664 builtin_function_2 (NULL
, "_exit", NULL_TREE
,
2665 builtin_types
[BT_FN_VOID_INT
],
2666 0, NOT_BUILT_IN
, 0, 1, 1);
2667 builtin_function_2 (NULL
, "_Exit", NULL_TREE
,
2668 builtin_types
[BT_FN_VOID_INT
],
2669 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
2671 /* Declare these functions non-returning
2672 to avoid spurious "control drops through" warnings. */
2673 builtin_function_2 (NULL
, "abort",
2674 NULL_TREE
, ((c_language
== clk_cplusplus
)
2675 ? builtin_types
[BT_FN_VOID
]
2676 : builtin_types
[BT_FN_VOID_VAR
]),
2677 0, NOT_BUILT_IN
, 0, 0, 1);
2679 builtin_function_2 (NULL
, "exit",
2680 NULL_TREE
, ((c_language
== clk_cplusplus
)
2681 ? builtin_types
[BT_FN_VOID_INT
]
2682 : builtin_types
[BT_FN_VOID_VAR
]),
2683 0, NOT_BUILT_IN
, 0, 0, 1);
2685 main_identifier_node
= get_identifier ("main");
2687 /* ??? Perhaps there's a better place to do this. But it is related
2688 to __builtin_va_arg, so it isn't that off-the-wall. */
2689 lang_type_promotes_to
= simple_type_promotes_to
;
2693 build_va_arg (expr
, type
)
2696 return build1 (VA_ARG_EXPR
, type
, expr
);
2700 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2701 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2702 of these may be NULL (though both being NULL is useless).
2703 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2704 TYPE is the type of the function with the ordinary name. These
2705 may differ if the ordinary name is declared with a looser type to avoid
2706 conflicts with headers. FUNCTION_CODE and CLASS are as for
2707 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2708 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2709 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2710 NORETURN_P is nonzero, the function is marked as non-returning.
2711 Returns the declaration of BUILTIN_NAME, if any, otherwise
2712 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2713 or if NONANSI_P and flag_no_nonansi_builtin. */
2716 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
2717 class, library_name_p
, nonansi_p
, noreturn_p
)
2718 const char *builtin_name
;
2723 enum built_in_class
class;
2728 tree bdecl
= NULL_TREE
;
2729 tree decl
= NULL_TREE
;
2730 if (builtin_name
!= 0)
2732 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
2733 class, library_name_p
? name
: NULL
);
2736 TREE_THIS_VOLATILE (bdecl
) = 1;
2737 TREE_SIDE_EFFECTS (bdecl
) = 1;
2740 if (name
!= 0 && !flag_no_builtin
&& !(nonansi_p
&& flag_no_nonansi_builtin
))
2742 decl
= builtin_function (name
, type
, function_code
, class, NULL
);
2744 DECL_BUILT_IN_NONANSI (decl
) = 1;
2747 TREE_THIS_VOLATILE (decl
) = 1;
2748 TREE_SIDE_EFFECTS (decl
) = 1;
2751 return (bdecl
!= 0 ? bdecl
: decl
);
2754 /* Nonzero if the type T promotes to int. This is (nearly) the
2755 integral promotions defined in ISO C99 6.3.1.1/2. */
2758 c_promoting_integer_type_p (t
)
2761 switch (TREE_CODE (t
))
2764 return (TYPE_MAIN_VARIANT (t
) == char_type_node
2765 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
2766 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
2767 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
2768 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
2769 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
2772 /* ??? Technically all enumerations not larger than an int
2773 promote to an int. But this is used along code paths
2774 that only want to notice a size change. */
2775 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
2785 /* Given a type, apply default promotions wrt unnamed function arguments
2786 and return the new type. Return NULL_TREE if no change. */
2787 /* ??? There is a function of the same name in the C++ front end that
2788 does something similar, but is more thorough and does not return NULL
2789 if no change. We could perhaps share code, but it would make the
2790 self_promoting_type property harder to identify. */
2793 simple_type_promotes_to (type
)
2796 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2797 return double_type_node
;
2799 if (c_promoting_integer_type_p (type
))
2801 /* Traditionally, unsignedness is preserved in default promotions.
2802 Also preserve unsignedness if not really getting any wider. */
2803 if (TREE_UNSIGNED (type
)
2804 && (flag_traditional
2805 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
2806 return unsigned_type_node
;
2807 return integer_type_node
;
2813 /* Return 1 if PARMS specifies a fixed number of parameters
2814 and none of their types is affected by default promotions. */
2817 self_promoting_args_p (parms
)
2821 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
2823 tree type
= TREE_VALUE (t
);
2825 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
2831 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
2834 if (c_promoting_integer_type_p (type
))
2840 /* Recursively examines the array elements of TYPE, until a non-array
2841 element type is found. */
2844 strip_array_types (type
)
2847 while (TREE_CODE (type
) == ARRAY_TYPE
)
2848 type
= TREE_TYPE (type
);
2853 /* Recognize certain built-in functions so we can make tree-codes
2854 other than CALL_EXPR. We do this when it enables fold-const.c
2855 to do something useful. */
2856 /* ??? By rights this should go in builtins.c, but only C and C++
2857 implement build_{binary,unary}_op. Not exactly sure what bits
2858 of functionality are actually needed from those functions, or
2859 where the similar functionality exists in the other front ends. */
2862 expand_tree_builtin (function
, params
, coerced_params
)
2863 tree function
, params
, coerced_params
;
2865 enum tree_code code
;
2867 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
2870 switch (DECL_FUNCTION_CODE (function
))
2874 case BUILT_IN_LLABS
:
2875 case BUILT_IN_IMAXABS
:
2877 case BUILT_IN_FABSL
:
2878 case BUILT_IN_FABSF
:
2879 if (coerced_params
== 0)
2880 return integer_zero_node
;
2881 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
2884 case BUILT_IN_CONJF
:
2885 case BUILT_IN_CONJL
:
2886 if (coerced_params
== 0)
2887 return integer_zero_node
;
2888 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
2890 case BUILT_IN_CREAL
:
2891 case BUILT_IN_CREALF
:
2892 case BUILT_IN_CREALL
:
2893 if (coerced_params
== 0)
2894 return integer_zero_node
;
2895 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
2897 case BUILT_IN_CIMAG
:
2898 case BUILT_IN_CIMAGF
:
2899 case BUILT_IN_CIMAGL
:
2900 if (coerced_params
== 0)
2901 return integer_zero_node
;
2902 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
2904 case BUILT_IN_ISGREATER
:
2905 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
2911 case BUILT_IN_ISGREATEREQUAL
:
2912 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
2918 case BUILT_IN_ISLESS
:
2919 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
2925 case BUILT_IN_ISLESSEQUAL
:
2926 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
2932 case BUILT_IN_ISLESSGREATER
:
2933 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
2939 case BUILT_IN_ISUNORDERED
:
2940 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
2941 return integer_zero_node
;
2942 code
= UNORDERED_EXPR
;
2950 || TREE_CHAIN (params
) == 0)
2952 error ("too few arguments to function `%s'",
2953 IDENTIFIER_POINTER (DECL_NAME (function
)));
2954 return error_mark_node
;
2956 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
2958 error ("too many arguments to function `%s'",
2959 IDENTIFIER_POINTER (DECL_NAME (function
)));
2960 return error_mark_node
;
2963 arg0
= TREE_VALUE (params
);
2964 arg1
= TREE_VALUE (TREE_CHAIN (params
));
2965 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
2966 if (code
!= UNORDERED_EXPR
)
2967 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
2979 /* Returns non-zero if CODE is the code for a statement. */
2982 statement_code_p (code
)
2983 enum tree_code code
;
3006 if (lang_statement_code_p
)
3007 return (*lang_statement_code_p
) (code
);
3012 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3013 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3014 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3015 value, the traversal is aborted, and the value returned by FUNC is
3016 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3017 the node being visited are not walked.
3019 We don't need a without_duplicates variant of this one because the
3020 statement tree is a tree, not a graph. */
3023 walk_stmt_tree (tp
, func
, data
)
3028 enum tree_code code
;
3033 #define WALK_SUBTREE(NODE) \
3036 result = walk_stmt_tree (&(NODE), func, data); \
3042 /* Skip empty subtrees. */
3046 /* Skip subtrees below non-statement nodes. */
3047 if (!statement_code_p (TREE_CODE (*tp
)))
3050 /* Call the function. */
3052 result
= (*func
) (tp
, &walk_subtrees
, data
);
3054 /* If we found something, return it. */
3058 /* FUNC may have modified the tree, recheck that we're looking at a
3060 code
= TREE_CODE (*tp
);
3061 if (!statement_code_p (code
))
3064 /* Visit the subtrees unless FUNC decided that there was nothing
3065 interesting below this point in the tree. */
3068 /* Walk over all the sub-trees of this operand. Statement nodes
3069 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3070 len
= TREE_CODE_LENGTH (code
);
3072 /* Go through the subtrees. We need to do this in forward order so
3073 that the scope of a FOR_EXPR is handled properly. */
3074 for (i
= 0; i
< len
; ++i
)
3075 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3078 /* Finally visit the chain. This can be tail-recursion optimized if
3079 we write it this way. */
3080 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3085 /* Used to compare case labels. K1 and K2 are actually tree nodes
3086 representing case labels, or NULL_TREE for a `default' label.
3087 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3088 K2, and 0 if K1 and K2 are equal. */
3091 case_compare (k1
, k2
)
3095 /* Consider a NULL key (such as arises with a `default' label) to be
3096 smaller than anything else. */
3102 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3105 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3106 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3107 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3108 case label was declared using the usual C/C++ syntax, rather than
3109 the GNU case range extension. CASES is a tree containing all the
3110 case ranges processed so far; COND is the condition for the
3111 switch-statement itself. Returns the CASE_LABEL created, or
3112 ERROR_MARK_NODE if no CASE_LABEL is created. */
3115 c_add_case_label (cases
, cond
, low_value
, high_value
)
3124 splay_tree_node node
;
3126 /* Create the LABEL_DECL itself. */
3127 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3128 DECL_CONTEXT (label
) = current_function_decl
;
3130 /* If there was an error processing the switch condition, bail now
3131 before we get more confused. */
3132 if (!cond
|| cond
== error_mark_node
)
3134 /* Add a label anyhow so that the back-end doesn't think that
3135 the beginning of the switch is unreachable. */
3137 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3138 return error_mark_node
;
3141 if ((low_value
&& TREE_TYPE (low_value
)
3142 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3143 || (high_value
&& TREE_TYPE (high_value
)
3144 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3145 error ("pointers are not permitted as case values");
3147 /* Case ranges are a GNU extension. */
3148 if (high_value
&& pedantic
)
3150 if (c_language
== clk_cplusplus
)
3151 pedwarn ("ISO C++ forbids range expressions in switch statements");
3153 pedwarn ("ISO C forbids range expressions in switch statements");
3156 type
= TREE_TYPE (cond
);
3159 low_value
= check_case_value (low_value
);
3160 low_value
= convert_and_check (type
, low_value
);
3164 high_value
= check_case_value (high_value
);
3165 high_value
= convert_and_check (type
, high_value
);
3168 /* If an error has occurred, bail out now. */
3169 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3172 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3173 return error_mark_node
;
3176 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3177 really a case range, even though it was written that way. Remove
3178 the HIGH_VALUE to simplify later processing. */
3179 if (tree_int_cst_equal (low_value
, high_value
))
3180 high_value
= NULL_TREE
;
3181 if (low_value
&& high_value
3182 && !tree_int_cst_lt (low_value
, high_value
))
3183 warning ("empty range specified");
3185 /* Look up the LOW_VALUE in the table of case labels we already
3187 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3188 /* If there was not an exact match, check for overlapping ranges.
3189 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3190 that's a `default' label and the only overlap is an exact match. */
3191 if (!node
&& (low_value
|| high_value
))
3193 splay_tree_node low_bound
;
3194 splay_tree_node high_bound
;
3196 /* Even though there wasn't an exact match, there might be an
3197 overlap between this case range and another case range.
3198 Since we've (inductively) not allowed any overlapping case
3199 ranges, we simply need to find the greatest low case label
3200 that is smaller that LOW_VALUE, and the smallest low case
3201 label that is greater than LOW_VALUE. If there is an overlap
3202 it will occur in one of these two ranges. */
3203 low_bound
= splay_tree_predecessor (cases
,
3204 (splay_tree_key
) low_value
);
3205 high_bound
= splay_tree_successor (cases
,
3206 (splay_tree_key
) low_value
);
3208 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3209 the LOW_VALUE, so there is no need to check unless the
3210 LOW_BOUND is in fact itself a case range. */
3212 && CASE_HIGH ((tree
) low_bound
->value
)
3213 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3216 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3217 range is bigger than the low end of the current range, so we
3218 are only interested if the current range is a real range, and
3219 not an ordinary case label. */
3222 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3227 /* If there was an overlap, issue an error. */
3230 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3234 error ("duplicate (or overlapping) case value");
3235 error_with_decl (duplicate
,
3236 "this is the first entry overlapping that value");
3240 error ("duplicate case value") ;
3241 error_with_decl (duplicate
, "previously used here");
3245 error ("multiple default labels in one switch");
3246 error_with_decl (duplicate
, "this is the first default label");
3249 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3252 /* Add a CASE_LABEL to the statement-tree. */
3253 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3254 /* Register this case label in the splay tree. */
3255 splay_tree_insert (cases
,
3256 (splay_tree_key
) low_value
,
3257 (splay_tree_value
) case_label
);
3262 /* Finish an expression taking the address of LABEL. Returns an
3263 expression for the address. */
3266 finish_label_address_expr (label
)
3273 if (c_language
== clk_cplusplus
)
3274 pedwarn ("ISO C++ forbids taking the address of a label");
3276 pedwarn ("ISO C forbids taking the address of a label");
3279 label
= lookup_label (label
);
3280 if (label
== NULL_TREE
)
3281 result
= null_pointer_node
;
3284 TREE_USED (label
) = 1;
3285 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3286 TREE_CONSTANT (result
) = 1;
3287 /* The current function in not necessarily uninlinable.
3288 Computed gotos are incompatible with inlining, but the value
3289 here could be used only in a diagnostic, for example. */
3295 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3296 parameter allows this function to be used as a GC-marking
3303 stmt_tree st
= (stmt_tree
) p
;
3305 ggc_mark_tree (st
->x_last_stmt
);
3306 ggc_mark_tree (st
->x_last_expr_type
);
3309 /* Mark LD for GC. */
3312 c_mark_lang_decl (c
)
3313 struct c_lang_decl
*c ATTRIBUTE_UNUSED
;
3317 /* Mark F for GC. */
3320 mark_c_language_function (f
)
3321 struct language_function
*f
;
3326 mark_stmt_tree (&f
->x_stmt_tree
);
3327 ggc_mark_tree (f
->x_scope_stmt_stack
);
3330 /* Hook used by expand_expr to expand language-specific tree codes. */
3333 c_expand_expr (exp
, target
, tmode
, modifier
)
3336 enum machine_mode tmode
;
3337 enum expand_modifier modifier
;
3339 switch (TREE_CODE (exp
))
3346 /* Since expand_expr_stmt calls free_temp_slots after every
3347 expression statement, we must call push_temp_slots here.
3348 Otherwise, any temporaries in use now would be considered
3349 out-of-scope after the first EXPR_STMT from within the
3352 rtl_expr
= expand_start_stmt_expr ();
3353 expand_stmt (STMT_EXPR_STMT (exp
));
3354 expand_end_stmt_expr (rtl_expr
);
3355 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
3363 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3364 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3366 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3367 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3368 == BUILT_IN_FRONTEND
))
3369 return c_expand_builtin (exp
, target
, tmode
, modifier
);
3383 /* Hook used by safe_from_p to handle language-specific tree codes. */
3386 c_safe_from_p (target
, exp
)
3390 /* We can see statements here when processing the body of a
3391 statement-expression. For a declaration statement declaring a
3392 variable, look at the variable's initializer. */
3393 if (TREE_CODE (exp
) == DECL_STMT
)
3395 tree decl
= DECL_STMT_DECL (exp
);
3397 if (TREE_CODE (decl
) == VAR_DECL
3398 && DECL_INITIAL (decl
)
3399 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
3403 /* For any statement, we must follow the statement-chain. */
3404 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
3405 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
3407 /* Assume everything else is safe. */
3411 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3414 c_unsafe_for_reeval (exp
)
3417 /* Statement expressions may not be reevaluated. */
3418 if (TREE_CODE (exp
) == STMT_EXPR
)
3421 /* Walk all other expressions. */
3425 /* Tree code classes. */
3427 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
3429 static const char c_tree_code_type
[] = {
3431 #include "c-common.def"
3435 /* Table indexed by tree code giving number of expression
3436 operands beyond the fixed part of the node structure.
3437 Not used for types or decls. */
3439 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
3441 static const int c_tree_code_length
[] = {
3443 #include "c-common.def"
3447 /* Names of tree components.
3448 Used for printing out the tree and error messages. */
3449 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
3451 static const char *const c_tree_code_name
[] = {
3453 #include "c-common.def"
3457 /* Adds the tree codes specific to the C front end to the list of all
3463 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3465 (int)LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
3466 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3468 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
3469 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
3471 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
3472 lang_unsafe_for_reeval
= c_unsafe_for_reeval
;
3475 #define CALLED_AS_BUILT_IN(NODE) \
3476 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3479 c_expand_builtin (exp
, target
, tmode
, modifier
)
3482 enum machine_mode tmode
;
3483 enum expand_modifier modifier
;
3485 tree type
= TREE_TYPE (exp
);
3486 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3487 tree arglist
= TREE_OPERAND (exp
, 1);
3488 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3489 enum tree_code code
= TREE_CODE (exp
);
3490 const int ignore
= (target
== const0_rtx
3491 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
3492 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
3493 || code
== COND_EXPR
)
3494 && TREE_CODE (type
) == VOID_TYPE
));
3496 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
3497 return expand_call (exp
, target
, ignore
);
3501 case BUILT_IN_PRINTF
:
3502 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3508 case BUILT_IN_FPRINTF
:
3509 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3515 default: /* just do library call, if unknown builtin */
3516 error ("built-in function `%s' not currently supported",
3517 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3520 /* The switch statement above can drop through to cause the function
3521 to be called normally. */
3522 return expand_call (exp
, target
, ignore
);
3525 /* Check an arglist to *printf for problems. The arglist should start
3526 at the format specifier, with the remaining arguments immediately
3529 is_valid_printf_arglist (arglist
)
3532 /* Save this value so we can restore it later. */
3533 const int SAVE_pedantic
= pedantic
;
3534 int diagnostic_occurred
= 0;
3537 /* Set this to a known value so the user setting won't affect code
3540 /* Check to make sure there are no format specifier errors. */
3541 attrs
= tree_cons (get_identifier ("format"),
3542 tree_cons (NULL_TREE
,
3543 get_identifier ("printf"),
3544 tree_cons (NULL_TREE
,
3546 tree_cons (NULL_TREE
,
3550 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
3552 /* Restore the value of `pedantic'. */
3553 pedantic
= SAVE_pedantic
;
3555 /* If calling `check_function_format_ptr' produces a warning, we
3556 return false, otherwise we return true. */
3557 return ! diagnostic_occurred
;
3560 /* If the arguments passed to printf are suitable for optimizations,
3561 we attempt to transform the call. */
3563 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
)
3566 enum machine_mode tmode
;
3567 enum expand_modifier modifier
;
3570 tree fn_putchar
= built_in_decls
[BUILT_IN_PUTCHAR
],
3571 fn_puts
= built_in_decls
[BUILT_IN_PUTS
];
3572 tree fn
, format_arg
, stripped_string
;
3574 /* If the return value is used, or the replacement _DECL isn't
3575 initialized, don't do the transformation. */
3576 if (!ignore
|| !fn_putchar
|| !fn_puts
)
3579 /* Verify the required arguments in the original call. */
3581 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
3584 /* Check the specifier vs. the parameters. */
3585 if (!is_valid_printf_arglist (arglist
))
3588 format_arg
= TREE_VALUE (arglist
);
3589 stripped_string
= format_arg
;
3590 STRIP_NOPS (stripped_string
);
3591 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3592 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3594 /* If the format specifier isn't a STRING_CST, punt. */
3595 if (TREE_CODE (stripped_string
) != STRING_CST
)
3598 /* OK! We can attempt optimization. */
3600 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3601 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
3603 arglist
= TREE_CHAIN (arglist
);
3606 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3607 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3609 arglist
= TREE_CHAIN (arglist
);
3614 /* We can't handle anything else with % args or %% ... yet. */
3615 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3618 /* If the resulting constant string has a length of 1, call
3619 putchar. Note, TREE_STRING_LENGTH includes the terminating
3620 NULL in its count. */
3621 if (TREE_STRING_LENGTH (stripped_string
) == 2)
3623 /* Given printf("c"), (where c is any one character,)
3624 convert "c"[0] to an int and pass that to the replacement
3626 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
3627 arglist
= build_tree_list (NULL_TREE
, arglist
);
3631 /* If the resulting constant was "string\n", call
3632 __builtin_puts("string"). Ensure "string" has at least one
3633 character besides the trailing \n. Note, TREE_STRING_LENGTH
3634 includes the terminating NULL in its count. */
3635 else if (TREE_STRING_LENGTH (stripped_string
) > 2
3636 && TREE_STRING_POINTER (stripped_string
)
3637 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
3639 /* Create a NULL-terminated string that's one char shorter
3640 than the original, stripping off the trailing '\n'. */
3641 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
3642 char *newstr
= (char *) alloca (newlen
);
3643 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
3644 newstr
[newlen
- 1] = 0;
3646 arglist
= combine_strings (build_string (newlen
, newstr
));
3647 arglist
= build_tree_list (NULL_TREE
, arglist
);
3651 /* We'd like to arrange to call fputs(string) here, but we
3652 need stdout and don't have a way to get it ... yet. */
3656 return expand_expr (build_function_call (fn
, arglist
),
3657 (ignore
? const0_rtx
: target
),
3661 /* If the arguments passed to fprintf are suitable for optimizations,
3662 we attempt to transform the call. */
3664 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
)
3667 enum machine_mode tmode
;
3668 enum expand_modifier modifier
;
3671 tree fn_fputc
= built_in_decls
[BUILT_IN_FPUTC
],
3672 fn_fputs
= built_in_decls
[BUILT_IN_FPUTS
];
3673 tree fn
, format_arg
, stripped_string
;
3675 /* If the return value is used, or the replacement _DECL isn't
3676 initialized, don't do the transformation. */
3677 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
3680 /* Verify the required arguments in the original call. */
3682 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
3683 || (TREE_CHAIN (arglist
) == 0)
3684 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
3688 /* Check the specifier vs. the parameters. */
3689 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
3692 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
3693 stripped_string
= format_arg
;
3694 STRIP_NOPS (stripped_string
);
3695 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
3696 stripped_string
= TREE_OPERAND (stripped_string
, 0);
3698 /* If the format specifier isn't a STRING_CST, punt. */
3699 if (TREE_CODE (stripped_string
) != STRING_CST
)
3702 /* OK! We can attempt optimization. */
3704 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3705 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
3707 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3708 arglist
= tree_cons (NULL_TREE
,
3709 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3713 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3714 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
3716 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
3717 arglist
= tree_cons (NULL_TREE
,
3718 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
3724 /* We can't handle anything else with % args or %% ... yet. */
3725 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
3728 /* When "string" doesn't contain %, replace all cases of
3729 fprintf(stream,string) with fputs(string,stream). The fputs
3730 builtin will take take of special cases like length==1. */
3731 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
3732 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
3736 return expand_expr (build_function_call (fn
, arglist
),
3737 (ignore
? const0_rtx
: target
),
3742 /* Given a boolean expression ARG, return a tree representing an increment
3743 or decrement (as indicated by CODE) of ARG. The front end must check for
3744 invalid cases (e.g., decrement in C++). */
3746 boolean_increment (code
, arg
)
3747 enum tree_code code
;
3751 tree true_res
= (c_language
== clk_cplusplus
3753 : c_bool_true_node
);
3754 arg
= stabilize_reference (arg
);
3757 case PREINCREMENT_EXPR
:
3758 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3760 case POSTINCREMENT_EXPR
:
3761 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
3762 arg
= save_expr (arg
);
3763 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3764 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3766 case PREDECREMENT_EXPR
:
3767 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3769 case POSTDECREMENT_EXPR
:
3770 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
3771 arg
= save_expr (arg
);
3772 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
3773 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
3778 TREE_SIDE_EFFECTS (val
) = 1;
3782 /* Handle C and C++ default attributes. */
3784 enum built_in_attribute
3786 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3787 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3788 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3789 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3790 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
3791 #include "builtin-attrs.def"
3792 #undef DEF_ATTR_NULL_TREE
3794 #undef DEF_ATTR_IDENT
3795 #undef DEF_ATTR_TREE_LIST
3800 static tree built_in_attributes
[(int) ATTR_LAST
];
3802 static bool c_attrs_initialized
= false;
3804 static void c_init_attributes
PARAMS ((void));
3806 /* Do the parts of lang_init common to C and C++. */
3808 c_common_lang_init ()
3810 /* If still "unspecified", make it match -fbounded-pointers. */
3811 if (flag_bounds_check
< 0)
3812 flag_bounds_check
= flag_bounded_pointers
;
3814 /* Special format checking options don't work without -Wformat; warn if
3816 if (warn_format_y2k
&& !warn_format
)
3817 warning ("-Wformat-y2k ignored without -Wformat");
3818 if (warn_format_extra_args
&& !warn_format
)
3819 warning ("-Wformat-extra-args ignored without -Wformat");
3820 if (warn_format_nonliteral
&& !warn_format
)
3821 warning ("-Wformat-nonliteral ignored without -Wformat");
3822 if (warn_format_security
&& !warn_format
)
3823 warning ("-Wformat-security ignored without -Wformat");
3824 if (warn_missing_format_attribute
&& !warn_format
)
3825 warning ("-Wmissing-format-attribute ignored without -Wformat");
3827 if (!c_attrs_initialized
)
3828 c_init_attributes ();
3832 c_init_attributes ()
3834 /* Fill in the built_in_attributes array. */
3835 #define DEF_ATTR_NULL_TREE(ENUM) \
3836 built_in_attributes[(int) ENUM] = NULL_TREE;
3837 #define DEF_ATTR_INT(ENUM, VALUE) \
3838 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
3839 #define DEF_ATTR_IDENT(ENUM, STRING) \
3840 built_in_attributes[(int) ENUM] = get_identifier (STRING);
3841 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
3842 built_in_attributes[(int) ENUM] \
3843 = tree_cons (built_in_attributes[(int) PURPOSE], \
3844 built_in_attributes[(int) VALUE], \
3845 built_in_attributes[(int) CHAIN]);
3846 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
3847 #include "builtin-attrs.def"
3848 #undef DEF_ATTR_NULL_TREE
3850 #undef DEF_ATTR_IDENT
3851 #undef DEF_ATTR_TREE_LIST
3853 ggc_add_tree_root (built_in_attributes
, (int) ATTR_LAST
);
3854 c_attrs_initialized
= true;
3857 /* Depending on the name of DECL, apply default attributes to it. */
3860 c_common_insert_default_attributes (decl
)
3863 tree name
= DECL_NAME (decl
);
3865 if (!c_attrs_initialized
)
3866 c_init_attributes ();
3868 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
3869 #define DEF_ATTR_INT(ENUM, VALUE)
3870 #define DEF_ATTR_IDENT(ENUM, STRING)
3871 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
3872 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
3873 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
3874 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
3875 ATTR_FLAG_BUILT_IN);
3876 #include "builtin-attrs.def"
3877 #undef DEF_ATTR_NULL_TREE
3879 #undef DEF_ATTR_IDENT
3880 #undef DEF_ATTR_TREE_LIST