1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
33 #include "tree-inline.h"
34 #include "diagnostic.h"
40 #include "langhooks.h"
41 cpp_reader *parse_in; /* Declared in c-lex.h. */
43 #undef WCHAR_TYPE_SIZE
44 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
46 /* We let tm.h override the types used here, to handle trivial differences
47 such as the choice of unsigned int or long unsigned int for size_t.
48 When machines start needing nontrivial differences in the size type,
49 it would be best to do something here to figure out automatically
50 from other information what type to use. */
53 #define SIZE_TYPE "long unsigned int"
57 #define WCHAR_TYPE "int"
61 #define PTRDIFF_TYPE "long int"
65 #define WINT_TYPE "unsigned int"
69 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
71 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
77 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
80 ? "long unsigned int" \
81 : "long long unsigned int"))
84 /* The variant of the C language being processed. */
86 enum c_language_kind c_language;
88 /* The following symbols are subsumed in the c_global_trees array, and
89 listed here individually for documentation purposes.
91 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
93 tree short_integer_type_node;
94 tree long_integer_type_node;
95 tree long_long_integer_type_node;
97 tree short_unsigned_type_node;
98 tree long_unsigned_type_node;
99 tree long_long_unsigned_type_node;
101 tree boolean_type_node;
102 tree boolean_false_node;
103 tree boolean_true_node;
105 tree ptrdiff_type_node;
107 tree unsigned_char_type_node;
108 tree signed_char_type_node;
109 tree wchar_type_node;
110 tree signed_wchar_type_node;
111 tree unsigned_wchar_type_node;
113 tree float_type_node;
114 tree double_type_node;
115 tree long_double_type_node;
117 tree complex_integer_type_node;
118 tree complex_float_type_node;
119 tree complex_double_type_node;
120 tree complex_long_double_type_node;
122 tree intQI_type_node;
123 tree intHI_type_node;
124 tree intSI_type_node;
125 tree intDI_type_node;
126 tree intTI_type_node;
128 tree unsigned_intQI_type_node;
129 tree unsigned_intHI_type_node;
130 tree unsigned_intSI_type_node;
131 tree unsigned_intDI_type_node;
132 tree unsigned_intTI_type_node;
134 tree widest_integer_literal_type_node;
135 tree widest_unsigned_literal_type_node;
137 Nodes for types `void *' and `const void *'.
139 tree ptr_type_node, const_ptr_type_node;
141 Nodes for types `char *' and `const char *'.
143 tree string_type_node, const_string_type_node;
145 Type `char[SOMENUMBER]'.
146 Used when an array of char is needed and the size is irrelevant.
148 tree char_array_type_node;
150 Type `int[SOMENUMBER]' or something like it.
151 Used when an array of int needed and the size is irrelevant.
153 tree int_array_type_node;
155 Type `wchar_t[SOMENUMBER]' or something like it.
156 Used when a wide string literal is created.
158 tree wchar_array_type_node;
160 Type `int ()' -- used for implicit declaration of functions.
162 tree default_function_type;
164 A VOID_TYPE node, packaged in a TREE_LIST.
168 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
169 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
170 VAR_DECLS, but C++ does.)
172 tree function_name_decl_node;
173 tree pretty_function_name_decl_node;
174 tree c99_function_name_decl_node;
176 Stack of nested function name VAR_DECLs.
178 tree saved_function_name_decls;
182 tree c_global_trees[CTI_MAX];
184 /* Nonzero if prepreprocessing only. */
185 int flag_preprocess_only;
187 /* Nonzero means don't recognize the non-ANSI builtin functions. */
191 /* Nonzero means don't recognize the non-ANSI builtin functions.
194 int flag_no_nonansi_builtin;
196 /* Nonzero means give `double' the same size as `float'. */
198 int flag_short_double;
200 /* Nonzero means give `wchar_t' the same size as `short'. */
202 int flag_short_wchar;
204 /* Nonzero means warn about possible violations of sequence point rules. */
206 int warn_sequence_point;
208 /* Nonzero means to warn about compile-time division by zero. */
209 int warn_div_by_zero = 1;
211 /* The elements of `ridpointers' are identifier nodes for the reserved
212 type names and storage classes. It is indexed by a RID_... value. */
215 tree (*make_fname_decl) PARAMS ((tree, int));
217 /* If non-NULL, the address of a language-specific function that
218 returns 1 for language-specific statement codes. */
219 int (*lang_statement_code_p) PARAMS ((enum tree_code));
221 /* If non-NULL, the address of a language-specific function that takes
222 any action required right before expand_function_end is called. */
223 void (*lang_expand_function_end) PARAMS ((void));
225 /* Nonzero means the expression being parsed will never be evaluated.
226 This is a count, since unevaluated expressions can nest. */
229 /* Information about how a function name is generated. */
232 tree *const decl; /* pointer to the VAR_DECL. */
233 const unsigned rid; /* RID number for the identifier. */
234 const int pretty; /* How pretty is it? */
237 /* The three ways of getting then name of the current function. */
239 const struct fname_var_t fname_vars[] =
241 /* C99 compliant __func__, must be first. */
242 {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
243 /* GCC __FUNCTION__ compliant. */
244 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
245 /* GCC __PRETTY_FUNCTION__ compliant. */
246 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
250 static int constant_fits_type_p PARAMS ((tree, tree));
252 /* Keep a stack of if statements. We record the number of compound
253 statements seen up to the if keyword, as well as the line number
254 and file of the if. If a potentially ambiguous else is seen, that
255 fact is recorded; the warning is issued when we can be sure that
256 the enclosing if statement does not have an else branch. */
266 static if_elt *if_stack;
268 /* Amount of space in the if statement stack. */
269 static int if_stack_space = 0;
272 static int if_stack_pointer = 0;
274 /* Record the start of an if-then, and record the start of it
275 for ambiguous else detection.
277 COND is the condition for the if-then statement.
279 IF_STMT is the statement node that has already been created for
280 this if-then statement. It is created before parsing the
281 condition to keep line number information accurate. */
284 c_expand_start_cond (cond, compstmt_count, if_stmt)
289 /* Make sure there is enough space on the stack. */
290 if (if_stack_space == 0)
293 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
295 else if (if_stack_space == if_stack_pointer)
297 if_stack_space += 10;
298 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
301 IF_COND (if_stmt) = cond;
304 /* Record this if statement. */
305 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
306 if_stack[if_stack_pointer].file = input_filename;
307 if_stack[if_stack_pointer].line = lineno;
308 if_stack[if_stack_pointer].needs_warning = 0;
309 if_stack[if_stack_pointer].if_stmt = if_stmt;
313 /* Called after the then-clause for an if-statement is processed. */
318 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
319 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
322 /* Record the end of an if-then. Optionally warn if a nested
323 if statement had an ambiguous else clause. */
329 if (if_stack[if_stack_pointer].needs_warning)
330 warning_with_file_and_line (if_stack[if_stack_pointer].file,
331 if_stack[if_stack_pointer].line,
332 "suggest explicit braces to avoid ambiguous `else'");
333 last_expr_type = NULL_TREE;
336 /* Called between the then-clause and the else-clause
337 of an if-then-else. */
340 c_expand_start_else ()
342 /* An ambiguous else warning must be generated for the enclosing if
343 statement, unless we see an else branch for that one, too. */
345 && if_stack_pointer > 1
346 && (if_stack[if_stack_pointer - 1].compstmt_count
347 == if_stack[if_stack_pointer - 2].compstmt_count))
348 if_stack[if_stack_pointer - 2].needs_warning = 1;
350 /* Even if a nested if statement had an else branch, it can't be
351 ambiguous if this one also has an else. So don't warn in that
352 case. Also don't warn for any if statements nested in this else. */
353 if_stack[if_stack_pointer - 1].needs_warning = 0;
354 if_stack[if_stack_pointer - 1].compstmt_count--;
357 /* Called after the else-clause for an if-statement is processed. */
362 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
363 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
366 /* Begin an if-statement. Returns a newly created IF_STMT if
369 Unlike the C++ front-end, we do not call add_stmt here; it is
370 probably safe to do so, but I am not very familiar with this
371 code so I am being extra careful not to change its behavior
372 beyond what is strictly necessary for correctness. */
378 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
382 /* Begin a while statement. Returns a newly created WHILE_STMT if
385 Unlike the C++ front-end, we do not call add_stmt here; it is
386 probably safe to do so, but I am not very familiar with this
387 code so I am being extra careful not to change its behavior
388 beyond what is strictly necessary for correctness. */
391 c_begin_while_stmt ()
394 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
399 c_finish_while_stmt_cond (cond, while_stmt)
403 WHILE_COND (while_stmt) = cond;
406 /* Push current bindings for the function name VAR_DECLS. */
412 tree saved = NULL_TREE;
414 for (ix = 0; fname_vars[ix].decl; ix++)
416 tree decl = *fname_vars[ix].decl;
420 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
421 *fname_vars[ix].decl = NULL_TREE;
424 if (saved || saved_function_name_decls)
425 /* Normally they'll have been NULL, so only push if we've got a
426 stack, or they are non-NULL. */
427 saved_function_name_decls = tree_cons (saved, NULL_TREE,
428 saved_function_name_decls);
431 /* Finish up the current bindings, adding them into the
432 current function's statement tree. This is done by wrapping the
433 function's body in a COMPOUND_STMT containing these decls too. This
434 must be done _before_ finish_stmt_tree is called. If there is no
435 current function, we must be at file scope and no statements are
436 involved. Pop the previous bindings. */
439 finish_fname_decls ()
442 tree body = NULL_TREE;
443 tree stack = saved_function_name_decls;
445 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
446 body = chainon (TREE_VALUE (stack), body);
450 /* They were called into existence, so add to statement tree. */
451 body = chainon (body,
452 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
453 body = build_stmt (COMPOUND_STMT, body);
455 COMPOUND_STMT_NO_SCOPE (body) = 1;
456 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
459 for (ix = 0; fname_vars[ix].decl; ix++)
460 *fname_vars[ix].decl = NULL_TREE;
464 /* We had saved values, restore them. */
467 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
469 tree decl = TREE_PURPOSE (saved);
470 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
472 *fname_vars[ix].decl = decl;
474 stack = TREE_CHAIN (stack);
476 saved_function_name_decls = stack;
479 /* Return the text name of the current function, suitable prettified
483 fname_as_string (pretty_p)
486 const char *name = NULL;
489 name = (current_function_decl
490 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
492 else if (current_function_decl && DECL_NAME (current_function_decl))
493 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
499 /* Return the text name of the current function, formatted as
500 required by the supplied RID value. */
508 for (ix = 0; fname_vars[ix].decl; ix++)
509 if (fname_vars[ix].rid == rid)
511 return fname_as_string (fname_vars[ix].pretty);
514 /* Return the VAR_DECL for a const char array naming the current
515 function. If the VAR_DECL has not yet been created, create it
516 now. RID indicates how it should be formatted and IDENTIFIER_NODE
517 ID is its name (unfortunately C and C++ hold the RID values of
518 keywords in different places, so we can't derive RID from ID in
519 this language independent code. */
527 tree decl = NULL_TREE;
529 for (ix = 0; fname_vars[ix].decl; ix++)
530 if (fname_vars[ix].rid == rid)
533 decl = *fname_vars[ix].decl;
536 tree saved_last_tree = last_tree;
538 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
539 if (last_tree != saved_last_tree)
541 /* We created some statement tree for the decl. This belongs
542 at the start of the function, so remove it now and reinsert
543 it after the function is complete. */
544 tree stmts = TREE_CHAIN (saved_last_tree);
546 TREE_CHAIN (saved_last_tree) = NULL_TREE;
547 last_tree = saved_last_tree;
548 saved_function_name_decls = tree_cons (decl, stmts,
549 saved_function_name_decls);
551 *fname_vars[ix].decl = decl;
553 if (!ix && !current_function_decl)
554 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
559 /* Given a chain of STRING_CST nodes,
560 concatenate them into one STRING_CST
561 and give it a suitable array-of-chars data type. */
564 combine_strings (strings)
571 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
573 const int nchars_max = flag_isoc99 ? 4095 : 509;
575 if (TREE_CHAIN (strings))
577 /* More than one in the chain, so concatenate. */
580 /* Don't include the \0 at the end of each substring,
581 except for the last one.
582 Count wide strings and ordinary strings separately. */
583 for (t = strings; t; t = TREE_CHAIN (t))
585 if (TREE_TYPE (t) == wchar_array_type_node)
587 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
592 length += (TREE_STRING_LENGTH (t) - 1);
593 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
594 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
598 /* If anything is wide, the non-wides will be converted,
599 which makes them take more space. */
601 length = length * wchar_bytes + wide_length;
605 /* Copy the individual strings into the new combined string.
606 If the combined string is wide, convert the chars to ints
607 for any individual strings that are not wide. */
610 for (t = strings; t; t = TREE_CHAIN (t))
612 int len = (TREE_STRING_LENGTH (t)
613 - ((TREE_TYPE (t) == wchar_array_type_node)
615 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
617 memcpy (q, TREE_STRING_POINTER (t), len);
623 for (i = 0; i < len; i++)
625 if (BYTES_BIG_ENDIAN)
627 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
629 *q++ = TREE_STRING_POINTER (t)[i];
633 *q++ = TREE_STRING_POINTER (t)[i];
634 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
643 for (i = 0; i < wchar_bytes; i++)
649 value = build_string (length, p);
654 length = TREE_STRING_LENGTH (value);
655 if (TREE_TYPE (value) == wchar_array_type_node)
659 /* Compute the number of elements, for the array type. */
660 nchars = wide_flag ? length / wchar_bytes : length;
662 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
663 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
664 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
666 /* Create the array type for the string constant.
667 -Wwrite-strings says make the string constant an array of const char
668 so that copying it to a non-const pointer will get a warning.
669 For C++, this is the standard behavior. */
670 if (flag_const_strings && ! flag_writable_strings)
673 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
676 = build_array_type (elements,
677 build_index_type (build_int_2 (nchars - 1, 0)));
681 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
682 build_index_type (build_int_2 (nchars - 1, 0)));
684 TREE_CONSTANT (value) = 1;
685 TREE_READONLY (value) = ! flag_writable_strings;
686 TREE_STATIC (value) = 1;
690 static int is_valid_printf_arglist PARAMS ((tree));
691 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
692 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
693 enum expand_modifier, int, int));
694 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
695 enum expand_modifier, int, int));
697 /* Print a warning if a constant expression had overflow in folding.
698 Invoke this function on every expression that the language
699 requires to be a constant expression.
700 Note the ANSI C standard says it is erroneous for a
701 constant expression to overflow. */
704 constant_expression_warning (value)
707 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
708 || TREE_CODE (value) == VECTOR_CST
709 || TREE_CODE (value) == COMPLEX_CST)
710 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
711 pedwarn ("overflow in constant expression");
714 /* Print a warning if an expression had overflow in folding.
715 Invoke this function on every expression that
716 (1) appears in the source code, and
717 (2) might be a constant expression that overflowed, and
718 (3) is not already checked by convert_and_check;
719 however, do not invoke this function on operands of explicit casts. */
722 overflow_warning (value)
725 if ((TREE_CODE (value) == INTEGER_CST
726 || (TREE_CODE (value) == COMPLEX_CST
727 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
728 && TREE_OVERFLOW (value))
730 TREE_OVERFLOW (value) = 0;
731 if (skip_evaluation == 0)
732 warning ("integer overflow in expression");
734 else if ((TREE_CODE (value) == REAL_CST
735 || (TREE_CODE (value) == COMPLEX_CST
736 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
737 && TREE_OVERFLOW (value))
739 TREE_OVERFLOW (value) = 0;
740 if (skip_evaluation == 0)
741 warning ("floating point overflow in expression");
743 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
745 TREE_OVERFLOW (value) = 0;
746 if (skip_evaluation == 0)
747 warning ("vector overflow in expression");
751 /* Print a warning if a large constant is truncated to unsigned,
752 or if -Wconversion is used and a constant < 0 is converted to unsigned.
753 Invoke this function on every expression that might be implicitly
754 converted to an unsigned type. */
757 unsigned_conversion_warning (result, operand)
758 tree result, operand;
760 tree type = TREE_TYPE (result);
762 if (TREE_CODE (operand) == INTEGER_CST
763 && TREE_CODE (type) == INTEGER_TYPE
764 && TREE_UNSIGNED (type)
765 && skip_evaluation == 0
766 && !int_fits_type_p (operand, type))
768 if (!int_fits_type_p (operand, c_common_signed_type (type)))
769 /* This detects cases like converting -129 or 256 to unsigned char. */
770 warning ("large integer implicitly truncated to unsigned type");
771 else if (warn_conversion)
772 warning ("negative integer implicitly converted to unsigned type");
776 /* Nonzero if constant C has a value that is permissible
777 for type TYPE (an INTEGER_TYPE). */
780 constant_fits_type_p (c, type)
783 if (TREE_CODE (c) == INTEGER_CST)
784 return int_fits_type_p (c, type);
786 c = convert (type, c);
787 return !TREE_OVERFLOW (c);
790 /* Convert EXPR to TYPE, warning about conversion problems with constants.
791 Invoke this function on every expression that is converted implicitly,
792 i.e. because of language rules and not because of an explicit cast. */
795 convert_and_check (type, expr)
798 tree t = convert (type, expr);
799 if (TREE_CODE (t) == INTEGER_CST)
801 if (TREE_OVERFLOW (t))
803 TREE_OVERFLOW (t) = 0;
805 /* Do not diagnose overflow in a constant expression merely
806 because a conversion overflowed. */
807 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
809 /* No warning for converting 0x80000000 to int. */
810 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
811 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
812 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
813 /* If EXPR fits in the unsigned version of TYPE,
814 don't warn unless pedantic. */
816 || TREE_UNSIGNED (type)
817 || ! constant_fits_type_p (expr,
818 c_common_unsigned_type (type)))
819 && skip_evaluation == 0)
820 warning ("overflow in implicit constant conversion");
823 unsigned_conversion_warning (t, expr);
828 /* A node in a list that describes references to variables (EXPR), which are
829 either read accesses if WRITER is zero, or write accesses, in which case
830 WRITER is the parent of EXPR. */
837 /* Used to implement a cache the results of a call to verify_tree. We only
838 use this for SAVE_EXPRs. */
841 struct tlist_cache *next;
842 struct tlist *cache_before_sp;
843 struct tlist *cache_after_sp;
847 /* Obstack to use when allocating tlist structures, and corresponding
849 static struct obstack tlist_obstack;
850 static char *tlist_firstobj = 0;
852 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
854 static struct tlist *warned_ids;
855 /* SAVE_EXPRs need special treatment. We process them only once and then
856 cache the results. */
857 static struct tlist_cache *save_expr_cache;
859 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
860 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
861 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
862 static int warning_candidate_p PARAMS ((tree));
863 static void warn_for_collisions PARAMS ((struct tlist *));
864 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
865 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
866 static void verify_sequence_points PARAMS ((tree));
868 /* Create a new struct tlist and fill in its fields. */
869 static struct tlist *
870 new_tlist (next, t, writer)
876 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
883 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
884 is nonnull, we ignore any node we find which has a writer equal to it. */
887 add_tlist (to, add, exclude_writer, copy)
895 struct tlist *next = add->next;
898 if (! exclude_writer || add->writer != exclude_writer)
899 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
904 /* Merge the nodes of ADD into TO. This merging process is done so that for
905 each variable that already exists in TO, no new node is added; however if
906 there is a write access recorded in ADD, and an occurrence on TO is only
907 a read access, then the occurrence in TO will be modified to record the
911 merge_tlist (to, add, copy)
916 struct tlist **end = to;
925 struct tlist *next = add->next;
927 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
928 if (tmp2->expr == add->expr)
932 tmp2->writer = add->writer;
936 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
944 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
945 references in list LIST conflict with it, excluding reads if ONLY writers
949 warn_for_collisions_1 (written, writer, list, only_writes)
950 tree written, writer;
956 /* Avoid duplicate warnings. */
957 for (tmp = warned_ids; tmp; tmp = tmp->next)
958 if (tmp->expr == written)
963 if (list->expr == written
964 && list->writer != writer
965 && (! only_writes || list->writer))
967 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
968 warning ("operation on `%s' may be undefined",
969 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
975 /* Given a list LIST of references to variables, find whether any of these
976 can cause conflicts due to missing sequence points. */
979 warn_for_collisions (list)
984 for (tmp = list; tmp; tmp = tmp->next)
987 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
991 /* Return nonzero if X is a tree that can be verified by the sequence point
994 warning_candidate_p (x)
997 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1000 /* Walk the tree X, and record accesses to variables. If X is written by the
1001 parent tree, WRITER is the parent.
1002 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1003 expression or its only operand forces a sequence point, then everything up
1004 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1006 Once we return, we will have emitted warnings if any subexpression before
1007 such a sequence point could be undefined. On a higher level, however, the
1008 sequence point may not be relevant, and we'll merge the two lists.
1010 Example: (b++, a) + b;
1011 The call that processes the COMPOUND_EXPR will store the increment of B
1012 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1013 processes the PLUS_EXPR will need to merge the two lists so that
1014 eventually, all accesses end up on the same list (and we'll warn about the
1015 unordered subexpressions b++ and b.
1017 A note on merging. If we modify the former example so that our expression
1020 care must be taken not simply to add all three expressions into the final
1021 PNO_SP list. The function merge_tlist takes care of that by merging the
1022 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1023 way, so that no more than one access to B is recorded. */
1026 verify_tree (x, pbefore_sp, pno_sp, writer)
1028 struct tlist **pbefore_sp, **pno_sp;
1031 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1032 enum tree_code code;
1035 /* X may be NULL if it is the operand of an empty statement expression
1041 code = TREE_CODE (x);
1042 class = TREE_CODE_CLASS (code);
1044 if (warning_candidate_p (x))
1046 *pno_sp = new_tlist (*pno_sp, x, writer);
1056 case TRUTH_ANDIF_EXPR:
1057 case TRUTH_ORIF_EXPR:
1058 tmp_before = tmp_nosp = tmp_list3 = 0;
1059 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1060 warn_for_collisions (tmp_nosp);
1061 merge_tlist (pbefore_sp, tmp_before, 0);
1062 merge_tlist (pbefore_sp, tmp_nosp, 0);
1063 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1064 merge_tlist (pbefore_sp, tmp_list3, 0);
1068 tmp_before = tmp_list2 = 0;
1069 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1070 warn_for_collisions (tmp_list2);
1071 merge_tlist (pbefore_sp, tmp_before, 0);
1072 merge_tlist (pbefore_sp, tmp_list2, 1);
1074 tmp_list3 = tmp_nosp = 0;
1075 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1076 warn_for_collisions (tmp_nosp);
1077 merge_tlist (pbefore_sp, tmp_list3, 0);
1079 tmp_list3 = tmp_list2 = 0;
1080 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1081 warn_for_collisions (tmp_list2);
1082 merge_tlist (pbefore_sp, tmp_list3, 0);
1083 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1084 two first, to avoid warning for (a ? b++ : b++). */
1085 merge_tlist (&tmp_nosp, tmp_list2, 0);
1086 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1089 case PREDECREMENT_EXPR:
1090 case PREINCREMENT_EXPR:
1091 case POSTDECREMENT_EXPR:
1092 case POSTINCREMENT_EXPR:
1093 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1097 tmp_before = tmp_nosp = tmp_list3 = 0;
1098 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1099 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1100 /* Expressions inside the LHS are not ordered wrt. the sequence points
1101 in the RHS. Example:
1103 Despite the fact that the modification of "a" is in the before_sp
1104 list (tmp_before), it conflicts with the use of "a" in the LHS.
1105 We can handle this by adding the contents of tmp_list3
1106 to those of tmp_before, and redoing the collision warnings for that
1108 add_tlist (&tmp_before, tmp_list3, x, 1);
1109 warn_for_collisions (tmp_before);
1110 /* Exclude the LHS itself here; we first have to merge it into the
1111 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1112 didn't exclude the LHS, we'd get it twice, once as a read and once
1114 add_tlist (pno_sp, tmp_list3, x, 0);
1115 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1117 merge_tlist (pbefore_sp, tmp_before, 0);
1118 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1119 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1120 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1124 /* We need to warn about conflicts among arguments and conflicts between
1125 args and the function address. Side effects of the function address,
1126 however, are not ordered by the sequence point of the call. */
1127 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1128 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1129 if (TREE_OPERAND (x, 1))
1130 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1131 merge_tlist (&tmp_list3, tmp_list2, 0);
1132 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1133 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1134 warn_for_collisions (tmp_before);
1135 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1139 /* Scan all the list, e.g. indices of multi dimensional array. */
1142 tmp_before = tmp_nosp = 0;
1143 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1144 merge_tlist (&tmp_nosp, tmp_before, 0);
1145 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1152 struct tlist_cache *t;
1153 for (t = save_expr_cache; t; t = t->next)
1159 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1161 t->next = save_expr_cache;
1163 save_expr_cache = t;
1165 tmp_before = tmp_nosp = 0;
1166 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1167 warn_for_collisions (tmp_nosp);
1172 struct tlist *t = tmp_nosp;
1174 merge_tlist (&tmp_list3, t, 0);
1176 t->cache_before_sp = tmp_before;
1177 t->cache_after_sp = tmp_list3;
1179 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1180 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1189 if (first_rtl_op (code) == 0)
1191 x = TREE_OPERAND (x, 0);
1207 int max = first_rtl_op (TREE_CODE (x));
1208 for (lp = 0; lp < max; lp++)
1210 tmp_before = tmp_nosp = 0;
1211 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1212 merge_tlist (&tmp_nosp, tmp_before, 0);
1213 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1220 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1224 verify_sequence_points (expr)
1227 struct tlist *before_sp = 0, *after_sp = 0;
1230 save_expr_cache = 0;
1231 if (tlist_firstobj == 0)
1233 gcc_obstack_init (&tlist_obstack);
1234 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1237 verify_tree (expr, &before_sp, &after_sp, 0);
1238 warn_for_collisions (after_sp);
1239 obstack_free (&tlist_obstack, tlist_firstobj);
1243 c_expand_expr_stmt (expr)
1246 /* Do default conversion if safe and possibly important,
1247 in case within ({...}). */
1248 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1249 && (flag_isoc99 || lvalue_p (expr)))
1250 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1251 expr = default_conversion (expr);
1253 if (warn_sequence_point)
1254 verify_sequence_points (expr);
1256 if (TREE_TYPE (expr) != error_mark_node
1257 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1258 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1259 error ("expression statement has incomplete type");
1261 last_expr_type = TREE_TYPE (expr);
1262 return add_stmt (build_stmt (EXPR_STMT, expr));
1265 /* Validate the expression after `case' and apply default promotions. */
1268 check_case_value (value)
1271 if (value == NULL_TREE)
1274 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1275 STRIP_TYPE_NOPS (value);
1276 /* In C++, the following is allowed:
1279 switch (...) { case i: ... }
1281 So, we try to reduce the VALUE to a constant that way. */
1282 if (c_language == clk_cplusplus)
1284 value = decl_constant_value (value);
1285 STRIP_TYPE_NOPS (value);
1286 value = fold (value);
1289 if (TREE_CODE (value) != INTEGER_CST
1290 && value != error_mark_node)
1292 error ("case label does not reduce to an integer constant");
1293 value = error_mark_node;
1296 /* Promote char or short to int. */
1297 value = default_conversion (value);
1299 constant_expression_warning (value);
1304 /* Return an integer type with BITS bits of precision,
1305 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1308 c_common_type_for_size (bits, unsignedp)
1312 if (bits == TYPE_PRECISION (integer_type_node))
1313 return unsignedp ? unsigned_type_node : integer_type_node;
1315 if (bits == TYPE_PRECISION (signed_char_type_node))
1316 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1318 if (bits == TYPE_PRECISION (short_integer_type_node))
1319 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1321 if (bits == TYPE_PRECISION (long_integer_type_node))
1322 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1324 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1325 return (unsignedp ? long_long_unsigned_type_node
1326 : long_long_integer_type_node);
1328 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1329 return (unsignedp ? widest_unsigned_literal_type_node
1330 : widest_integer_literal_type_node);
1332 if (bits <= TYPE_PRECISION (intQI_type_node))
1333 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1335 if (bits <= TYPE_PRECISION (intHI_type_node))
1336 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1338 if (bits <= TYPE_PRECISION (intSI_type_node))
1339 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1341 if (bits <= TYPE_PRECISION (intDI_type_node))
1342 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1347 /* Return a data type that has machine mode MODE.
1348 If the mode is an integer,
1349 then UNSIGNEDP selects between signed and unsigned types. */
1352 c_common_type_for_mode (mode, unsignedp)
1353 enum machine_mode mode;
1356 if (mode == TYPE_MODE (integer_type_node))
1357 return unsignedp ? unsigned_type_node : integer_type_node;
1359 if (mode == TYPE_MODE (signed_char_type_node))
1360 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1362 if (mode == TYPE_MODE (short_integer_type_node))
1363 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1365 if (mode == TYPE_MODE (long_integer_type_node))
1366 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1368 if (mode == TYPE_MODE (long_long_integer_type_node))
1369 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1371 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1372 return unsignedp ? widest_unsigned_literal_type_node
1373 : widest_integer_literal_type_node;
1376 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1379 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1382 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1385 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1387 #if HOST_BITS_PER_WIDE_INT >= 64
1388 if (mode == TYPE_MODE (intTI_type_node))
1389 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1392 if (mode == TYPE_MODE (float_type_node))
1393 return float_type_node;
1395 if (mode == TYPE_MODE (double_type_node))
1396 return double_type_node;
1398 if (mode == TYPE_MODE (long_double_type_node))
1399 return long_double_type_node;
1401 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1402 return build_pointer_type (char_type_node);
1404 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1405 return build_pointer_type (integer_type_node);
1407 #ifdef VECTOR_MODE_SUPPORTED_P
1408 if (VECTOR_MODE_SUPPORTED_P (mode))
1413 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1415 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1417 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1419 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1421 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1423 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1425 return V16SF_type_node;
1427 return V4SF_type_node;
1429 return V2SF_type_node;
1439 /* Return an unsigned type the same as TYPE in other respects. */
1441 c_common_unsigned_type (type)
1444 tree type1 = TYPE_MAIN_VARIANT (type);
1445 if (type1 == signed_char_type_node || type1 == char_type_node)
1446 return unsigned_char_type_node;
1447 if (type1 == integer_type_node)
1448 return unsigned_type_node;
1449 if (type1 == short_integer_type_node)
1450 return short_unsigned_type_node;
1451 if (type1 == long_integer_type_node)
1452 return long_unsigned_type_node;
1453 if (type1 == long_long_integer_type_node)
1454 return long_long_unsigned_type_node;
1455 if (type1 == widest_integer_literal_type_node)
1456 return widest_unsigned_literal_type_node;
1457 #if HOST_BITS_PER_WIDE_INT >= 64
1458 if (type1 == intTI_type_node)
1459 return unsigned_intTI_type_node;
1461 if (type1 == intDI_type_node)
1462 return unsigned_intDI_type_node;
1463 if (type1 == intSI_type_node)
1464 return unsigned_intSI_type_node;
1465 if (type1 == intHI_type_node)
1466 return unsigned_intHI_type_node;
1467 if (type1 == intQI_type_node)
1468 return unsigned_intQI_type_node;
1470 return c_common_signed_or_unsigned_type (1, type);
1473 /* Return a signed type the same as TYPE in other respects. */
1476 c_common_signed_type (type)
1479 tree type1 = TYPE_MAIN_VARIANT (type);
1480 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1481 return signed_char_type_node;
1482 if (type1 == unsigned_type_node)
1483 return integer_type_node;
1484 if (type1 == short_unsigned_type_node)
1485 return short_integer_type_node;
1486 if (type1 == long_unsigned_type_node)
1487 return long_integer_type_node;
1488 if (type1 == long_long_unsigned_type_node)
1489 return long_long_integer_type_node;
1490 if (type1 == widest_unsigned_literal_type_node)
1491 return widest_integer_literal_type_node;
1492 #if HOST_BITS_PER_WIDE_INT >= 64
1493 if (type1 == unsigned_intTI_type_node)
1494 return intTI_type_node;
1496 if (type1 == unsigned_intDI_type_node)
1497 return intDI_type_node;
1498 if (type1 == unsigned_intSI_type_node)
1499 return intSI_type_node;
1500 if (type1 == unsigned_intHI_type_node)
1501 return intHI_type_node;
1502 if (type1 == unsigned_intQI_type_node)
1503 return intQI_type_node;
1505 return c_common_signed_or_unsigned_type (0, type);
1508 /* Return a type the same as TYPE except unsigned or
1509 signed according to UNSIGNEDP. */
1512 c_common_signed_or_unsigned_type (unsignedp, type)
1516 if (! INTEGRAL_TYPE_P (type)
1517 || TREE_UNSIGNED (type) == unsignedp)
1520 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1521 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1522 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1523 return unsignedp ? unsigned_type_node : integer_type_node;
1524 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1525 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1526 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1527 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1528 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1529 return (unsignedp ? long_long_unsigned_type_node
1530 : long_long_integer_type_node);
1531 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1532 return (unsignedp ? widest_unsigned_literal_type_node
1533 : widest_integer_literal_type_node);
1535 #if HOST_BITS_PER_WIDE_INT >= 64
1536 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1537 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1539 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1540 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1541 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1542 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1543 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1544 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1545 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1546 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1551 /* Return the minimum number of bits needed to represent VALUE in a
1552 signed or unsigned type, UNSIGNEDP says which. */
1555 min_precision (value, unsignedp)
1561 /* If the value is negative, compute its negative minus 1. The latter
1562 adjustment is because the absolute value of the largest negative value
1563 is one larger than the largest positive value. This is equivalent to
1564 a bit-wise negation, so use that operation instead. */
1566 if (tree_int_cst_sgn (value) < 0)
1567 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1569 /* Return the number of bits needed, taking into account the fact
1570 that we need one more bit for a signed than unsigned type. */
1572 if (integer_zerop (value))
1575 log = tree_floor_log2 (value);
1577 return log + 1 + ! unsignedp;
1580 /* Print an error message for invalid operands to arith operation
1581 CODE. NOP_EXPR is used as a special case (see
1582 c_common_truthvalue_conversion). */
1585 binary_op_error (code)
1586 enum tree_code code;
1593 error ("invalid truth-value expression");
1597 opname = "+"; break;
1599 opname = "-"; break;
1601 opname = "*"; break;
1603 opname = "max"; break;
1605 opname = "min"; break;
1607 opname = "=="; break;
1609 opname = "!="; break;
1611 opname = "<="; break;
1613 opname = ">="; break;
1615 opname = "<"; break;
1617 opname = ">"; break;
1619 opname = "<<"; break;
1621 opname = ">>"; break;
1622 case TRUNC_MOD_EXPR:
1623 case FLOOR_MOD_EXPR:
1624 opname = "%"; break;
1625 case TRUNC_DIV_EXPR:
1626 case FLOOR_DIV_EXPR:
1627 opname = "/"; break;
1629 opname = "&"; break;
1631 opname = "|"; break;
1632 case TRUTH_ANDIF_EXPR:
1633 opname = "&&"; break;
1634 case TRUTH_ORIF_EXPR:
1635 opname = "||"; break;
1637 opname = "^"; break;
1640 opname = "rotate"; break;
1642 opname = "unknown"; break;
1644 error ("invalid operands to binary %s", opname);
1647 /* Subroutine of build_binary_op, used for comparison operations.
1648 See if the operands have both been converted from subword integer types
1649 and, if so, perhaps change them both back to their original type.
1650 This function is also responsible for converting the two operands
1651 to the proper common type for comparison.
1653 The arguments of this function are all pointers to local variables
1654 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1655 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1657 If this function returns nonzero, it means that the comparison has
1658 a constant value. What this function returns is an expression for
1662 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1663 tree *op0_ptr, *op1_ptr;
1665 enum tree_code *rescode_ptr;
1668 tree op0 = *op0_ptr;
1669 tree op1 = *op1_ptr;
1670 int unsignedp0, unsignedp1;
1672 tree primop0, primop1;
1673 enum tree_code code = *rescode_ptr;
1675 /* Throw away any conversions to wider types
1676 already present in the operands. */
1678 primop0 = get_narrower (op0, &unsignedp0);
1679 primop1 = get_narrower (op1, &unsignedp1);
1681 /* Handle the case that OP0 does not *contain* a conversion
1682 but it *requires* conversion to FINAL_TYPE. */
1684 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1685 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1686 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1687 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1689 /* If one of the operands must be floated, we cannot optimize. */
1690 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1691 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1693 /* If first arg is constant, swap the args (changing operation
1694 so value is preserved), for canonicalization. Don't do this if
1695 the second arg is 0. */
1697 if (TREE_CONSTANT (primop0)
1698 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1701 int temi = unsignedp0;
1709 unsignedp0 = unsignedp1;
1732 *rescode_ptr = code;
1735 /* If comparing an integer against a constant more bits wide,
1736 maybe we can deduce a value of 1 or 0 independent of the data.
1737 Or else truncate the constant now
1738 rather than extend the variable at run time.
1740 This is only interesting if the constant is the wider arg.
1741 Also, it is not safe if the constant is unsigned and the
1742 variable arg is signed, since in this case the variable
1743 would be sign-extended and then regarded as unsigned.
1744 Our technique fails in this case because the lowest/highest
1745 possible unsigned results don't follow naturally from the
1746 lowest/highest possible values of the variable operand.
1747 For just EQ_EXPR and NE_EXPR there is another technique that
1748 could be used: see if the constant can be faithfully represented
1749 in the other operand's type, by truncating it and reextending it
1750 and see if that preserves the constant's value. */
1752 if (!real1 && !real2
1753 && TREE_CODE (primop1) == INTEGER_CST
1754 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1756 int min_gt, max_gt, min_lt, max_lt;
1757 tree maxval, minval;
1758 /* 1 if comparison is nominally unsigned. */
1759 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1762 type = c_common_signed_or_unsigned_type (unsignedp0,
1763 TREE_TYPE (primop0));
1765 /* If TYPE is an enumeration, then we need to get its min/max
1766 values from it's underlying integral type, not the enumerated
1768 if (TREE_CODE (type) == ENUMERAL_TYPE)
1769 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1771 maxval = TYPE_MAX_VALUE (type);
1772 minval = TYPE_MIN_VALUE (type);
1774 if (unsignedp && !unsignedp0)
1775 *restype_ptr = c_common_signed_type (*restype_ptr);
1777 if (TREE_TYPE (primop1) != *restype_ptr)
1778 primop1 = convert (*restype_ptr, primop1);
1779 if (type != *restype_ptr)
1781 minval = convert (*restype_ptr, minval);
1782 maxval = convert (*restype_ptr, maxval);
1785 if (unsignedp && unsignedp0)
1787 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1788 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1789 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1790 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1794 min_gt = INT_CST_LT (primop1, minval);
1795 max_gt = INT_CST_LT (primop1, maxval);
1796 min_lt = INT_CST_LT (minval, primop1);
1797 max_lt = INT_CST_LT (maxval, primop1);
1801 /* This used to be a switch, but Genix compiler can't handle that. */
1802 if (code == NE_EXPR)
1804 if (max_lt || min_gt)
1805 val = boolean_true_node;
1807 else if (code == EQ_EXPR)
1809 if (max_lt || min_gt)
1810 val = boolean_false_node;
1812 else if (code == LT_EXPR)
1815 val = boolean_true_node;
1817 val = boolean_false_node;
1819 else if (code == GT_EXPR)
1822 val = boolean_true_node;
1824 val = boolean_false_node;
1826 else if (code == LE_EXPR)
1829 val = boolean_true_node;
1831 val = boolean_false_node;
1833 else if (code == GE_EXPR)
1836 val = boolean_true_node;
1838 val = boolean_false_node;
1841 /* If primop0 was sign-extended and unsigned comparison specd,
1842 we did a signed comparison above using the signed type bounds.
1843 But the comparison we output must be unsigned.
1845 Also, for inequalities, VAL is no good; but if the signed
1846 comparison had *any* fixed result, it follows that the
1847 unsigned comparison just tests the sign in reverse
1848 (positive values are LE, negative ones GE).
1849 So we can generate an unsigned comparison
1850 against an extreme value of the signed type. */
1852 if (unsignedp && !unsignedp0)
1859 primop1 = TYPE_MIN_VALUE (type);
1865 primop1 = TYPE_MAX_VALUE (type);
1872 type = c_common_unsigned_type (type);
1875 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1877 /* This is the case of (char)x >?< 0x80, which people used to use
1878 expecting old C compilers to change the 0x80 into -0x80. */
1879 if (val == boolean_false_node)
1880 warning ("comparison is always false due to limited range of data type");
1881 if (val == boolean_true_node)
1882 warning ("comparison is always true due to limited range of data type");
1885 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1887 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1888 if (val == boolean_false_node)
1889 warning ("comparison is always false due to limited range of data type");
1890 if (val == boolean_true_node)
1891 warning ("comparison is always true due to limited range of data type");
1896 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1897 if (TREE_SIDE_EFFECTS (primop0))
1898 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1902 /* Value is not predetermined, but do the comparison
1903 in the type of the operand that is not constant.
1904 TYPE is already properly set. */
1906 else if (real1 && real2
1907 && (TYPE_PRECISION (TREE_TYPE (primop0))
1908 == TYPE_PRECISION (TREE_TYPE (primop1))))
1909 type = TREE_TYPE (primop0);
1911 /* If args' natural types are both narrower than nominal type
1912 and both extend in the same manner, compare them
1913 in the type of the wider arg.
1914 Otherwise must actually extend both to the nominal
1915 common type lest different ways of extending
1917 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1919 else if (unsignedp0 == unsignedp1 && real1 == real2
1920 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1921 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1923 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1924 type = c_common_signed_or_unsigned_type (unsignedp0
1925 || TREE_UNSIGNED (*restype_ptr),
1927 /* Make sure shorter operand is extended the right way
1928 to match the longer operand. */
1930 = convert (c_common_signed_or_unsigned_type (unsignedp0,
1931 TREE_TYPE (primop0)),
1934 = convert (c_common_signed_or_unsigned_type (unsignedp1,
1935 TREE_TYPE (primop1)),
1940 /* Here we must do the comparison on the nominal type
1941 using the args exactly as we received them. */
1942 type = *restype_ptr;
1946 if (!real1 && !real2 && integer_zerop (primop1)
1947 && TREE_UNSIGNED (*restype_ptr))
1953 /* All unsigned values are >= 0, so we warn if extra warnings
1954 are requested. However, if OP0 is a constant that is
1955 >= 0, the signedness of the comparison isn't an issue,
1956 so suppress the warning. */
1957 if (extra_warnings && !in_system_header
1958 && ! (TREE_CODE (primop0) == INTEGER_CST
1959 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
1961 warning ("comparison of unsigned expression >= 0 is always true");
1962 value = boolean_true_node;
1966 if (extra_warnings && !in_system_header
1967 && ! (TREE_CODE (primop0) == INTEGER_CST
1968 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
1970 warning ("comparison of unsigned expression < 0 is always false");
1971 value = boolean_false_node;
1980 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1981 if (TREE_SIDE_EFFECTS (primop0))
1982 return build (COMPOUND_EXPR, TREE_TYPE (value),
1989 *op0_ptr = convert (type, primop0);
1990 *op1_ptr = convert (type, primop1);
1992 *restype_ptr = boolean_type_node;
1997 /* Return a tree for the sum or difference (RESULTCODE says which)
1998 of pointer PTROP and integer INTOP. */
2001 pointer_int_sum (resultcode, ptrop, intop)
2002 enum tree_code resultcode;
2010 /* The result is a pointer of the same type that is being added. */
2012 tree result_type = TREE_TYPE (ptrop);
2014 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2016 if (pedantic || warn_pointer_arith)
2017 pedwarn ("pointer of type `void *' used in arithmetic");
2018 size_exp = integer_one_node;
2020 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2022 if (pedantic || warn_pointer_arith)
2023 pedwarn ("pointer to a function used in arithmetic");
2024 size_exp = integer_one_node;
2026 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2028 if (pedantic || warn_pointer_arith)
2029 pedwarn ("pointer to member function used in arithmetic");
2030 size_exp = integer_one_node;
2032 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2034 if (pedantic || warn_pointer_arith)
2035 pedwarn ("pointer to a member used in arithmetic");
2036 size_exp = integer_one_node;
2039 size_exp = size_in_bytes (TREE_TYPE (result_type));
2041 /* If what we are about to multiply by the size of the elements
2042 contains a constant term, apply distributive law
2043 and multiply that constant term separately.
2044 This helps produce common subexpressions. */
2046 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2047 && ! TREE_CONSTANT (intop)
2048 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2049 && TREE_CONSTANT (size_exp)
2050 /* If the constant comes from pointer subtraction,
2051 skip this optimization--it would cause an error. */
2052 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2053 /* If the constant is unsigned, and smaller than the pointer size,
2054 then we must skip this optimization. This is because it could cause
2055 an overflow error if the constant is negative but INTOP is not. */
2056 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2057 || (TYPE_PRECISION (TREE_TYPE (intop))
2058 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2060 enum tree_code subcode = resultcode;
2061 tree int_type = TREE_TYPE (intop);
2062 if (TREE_CODE (intop) == MINUS_EXPR)
2063 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2064 /* Convert both subexpression types to the type of intop,
2065 because weird cases involving pointer arithmetic
2066 can result in a sum or difference with different type args. */
2067 ptrop = build_binary_op (subcode, ptrop,
2068 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2069 intop = convert (int_type, TREE_OPERAND (intop, 0));
2072 /* Convert the integer argument to a type the same size as sizetype
2073 so the multiply won't overflow spuriously. */
2075 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2076 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2077 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2078 TREE_UNSIGNED (sizetype)), intop);
2080 /* Replace the integer argument with a suitable product by the object size.
2081 Do this multiplication as signed, then convert to the appropriate
2082 pointer type (actually unsigned integral). */
2084 intop = convert (result_type,
2085 build_binary_op (MULT_EXPR, intop,
2086 convert (TREE_TYPE (intop), size_exp), 1));
2088 /* Create the sum or difference. */
2090 result = build (resultcode, result_type, ptrop, intop);
2092 folded = fold (result);
2093 if (folded == result)
2094 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2098 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2099 or validate its data type for an `if' or `while' statement or ?..: exp.
2101 This preparation consists of taking the ordinary
2102 representation of an expression expr and producing a valid tree
2103 boolean expression describing whether expr is nonzero. We could
2104 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2105 but we optimize comparisons, &&, ||, and !.
2107 The resulting type should always be `boolean_type_node'. */
2110 c_common_truthvalue_conversion (expr)
2113 if (TREE_CODE (expr) == ERROR_MARK)
2116 #if 0 /* This appears to be wrong for C++. */
2117 /* These really should return error_mark_node after 2.4 is stable.
2118 But not all callers handle ERROR_MARK properly. */
2119 switch (TREE_CODE (TREE_TYPE (expr)))
2122 error ("struct type value used where scalar is required");
2123 return boolean_false_node;
2126 error ("union type value used where scalar is required");
2127 return boolean_false_node;
2130 error ("array type value used where scalar is required");
2131 return boolean_false_node;
2138 switch (TREE_CODE (expr))
2141 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2142 case TRUTH_ANDIF_EXPR:
2143 case TRUTH_ORIF_EXPR:
2144 case TRUTH_AND_EXPR:
2146 case TRUTH_XOR_EXPR:
2147 case TRUTH_NOT_EXPR:
2148 TREE_TYPE (expr) = boolean_type_node;
2155 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2158 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2161 /* If we are taking the address of an external decl, it might be zero
2162 if it is weak, so we cannot optimize. */
2163 if (DECL_P (TREE_OPERAND (expr, 0))
2164 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2167 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2168 return build (COMPOUND_EXPR, boolean_type_node,
2169 TREE_OPERAND (expr, 0), boolean_true_node);
2171 return boolean_true_node;
2174 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2175 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2176 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2177 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2184 /* These don't change whether an object is non-zero or zero. */
2185 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2189 /* These don't change whether an object is zero or non-zero, but
2190 we can't ignore them if their second arg has side-effects. */
2191 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2192 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2193 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2195 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2198 /* Distribute the conversion into the arms of a COND_EXPR. */
2199 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2200 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2201 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2204 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2205 since that affects how `default_conversion' will behave. */
2206 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2207 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2209 /* fall through... */
2211 /* If this is widening the argument, we can ignore it. */
2212 if (TYPE_PRECISION (TREE_TYPE (expr))
2213 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2214 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2218 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2219 aren't guaranteed to the be same for modes that can represent
2220 infinity, since if x and y are both +infinity, or both
2221 -infinity, then x - y is not a number.
2223 Note that this transformation is safe when x or y is NaN.
2224 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2226 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2228 /* fall through... */
2230 /* This and MINUS_EXPR can be changed into a comparison of the
2232 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2233 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2234 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2235 TREE_OPERAND (expr, 1), 1);
2236 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2237 fold (build1 (NOP_EXPR,
2238 TREE_TYPE (TREE_OPERAND (expr, 0)),
2239 TREE_OPERAND (expr, 1))), 1);
2242 if (integer_onep (TREE_OPERAND (expr, 1))
2243 && TREE_TYPE (expr) != boolean_type_node)
2244 /* Using convert here would cause infinite recursion. */
2245 return build1 (NOP_EXPR, boolean_type_node, expr);
2249 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2250 warning ("suggest parentheses around assignment used as truth value");
2257 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2259 tree t = save_expr (expr);
2260 return (build_binary_op
2261 ((TREE_SIDE_EFFECTS (expr)
2262 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2263 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2264 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2268 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2271 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2272 int, enum built_in_class, int, int,
2275 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2276 down to the element type of an array. */
2279 c_build_qualified_type (type, type_quals)
2283 /* A restrict-qualified pointer type must be a pointer to object or
2284 incomplete type. Note that the use of POINTER_TYPE_P also allows
2285 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2286 the C++ front-end also use POINTER_TYPE for pointer-to-member
2287 values, so even though it should be illegal to use `restrict'
2288 with such an entity we don't flag that here. Thus, special case
2289 code for that case is required in the C++ front-end. */
2290 if ((type_quals & TYPE_QUAL_RESTRICT)
2291 && (!POINTER_TYPE_P (type)
2292 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2294 error ("invalid use of `restrict'");
2295 type_quals &= ~TYPE_QUAL_RESTRICT;
2298 if (TREE_CODE (type) == ARRAY_TYPE)
2299 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2301 TYPE_DOMAIN (type));
2302 return build_qualified_type (type, type_quals);
2305 /* Apply the TYPE_QUALS to the new DECL. */
2308 c_apply_type_quals_to_decl (type_quals, decl)
2312 if ((type_quals & TYPE_QUAL_CONST)
2313 || (TREE_TYPE (decl)
2314 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2315 TREE_READONLY (decl) = 1;
2316 if (type_quals & TYPE_QUAL_VOLATILE)
2318 TREE_SIDE_EFFECTS (decl) = 1;
2319 TREE_THIS_VOLATILE (decl) = 1;
2321 if (type_quals & TYPE_QUAL_RESTRICT)
2323 if (!TREE_TYPE (decl)
2324 || !POINTER_TYPE_P (TREE_TYPE (decl))
2325 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2326 error ("invalid use of `restrict'");
2327 else if (flag_strict_aliasing)
2328 /* Indicate we need to make a unique alias set for this pointer.
2329 We can't do it here because it might be pointing to an
2331 DECL_POINTER_ALIAS_SET (decl) = -2;
2335 /* Return the typed-based alias set for T, which may be an expression
2336 or a type. Return -1 if we don't do anything special. */
2339 c_common_get_alias_set (t)
2344 /* We know nothing about vector types */
2345 if (TREE_CODE (t) == VECTOR_TYPE)
2348 /* Permit type-punning when accessing a union, provided the access
2349 is directly through the union. For example, this code does not
2350 permit taking the address of a union member and then storing
2351 through it. Even the type-punning allowed here is a GCC
2352 extension, albeit a common and useful one; the C standard says
2353 that such accesses have implementation-defined behavior. */
2355 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2356 u = TREE_OPERAND (u, 0))
2357 if (TREE_CODE (u) == COMPONENT_REF
2358 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2361 /* If this is a char *, the ANSI C standard says it can alias
2362 anything. Note that all references need do this. */
2363 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2364 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2365 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2368 /* That's all the expressions we handle specially. */
2372 /* The C standard specifically allows aliasing between signed and
2373 unsigned variants of the same type. We treat the signed
2374 variant as canonical. */
2375 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2377 tree t1 = c_common_signed_type (t);
2379 /* t1 == t can happen for boolean nodes which are always unsigned. */
2381 return get_alias_set (t1);
2383 else if (POINTER_TYPE_P (t))
2387 /* Unfortunately, there is no canonical form of a pointer type.
2388 In particular, if we have `typedef int I', then `int *', and
2389 `I *' are different types. So, we have to pick a canonical
2390 representative. We do this below.
2392 Technically, this approach is actually more conservative that
2393 it needs to be. In particular, `const int *' and `int *'
2394 should be in different alias sets, according to the C and C++
2395 standard, since their types are not the same, and so,
2396 technically, an `int **' and `const int **' cannot point at
2399 But, the standard is wrong. In particular, this code is
2404 const int* const* cipp = &ipp;
2406 And, it doesn't make sense for that to be legal unless you
2407 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2408 the pointed-to types. This issue has been reported to the
2410 t1 = build_type_no_quals (t);
2412 return get_alias_set (t1);
2418 /* Implement the __alignof keyword: Return the minimum required
2419 alignment of TYPE, measured in bytes. */
2425 enum tree_code code = TREE_CODE (type);
2428 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2429 if (code == REFERENCE_TYPE)
2431 type = TREE_TYPE (type);
2432 code = TREE_CODE (type);
2435 if (code == FUNCTION_TYPE)
2436 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2437 else if (code == VOID_TYPE || code == ERROR_MARK)
2439 else if (!COMPLETE_TYPE_P (type))
2441 error ("__alignof__ applied to an incomplete type");
2445 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2447 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2450 /* Implement the __alignof keyword: Return the minimum required
2451 alignment of EXPR, measured in bytes. For VAR_DECL's and
2452 FIELD_DECL's return DECL_ALIGN (which can be set from an
2453 "aligned" __attribute__ specification). */
2456 c_alignof_expr (expr)
2461 if (TREE_CODE (expr) == VAR_DECL)
2462 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2464 else if (TREE_CODE (expr) == COMPONENT_REF
2465 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2467 error ("`__alignof' applied to a bit-field");
2470 else if (TREE_CODE (expr) == COMPONENT_REF
2471 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2472 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2474 else if (TREE_CODE (expr) == INDIRECT_REF)
2476 tree t = TREE_OPERAND (expr, 0);
2478 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2480 while (TREE_CODE (t) == NOP_EXPR
2481 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2485 t = TREE_OPERAND (t, 0);
2486 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2487 if (thisalign > bestalign)
2488 best = t, bestalign = thisalign;
2490 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2493 return c_alignof (TREE_TYPE (expr));
2495 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2498 /* Give the specifications for the format attributes, used by C and all
2501 static const struct attribute_spec c_format_attribute_table[] =
2503 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2504 { "format", 3, 3, false, true, true,
2505 handle_format_attribute },
2506 { "format_arg", 1, 1, false, true, true,
2507 handle_format_arg_attribute },
2508 { NULL, 0, 0, false, false, false, NULL }
2511 /* Build tree nodes and builtin functions common to both C and C++ language
2515 c_common_nodes_and_builtins ()
2519 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2520 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2521 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2522 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2523 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2524 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2525 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2526 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2527 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2528 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2529 #include "builtin-types.def"
2530 #undef DEF_PRIMITIVE_TYPE
2531 #undef DEF_FUNCTION_TYPE_0
2532 #undef DEF_FUNCTION_TYPE_1
2533 #undef DEF_FUNCTION_TYPE_2
2534 #undef DEF_FUNCTION_TYPE_3
2535 #undef DEF_FUNCTION_TYPE_4
2536 #undef DEF_FUNCTION_TYPE_VAR_0
2537 #undef DEF_FUNCTION_TYPE_VAR_1
2538 #undef DEF_FUNCTION_TYPE_VAR_2
2539 #undef DEF_POINTER_TYPE
2543 typedef enum builtin_type builtin_type;
2545 tree builtin_types[(int) BT_LAST];
2546 int wchar_type_size;
2547 tree array_domain_type;
2548 tree va_list_ref_type_node;
2549 tree va_list_arg_type_node;
2551 /* We must initialize this before any builtin functions (which might have
2552 attributes) are declared. (c_common_init is too late.) */
2553 format_attribute_table = c_format_attribute_table;
2555 /* Define `int' and `char' first so that dbx will output them first. */
2556 record_builtin_type (RID_INT, NULL, integer_type_node);
2557 record_builtin_type (RID_CHAR, "char", char_type_node);
2559 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2560 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2561 but not C. Are the conditionals here needed? */
2562 if (c_language == clk_cplusplus)
2563 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2564 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2565 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2566 record_builtin_type (RID_MAX, "long unsigned int",
2567 long_unsigned_type_node);
2568 if (c_language == clk_cplusplus)
2569 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2570 record_builtin_type (RID_MAX, "long long int",
2571 long_long_integer_type_node);
2572 record_builtin_type (RID_MAX, "long long unsigned int",
2573 long_long_unsigned_type_node);
2574 if (c_language == clk_cplusplus)
2575 record_builtin_type (RID_MAX, "long long unsigned",
2576 long_long_unsigned_type_node);
2577 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2578 record_builtin_type (RID_MAX, "short unsigned int",
2579 short_unsigned_type_node);
2580 if (c_language == clk_cplusplus)
2581 record_builtin_type (RID_MAX, "unsigned short",
2582 short_unsigned_type_node);
2584 /* Define both `signed char' and `unsigned char'. */
2585 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2586 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2588 /* These are types that c_common_type_for_size and
2589 c_common_type_for_mode use. */
2590 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2592 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2594 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2596 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2598 #if HOST_BITS_PER_WIDE_INT >= 64
2599 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2600 get_identifier ("__int128_t"),
2603 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2604 unsigned_intQI_type_node));
2605 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2606 unsigned_intHI_type_node));
2607 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2608 unsigned_intSI_type_node));
2609 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2610 unsigned_intDI_type_node));
2611 #if HOST_BITS_PER_WIDE_INT >= 64
2612 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2613 get_identifier ("__uint128_t"),
2614 unsigned_intTI_type_node));
2617 /* Create the widest literal types. */
2618 widest_integer_literal_type_node
2619 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2620 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2621 widest_integer_literal_type_node));
2623 widest_unsigned_literal_type_node
2624 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2625 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2626 widest_unsigned_literal_type_node));
2628 /* `unsigned long' is the standard type for sizeof.
2629 Note that stddef.h uses `unsigned long',
2630 and this must agree, even if long and int are the same size. */
2632 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2633 signed_size_type_node = c_common_signed_type (c_size_type_node);
2634 set_sizetype (c_size_type_node);
2636 build_common_tree_nodes_2 (flag_short_double);
2638 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2639 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2640 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2642 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2643 get_identifier ("complex int"),
2644 complex_integer_type_node));
2645 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2646 get_identifier ("complex float"),
2647 complex_float_type_node));
2648 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2649 get_identifier ("complex double"),
2650 complex_double_type_node));
2651 (*lang_hooks.decls.pushdecl)
2652 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2653 complex_long_double_type_node));
2655 /* Types which are common to the fortran compiler and libf2c. When
2656 changing these, you also need to be concerned with f/com.h. */
2658 if (TYPE_PRECISION (float_type_node)
2659 == TYPE_PRECISION (long_integer_type_node))
2661 g77_integer_type_node = long_integer_type_node;
2662 g77_uinteger_type_node = long_unsigned_type_node;
2664 else if (TYPE_PRECISION (float_type_node)
2665 == TYPE_PRECISION (integer_type_node))
2667 g77_integer_type_node = integer_type_node;
2668 g77_uinteger_type_node = unsigned_type_node;
2671 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
2673 if (g77_integer_type_node != NULL_TREE)
2675 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2676 get_identifier ("__g77_integer"),
2677 g77_integer_type_node));
2678 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2679 get_identifier ("__g77_uinteger"),
2680 g77_uinteger_type_node));
2683 if (TYPE_PRECISION (float_type_node) * 2
2684 == TYPE_PRECISION (long_integer_type_node))
2686 g77_longint_type_node = long_integer_type_node;
2687 g77_ulongint_type_node = long_unsigned_type_node;
2689 else if (TYPE_PRECISION (float_type_node) * 2
2690 == TYPE_PRECISION (long_long_integer_type_node))
2692 g77_longint_type_node = long_long_integer_type_node;
2693 g77_ulongint_type_node = long_long_unsigned_type_node;
2696 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
2698 if (g77_longint_type_node != NULL_TREE)
2700 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2701 get_identifier ("__g77_longint"),
2702 g77_longint_type_node));
2703 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2704 get_identifier ("__g77_ulongint"),
2705 g77_ulongint_type_node));
2708 record_builtin_type (RID_VOID, NULL, void_type_node);
2710 void_zero_node = build_int_2 (0, 0);
2711 TREE_TYPE (void_zero_node) = void_type_node;
2713 void_list_node = build_void_list_node ();
2715 /* Make a type to be the domain of a few array types
2716 whose domains don't really matter.
2717 200 is small enough that it always fits in size_t
2718 and large enough that it can hold most function names for the
2719 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2720 array_domain_type = build_index_type (size_int (200));
2722 /* Make a type for arrays of characters.
2723 With luck nothing will ever really depend on the length of this
2725 char_array_type_node
2726 = build_array_type (char_type_node, array_domain_type);
2728 /* Likewise for arrays of ints. */
2730 = build_array_type (integer_type_node, array_domain_type);
2732 string_type_node = build_pointer_type (char_type_node);
2733 const_string_type_node
2734 = build_pointer_type (build_qualified_type
2735 (char_type_node, TYPE_QUAL_CONST));
2737 (*targetm.init_builtins) ();
2739 /* This is special for C++ so functions can be overloaded. */
2740 wchar_type_node = get_identifier (flag_short_wchar
2741 ? "short unsigned int"
2743 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2744 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2745 if (c_language == clk_cplusplus)
2747 if (TREE_UNSIGNED (wchar_type_node))
2748 wchar_type_node = make_unsigned_type (wchar_type_size);
2750 wchar_type_node = make_signed_type (wchar_type_size);
2751 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2755 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
2756 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
2759 /* This is for wide string constants. */
2760 wchar_array_type_node
2761 = build_array_type (wchar_type_node, array_domain_type);
2764 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2767 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2769 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2771 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2773 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2774 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
2776 (*lang_hooks.decls.pushdecl)
2777 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2778 va_list_type_node));
2780 (*lang_hooks.decls.pushdecl)
2781 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2782 ptrdiff_type_node));
2784 (*lang_hooks.decls.pushdecl)
2785 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2788 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2790 va_list_arg_type_node = va_list_ref_type_node =
2791 build_pointer_type (TREE_TYPE (va_list_type_node));
2795 va_list_arg_type_node = va_list_type_node;
2796 va_list_ref_type_node = build_reference_type (va_list_type_node);
2799 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2800 builtin_types[(int) ENUM] = VALUE;
2801 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2802 builtin_types[(int) ENUM] \
2803 = build_function_type (builtin_types[(int) RETURN], \
2805 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2806 builtin_types[(int) ENUM] \
2807 = build_function_type (builtin_types[(int) RETURN], \
2808 tree_cons (NULL_TREE, \
2809 builtin_types[(int) ARG1], \
2811 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2812 builtin_types[(int) ENUM] \
2813 = build_function_type \
2814 (builtin_types[(int) RETURN], \
2815 tree_cons (NULL_TREE, \
2816 builtin_types[(int) ARG1], \
2817 tree_cons (NULL_TREE, \
2818 builtin_types[(int) ARG2], \
2820 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2821 builtin_types[(int) ENUM] \
2822 = build_function_type \
2823 (builtin_types[(int) RETURN], \
2824 tree_cons (NULL_TREE, \
2825 builtin_types[(int) ARG1], \
2826 tree_cons (NULL_TREE, \
2827 builtin_types[(int) ARG2], \
2828 tree_cons (NULL_TREE, \
2829 builtin_types[(int) ARG3], \
2831 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2832 builtin_types[(int) ENUM] \
2833 = build_function_type \
2834 (builtin_types[(int) RETURN], \
2835 tree_cons (NULL_TREE, \
2836 builtin_types[(int) ARG1], \
2837 tree_cons (NULL_TREE, \
2838 builtin_types[(int) ARG2], \
2841 builtin_types[(int) ARG3], \
2842 tree_cons (NULL_TREE, \
2843 builtin_types[(int) ARG4], \
2844 void_list_node)))));
2845 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2846 builtin_types[(int) ENUM] \
2847 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2848 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2849 builtin_types[(int) ENUM] \
2850 = build_function_type (builtin_types[(int) RETURN], \
2851 tree_cons (NULL_TREE, \
2852 builtin_types[(int) ARG1], \
2855 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2856 builtin_types[(int) ENUM] \
2857 = build_function_type \
2858 (builtin_types[(int) RETURN], \
2859 tree_cons (NULL_TREE, \
2860 builtin_types[(int) ARG1], \
2861 tree_cons (NULL_TREE, \
2862 builtin_types[(int) ARG2], \
2864 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2865 builtin_types[(int) ENUM] \
2866 = build_pointer_type (builtin_types[(int) TYPE]);
2867 #include "builtin-types.def"
2868 #undef DEF_PRIMITIVE_TYPE
2869 #undef DEF_FUNCTION_TYPE_1
2870 #undef DEF_FUNCTION_TYPE_2
2871 #undef DEF_FUNCTION_TYPE_3
2872 #undef DEF_FUNCTION_TYPE_4
2873 #undef DEF_FUNCTION_TYPE_VAR_0
2874 #undef DEF_FUNCTION_TYPE_VAR_1
2875 #undef DEF_POINTER_TYPE
2877 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2878 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2883 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2887 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2890 ? (NAME + strlen ("__builtin_")) \
2893 decl = builtin_function_2 (NAME, \
2894 NAME + strlen ("__builtin_"), \
2895 builtin_types[TYPE], \
2896 builtin_types[LIBTYPE], \
2901 /*noreturn_p=*/0); \
2903 built_in_decls[(int) ENUM] = decl; \
2905 #include "builtins.def"
2908 /* Declare _exit and _Exit just to mark them as non-returning. */
2909 builtin_function_2 (NULL, "_exit", NULL_TREE,
2910 builtin_types[BT_FN_VOID_INT],
2911 0, NOT_BUILT_IN, 0, 1, 1);
2912 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2913 builtin_types[BT_FN_VOID_INT],
2914 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2916 /* Declare these functions non-returning
2917 to avoid spurious "control drops through" warnings. */
2918 builtin_function_2 (NULL, "abort",
2919 NULL_TREE, ((c_language == clk_cplusplus)
2920 ? builtin_types[BT_FN_VOID]
2921 : builtin_types[BT_FN_VOID_VAR]),
2922 0, NOT_BUILT_IN, 0, 0, 1);
2924 builtin_function_2 (NULL, "exit",
2925 NULL_TREE, ((c_language == clk_cplusplus)
2926 ? builtin_types[BT_FN_VOID_INT]
2927 : builtin_types[BT_FN_VOID_VAR]),
2928 0, NOT_BUILT_IN, 0, 0, 1);
2930 main_identifier_node = get_identifier ("main");
2932 /* ??? Perhaps there's a better place to do this. But it is related
2933 to __builtin_va_arg, so it isn't that off-the-wall. */
2934 lang_type_promotes_to = simple_type_promotes_to;
2938 build_va_arg (expr, type)
2941 return build1 (VA_ARG_EXPR, type, expr);
2945 /* Linked list of disabled built-in functions. */
2947 typedef struct disabled_builtin
2950 struct disabled_builtin *next;
2952 static disabled_builtin *disabled_builtins = NULL;
2954 static bool builtin_function_disabled_p PARAMS ((const char *));
2956 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2957 begins with "__builtin_", give an error. */
2960 disable_builtin_function (name)
2963 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2964 error ("cannot disable built-in function `%s'", name);
2967 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2969 new->next = disabled_builtins;
2970 disabled_builtins = new;
2975 /* Return true if the built-in function NAME has been disabled, false
2979 builtin_function_disabled_p (name)
2982 disabled_builtin *p;
2983 for (p = disabled_builtins; p != NULL; p = p->next)
2985 if (strcmp (name, p->name) == 0)
2992 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2993 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2994 of these may be NULL (though both being NULL is useless).
2995 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2996 TYPE is the type of the function with the ordinary name. These
2997 may differ if the ordinary name is declared with a looser type to avoid
2998 conflicts with headers. FUNCTION_CODE and CLASS are as for
2999 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3000 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3001 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3002 NORETURN_P is nonzero, the function is marked as non-returning.
3003 Returns the declaration of BUILTIN_NAME, if any, otherwise
3004 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3005 or if NONANSI_P and flag_no_nonansi_builtin. */
3008 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3009 class, library_name_p, nonansi_p, noreturn_p)
3010 const char *builtin_name;
3015 enum built_in_class class;
3020 tree bdecl = NULL_TREE;
3021 tree decl = NULL_TREE;
3022 if (builtin_name != 0)
3024 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3025 class, library_name_p ? name : NULL);
3028 TREE_THIS_VOLATILE (bdecl) = 1;
3029 TREE_SIDE_EFFECTS (bdecl) = 1;
3032 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3033 && !(nonansi_p && flag_no_nonansi_builtin))
3035 decl = builtin_function (name, type, function_code, class, NULL);
3037 DECL_BUILT_IN_NONANSI (decl) = 1;
3040 TREE_THIS_VOLATILE (decl) = 1;
3041 TREE_SIDE_EFFECTS (decl) = 1;
3044 return (bdecl != 0 ? bdecl : decl);
3047 /* Nonzero if the type T promotes to int. This is (nearly) the
3048 integral promotions defined in ISO C99 6.3.1.1/2. */
3051 c_promoting_integer_type_p (t)
3054 switch (TREE_CODE (t))
3057 return (TYPE_MAIN_VARIANT (t) == char_type_node
3058 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3059 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3060 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3061 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3062 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3065 /* ??? Technically all enumerations not larger than an int
3066 promote to an int. But this is used along code paths
3067 that only want to notice a size change. */
3068 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3078 /* Given a type, apply default promotions wrt unnamed function arguments
3079 and return the new type. Return NULL_TREE if no change. */
3080 /* ??? There is a function of the same name in the C++ front end that
3081 does something similar, but is more thorough and does not return NULL
3082 if no change. We could perhaps share code, but it would make the
3083 self_promoting_type property harder to identify. */
3086 simple_type_promotes_to (type)
3089 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3090 return double_type_node;
3092 if (c_promoting_integer_type_p (type))
3094 /* Preserve unsignedness if not really getting any wider. */
3095 if (TREE_UNSIGNED (type)
3096 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3097 return unsigned_type_node;
3098 return integer_type_node;
3104 /* Return 1 if PARMS specifies a fixed number of parameters
3105 and none of their types is affected by default promotions. */
3108 self_promoting_args_p (parms)
3112 for (t = parms; t; t = TREE_CHAIN (t))
3114 tree type = TREE_VALUE (t);
3116 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3122 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3125 if (c_promoting_integer_type_p (type))
3131 /* Recursively examines the array elements of TYPE, until a non-array
3132 element type is found. */
3135 strip_array_types (type)
3138 while (TREE_CODE (type) == ARRAY_TYPE)
3139 type = TREE_TYPE (type);
3144 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3147 /* Expand a call to an unordered comparison function such as
3148 __builtin_isgreater(). FUNCTION is the function's declaration and
3149 PARAMS a list of the values passed. For __builtin_isunordered(),
3150 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3151 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3152 that give the opposite of the desired result. UNORDERED_CODE is
3153 used for modes that can hold NaNs and ORDERED_CODE is used for the
3157 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3158 tree function, params;
3159 enum tree_code unordered_code, ordered_code;
3161 tree arg0, arg1, type;
3162 enum tree_code code0, code1;
3164 /* Check that we have exactly two arguments. */
3165 if (params == 0 || TREE_CHAIN (params) == 0)
3167 error ("too few arguments to function `%s'",
3168 IDENTIFIER_POINTER (DECL_NAME (function)));
3169 return error_mark_node;
3171 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3173 error ("too many arguments to function `%s'",
3174 IDENTIFIER_POINTER (DECL_NAME (function)));
3175 return error_mark_node;
3178 arg0 = TREE_VALUE (params);
3179 arg1 = TREE_VALUE (TREE_CHAIN (params));
3181 code0 = TREE_CODE (TREE_TYPE (arg0));
3182 code1 = TREE_CODE (TREE_TYPE (arg1));
3184 /* Make sure that the arguments have a common type of REAL. */
3186 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3187 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3188 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3190 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3192 error ("non-floating-point argument to function `%s'",
3193 IDENTIFIER_POINTER (DECL_NAME (function)));
3194 return error_mark_node;
3197 if (unordered_code == UNORDERED_EXPR)
3199 if (MODE_HAS_NANS (TYPE_MODE (type)))
3200 return build_binary_op (unordered_code,
3201 convert (type, arg0),
3202 convert (type, arg1),
3205 return integer_zero_node;
3208 return build_unary_op (TRUTH_NOT_EXPR,
3209 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3212 convert (type, arg0),
3213 convert (type, arg1),
3219 /* Recognize certain built-in functions so we can make tree-codes
3220 other than CALL_EXPR. We do this when it enables fold-const.c
3221 to do something useful. */
3222 /* ??? By rights this should go in builtins.c, but only C and C++
3223 implement build_{binary,unary}_op. Not exactly sure what bits
3224 of functionality are actually needed from those functions, or
3225 where the similar functionality exists in the other front ends. */
3228 expand_tree_builtin (function, params, coerced_params)
3229 tree function, params, coerced_params;
3231 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3234 switch (DECL_FUNCTION_CODE (function))
3238 case BUILT_IN_LLABS:
3239 case BUILT_IN_IMAXABS:
3241 case BUILT_IN_FABSL:
3242 case BUILT_IN_FABSF:
3243 if (coerced_params == 0)
3244 return integer_zero_node;
3245 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3248 case BUILT_IN_CONJF:
3249 case BUILT_IN_CONJL:
3250 if (coerced_params == 0)
3251 return integer_zero_node;
3252 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3254 case BUILT_IN_CREAL:
3255 case BUILT_IN_CREALF:
3256 case BUILT_IN_CREALL:
3257 if (coerced_params == 0)
3258 return integer_zero_node;
3259 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3261 case BUILT_IN_CIMAG:
3262 case BUILT_IN_CIMAGF:
3263 case BUILT_IN_CIMAGL:
3264 if (coerced_params == 0)
3265 return integer_zero_node;
3266 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3268 case BUILT_IN_ISGREATER:
3269 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3271 case BUILT_IN_ISGREATEREQUAL:
3272 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3274 case BUILT_IN_ISLESS:
3275 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3277 case BUILT_IN_ISLESSEQUAL:
3278 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3280 case BUILT_IN_ISLESSGREATER:
3281 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3283 case BUILT_IN_ISUNORDERED:
3284 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3293 /* Returns non-zero if CODE is the code for a statement. */
3296 statement_code_p (code)
3297 enum tree_code code;
3322 if (lang_statement_code_p)
3323 return (*lang_statement_code_p) (code);
3328 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3329 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3330 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3331 value, the traversal is aborted, and the value returned by FUNC is
3332 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3333 the node being visited are not walked.
3335 We don't need a without_duplicates variant of this one because the
3336 statement tree is a tree, not a graph. */
3339 walk_stmt_tree (tp, func, data)
3344 enum tree_code code;
3349 #define WALK_SUBTREE(NODE) \
3352 result = walk_stmt_tree (&(NODE), func, data); \
3358 /* Skip empty subtrees. */
3362 /* Skip subtrees below non-statement nodes. */
3363 if (!statement_code_p (TREE_CODE (*tp)))
3366 /* Call the function. */
3368 result = (*func) (tp, &walk_subtrees, data);
3370 /* If we found something, return it. */
3374 /* FUNC may have modified the tree, recheck that we're looking at a
3376 code = TREE_CODE (*tp);
3377 if (!statement_code_p (code))
3380 /* Visit the subtrees unless FUNC decided that there was nothing
3381 interesting below this point in the tree. */
3384 /* Walk over all the sub-trees of this operand. Statement nodes
3385 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3386 len = TREE_CODE_LENGTH (code);
3388 /* Go through the subtrees. We need to do this in forward order so
3389 that the scope of a FOR_EXPR is handled properly. */
3390 for (i = 0; i < len; ++i)
3391 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3394 /* Finally visit the chain. This can be tail-recursion optimized if
3395 we write it this way. */
3396 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3401 /* Used to compare case labels. K1 and K2 are actually tree nodes
3402 representing case labels, or NULL_TREE for a `default' label.
3403 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3404 K2, and 0 if K1 and K2 are equal. */
3407 case_compare (k1, k2)
3411 /* Consider a NULL key (such as arises with a `default' label) to be
3412 smaller than anything else. */
3418 return tree_int_cst_compare ((tree) k1, (tree) k2);
3421 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3422 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3423 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3424 case label was declared using the usual C/C++ syntax, rather than
3425 the GNU case range extension. CASES is a tree containing all the
3426 case ranges processed so far; COND is the condition for the
3427 switch-statement itself. Returns the CASE_LABEL created, or
3428 ERROR_MARK_NODE if no CASE_LABEL is created. */
3431 c_add_case_label (cases, cond, low_value, high_value)
3440 splay_tree_node node;
3442 /* Create the LABEL_DECL itself. */
3443 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3444 DECL_CONTEXT (label) = current_function_decl;
3446 /* If there was an error processing the switch condition, bail now
3447 before we get more confused. */
3448 if (!cond || cond == error_mark_node)
3450 /* Add a label anyhow so that the back-end doesn't think that
3451 the beginning of the switch is unreachable. */
3453 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3454 return error_mark_node;
3457 if ((low_value && TREE_TYPE (low_value)
3458 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3459 || (high_value && TREE_TYPE (high_value)
3460 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3461 error ("pointers are not permitted as case values");
3463 /* Case ranges are a GNU extension. */
3464 if (high_value && pedantic)
3466 if (c_language == clk_cplusplus)
3467 pedwarn ("ISO C++ forbids range expressions in switch statements");
3469 pedwarn ("ISO C forbids range expressions in switch statements");
3472 type = TREE_TYPE (cond);
3475 low_value = check_case_value (low_value);
3476 low_value = convert_and_check (type, low_value);
3480 high_value = check_case_value (high_value);
3481 high_value = convert_and_check (type, high_value);
3484 /* If an error has occurred, bail out now. */
3485 if (low_value == error_mark_node || high_value == error_mark_node)
3488 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3489 return error_mark_node;
3492 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3493 really a case range, even though it was written that way. Remove
3494 the HIGH_VALUE to simplify later processing. */
3495 if (tree_int_cst_equal (low_value, high_value))
3496 high_value = NULL_TREE;
3497 if (low_value && high_value
3498 && !tree_int_cst_lt (low_value, high_value))
3499 warning ("empty range specified");
3501 /* Look up the LOW_VALUE in the table of case labels we already
3503 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3504 /* If there was not an exact match, check for overlapping ranges.
3505 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3506 that's a `default' label and the only overlap is an exact match. */
3507 if (!node && (low_value || high_value))
3509 splay_tree_node low_bound;
3510 splay_tree_node high_bound;
3512 /* Even though there wasn't an exact match, there might be an
3513 overlap between this case range and another case range.
3514 Since we've (inductively) not allowed any overlapping case
3515 ranges, we simply need to find the greatest low case label
3516 that is smaller that LOW_VALUE, and the smallest low case
3517 label that is greater than LOW_VALUE. If there is an overlap
3518 it will occur in one of these two ranges. */
3519 low_bound = splay_tree_predecessor (cases,
3520 (splay_tree_key) low_value);
3521 high_bound = splay_tree_successor (cases,
3522 (splay_tree_key) low_value);
3524 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3525 the LOW_VALUE, so there is no need to check unless the
3526 LOW_BOUND is in fact itself a case range. */
3528 && CASE_HIGH ((tree) low_bound->value)
3529 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3532 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3533 range is bigger than the low end of the current range, so we
3534 are only interested if the current range is a real range, and
3535 not an ordinary case label. */
3538 && (tree_int_cst_compare ((tree) high_bound->key,
3543 /* If there was an overlap, issue an error. */
3546 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3550 error ("duplicate (or overlapping) case value");
3551 error_with_decl (duplicate,
3552 "this is the first entry overlapping that value");
3556 error ("duplicate case value") ;
3557 error_with_decl (duplicate, "previously used here");
3561 error ("multiple default labels in one switch");
3562 error_with_decl (duplicate, "this is the first default label");
3565 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3568 /* Add a CASE_LABEL to the statement-tree. */
3569 case_label = add_stmt (build_case_label (low_value, high_value, label));
3570 /* Register this case label in the splay tree. */
3571 splay_tree_insert (cases,
3572 (splay_tree_key) low_value,
3573 (splay_tree_value) case_label);
3578 /* Finish an expression taking the address of LABEL. Returns an
3579 expression for the address. */
3582 finish_label_address_expr (label)
3589 if (c_language == clk_cplusplus)
3590 pedwarn ("ISO C++ forbids taking the address of a label");
3592 pedwarn ("ISO C forbids taking the address of a label");
3595 label = lookup_label (label);
3596 if (label == NULL_TREE)
3597 result = null_pointer_node;
3600 TREE_USED (label) = 1;
3601 result = build1 (ADDR_EXPR, ptr_type_node, label);
3602 TREE_CONSTANT (result) = 1;
3603 /* The current function in not necessarily uninlinable.
3604 Computed gotos are incompatible with inlining, but the value
3605 here could be used only in a diagnostic, for example. */
3611 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3612 parameter allows this function to be used as a GC-marking
3619 stmt_tree st = (stmt_tree) p;
3621 ggc_mark_tree (st->x_last_stmt);
3622 ggc_mark_tree (st->x_last_expr_type);
3625 /* Mark LD for GC. */
3628 c_mark_lang_decl (c)
3629 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3633 /* Mark F for GC. */
3636 mark_c_language_function (f)
3637 struct language_function *f;
3642 mark_stmt_tree (&f->x_stmt_tree);
3643 ggc_mark_tree (f->x_scope_stmt_stack);
3646 /* Hook used by expand_expr to expand language-specific tree codes. */
3649 c_expand_expr (exp, target, tmode, modifier)
3652 enum machine_mode tmode;
3653 int modifier; /* Actually enum_modifier. */
3655 switch (TREE_CODE (exp))
3661 bool preserve_result = false;
3663 /* Since expand_expr_stmt calls free_temp_slots after every
3664 expression statement, we must call push_temp_slots here.
3665 Otherwise, any temporaries in use now would be considered
3666 out-of-scope after the first EXPR_STMT from within the
3669 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
3671 /* If we want the result of this expression, find the last
3672 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3673 if (target != const0_rtx
3674 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3675 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3677 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3678 tree last = TREE_CHAIN (expr);
3680 while (TREE_CHAIN (last))
3683 last = TREE_CHAIN (last);
3686 if (TREE_CODE (last) == SCOPE_STMT
3687 && TREE_CODE (expr) == EXPR_STMT)
3689 TREE_ADDRESSABLE (expr) = 1;
3690 preserve_result = true;
3694 expand_stmt (STMT_EXPR_STMT (exp));
3695 expand_end_stmt_expr (rtl_expr);
3697 result = expand_expr (rtl_expr, target, tmode, modifier);
3698 if (preserve_result && GET_CODE (result) == MEM)
3700 if (GET_MODE (result) != BLKmode)
3701 result = copy_to_reg (result);
3703 preserve_temp_slots (result);
3706 /* If the statment-expression does not have a scope, then the
3707 new temporaries we created within it must live beyond the
3708 statement-expression. */
3709 if (STMT_EXPR_NO_SCOPE (exp))
3710 preserve_temp_slots (NULL_RTX);
3719 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3720 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3722 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3723 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3724 == BUILT_IN_FRONTEND))
3725 return c_expand_builtin (exp, target, tmode, modifier);
3731 case COMPOUND_LITERAL_EXPR:
3733 /* Initialize the anonymous variable declared in the compound
3734 literal, then return the variable. */
3735 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3736 emit_local_var (decl);
3737 return expand_expr (decl, target, tmode, modifier);
3748 /* Hook used by safe_from_p to handle language-specific tree codes. */
3751 c_safe_from_p (target, exp)
3755 /* We can see statements here when processing the body of a
3756 statement-expression. For a declaration statement declaring a
3757 variable, look at the variable's initializer. */
3758 if (TREE_CODE (exp) == DECL_STMT)
3760 tree decl = DECL_STMT_DECL (exp);
3762 if (TREE_CODE (decl) == VAR_DECL
3763 && DECL_INITIAL (decl)
3764 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3768 /* For any statement, we must follow the statement-chain. */
3769 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3770 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3772 /* Assume everything else is safe. */
3776 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3779 c_common_unsafe_for_reeval (exp)
3782 /* Statement expressions may not be reevaluated, likewise compound
3784 if (TREE_CODE (exp) == STMT_EXPR
3785 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3788 /* Walk all other expressions. */
3792 /* Hook used by staticp to handle language-specific tree codes. */
3798 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3799 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3804 #define CALLED_AS_BUILT_IN(NODE) \
3805 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3808 c_expand_builtin (exp, target, tmode, modifier)
3811 enum machine_mode tmode;
3812 enum expand_modifier modifier;
3814 tree type = TREE_TYPE (exp);
3815 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3816 tree arglist = TREE_OPERAND (exp, 1);
3817 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3818 enum tree_code code = TREE_CODE (exp);
3819 const int ignore = (target == const0_rtx
3820 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3821 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3822 || code == COND_EXPR)
3823 && TREE_CODE (type) == VOID_TYPE));
3825 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3826 return expand_call (exp, target, ignore);
3830 case BUILT_IN_PRINTF:
3831 target = c_expand_builtin_printf (arglist, target, tmode,
3832 modifier, ignore, /*unlocked=*/ 0);
3837 case BUILT_IN_PRINTF_UNLOCKED:
3838 target = c_expand_builtin_printf (arglist, target, tmode,
3839 modifier, ignore, /*unlocked=*/ 1);
3844 case BUILT_IN_FPRINTF:
3845 target = c_expand_builtin_fprintf (arglist, target, tmode,
3846 modifier, ignore, /*unlocked=*/ 0);
3851 case BUILT_IN_FPRINTF_UNLOCKED:
3852 target = c_expand_builtin_fprintf (arglist, target, tmode,
3853 modifier, ignore, /*unlocked=*/ 1);
3858 default: /* just do library call, if unknown builtin */
3859 error ("built-in function `%s' not currently supported",
3860 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3863 /* The switch statement above can drop through to cause the function
3864 to be called normally. */
3865 return expand_call (exp, target, ignore);
3868 /* Check an arglist to *printf for problems. The arglist should start
3869 at the format specifier, with the remaining arguments immediately
3872 is_valid_printf_arglist (arglist)
3875 /* Save this value so we can restore it later. */
3876 const int SAVE_pedantic = pedantic;
3877 int diagnostic_occurred = 0;
3880 /* Set this to a known value so the user setting won't affect code
3883 /* Check to make sure there are no format specifier errors. */
3884 attrs = tree_cons (get_identifier ("format"),
3885 tree_cons (NULL_TREE,
3886 get_identifier ("printf"),
3887 tree_cons (NULL_TREE,
3889 tree_cons (NULL_TREE,
3893 check_function_format (&diagnostic_occurred, attrs, arglist);
3895 /* Restore the value of `pedantic'. */
3896 pedantic = SAVE_pedantic;
3898 /* If calling `check_function_format_ptr' produces a warning, we
3899 return false, otherwise we return true. */
3900 return ! diagnostic_occurred;
3903 /* If the arguments passed to printf are suitable for optimizations,
3904 we attempt to transform the call. */
3906 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
3909 enum machine_mode tmode;
3910 enum expand_modifier modifier;
3914 tree fn_putchar = unlocked ?
3915 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
3916 tree fn_puts = unlocked ?
3917 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
3918 tree fn, format_arg, stripped_string;
3920 /* If the return value is used, or the replacement _DECL isn't
3921 initialized, don't do the transformation. */
3922 if (!ignore || !fn_putchar || !fn_puts)
3925 /* Verify the required arguments in the original call. */
3927 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3930 /* Check the specifier vs. the parameters. */
3931 if (!is_valid_printf_arglist (arglist))
3934 format_arg = TREE_VALUE (arglist);
3935 stripped_string = format_arg;
3936 STRIP_NOPS (stripped_string);
3937 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3938 stripped_string = TREE_OPERAND (stripped_string, 0);
3940 /* If the format specifier isn't a STRING_CST, punt. */
3941 if (TREE_CODE (stripped_string) != STRING_CST)
3944 /* OK! We can attempt optimization. */
3946 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3947 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3949 arglist = TREE_CHAIN (arglist);
3952 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3953 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3955 arglist = TREE_CHAIN (arglist);
3960 /* We can't handle anything else with % args or %% ... yet. */
3961 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3964 /* If the resulting constant string has a length of 1, call
3965 putchar. Note, TREE_STRING_LENGTH includes the terminating
3966 NULL in its count. */
3967 if (TREE_STRING_LENGTH (stripped_string) == 2)
3969 /* Given printf("c"), (where c is any one character,)
3970 convert "c"[0] to an int and pass that to the replacement
3972 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3973 arglist = build_tree_list (NULL_TREE, arglist);
3977 /* If the resulting constant was "string\n", call
3978 __builtin_puts("string"). Ensure "string" has at least one
3979 character besides the trailing \n. Note, TREE_STRING_LENGTH
3980 includes the terminating NULL in its count. */
3981 else if (TREE_STRING_LENGTH (stripped_string) > 2
3982 && TREE_STRING_POINTER (stripped_string)
3983 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3985 /* Create a NULL-terminated string that's one char shorter
3986 than the original, stripping off the trailing '\n'. */
3987 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3988 char *newstr = (char *) alloca (newlen);
3989 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3990 newstr[newlen - 1] = 0;
3992 arglist = combine_strings (build_string (newlen, newstr));
3993 arglist = build_tree_list (NULL_TREE, arglist);
3997 /* We'd like to arrange to call fputs(string) here, but we
3998 need stdout and don't have a way to get it ... yet. */
4002 return expand_expr (build_function_call (fn, arglist),
4003 (ignore ? const0_rtx : target),
4007 /* If the arguments passed to fprintf are suitable for optimizations,
4008 we attempt to transform the call. */
4010 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4013 enum machine_mode tmode;
4014 enum expand_modifier modifier;
4018 tree fn_fputc = unlocked ?
4019 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4020 tree fn_fputs = unlocked ?
4021 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4022 tree fn, format_arg, stripped_string;
4024 /* If the return value is used, or the replacement _DECL isn't
4025 initialized, don't do the transformation. */
4026 if (!ignore || !fn_fputc || !fn_fputs)
4029 /* Verify the required arguments in the original call. */
4031 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4032 || (TREE_CHAIN (arglist) == 0)
4033 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4037 /* Check the specifier vs. the parameters. */
4038 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4041 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4042 stripped_string = format_arg;
4043 STRIP_NOPS (stripped_string);
4044 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4045 stripped_string = TREE_OPERAND (stripped_string, 0);
4047 /* If the format specifier isn't a STRING_CST, punt. */
4048 if (TREE_CODE (stripped_string) != STRING_CST)
4051 /* OK! We can attempt optimization. */
4053 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4054 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4056 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4057 arglist = tree_cons (NULL_TREE,
4058 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4062 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4063 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4065 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4066 arglist = tree_cons (NULL_TREE,
4067 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4073 /* We can't handle anything else with % args or %% ... yet. */
4074 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4077 /* When "string" doesn't contain %, replace all cases of
4078 fprintf(stream,string) with fputs(string,stream). The fputs
4079 builtin will take take of special cases like length==1. */
4080 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4081 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4085 return expand_expr (build_function_call (fn, arglist),
4086 (ignore ? const0_rtx : target),
4091 /* Given a boolean expression ARG, return a tree representing an increment
4092 or decrement (as indicated by CODE) of ARG. The front end must check for
4093 invalid cases (e.g., decrement in C++). */
4095 boolean_increment (code, arg)
4096 enum tree_code code;
4100 tree true_res = (c_language == clk_cplusplus
4102 : c_bool_true_node);
4103 arg = stabilize_reference (arg);
4106 case PREINCREMENT_EXPR:
4107 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4109 case POSTINCREMENT_EXPR:
4110 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4111 arg = save_expr (arg);
4112 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4113 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4115 case PREDECREMENT_EXPR:
4116 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4118 case POSTDECREMENT_EXPR:
4119 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4120 arg = save_expr (arg);
4121 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4122 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4127 TREE_SIDE_EFFECTS (val) = 1;
4131 /* Handle C and C++ default attributes. */
4133 enum built_in_attribute
4135 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4136 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4137 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4138 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4139 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
4140 #include "builtin-attrs.def"
4141 #undef DEF_ATTR_NULL_TREE
4143 #undef DEF_ATTR_IDENT
4144 #undef DEF_ATTR_TREE_LIST
4149 static tree built_in_attributes[(int) ATTR_LAST];
4151 static bool c_attrs_initialized = false;
4153 static void c_init_attributes PARAMS ((void));
4155 /* Common initialization before parsing options. */
4157 c_common_init_options (lang)
4158 enum c_language_kind lang;
4161 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
4162 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
4164 /* Mark as "unspecified" (see c_common_post_options). */
4165 flag_bounds_check = -1;
4168 /* Post-switch processing. */
4170 c_common_post_options ()
4172 cpp_post_options (parse_in);
4174 flag_inline_trees = 1;
4176 /* Use tree inlining if possible. Function instrumentation is only
4177 done in the RTL level, so we disable tree inlining. */
4178 if (! flag_instrument_function_entry_exit)
4180 if (!flag_no_inline)
4182 if (flag_inline_functions)
4184 flag_inline_trees = 2;
4185 flag_inline_functions = 0;
4189 /* If still "unspecified", make it match -fbounded-pointers. */
4190 if (flag_bounds_check == -1)
4191 flag_bounds_check = flag_bounded_pointers;
4193 /* Special format checking options don't work without -Wformat; warn if
4195 if (warn_format_y2k && !warn_format)
4196 warning ("-Wformat-y2k ignored without -Wformat");
4197 if (warn_format_extra_args && !warn_format)
4198 warning ("-Wformat-extra-args ignored without -Wformat");
4199 if (warn_format_nonliteral && !warn_format)
4200 warning ("-Wformat-nonliteral ignored without -Wformat");
4201 if (warn_format_security && !warn_format)
4202 warning ("-Wformat-security ignored without -Wformat");
4203 if (warn_missing_format_attribute && !warn_format)
4204 warning ("-Wmissing-format-attribute ignored without -Wformat");
4207 /* Front end initialization common to C, ObjC and C++. */
4209 c_common_init (filename)
4210 const char *filename;
4212 /* NULL is passed up to toplev.c and we exit quickly. */
4213 if (flag_preprocess_only)
4215 cpp_preprocess_file (parse_in);
4219 /* Do this before initializing pragmas, as then cpplib's hash table
4221 filename = init_c_lex (filename);
4225 if (!c_attrs_initialized)
4226 c_init_attributes ();
4231 /* Common finish hook for the C, ObjC and C++ front ends. */
4235 cpp_finish (parse_in);
4237 /* For performance, avoid tearing down cpplib's internal structures.
4238 Call cpp_errors () instead of cpp_destroy (). */
4239 errorcount += cpp_errors (parse_in);
4243 c_init_attributes ()
4245 /* Fill in the built_in_attributes array. */
4246 #define DEF_ATTR_NULL_TREE(ENUM) \
4247 built_in_attributes[(int) ENUM] = NULL_TREE;
4248 #define DEF_ATTR_INT(ENUM, VALUE) \
4249 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4250 #define DEF_ATTR_IDENT(ENUM, STRING) \
4251 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4252 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4253 built_in_attributes[(int) ENUM] \
4254 = tree_cons (built_in_attributes[(int) PURPOSE], \
4255 built_in_attributes[(int) VALUE], \
4256 built_in_attributes[(int) CHAIN]);
4257 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4258 #include "builtin-attrs.def"
4259 #undef DEF_ATTR_NULL_TREE
4261 #undef DEF_ATTR_IDENT
4262 #undef DEF_ATTR_TREE_LIST
4264 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4265 c_attrs_initialized = true;
4268 /* Depending on the name of DECL, apply default attributes to it. */
4271 c_common_insert_default_attributes (decl)
4274 tree name = DECL_NAME (decl);
4276 if (!c_attrs_initialized)
4277 c_init_attributes ();
4279 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4280 #define DEF_ATTR_INT(ENUM, VALUE)
4281 #define DEF_ATTR_IDENT(ENUM, STRING)
4282 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4283 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4284 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4285 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4286 ATTR_FLAG_BUILT_IN);
4287 #include "builtin-attrs.def"
4288 #undef DEF_ATTR_NULL_TREE
4290 #undef DEF_ATTR_IDENT
4291 #undef DEF_ATTR_TREE_LIST
4295 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4296 additionally give the location of the previous declaration DECL. */
4298 shadow_warning (msgid, name, decl)
4302 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4303 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4304 DECL_SOURCE_LINE (decl),
4305 "shadowed declaration is here");