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 if (TREE_CODE (operand) == INTEGER_CST
761 && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE
762 && TREE_UNSIGNED (TREE_TYPE (result))
763 && skip_evaluation == 0
764 && !int_fits_type_p (operand, TREE_TYPE (result)))
766 if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result))))
767 /* This detects cases like converting -129 or 256 to unsigned char. */
768 warning ("large integer implicitly truncated to unsigned type");
769 else if (warn_conversion)
770 warning ("negative integer implicitly converted to unsigned type");
774 /* Nonzero if constant C has a value that is permissible
775 for type TYPE (an INTEGER_TYPE). */
778 constant_fits_type_p (c, type)
781 if (TREE_CODE (c) == INTEGER_CST)
782 return int_fits_type_p (c, type);
784 c = convert (type, c);
785 return !TREE_OVERFLOW (c);
788 /* Convert EXPR to TYPE, warning about conversion problems with constants.
789 Invoke this function on every expression that is converted implicitly,
790 i.e. because of language rules and not because of an explicit cast. */
793 convert_and_check (type, expr)
796 tree t = convert (type, expr);
797 if (TREE_CODE (t) == INTEGER_CST)
799 if (TREE_OVERFLOW (t))
801 TREE_OVERFLOW (t) = 0;
803 /* Do not diagnose overflow in a constant expression merely
804 because a conversion overflowed. */
805 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
807 /* No warning for converting 0x80000000 to int. */
808 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
809 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
810 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
811 /* If EXPR fits in the unsigned version of TYPE,
812 don't warn unless pedantic. */
814 || TREE_UNSIGNED (type)
815 || ! constant_fits_type_p (expr, unsigned_type (type)))
816 && skip_evaluation == 0)
817 warning ("overflow in implicit constant conversion");
820 unsigned_conversion_warning (t, expr);
825 /* A node in a list that describes references to variables (EXPR), which are
826 either read accesses if WRITER is zero, or write accesses, in which case
827 WRITER is the parent of EXPR. */
834 /* Used to implement a cache the results of a call to verify_tree. We only
835 use this for SAVE_EXPRs. */
838 struct tlist_cache *next;
839 struct tlist *cache_before_sp;
840 struct tlist *cache_after_sp;
844 /* Obstack to use when allocating tlist structures, and corresponding
846 static struct obstack tlist_obstack;
847 static char *tlist_firstobj = 0;
849 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
851 static struct tlist *warned_ids;
852 /* SAVE_EXPRs need special treatment. We process them only once and then
853 cache the results. */
854 static struct tlist_cache *save_expr_cache;
856 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
857 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
858 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
859 static int warning_candidate_p PARAMS ((tree));
860 static void warn_for_collisions PARAMS ((struct tlist *));
861 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
862 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
863 static void verify_sequence_points PARAMS ((tree));
865 /* Create a new struct tlist and fill in its fields. */
866 static struct tlist *
867 new_tlist (next, t, writer)
873 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
880 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
881 is nonnull, we ignore any node we find which has a writer equal to it. */
884 add_tlist (to, add, exclude_writer, copy)
892 struct tlist *next = add->next;
895 if (! exclude_writer || add->writer != exclude_writer)
896 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
901 /* Merge the nodes of ADD into TO. This merging process is done so that for
902 each variable that already exists in TO, no new node is added; however if
903 there is a write access recorded in ADD, and an occurrence on TO is only
904 a read access, then the occurrence in TO will be modified to record the
908 merge_tlist (to, add, copy)
913 struct tlist **end = to;
922 struct tlist *next = add->next;
924 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
925 if (tmp2->expr == add->expr)
929 tmp2->writer = add->writer;
933 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
941 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
942 references in list LIST conflict with it, excluding reads if ONLY writers
946 warn_for_collisions_1 (written, writer, list, only_writes)
947 tree written, writer;
953 /* Avoid duplicate warnings. */
954 for (tmp = warned_ids; tmp; tmp = tmp->next)
955 if (tmp->expr == written)
960 if (list->expr == written
961 && list->writer != writer
962 && (! only_writes || list->writer))
964 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
965 warning ("operation on `%s' may be undefined",
966 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
972 /* Given a list LIST of references to variables, find whether any of these
973 can cause conflicts due to missing sequence points. */
976 warn_for_collisions (list)
981 for (tmp = list; tmp; tmp = tmp->next)
984 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
988 /* Return nonzero if X is a tree that can be verified by the sequence point
991 warning_candidate_p (x)
994 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
997 /* Walk the tree X, and record accesses to variables. If X is written by the
998 parent tree, WRITER is the parent.
999 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1000 expression or its only operand forces a sequence point, then everything up
1001 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1003 Once we return, we will have emitted warnings if any subexpression before
1004 such a sequence point could be undefined. On a higher level, however, the
1005 sequence point may not be relevant, and we'll merge the two lists.
1007 Example: (b++, a) + b;
1008 The call that processes the COMPOUND_EXPR will store the increment of B
1009 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1010 processes the PLUS_EXPR will need to merge the two lists so that
1011 eventually, all accesses end up on the same list (and we'll warn about the
1012 unordered subexpressions b++ and b.
1014 A note on merging. If we modify the former example so that our expression
1017 care must be taken not simply to add all three expressions into the final
1018 PNO_SP list. The function merge_tlist takes care of that by merging the
1019 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1020 way, so that no more than one access to B is recorded. */
1023 verify_tree (x, pbefore_sp, pno_sp, writer)
1025 struct tlist **pbefore_sp, **pno_sp;
1028 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1029 enum tree_code code;
1032 /* X may be NULL if it is the operand of an empty statement expression
1038 code = TREE_CODE (x);
1039 class = TREE_CODE_CLASS (code);
1041 if (warning_candidate_p (x))
1043 *pno_sp = new_tlist (*pno_sp, x, writer);
1053 case TRUTH_ANDIF_EXPR:
1054 case TRUTH_ORIF_EXPR:
1055 tmp_before = tmp_nosp = tmp_list3 = 0;
1056 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1057 warn_for_collisions (tmp_nosp);
1058 merge_tlist (pbefore_sp, tmp_before, 0);
1059 merge_tlist (pbefore_sp, tmp_nosp, 0);
1060 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1061 merge_tlist (pbefore_sp, tmp_list3, 0);
1065 tmp_before = tmp_list2 = 0;
1066 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1067 warn_for_collisions (tmp_list2);
1068 merge_tlist (pbefore_sp, tmp_before, 0);
1069 merge_tlist (pbefore_sp, tmp_list2, 1);
1071 tmp_list3 = tmp_nosp = 0;
1072 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1073 warn_for_collisions (tmp_nosp);
1074 merge_tlist (pbefore_sp, tmp_list3, 0);
1076 tmp_list3 = tmp_list2 = 0;
1077 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1078 warn_for_collisions (tmp_list2);
1079 merge_tlist (pbefore_sp, tmp_list3, 0);
1080 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1081 two first, to avoid warning for (a ? b++ : b++). */
1082 merge_tlist (&tmp_nosp, tmp_list2, 0);
1083 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1086 case PREDECREMENT_EXPR:
1087 case PREINCREMENT_EXPR:
1088 case POSTDECREMENT_EXPR:
1089 case POSTINCREMENT_EXPR:
1090 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1094 tmp_before = tmp_nosp = tmp_list3 = 0;
1095 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1096 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1097 /* Expressions inside the LHS are not ordered wrt. the sequence points
1098 in the RHS. Example:
1100 Despite the fact that the modification of "a" is in the before_sp
1101 list (tmp_before), it conflicts with the use of "a" in the LHS.
1102 We can handle this by adding the contents of tmp_list3
1103 to those of tmp_before, and redoing the collision warnings for that
1105 add_tlist (&tmp_before, tmp_list3, x, 1);
1106 warn_for_collisions (tmp_before);
1107 /* Exclude the LHS itself here; we first have to merge it into the
1108 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1109 didn't exclude the LHS, we'd get it twice, once as a read and once
1111 add_tlist (pno_sp, tmp_list3, x, 0);
1112 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1114 merge_tlist (pbefore_sp, tmp_before, 0);
1115 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1116 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1117 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1121 /* We need to warn about conflicts among arguments and conflicts between
1122 args and the function address. Side effects of the function address,
1123 however, are not ordered by the sequence point of the call. */
1124 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1125 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1126 if (TREE_OPERAND (x, 1))
1127 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1128 merge_tlist (&tmp_list3, tmp_list2, 0);
1129 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1130 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1131 warn_for_collisions (tmp_before);
1132 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1136 /* Scan all the list, e.g. indices of multi dimensional array. */
1139 tmp_before = tmp_nosp = 0;
1140 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1141 merge_tlist (&tmp_nosp, tmp_before, 0);
1142 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1149 struct tlist_cache *t;
1150 for (t = save_expr_cache; t; t = t->next)
1156 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1158 t->next = save_expr_cache;
1160 save_expr_cache = t;
1162 tmp_before = tmp_nosp = 0;
1163 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1164 warn_for_collisions (tmp_nosp);
1169 struct tlist *t = tmp_nosp;
1171 merge_tlist (&tmp_list3, t, 0);
1173 t->cache_before_sp = tmp_before;
1174 t->cache_after_sp = tmp_list3;
1176 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1177 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1186 if (first_rtl_op (code) == 0)
1188 x = TREE_OPERAND (x, 0);
1204 int max = first_rtl_op (TREE_CODE (x));
1205 for (lp = 0; lp < max; lp++)
1207 tmp_before = tmp_nosp = 0;
1208 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1209 merge_tlist (&tmp_nosp, tmp_before, 0);
1210 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1217 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1221 verify_sequence_points (expr)
1224 struct tlist *before_sp = 0, *after_sp = 0;
1227 save_expr_cache = 0;
1228 if (tlist_firstobj == 0)
1230 gcc_obstack_init (&tlist_obstack);
1231 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1234 verify_tree (expr, &before_sp, &after_sp, 0);
1235 warn_for_collisions (after_sp);
1236 obstack_free (&tlist_obstack, tlist_firstobj);
1240 c_expand_expr_stmt (expr)
1243 /* Do default conversion if safe and possibly important,
1244 in case within ({...}). */
1245 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1246 && (flag_isoc99 || lvalue_p (expr)))
1247 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1248 expr = default_conversion (expr);
1250 if (warn_sequence_point)
1251 verify_sequence_points (expr);
1253 if (TREE_TYPE (expr) != error_mark_node
1254 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1255 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1256 error ("expression statement has incomplete type");
1258 last_expr_type = TREE_TYPE (expr);
1259 return add_stmt (build_stmt (EXPR_STMT, expr));
1262 /* Validate the expression after `case' and apply default promotions. */
1265 check_case_value (value)
1268 if (value == NULL_TREE)
1271 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1272 STRIP_TYPE_NOPS (value);
1273 /* In C++, the following is allowed:
1276 switch (...) { case i: ... }
1278 So, we try to reduce the VALUE to a constant that way. */
1279 if (c_language == clk_cplusplus)
1281 value = decl_constant_value (value);
1282 STRIP_TYPE_NOPS (value);
1283 value = fold (value);
1286 if (TREE_CODE (value) != INTEGER_CST
1287 && value != error_mark_node)
1289 error ("case label does not reduce to an integer constant");
1290 value = error_mark_node;
1293 /* Promote char or short to int. */
1294 value = default_conversion (value);
1296 constant_expression_warning (value);
1301 /* Return an integer type with BITS bits of precision,
1302 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1305 c_common_type_for_size (bits, unsignedp)
1309 if (bits == TYPE_PRECISION (integer_type_node))
1310 return unsignedp ? unsigned_type_node : integer_type_node;
1312 if (bits == TYPE_PRECISION (signed_char_type_node))
1313 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1315 if (bits == TYPE_PRECISION (short_integer_type_node))
1316 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1318 if (bits == TYPE_PRECISION (long_integer_type_node))
1319 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1321 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1322 return (unsignedp ? long_long_unsigned_type_node
1323 : long_long_integer_type_node);
1325 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1326 return (unsignedp ? widest_unsigned_literal_type_node
1327 : widest_integer_literal_type_node);
1329 if (bits <= TYPE_PRECISION (intQI_type_node))
1330 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1332 if (bits <= TYPE_PRECISION (intHI_type_node))
1333 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1335 if (bits <= TYPE_PRECISION (intSI_type_node))
1336 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1338 if (bits <= TYPE_PRECISION (intDI_type_node))
1339 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1344 /* Return a data type that has machine mode MODE.
1345 If the mode is an integer,
1346 then UNSIGNEDP selects between signed and unsigned types. */
1349 c_common_type_for_mode (mode, unsignedp)
1350 enum machine_mode mode;
1353 if (mode == TYPE_MODE (integer_type_node))
1354 return unsignedp ? unsigned_type_node : integer_type_node;
1356 if (mode == TYPE_MODE (signed_char_type_node))
1357 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1359 if (mode == TYPE_MODE (short_integer_type_node))
1360 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1362 if (mode == TYPE_MODE (long_integer_type_node))
1363 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1365 if (mode == TYPE_MODE (long_long_integer_type_node))
1366 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1368 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1369 return unsignedp ? widest_unsigned_literal_type_node
1370 : widest_integer_literal_type_node;
1373 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1376 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1379 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1382 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1384 #if HOST_BITS_PER_WIDE_INT >= 64
1385 if (mode == TYPE_MODE (intTI_type_node))
1386 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1389 if (mode == TYPE_MODE (float_type_node))
1390 return float_type_node;
1392 if (mode == TYPE_MODE (double_type_node))
1393 return double_type_node;
1395 if (mode == TYPE_MODE (long_double_type_node))
1396 return long_double_type_node;
1398 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1399 return build_pointer_type (char_type_node);
1401 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1402 return build_pointer_type (integer_type_node);
1404 #ifdef VECTOR_MODE_SUPPORTED_P
1405 if (VECTOR_MODE_SUPPORTED_P (mode))
1410 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1412 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1414 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1416 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1418 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1420 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1422 return V16SF_type_node;
1424 return V4SF_type_node;
1426 return V2SF_type_node;
1436 /* Return an unsigned type the same as TYPE in other respects. */
1438 unsigned_type (type)
1441 tree type1 = TYPE_MAIN_VARIANT (type);
1442 if (type1 == signed_char_type_node || type1 == char_type_node)
1443 return unsigned_char_type_node;
1444 if (type1 == integer_type_node)
1445 return unsigned_type_node;
1446 if (type1 == short_integer_type_node)
1447 return short_unsigned_type_node;
1448 if (type1 == long_integer_type_node)
1449 return long_unsigned_type_node;
1450 if (type1 == long_long_integer_type_node)
1451 return long_long_unsigned_type_node;
1452 if (type1 == widest_integer_literal_type_node)
1453 return widest_unsigned_literal_type_node;
1454 #if HOST_BITS_PER_WIDE_INT >= 64
1455 if (type1 == intTI_type_node)
1456 return unsigned_intTI_type_node;
1458 if (type1 == intDI_type_node)
1459 return unsigned_intDI_type_node;
1460 if (type1 == intSI_type_node)
1461 return unsigned_intSI_type_node;
1462 if (type1 == intHI_type_node)
1463 return unsigned_intHI_type_node;
1464 if (type1 == intQI_type_node)
1465 return unsigned_intQI_type_node;
1467 return signed_or_unsigned_type (1, type);
1470 /* Return a signed type the same as TYPE in other respects. */
1476 tree type1 = TYPE_MAIN_VARIANT (type);
1477 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1478 return signed_char_type_node;
1479 if (type1 == unsigned_type_node)
1480 return integer_type_node;
1481 if (type1 == short_unsigned_type_node)
1482 return short_integer_type_node;
1483 if (type1 == long_unsigned_type_node)
1484 return long_integer_type_node;
1485 if (type1 == long_long_unsigned_type_node)
1486 return long_long_integer_type_node;
1487 if (type1 == widest_unsigned_literal_type_node)
1488 return widest_integer_literal_type_node;
1489 #if HOST_BITS_PER_WIDE_INT >= 64
1490 if (type1 == unsigned_intTI_type_node)
1491 return intTI_type_node;
1493 if (type1 == unsigned_intDI_type_node)
1494 return intDI_type_node;
1495 if (type1 == unsigned_intSI_type_node)
1496 return intSI_type_node;
1497 if (type1 == unsigned_intHI_type_node)
1498 return intHI_type_node;
1499 if (type1 == unsigned_intQI_type_node)
1500 return intQI_type_node;
1502 return signed_or_unsigned_type (0, type);
1505 /* Return a type the same as TYPE except unsigned or
1506 signed according to UNSIGNEDP. */
1509 signed_or_unsigned_type (unsignedp, type)
1513 if (! INTEGRAL_TYPE_P (type)
1514 || TREE_UNSIGNED (type) == unsignedp)
1517 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1518 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1519 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1520 return unsignedp ? unsigned_type_node : integer_type_node;
1521 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1522 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1523 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1524 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1525 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1526 return (unsignedp ? long_long_unsigned_type_node
1527 : long_long_integer_type_node);
1528 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1529 return (unsignedp ? widest_unsigned_literal_type_node
1530 : widest_integer_literal_type_node);
1532 #if HOST_BITS_PER_WIDE_INT >= 64
1533 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1534 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1536 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1537 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1538 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1539 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1540 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1541 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1542 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1543 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1548 /* Return the minimum number of bits needed to represent VALUE in a
1549 signed or unsigned type, UNSIGNEDP says which. */
1552 min_precision (value, unsignedp)
1558 /* If the value is negative, compute its negative minus 1. The latter
1559 adjustment is because the absolute value of the largest negative value
1560 is one larger than the largest positive value. This is equivalent to
1561 a bit-wise negation, so use that operation instead. */
1563 if (tree_int_cst_sgn (value) < 0)
1564 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1566 /* Return the number of bits needed, taking into account the fact
1567 that we need one more bit for a signed than unsigned type. */
1569 if (integer_zerop (value))
1572 log = tree_floor_log2 (value);
1574 return log + 1 + ! unsignedp;
1577 /* Print an error message for invalid operands to arith operation CODE.
1578 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1581 binary_op_error (code)
1582 enum tree_code code;
1589 error ("invalid truth-value expression");
1593 opname = "+"; break;
1595 opname = "-"; break;
1597 opname = "*"; break;
1599 opname = "max"; break;
1601 opname = "min"; break;
1603 opname = "=="; break;
1605 opname = "!="; break;
1607 opname = "<="; break;
1609 opname = ">="; break;
1611 opname = "<"; break;
1613 opname = ">"; break;
1615 opname = "<<"; break;
1617 opname = ">>"; break;
1618 case TRUNC_MOD_EXPR:
1619 case FLOOR_MOD_EXPR:
1620 opname = "%"; break;
1621 case TRUNC_DIV_EXPR:
1622 case FLOOR_DIV_EXPR:
1623 opname = "/"; break;
1625 opname = "&"; break;
1627 opname = "|"; break;
1628 case TRUTH_ANDIF_EXPR:
1629 opname = "&&"; break;
1630 case TRUTH_ORIF_EXPR:
1631 opname = "||"; break;
1633 opname = "^"; break;
1636 opname = "rotate"; break;
1638 opname = "unknown"; break;
1640 error ("invalid operands to binary %s", opname);
1643 /* Subroutine of build_binary_op, used for comparison operations.
1644 See if the operands have both been converted from subword integer types
1645 and, if so, perhaps change them both back to their original type.
1646 This function is also responsible for converting the two operands
1647 to the proper common type for comparison.
1649 The arguments of this function are all pointers to local variables
1650 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1651 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1653 If this function returns nonzero, it means that the comparison has
1654 a constant value. What this function returns is an expression for
1658 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1659 tree *op0_ptr, *op1_ptr;
1661 enum tree_code *rescode_ptr;
1664 tree op0 = *op0_ptr;
1665 tree op1 = *op1_ptr;
1666 int unsignedp0, unsignedp1;
1668 tree primop0, primop1;
1669 enum tree_code code = *rescode_ptr;
1671 /* Throw away any conversions to wider types
1672 already present in the operands. */
1674 primop0 = get_narrower (op0, &unsignedp0);
1675 primop1 = get_narrower (op1, &unsignedp1);
1677 /* Handle the case that OP0 does not *contain* a conversion
1678 but it *requires* conversion to FINAL_TYPE. */
1680 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1681 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1682 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1683 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1685 /* If one of the operands must be floated, we cannot optimize. */
1686 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1687 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1689 /* If first arg is constant, swap the args (changing operation
1690 so value is preserved), for canonicalization. Don't do this if
1691 the second arg is 0. */
1693 if (TREE_CONSTANT (primop0)
1694 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1697 int temi = unsignedp0;
1705 unsignedp0 = unsignedp1;
1728 *rescode_ptr = code;
1731 /* If comparing an integer against a constant more bits wide,
1732 maybe we can deduce a value of 1 or 0 independent of the data.
1733 Or else truncate the constant now
1734 rather than extend the variable at run time.
1736 This is only interesting if the constant is the wider arg.
1737 Also, it is not safe if the constant is unsigned and the
1738 variable arg is signed, since in this case the variable
1739 would be sign-extended and then regarded as unsigned.
1740 Our technique fails in this case because the lowest/highest
1741 possible unsigned results don't follow naturally from the
1742 lowest/highest possible values of the variable operand.
1743 For just EQ_EXPR and NE_EXPR there is another technique that
1744 could be used: see if the constant can be faithfully represented
1745 in the other operand's type, by truncating it and reextending it
1746 and see if that preserves the constant's value. */
1748 if (!real1 && !real2
1749 && TREE_CODE (primop1) == INTEGER_CST
1750 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1752 int min_gt, max_gt, min_lt, max_lt;
1753 tree maxval, minval;
1754 /* 1 if comparison is nominally unsigned. */
1755 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1758 type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0));
1760 /* If TYPE is an enumeration, then we need to get its min/max
1761 values from it's underlying integral type, not the enumerated
1763 if (TREE_CODE (type) == ENUMERAL_TYPE)
1764 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1766 maxval = TYPE_MAX_VALUE (type);
1767 minval = TYPE_MIN_VALUE (type);
1769 if (unsignedp && !unsignedp0)
1770 *restype_ptr = signed_type (*restype_ptr);
1772 if (TREE_TYPE (primop1) != *restype_ptr)
1773 primop1 = convert (*restype_ptr, primop1);
1774 if (type != *restype_ptr)
1776 minval = convert (*restype_ptr, minval);
1777 maxval = convert (*restype_ptr, maxval);
1780 if (unsignedp && unsignedp0)
1782 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1783 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1784 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1785 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1789 min_gt = INT_CST_LT (primop1, minval);
1790 max_gt = INT_CST_LT (primop1, maxval);
1791 min_lt = INT_CST_LT (minval, primop1);
1792 max_lt = INT_CST_LT (maxval, primop1);
1796 /* This used to be a switch, but Genix compiler can't handle that. */
1797 if (code == NE_EXPR)
1799 if (max_lt || min_gt)
1800 val = boolean_true_node;
1802 else if (code == EQ_EXPR)
1804 if (max_lt || min_gt)
1805 val = boolean_false_node;
1807 else if (code == LT_EXPR)
1810 val = boolean_true_node;
1812 val = boolean_false_node;
1814 else if (code == GT_EXPR)
1817 val = boolean_true_node;
1819 val = boolean_false_node;
1821 else if (code == LE_EXPR)
1824 val = boolean_true_node;
1826 val = boolean_false_node;
1828 else if (code == GE_EXPR)
1831 val = boolean_true_node;
1833 val = boolean_false_node;
1836 /* If primop0 was sign-extended and unsigned comparison specd,
1837 we did a signed comparison above using the signed type bounds.
1838 But the comparison we output must be unsigned.
1840 Also, for inequalities, VAL is no good; but if the signed
1841 comparison had *any* fixed result, it follows that the
1842 unsigned comparison just tests the sign in reverse
1843 (positive values are LE, negative ones GE).
1844 So we can generate an unsigned comparison
1845 against an extreme value of the signed type. */
1847 if (unsignedp && !unsignedp0)
1854 primop1 = TYPE_MIN_VALUE (type);
1860 primop1 = TYPE_MAX_VALUE (type);
1867 type = unsigned_type (type);
1870 if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1872 /* This is the case of (char)x >?< 0x80, which people used to use
1873 expecting old C compilers to change the 0x80 into -0x80. */
1874 if (val == boolean_false_node)
1875 warning ("comparison is always false due to limited range of data type");
1876 if (val == boolean_true_node)
1877 warning ("comparison is always true due to limited range of data type");
1880 if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST)
1882 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1883 if (val == boolean_false_node)
1884 warning ("comparison is always false due to limited range of data type");
1885 if (val == boolean_true_node)
1886 warning ("comparison is always true due to limited range of data type");
1891 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1892 if (TREE_SIDE_EFFECTS (primop0))
1893 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
1897 /* Value is not predetermined, but do the comparison
1898 in the type of the operand that is not constant.
1899 TYPE is already properly set. */
1901 else if (real1 && real2
1902 && (TYPE_PRECISION (TREE_TYPE (primop0))
1903 == TYPE_PRECISION (TREE_TYPE (primop1))))
1904 type = TREE_TYPE (primop0);
1906 /* If args' natural types are both narrower than nominal type
1907 and both extend in the same manner, compare them
1908 in the type of the wider arg.
1909 Otherwise must actually extend both to the nominal
1910 common type lest different ways of extending
1912 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1914 else if (unsignedp0 == unsignedp1 && real1 == real2
1915 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
1916 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
1918 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
1919 type = signed_or_unsigned_type (unsignedp0
1920 || TREE_UNSIGNED (*restype_ptr),
1922 /* Make sure shorter operand is extended the right way
1923 to match the longer operand. */
1924 primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)),
1926 primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)),
1931 /* Here we must do the comparison on the nominal type
1932 using the args exactly as we received them. */
1933 type = *restype_ptr;
1937 if (!real1 && !real2 && integer_zerop (primop1)
1938 && TREE_UNSIGNED (*restype_ptr))
1944 /* All unsigned values are >= 0, so we warn if extra warnings
1945 are requested. However, if OP0 is a constant that is
1946 >= 0, the signedness of the comparison isn't an issue,
1947 so suppress the warning. */
1948 if (extra_warnings && !in_system_header
1949 && ! (TREE_CODE (primop0) == INTEGER_CST
1950 && ! TREE_OVERFLOW (convert (signed_type (type),
1952 warning ("comparison of unsigned expression >= 0 is always true");
1953 value = boolean_true_node;
1957 if (extra_warnings && !in_system_header
1958 && ! (TREE_CODE (primop0) == INTEGER_CST
1959 && ! TREE_OVERFLOW (convert (signed_type (type),
1961 warning ("comparison of unsigned expression < 0 is always false");
1962 value = boolean_false_node;
1971 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1972 if (TREE_SIDE_EFFECTS (primop0))
1973 return build (COMPOUND_EXPR, TREE_TYPE (value),
1980 *op0_ptr = convert (type, primop0);
1981 *op1_ptr = convert (type, primop1);
1983 *restype_ptr = boolean_type_node;
1988 /* Return a tree for the sum or difference (RESULTCODE says which)
1989 of pointer PTROP and integer INTOP. */
1992 pointer_int_sum (resultcode, ptrop, intop)
1993 enum tree_code resultcode;
2001 /* The result is a pointer of the same type that is being added. */
2003 tree result_type = TREE_TYPE (ptrop);
2005 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2007 if (pedantic || warn_pointer_arith)
2008 pedwarn ("pointer of type `void *' used in arithmetic");
2009 size_exp = integer_one_node;
2011 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2013 if (pedantic || warn_pointer_arith)
2014 pedwarn ("pointer to a function used in arithmetic");
2015 size_exp = integer_one_node;
2017 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2019 if (pedantic || warn_pointer_arith)
2020 pedwarn ("pointer to member function used in arithmetic");
2021 size_exp = integer_one_node;
2023 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2025 if (pedantic || warn_pointer_arith)
2026 pedwarn ("pointer to a member used in arithmetic");
2027 size_exp = integer_one_node;
2030 size_exp = size_in_bytes (TREE_TYPE (result_type));
2032 /* If what we are about to multiply by the size of the elements
2033 contains a constant term, apply distributive law
2034 and multiply that constant term separately.
2035 This helps produce common subexpressions. */
2037 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2038 && ! TREE_CONSTANT (intop)
2039 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2040 && TREE_CONSTANT (size_exp)
2041 /* If the constant comes from pointer subtraction,
2042 skip this optimization--it would cause an error. */
2043 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2044 /* If the constant is unsigned, and smaller than the pointer size,
2045 then we must skip this optimization. This is because it could cause
2046 an overflow error if the constant is negative but INTOP is not. */
2047 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2048 || (TYPE_PRECISION (TREE_TYPE (intop))
2049 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2051 enum tree_code subcode = resultcode;
2052 tree int_type = TREE_TYPE (intop);
2053 if (TREE_CODE (intop) == MINUS_EXPR)
2054 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2055 /* Convert both subexpression types to the type of intop,
2056 because weird cases involving pointer arithmetic
2057 can result in a sum or difference with different type args. */
2058 ptrop = build_binary_op (subcode, ptrop,
2059 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2060 intop = convert (int_type, TREE_OPERAND (intop, 0));
2063 /* Convert the integer argument to a type the same size as sizetype
2064 so the multiply won't overflow spuriously. */
2066 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2067 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2068 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2069 TREE_UNSIGNED (sizetype)), intop);
2071 /* Replace the integer argument with a suitable product by the object size.
2072 Do this multiplication as signed, then convert to the appropriate
2073 pointer type (actually unsigned integral). */
2075 intop = convert (result_type,
2076 build_binary_op (MULT_EXPR, intop,
2077 convert (TREE_TYPE (intop), size_exp), 1));
2079 /* Create the sum or difference. */
2081 result = build (resultcode, result_type, ptrop, intop);
2083 folded = fold (result);
2084 if (folded == result)
2085 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2089 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2090 or validate its data type for an `if' or `while' statement or ?..: exp.
2092 This preparation consists of taking the ordinary
2093 representation of an expression expr and producing a valid tree
2094 boolean expression describing whether expr is nonzero. We could
2095 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2096 but we optimize comparisons, &&, ||, and !.
2098 The resulting type should always be `boolean_type_node'. */
2101 truthvalue_conversion (expr)
2104 if (TREE_CODE (expr) == ERROR_MARK)
2107 #if 0 /* This appears to be wrong for C++. */
2108 /* These really should return error_mark_node after 2.4 is stable.
2109 But not all callers handle ERROR_MARK properly. */
2110 switch (TREE_CODE (TREE_TYPE (expr)))
2113 error ("struct type value used where scalar is required");
2114 return boolean_false_node;
2117 error ("union type value used where scalar is required");
2118 return boolean_false_node;
2121 error ("array type value used where scalar is required");
2122 return boolean_false_node;
2129 switch (TREE_CODE (expr))
2132 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2133 case TRUTH_ANDIF_EXPR:
2134 case TRUTH_ORIF_EXPR:
2135 case TRUTH_AND_EXPR:
2137 case TRUTH_XOR_EXPR:
2138 case TRUTH_NOT_EXPR:
2139 TREE_TYPE (expr) = boolean_type_node;
2146 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2149 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2152 /* If we are taking the address of an external decl, it might be zero
2153 if it is weak, so we cannot optimize. */
2154 if (DECL_P (TREE_OPERAND (expr, 0))
2155 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2158 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2159 return build (COMPOUND_EXPR, boolean_type_node,
2160 TREE_OPERAND (expr, 0), boolean_true_node);
2162 return boolean_true_node;
2165 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2166 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2167 truthvalue_conversion (TREE_OPERAND (expr, 0)),
2168 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2175 /* These don't change whether an object is non-zero or zero. */
2176 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2180 /* These don't change whether an object is zero or non-zero, but
2181 we can't ignore them if their second arg has side-effects. */
2182 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2183 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2184 truthvalue_conversion (TREE_OPERAND (expr, 0)));
2186 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2189 /* Distribute the conversion into the arms of a COND_EXPR. */
2190 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2191 truthvalue_conversion (TREE_OPERAND (expr, 1)),
2192 truthvalue_conversion (TREE_OPERAND (expr, 2))));
2195 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2196 since that affects how `default_conversion' will behave. */
2197 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2198 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2200 /* fall through... */
2202 /* If this is widening the argument, we can ignore it. */
2203 if (TYPE_PRECISION (TREE_TYPE (expr))
2204 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2205 return truthvalue_conversion (TREE_OPERAND (expr, 0));
2209 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2210 aren't guaranteed to the be same for modes that can represent
2211 infinity, since if x and y are both +infinity, or both
2212 -infinity, then x - y is not a number.
2214 Note that this transformation is safe when x or y is NaN.
2215 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2217 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2219 /* fall through... */
2221 /* This and MINUS_EXPR can be changed into a comparison of the
2223 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2224 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2225 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2226 TREE_OPERAND (expr, 1), 1);
2227 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2228 fold (build1 (NOP_EXPR,
2229 TREE_TYPE (TREE_OPERAND (expr, 0)),
2230 TREE_OPERAND (expr, 1))), 1);
2233 if (integer_onep (TREE_OPERAND (expr, 1))
2234 && TREE_TYPE (expr) != boolean_type_node)
2235 /* Using convert here would cause infinite recursion. */
2236 return build1 (NOP_EXPR, boolean_type_node, expr);
2240 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2241 warning ("suggest parentheses around assignment used as truth value");
2248 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2250 tree tem = save_expr (expr);
2251 return (build_binary_op
2252 ((TREE_SIDE_EFFECTS (expr)
2253 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2254 truthvalue_conversion (build_unary_op (REALPART_EXPR, tem, 0)),
2255 truthvalue_conversion (build_unary_op (IMAGPART_EXPR, tem, 0)),
2259 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2262 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2263 int, enum built_in_class, int, int,
2266 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2267 down to the element type of an array. */
2270 c_build_qualified_type (type, type_quals)
2274 /* A restrict-qualified pointer type must be a pointer to object or
2275 incomplete type. Note that the use of POINTER_TYPE_P also allows
2276 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2277 the C++ front-end also use POINTER_TYPE for pointer-to-member
2278 values, so even though it should be illegal to use `restrict'
2279 with such an entity we don't flag that here. Thus, special case
2280 code for that case is required in the C++ front-end. */
2281 if ((type_quals & TYPE_QUAL_RESTRICT)
2282 && (!POINTER_TYPE_P (type)
2283 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2285 error ("invalid use of `restrict'");
2286 type_quals &= ~TYPE_QUAL_RESTRICT;
2289 if (TREE_CODE (type) == ARRAY_TYPE)
2290 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2292 TYPE_DOMAIN (type));
2293 return build_qualified_type (type, type_quals);
2296 /* Apply the TYPE_QUALS to the new DECL. */
2299 c_apply_type_quals_to_decl (type_quals, decl)
2303 if ((type_quals & TYPE_QUAL_CONST)
2304 || (TREE_TYPE (decl)
2305 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2306 TREE_READONLY (decl) = 1;
2307 if (type_quals & TYPE_QUAL_VOLATILE)
2309 TREE_SIDE_EFFECTS (decl) = 1;
2310 TREE_THIS_VOLATILE (decl) = 1;
2312 if (type_quals & TYPE_QUAL_RESTRICT)
2314 if (!TREE_TYPE (decl)
2315 || !POINTER_TYPE_P (TREE_TYPE (decl))
2316 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2317 error ("invalid use of `restrict'");
2318 else if (flag_strict_aliasing)
2319 /* Indicate we need to make a unique alias set for this pointer.
2320 We can't do it here because it might be pointing to an
2322 DECL_POINTER_ALIAS_SET (decl) = -2;
2326 /* Return the typed-based alias set for T, which may be an expression
2327 or a type. Return -1 if we don't do anything special. */
2330 c_common_get_alias_set (t)
2335 /* We know nothing about vector types */
2336 if (TREE_CODE (t) == VECTOR_TYPE)
2339 /* Permit type-punning when accessing a union, provided the access
2340 is directly through the union. For example, this code does not
2341 permit taking the address of a union member and then storing
2342 through it. Even the type-punning allowed here is a GCC
2343 extension, albeit a common and useful one; the C standard says
2344 that such accesses have implementation-defined behavior. */
2346 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2347 u = TREE_OPERAND (u, 0))
2348 if (TREE_CODE (u) == COMPONENT_REF
2349 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2352 /* If this is a char *, the ANSI C standard says it can alias
2353 anything. Note that all references need do this. */
2354 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2355 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2356 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2359 /* That's all the expressions we handle specially. */
2363 /* The C standard specifically allows aliasing between signed and
2364 unsigned variants of the same type. We treat the signed
2365 variant as canonical. */
2366 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2368 tree t1 = signed_type (t);
2370 /* t1 == t can happen for boolean nodes which are always unsigned. */
2372 return get_alias_set (t1);
2374 else if (POINTER_TYPE_P (t))
2378 /* Unfortunately, there is no canonical form of a pointer type.
2379 In particular, if we have `typedef int I', then `int *', and
2380 `I *' are different types. So, we have to pick a canonical
2381 representative. We do this below.
2383 Technically, this approach is actually more conservative that
2384 it needs to be. In particular, `const int *' and `int *'
2385 should be in different alias sets, according to the C and C++
2386 standard, since their types are not the same, and so,
2387 technically, an `int **' and `const int **' cannot point at
2390 But, the standard is wrong. In particular, this code is
2395 const int* const* cipp = &ipp;
2397 And, it doesn't make sense for that to be legal unless you
2398 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2399 the pointed-to types. This issue has been reported to the
2401 t1 = build_type_no_quals (t);
2403 return get_alias_set (t1);
2409 /* Implement the __alignof keyword: Return the minimum required
2410 alignment of TYPE, measured in bytes. */
2416 enum tree_code code = TREE_CODE (type);
2419 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2420 if (code == REFERENCE_TYPE)
2422 type = TREE_TYPE (type);
2423 code = TREE_CODE (type);
2426 if (code == FUNCTION_TYPE)
2427 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2428 else if (code == VOID_TYPE || code == ERROR_MARK)
2430 else if (!COMPLETE_TYPE_P (type))
2432 error ("__alignof__ applied to an incomplete type");
2436 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2438 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2441 /* Implement the __alignof keyword: Return the minimum required
2442 alignment of EXPR, measured in bytes. For VAR_DECL's and
2443 FIELD_DECL's return DECL_ALIGN (which can be set from an
2444 "aligned" __attribute__ specification). */
2447 c_alignof_expr (expr)
2452 if (TREE_CODE (expr) == VAR_DECL)
2453 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2455 else if (TREE_CODE (expr) == COMPONENT_REF
2456 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2458 error ("`__alignof' applied to a bit-field");
2461 else if (TREE_CODE (expr) == COMPONENT_REF
2462 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2463 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2465 else if (TREE_CODE (expr) == INDIRECT_REF)
2467 tree t = TREE_OPERAND (expr, 0);
2469 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2471 while (TREE_CODE (t) == NOP_EXPR
2472 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2476 t = TREE_OPERAND (t, 0);
2477 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2478 if (thisalign > bestalign)
2479 best = t, bestalign = thisalign;
2481 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2484 return c_alignof (TREE_TYPE (expr));
2486 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2489 /* Give the specifications for the format attributes, used by C and all
2492 static const struct attribute_spec c_format_attribute_table[] =
2494 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2495 { "format", 3, 3, false, true, true,
2496 handle_format_attribute },
2497 { "format_arg", 1, 1, false, true, true,
2498 handle_format_arg_attribute },
2499 { NULL, 0, 0, false, false, false, NULL }
2502 /* Build tree nodes and builtin functions common to both C and C++ language
2506 c_common_nodes_and_builtins ()
2510 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2511 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2512 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2513 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2514 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2515 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2516 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2517 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2518 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2519 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2520 #include "builtin-types.def"
2521 #undef DEF_PRIMITIVE_TYPE
2522 #undef DEF_FUNCTION_TYPE_0
2523 #undef DEF_FUNCTION_TYPE_1
2524 #undef DEF_FUNCTION_TYPE_2
2525 #undef DEF_FUNCTION_TYPE_3
2526 #undef DEF_FUNCTION_TYPE_4
2527 #undef DEF_FUNCTION_TYPE_VAR_0
2528 #undef DEF_FUNCTION_TYPE_VAR_1
2529 #undef DEF_FUNCTION_TYPE_VAR_2
2530 #undef DEF_POINTER_TYPE
2534 typedef enum builtin_type builtin_type;
2536 tree builtin_types[(int) BT_LAST];
2537 int wchar_type_size;
2538 tree array_domain_type;
2539 tree va_list_ref_type_node;
2540 tree va_list_arg_type_node;
2542 /* We must initialize this before any builtin functions (which might have
2543 attributes) are declared. (c_common_init is too late.) */
2544 format_attribute_table = c_format_attribute_table;
2546 /* Define `int' and `char' first so that dbx will output them first. */
2547 record_builtin_type (RID_INT, NULL, integer_type_node);
2548 record_builtin_type (RID_CHAR, "char", char_type_node);
2550 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2551 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2552 but not C. Are the conditionals here needed? */
2553 if (c_language == clk_cplusplus)
2554 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2555 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2556 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2557 record_builtin_type (RID_MAX, "long unsigned int",
2558 long_unsigned_type_node);
2559 if (c_language == clk_cplusplus)
2560 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2561 record_builtin_type (RID_MAX, "long long int",
2562 long_long_integer_type_node);
2563 record_builtin_type (RID_MAX, "long long unsigned int",
2564 long_long_unsigned_type_node);
2565 if (c_language == clk_cplusplus)
2566 record_builtin_type (RID_MAX, "long long unsigned",
2567 long_long_unsigned_type_node);
2568 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2569 record_builtin_type (RID_MAX, "short unsigned int",
2570 short_unsigned_type_node);
2571 if (c_language == clk_cplusplus)
2572 record_builtin_type (RID_MAX, "unsigned short",
2573 short_unsigned_type_node);
2575 /* Define both `signed char' and `unsigned char'. */
2576 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2577 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2579 /* These are types that c_common_type_for_size and
2580 c_common_type_for_mode use. */
2581 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2583 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2585 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2587 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2589 #if HOST_BITS_PER_WIDE_INT >= 64
2590 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2591 get_identifier ("__int128_t"),
2594 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2595 unsigned_intQI_type_node));
2596 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2597 unsigned_intHI_type_node));
2598 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2599 unsigned_intSI_type_node));
2600 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2601 unsigned_intDI_type_node));
2602 #if HOST_BITS_PER_WIDE_INT >= 64
2603 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2604 get_identifier ("__uint128_t"),
2605 unsigned_intTI_type_node));
2608 /* Create the widest literal types. */
2609 widest_integer_literal_type_node
2610 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2611 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2612 widest_integer_literal_type_node));
2614 widest_unsigned_literal_type_node
2615 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2616 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2617 widest_unsigned_literal_type_node));
2619 /* `unsigned long' is the standard type for sizeof.
2620 Note that stddef.h uses `unsigned long',
2621 and this must agree, even if long and int are the same size. */
2623 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2624 signed_size_type_node = signed_type (c_size_type_node);
2625 set_sizetype (c_size_type_node);
2627 build_common_tree_nodes_2 (flag_short_double);
2629 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2630 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2631 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2633 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2634 get_identifier ("complex int"),
2635 complex_integer_type_node));
2636 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2637 get_identifier ("complex float"),
2638 complex_float_type_node));
2639 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2640 get_identifier ("complex double"),
2641 complex_double_type_node));
2642 (*lang_hooks.decls.pushdecl)
2643 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2644 complex_long_double_type_node));
2646 record_builtin_type (RID_VOID, NULL, void_type_node);
2648 void_zero_node = build_int_2 (0, 0);
2649 TREE_TYPE (void_zero_node) = void_type_node;
2651 void_list_node = build_void_list_node ();
2653 /* Make a type to be the domain of a few array types
2654 whose domains don't really matter.
2655 200 is small enough that it always fits in size_t
2656 and large enough that it can hold most function names for the
2657 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2658 array_domain_type = build_index_type (size_int (200));
2660 /* Make a type for arrays of characters.
2661 With luck nothing will ever really depend on the length of this
2663 char_array_type_node
2664 = build_array_type (char_type_node, array_domain_type);
2666 /* Likewise for arrays of ints. */
2668 = build_array_type (integer_type_node, array_domain_type);
2670 string_type_node = build_pointer_type (char_type_node);
2671 const_string_type_node
2672 = build_pointer_type (build_qualified_type
2673 (char_type_node, TYPE_QUAL_CONST));
2675 (*targetm.init_builtins) ();
2677 /* This is special for C++ so functions can be overloaded. */
2678 wchar_type_node = get_identifier (flag_short_wchar
2679 ? "short unsigned int"
2681 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2682 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2683 if (c_language == clk_cplusplus)
2685 if (TREE_UNSIGNED (wchar_type_node))
2686 wchar_type_node = make_unsigned_type (wchar_type_size);
2688 wchar_type_node = make_signed_type (wchar_type_size);
2689 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2693 signed_wchar_type_node = signed_type (wchar_type_node);
2694 unsigned_wchar_type_node = unsigned_type (wchar_type_node);
2697 /* This is for wide string constants. */
2698 wchar_array_type_node
2699 = build_array_type (wchar_type_node, array_domain_type);
2702 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2705 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2707 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2709 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2711 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2712 unsigned_ptrdiff_type_node = unsigned_type (ptrdiff_type_node);
2714 (*lang_hooks.decls.pushdecl)
2715 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2716 va_list_type_node));
2718 (*lang_hooks.decls.pushdecl)
2719 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2720 ptrdiff_type_node));
2722 (*lang_hooks.decls.pushdecl)
2723 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2726 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2728 va_list_arg_type_node = va_list_ref_type_node =
2729 build_pointer_type (TREE_TYPE (va_list_type_node));
2733 va_list_arg_type_node = va_list_type_node;
2734 va_list_ref_type_node = build_reference_type (va_list_type_node);
2737 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2738 builtin_types[(int) ENUM] = VALUE;
2739 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2740 builtin_types[(int) ENUM] \
2741 = build_function_type (builtin_types[(int) RETURN], \
2743 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2744 builtin_types[(int) ENUM] \
2745 = build_function_type (builtin_types[(int) RETURN], \
2746 tree_cons (NULL_TREE, \
2747 builtin_types[(int) ARG1], \
2749 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2750 builtin_types[(int) ENUM] \
2751 = build_function_type \
2752 (builtin_types[(int) RETURN], \
2753 tree_cons (NULL_TREE, \
2754 builtin_types[(int) ARG1], \
2755 tree_cons (NULL_TREE, \
2756 builtin_types[(int) ARG2], \
2758 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2759 builtin_types[(int) ENUM] \
2760 = build_function_type \
2761 (builtin_types[(int) RETURN], \
2762 tree_cons (NULL_TREE, \
2763 builtin_types[(int) ARG1], \
2764 tree_cons (NULL_TREE, \
2765 builtin_types[(int) ARG2], \
2766 tree_cons (NULL_TREE, \
2767 builtin_types[(int) ARG3], \
2769 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2770 builtin_types[(int) ENUM] \
2771 = build_function_type \
2772 (builtin_types[(int) RETURN], \
2773 tree_cons (NULL_TREE, \
2774 builtin_types[(int) ARG1], \
2775 tree_cons (NULL_TREE, \
2776 builtin_types[(int) ARG2], \
2779 builtin_types[(int) ARG3], \
2780 tree_cons (NULL_TREE, \
2781 builtin_types[(int) ARG4], \
2782 void_list_node)))));
2783 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2784 builtin_types[(int) ENUM] \
2785 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2786 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2787 builtin_types[(int) ENUM] \
2788 = build_function_type (builtin_types[(int) RETURN], \
2789 tree_cons (NULL_TREE, \
2790 builtin_types[(int) ARG1], \
2793 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2794 builtin_types[(int) ENUM] \
2795 = build_function_type \
2796 (builtin_types[(int) RETURN], \
2797 tree_cons (NULL_TREE, \
2798 builtin_types[(int) ARG1], \
2799 tree_cons (NULL_TREE, \
2800 builtin_types[(int) ARG2], \
2802 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2803 builtin_types[(int) ENUM] \
2804 = build_pointer_type (builtin_types[(int) TYPE]);
2805 #include "builtin-types.def"
2806 #undef DEF_PRIMITIVE_TYPE
2807 #undef DEF_FUNCTION_TYPE_1
2808 #undef DEF_FUNCTION_TYPE_2
2809 #undef DEF_FUNCTION_TYPE_3
2810 #undef DEF_FUNCTION_TYPE_4
2811 #undef DEF_FUNCTION_TYPE_VAR_0
2812 #undef DEF_FUNCTION_TYPE_VAR_1
2813 #undef DEF_POINTER_TYPE
2815 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2816 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2821 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2825 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2828 ? (NAME + strlen ("__builtin_")) \
2831 decl = builtin_function_2 (NAME, \
2832 NAME + strlen ("__builtin_"), \
2833 builtin_types[TYPE], \
2834 builtin_types[LIBTYPE], \
2839 /*noreturn_p=*/0); \
2841 built_in_decls[(int) ENUM] = decl; \
2843 #include "builtins.def"
2846 /* Declare _exit and _Exit just to mark them as non-returning. */
2847 builtin_function_2 (NULL, "_exit", NULL_TREE,
2848 builtin_types[BT_FN_VOID_INT],
2849 0, NOT_BUILT_IN, 0, 1, 1);
2850 builtin_function_2 (NULL, "_Exit", NULL_TREE,
2851 builtin_types[BT_FN_VOID_INT],
2852 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
2854 /* Declare these functions non-returning
2855 to avoid spurious "control drops through" warnings. */
2856 builtin_function_2 (NULL, "abort",
2857 NULL_TREE, ((c_language == clk_cplusplus)
2858 ? builtin_types[BT_FN_VOID]
2859 : builtin_types[BT_FN_VOID_VAR]),
2860 0, NOT_BUILT_IN, 0, 0, 1);
2862 builtin_function_2 (NULL, "exit",
2863 NULL_TREE, ((c_language == clk_cplusplus)
2864 ? builtin_types[BT_FN_VOID_INT]
2865 : builtin_types[BT_FN_VOID_VAR]),
2866 0, NOT_BUILT_IN, 0, 0, 1);
2868 main_identifier_node = get_identifier ("main");
2870 /* ??? Perhaps there's a better place to do this. But it is related
2871 to __builtin_va_arg, so it isn't that off-the-wall. */
2872 lang_type_promotes_to = simple_type_promotes_to;
2876 build_va_arg (expr, type)
2879 return build1 (VA_ARG_EXPR, type, expr);
2883 /* Linked list of disabled built-in functions. */
2885 typedef struct disabled_builtin
2888 struct disabled_builtin *next;
2890 static disabled_builtin *disabled_builtins = NULL;
2892 static bool builtin_function_disabled_p PARAMS ((const char *));
2894 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
2895 begins with "__builtin_", give an error. */
2898 disable_builtin_function (name)
2901 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2902 error ("cannot disable built-in function `%s'", name);
2905 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
2907 new->next = disabled_builtins;
2908 disabled_builtins = new;
2913 /* Return true if the built-in function NAME has been disabled, false
2917 builtin_function_disabled_p (name)
2920 disabled_builtin *p;
2921 for (p = disabled_builtins; p != NULL; p = p->next)
2923 if (strcmp (name, p->name) == 0)
2930 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
2931 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
2932 of these may be NULL (though both being NULL is useless).
2933 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
2934 TYPE is the type of the function with the ordinary name. These
2935 may differ if the ordinary name is declared with a looser type to avoid
2936 conflicts with headers. FUNCTION_CODE and CLASS are as for
2937 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
2938 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
2939 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
2940 NORETURN_P is nonzero, the function is marked as non-returning.
2941 Returns the declaration of BUILTIN_NAME, if any, otherwise
2942 the declaration of NAME. Does not declare NAME if flag_no_builtin,
2943 or if NONANSI_P and flag_no_nonansi_builtin. */
2946 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
2947 class, library_name_p, nonansi_p, noreturn_p)
2948 const char *builtin_name;
2953 enum built_in_class class;
2958 tree bdecl = NULL_TREE;
2959 tree decl = NULL_TREE;
2960 if (builtin_name != 0)
2962 bdecl = builtin_function (builtin_name, builtin_type, function_code,
2963 class, library_name_p ? name : NULL);
2966 TREE_THIS_VOLATILE (bdecl) = 1;
2967 TREE_SIDE_EFFECTS (bdecl) = 1;
2970 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
2971 && !(nonansi_p && flag_no_nonansi_builtin))
2973 decl = builtin_function (name, type, function_code, class, NULL);
2975 DECL_BUILT_IN_NONANSI (decl) = 1;
2978 TREE_THIS_VOLATILE (decl) = 1;
2979 TREE_SIDE_EFFECTS (decl) = 1;
2982 return (bdecl != 0 ? bdecl : decl);
2985 /* Nonzero if the type T promotes to int. This is (nearly) the
2986 integral promotions defined in ISO C99 6.3.1.1/2. */
2989 c_promoting_integer_type_p (t)
2992 switch (TREE_CODE (t))
2995 return (TYPE_MAIN_VARIANT (t) == char_type_node
2996 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
2997 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
2998 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
2999 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3000 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3003 /* ??? Technically all enumerations not larger than an int
3004 promote to an int. But this is used along code paths
3005 that only want to notice a size change. */
3006 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3016 /* Given a type, apply default promotions wrt unnamed function arguments
3017 and return the new type. Return NULL_TREE if no change. */
3018 /* ??? There is a function of the same name in the C++ front end that
3019 does something similar, but is more thorough and does not return NULL
3020 if no change. We could perhaps share code, but it would make the
3021 self_promoting_type property harder to identify. */
3024 simple_type_promotes_to (type)
3027 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3028 return double_type_node;
3030 if (c_promoting_integer_type_p (type))
3032 /* Preserve unsignedness if not really getting any wider. */
3033 if (TREE_UNSIGNED (type)
3034 && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
3035 return unsigned_type_node;
3036 return integer_type_node;
3042 /* Return 1 if PARMS specifies a fixed number of parameters
3043 and none of their types is affected by default promotions. */
3046 self_promoting_args_p (parms)
3050 for (t = parms; t; t = TREE_CHAIN (t))
3052 tree type = TREE_VALUE (t);
3054 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3060 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3063 if (c_promoting_integer_type_p (type))
3069 /* Recursively examines the array elements of TYPE, until a non-array
3070 element type is found. */
3073 strip_array_types (type)
3076 while (TREE_CODE (type) == ARRAY_TYPE)
3077 type = TREE_TYPE (type);
3082 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3085 /* Expand a call to an unordered comparison function such as
3086 __builtin_isgreater(). FUNCTION is the function's declaration and
3087 PARAMS a list of the values passed. For __builtin_isunordered(),
3088 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3089 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3090 that give the opposite of the desired result. UNORDERED_CODE is
3091 used for modes that can hold NaNs and ORDERED_CODE is used for the
3095 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3096 tree function, params;
3097 enum tree_code unordered_code, ordered_code;
3099 tree arg0, arg1, type;
3100 enum tree_code code0, code1;
3102 /* Check that we have exactly two arguments. */
3103 if (params == 0 || TREE_CHAIN (params) == 0)
3105 error ("too few arguments to function `%s'",
3106 IDENTIFIER_POINTER (DECL_NAME (function)));
3107 return error_mark_node;
3109 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3111 error ("too many arguments to function `%s'",
3112 IDENTIFIER_POINTER (DECL_NAME (function)));
3113 return error_mark_node;
3116 arg0 = TREE_VALUE (params);
3117 arg1 = TREE_VALUE (TREE_CHAIN (params));
3119 code0 = TREE_CODE (TREE_TYPE (arg0));
3120 code1 = TREE_CODE (TREE_TYPE (arg1));
3122 /* Make sure that the arguments have a common type of REAL. */
3124 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3125 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3126 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3128 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3130 error ("non-floating-point argument to function `%s'",
3131 IDENTIFIER_POINTER (DECL_NAME (function)));
3132 return error_mark_node;
3135 if (unordered_code == UNORDERED_EXPR)
3137 if (MODE_HAS_NANS (TYPE_MODE (type)))
3138 return build_binary_op (unordered_code,
3139 convert (type, arg0),
3140 convert (type, arg1),
3143 return integer_zero_node;
3146 return build_unary_op (TRUTH_NOT_EXPR,
3147 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3150 convert (type, arg0),
3151 convert (type, arg1),
3157 /* Recognize certain built-in functions so we can make tree-codes
3158 other than CALL_EXPR. We do this when it enables fold-const.c
3159 to do something useful. */
3160 /* ??? By rights this should go in builtins.c, but only C and C++
3161 implement build_{binary,unary}_op. Not exactly sure what bits
3162 of functionality are actually needed from those functions, or
3163 where the similar functionality exists in the other front ends. */
3166 expand_tree_builtin (function, params, coerced_params)
3167 tree function, params, coerced_params;
3169 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3172 switch (DECL_FUNCTION_CODE (function))
3176 case BUILT_IN_LLABS:
3177 case BUILT_IN_IMAXABS:
3179 case BUILT_IN_FABSL:
3180 case BUILT_IN_FABSF:
3181 if (coerced_params == 0)
3182 return integer_zero_node;
3183 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3186 case BUILT_IN_CONJF:
3187 case BUILT_IN_CONJL:
3188 if (coerced_params == 0)
3189 return integer_zero_node;
3190 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3192 case BUILT_IN_CREAL:
3193 case BUILT_IN_CREALF:
3194 case BUILT_IN_CREALL:
3195 if (coerced_params == 0)
3196 return integer_zero_node;
3197 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3199 case BUILT_IN_CIMAG:
3200 case BUILT_IN_CIMAGF:
3201 case BUILT_IN_CIMAGL:
3202 if (coerced_params == 0)
3203 return integer_zero_node;
3204 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3206 case BUILT_IN_ISGREATER:
3207 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3209 case BUILT_IN_ISGREATEREQUAL:
3210 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3212 case BUILT_IN_ISLESS:
3213 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3215 case BUILT_IN_ISLESSEQUAL:
3216 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3218 case BUILT_IN_ISLESSGREATER:
3219 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3221 case BUILT_IN_ISUNORDERED:
3222 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3231 /* Returns non-zero if CODE is the code for a statement. */
3234 statement_code_p (code)
3235 enum tree_code code;
3260 if (lang_statement_code_p)
3261 return (*lang_statement_code_p) (code);
3266 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3267 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3268 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3269 value, the traversal is aborted, and the value returned by FUNC is
3270 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3271 the node being visited are not walked.
3273 We don't need a without_duplicates variant of this one because the
3274 statement tree is a tree, not a graph. */
3277 walk_stmt_tree (tp, func, data)
3282 enum tree_code code;
3287 #define WALK_SUBTREE(NODE) \
3290 result = walk_stmt_tree (&(NODE), func, data); \
3296 /* Skip empty subtrees. */
3300 /* Skip subtrees below non-statement nodes. */
3301 if (!statement_code_p (TREE_CODE (*tp)))
3304 /* Call the function. */
3306 result = (*func) (tp, &walk_subtrees, data);
3308 /* If we found something, return it. */
3312 /* FUNC may have modified the tree, recheck that we're looking at a
3314 code = TREE_CODE (*tp);
3315 if (!statement_code_p (code))
3318 /* Visit the subtrees unless FUNC decided that there was nothing
3319 interesting below this point in the tree. */
3322 /* Walk over all the sub-trees of this operand. Statement nodes
3323 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3324 len = TREE_CODE_LENGTH (code);
3326 /* Go through the subtrees. We need to do this in forward order so
3327 that the scope of a FOR_EXPR is handled properly. */
3328 for (i = 0; i < len; ++i)
3329 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3332 /* Finally visit the chain. This can be tail-recursion optimized if
3333 we write it this way. */
3334 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3339 /* Used to compare case labels. K1 and K2 are actually tree nodes
3340 representing case labels, or NULL_TREE for a `default' label.
3341 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3342 K2, and 0 if K1 and K2 are equal. */
3345 case_compare (k1, k2)
3349 /* Consider a NULL key (such as arises with a `default' label) to be
3350 smaller than anything else. */
3356 return tree_int_cst_compare ((tree) k1, (tree) k2);
3359 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3360 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3361 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3362 case label was declared using the usual C/C++ syntax, rather than
3363 the GNU case range extension. CASES is a tree containing all the
3364 case ranges processed so far; COND is the condition for the
3365 switch-statement itself. Returns the CASE_LABEL created, or
3366 ERROR_MARK_NODE if no CASE_LABEL is created. */
3369 c_add_case_label (cases, cond, low_value, high_value)
3378 splay_tree_node node;
3380 /* Create the LABEL_DECL itself. */
3381 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3382 DECL_CONTEXT (label) = current_function_decl;
3384 /* If there was an error processing the switch condition, bail now
3385 before we get more confused. */
3386 if (!cond || cond == error_mark_node)
3388 /* Add a label anyhow so that the back-end doesn't think that
3389 the beginning of the switch is unreachable. */
3391 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3392 return error_mark_node;
3395 if ((low_value && TREE_TYPE (low_value)
3396 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3397 || (high_value && TREE_TYPE (high_value)
3398 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3399 error ("pointers are not permitted as case values");
3401 /* Case ranges are a GNU extension. */
3402 if (high_value && pedantic)
3404 if (c_language == clk_cplusplus)
3405 pedwarn ("ISO C++ forbids range expressions in switch statements");
3407 pedwarn ("ISO C forbids range expressions in switch statements");
3410 type = TREE_TYPE (cond);
3413 low_value = check_case_value (low_value);
3414 low_value = convert_and_check (type, low_value);
3418 high_value = check_case_value (high_value);
3419 high_value = convert_and_check (type, high_value);
3422 /* If an error has occurred, bail out now. */
3423 if (low_value == error_mark_node || high_value == error_mark_node)
3426 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3427 return error_mark_node;
3430 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3431 really a case range, even though it was written that way. Remove
3432 the HIGH_VALUE to simplify later processing. */
3433 if (tree_int_cst_equal (low_value, high_value))
3434 high_value = NULL_TREE;
3435 if (low_value && high_value
3436 && !tree_int_cst_lt (low_value, high_value))
3437 warning ("empty range specified");
3439 /* Look up the LOW_VALUE in the table of case labels we already
3441 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3442 /* If there was not an exact match, check for overlapping ranges.
3443 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3444 that's a `default' label and the only overlap is an exact match. */
3445 if (!node && (low_value || high_value))
3447 splay_tree_node low_bound;
3448 splay_tree_node high_bound;
3450 /* Even though there wasn't an exact match, there might be an
3451 overlap between this case range and another case range.
3452 Since we've (inductively) not allowed any overlapping case
3453 ranges, we simply need to find the greatest low case label
3454 that is smaller that LOW_VALUE, and the smallest low case
3455 label that is greater than LOW_VALUE. If there is an overlap
3456 it will occur in one of these two ranges. */
3457 low_bound = splay_tree_predecessor (cases,
3458 (splay_tree_key) low_value);
3459 high_bound = splay_tree_successor (cases,
3460 (splay_tree_key) low_value);
3462 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3463 the LOW_VALUE, so there is no need to check unless the
3464 LOW_BOUND is in fact itself a case range. */
3466 && CASE_HIGH ((tree) low_bound->value)
3467 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3470 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3471 range is bigger than the low end of the current range, so we
3472 are only interested if the current range is a real range, and
3473 not an ordinary case label. */
3476 && (tree_int_cst_compare ((tree) high_bound->key,
3481 /* If there was an overlap, issue an error. */
3484 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3488 error ("duplicate (or overlapping) case value");
3489 error_with_decl (duplicate,
3490 "this is the first entry overlapping that value");
3494 error ("duplicate case value") ;
3495 error_with_decl (duplicate, "previously used here");
3499 error ("multiple default labels in one switch");
3500 error_with_decl (duplicate, "this is the first default label");
3503 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3506 /* Add a CASE_LABEL to the statement-tree. */
3507 case_label = add_stmt (build_case_label (low_value, high_value, label));
3508 /* Register this case label in the splay tree. */
3509 splay_tree_insert (cases,
3510 (splay_tree_key) low_value,
3511 (splay_tree_value) case_label);
3516 /* Finish an expression taking the address of LABEL. Returns an
3517 expression for the address. */
3520 finish_label_address_expr (label)
3527 if (c_language == clk_cplusplus)
3528 pedwarn ("ISO C++ forbids taking the address of a label");
3530 pedwarn ("ISO C forbids taking the address of a label");
3533 label = lookup_label (label);
3534 if (label == NULL_TREE)
3535 result = null_pointer_node;
3538 TREE_USED (label) = 1;
3539 result = build1 (ADDR_EXPR, ptr_type_node, label);
3540 TREE_CONSTANT (result) = 1;
3541 /* The current function in not necessarily uninlinable.
3542 Computed gotos are incompatible with inlining, but the value
3543 here could be used only in a diagnostic, for example. */
3549 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3550 parameter allows this function to be used as a GC-marking
3557 stmt_tree st = (stmt_tree) p;
3559 ggc_mark_tree (st->x_last_stmt);
3560 ggc_mark_tree (st->x_last_expr_type);
3563 /* Mark LD for GC. */
3566 c_mark_lang_decl (c)
3567 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3571 /* Mark F for GC. */
3574 mark_c_language_function (f)
3575 struct language_function *f;
3580 mark_stmt_tree (&f->x_stmt_tree);
3581 ggc_mark_tree (f->x_scope_stmt_stack);
3584 /* Hook used by expand_expr to expand language-specific tree codes. */
3587 c_expand_expr (exp, target, tmode, modifier)
3590 enum machine_mode tmode;
3591 int modifier; /* Actually enum_modifier. */
3593 switch (TREE_CODE (exp))
3599 bool preserve_result = false;
3601 /* Since expand_expr_stmt calls free_temp_slots after every
3602 expression statement, we must call push_temp_slots here.
3603 Otherwise, any temporaries in use now would be considered
3604 out-of-scope after the first EXPR_STMT from within the
3607 rtl_expr = expand_start_stmt_expr ();
3609 /* If we want the result of this expression, find the last
3610 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3611 if (target != const0_rtx
3612 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3613 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3615 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3616 tree last = TREE_CHAIN (expr);
3618 while (TREE_CHAIN (last))
3621 last = TREE_CHAIN (last);
3624 if (TREE_CODE (last) == SCOPE_STMT
3625 && TREE_CODE (expr) == EXPR_STMT)
3627 TREE_ADDRESSABLE (expr) = 1;
3628 preserve_result = true;
3632 expand_stmt (STMT_EXPR_STMT (exp));
3633 expand_end_stmt_expr (rtl_expr);
3635 result = expand_expr (rtl_expr, target, tmode, modifier);
3636 if (preserve_result && GET_CODE (result) == MEM)
3638 if (GET_MODE (result) != BLKmode)
3639 result = copy_to_reg (result);
3641 preserve_temp_slots (result);
3651 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3652 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3654 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3655 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3656 == BUILT_IN_FRONTEND))
3657 return c_expand_builtin (exp, target, tmode, modifier);
3663 case COMPOUND_LITERAL_EXPR:
3665 /* Initialize the anonymous variable declared in the compound
3666 literal, then return the variable. */
3667 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3668 emit_local_var (decl);
3669 return expand_expr (decl, target, tmode, modifier);
3680 /* Hook used by safe_from_p to handle language-specific tree codes. */
3683 c_safe_from_p (target, exp)
3687 /* We can see statements here when processing the body of a
3688 statement-expression. For a declaration statement declaring a
3689 variable, look at the variable's initializer. */
3690 if (TREE_CODE (exp) == DECL_STMT)
3692 tree decl = DECL_STMT_DECL (exp);
3694 if (TREE_CODE (decl) == VAR_DECL
3695 && DECL_INITIAL (decl)
3696 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3700 /* For any statement, we must follow the statement-chain. */
3701 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3702 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3704 /* Assume everything else is safe. */
3708 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3711 c_common_unsafe_for_reeval (exp)
3714 /* Statement expressions may not be reevaluated, likewise compound
3716 if (TREE_CODE (exp) == STMT_EXPR
3717 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3720 /* Walk all other expressions. */
3724 /* Hook used by staticp to handle language-specific tree codes. */
3730 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3731 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3736 #define CALLED_AS_BUILT_IN(NODE) \
3737 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3740 c_expand_builtin (exp, target, tmode, modifier)
3743 enum machine_mode tmode;
3744 enum expand_modifier modifier;
3746 tree type = TREE_TYPE (exp);
3747 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3748 tree arglist = TREE_OPERAND (exp, 1);
3749 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3750 enum tree_code code = TREE_CODE (exp);
3751 const int ignore = (target == const0_rtx
3752 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3753 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3754 || code == COND_EXPR)
3755 && TREE_CODE (type) == VOID_TYPE));
3757 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3758 return expand_call (exp, target, ignore);
3762 case BUILT_IN_PRINTF:
3763 target = c_expand_builtin_printf (arglist, target, tmode,
3764 modifier, ignore, /*unlocked=*/ 0);
3769 case BUILT_IN_PRINTF_UNLOCKED:
3770 target = c_expand_builtin_printf (arglist, target, tmode,
3771 modifier, ignore, /*unlocked=*/ 1);
3776 case BUILT_IN_FPRINTF:
3777 target = c_expand_builtin_fprintf (arglist, target, tmode,
3778 modifier, ignore, /*unlocked=*/ 0);
3783 case BUILT_IN_FPRINTF_UNLOCKED:
3784 target = c_expand_builtin_fprintf (arglist, target, tmode,
3785 modifier, ignore, /*unlocked=*/ 1);
3790 default: /* just do library call, if unknown builtin */
3791 error ("built-in function `%s' not currently supported",
3792 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3795 /* The switch statement above can drop through to cause the function
3796 to be called normally. */
3797 return expand_call (exp, target, ignore);
3800 /* Check an arglist to *printf for problems. The arglist should start
3801 at the format specifier, with the remaining arguments immediately
3804 is_valid_printf_arglist (arglist)
3807 /* Save this value so we can restore it later. */
3808 const int SAVE_pedantic = pedantic;
3809 int diagnostic_occurred = 0;
3812 /* Set this to a known value so the user setting won't affect code
3815 /* Check to make sure there are no format specifier errors. */
3816 attrs = tree_cons (get_identifier ("format"),
3817 tree_cons (NULL_TREE,
3818 get_identifier ("printf"),
3819 tree_cons (NULL_TREE,
3821 tree_cons (NULL_TREE,
3825 check_function_format (&diagnostic_occurred, attrs, arglist);
3827 /* Restore the value of `pedantic'. */
3828 pedantic = SAVE_pedantic;
3830 /* If calling `check_function_format_ptr' produces a warning, we
3831 return false, otherwise we return true. */
3832 return ! diagnostic_occurred;
3835 /* If the arguments passed to printf are suitable for optimizations,
3836 we attempt to transform the call. */
3838 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
3841 enum machine_mode tmode;
3842 enum expand_modifier modifier;
3846 tree fn_putchar = unlocked ?
3847 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
3848 tree fn_puts = unlocked ?
3849 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
3850 tree fn, format_arg, stripped_string;
3852 /* If the return value is used, or the replacement _DECL isn't
3853 initialized, don't do the transformation. */
3854 if (!ignore || !fn_putchar || !fn_puts)
3857 /* Verify the required arguments in the original call. */
3859 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3862 /* Check the specifier vs. the parameters. */
3863 if (!is_valid_printf_arglist (arglist))
3866 format_arg = TREE_VALUE (arglist);
3867 stripped_string = format_arg;
3868 STRIP_NOPS (stripped_string);
3869 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3870 stripped_string = TREE_OPERAND (stripped_string, 0);
3872 /* If the format specifier isn't a STRING_CST, punt. */
3873 if (TREE_CODE (stripped_string) != STRING_CST)
3876 /* OK! We can attempt optimization. */
3878 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
3879 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
3881 arglist = TREE_CHAIN (arglist);
3884 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
3885 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3887 arglist = TREE_CHAIN (arglist);
3892 /* We can't handle anything else with % args or %% ... yet. */
3893 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
3896 /* If the resulting constant string has a length of 1, call
3897 putchar. Note, TREE_STRING_LENGTH includes the terminating
3898 NULL in its count. */
3899 if (TREE_STRING_LENGTH (stripped_string) == 2)
3901 /* Given printf("c"), (where c is any one character,)
3902 convert "c"[0] to an int and pass that to the replacement
3904 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
3905 arglist = build_tree_list (NULL_TREE, arglist);
3909 /* If the resulting constant was "string\n", call
3910 __builtin_puts("string"). Ensure "string" has at least one
3911 character besides the trailing \n. Note, TREE_STRING_LENGTH
3912 includes the terminating NULL in its count. */
3913 else if (TREE_STRING_LENGTH (stripped_string) > 2
3914 && TREE_STRING_POINTER (stripped_string)
3915 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
3917 /* Create a NULL-terminated string that's one char shorter
3918 than the original, stripping off the trailing '\n'. */
3919 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
3920 char *newstr = (char *) alloca (newlen);
3921 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
3922 newstr[newlen - 1] = 0;
3924 arglist = combine_strings (build_string (newlen, newstr));
3925 arglist = build_tree_list (NULL_TREE, arglist);
3929 /* We'd like to arrange to call fputs(string) here, but we
3930 need stdout and don't have a way to get it ... yet. */
3934 return expand_expr (build_function_call (fn, arglist),
3935 (ignore ? const0_rtx : target),
3939 /* If the arguments passed to fprintf are suitable for optimizations,
3940 we attempt to transform the call. */
3942 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
3945 enum machine_mode tmode;
3946 enum expand_modifier modifier;
3950 tree fn_fputc = unlocked ?
3951 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
3952 tree fn_fputs = unlocked ?
3953 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
3954 tree fn, format_arg, stripped_string;
3956 /* If the return value is used, or the replacement _DECL isn't
3957 initialized, don't do the transformation. */
3958 if (!ignore || !fn_fputc || !fn_fputs)
3961 /* Verify the required arguments in the original call. */
3963 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
3964 || (TREE_CHAIN (arglist) == 0)
3965 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
3969 /* Check the specifier vs. the parameters. */
3970 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
3973 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
3974 stripped_string = format_arg;
3975 STRIP_NOPS (stripped_string);
3976 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
3977 stripped_string = TREE_OPERAND (stripped_string, 0);
3979 /* If the format specifier isn't a STRING_CST, punt. */
3980 if (TREE_CODE (stripped_string) != STRING_CST)
3983 /* OK! We can attempt optimization. */
3985 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
3986 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
3988 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3989 arglist = tree_cons (NULL_TREE,
3990 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
3994 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
3995 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
3997 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
3998 arglist = tree_cons (NULL_TREE,
3999 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4005 /* We can't handle anything else with % args or %% ... yet. */
4006 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4009 /* When "string" doesn't contain %, replace all cases of
4010 fprintf(stream,string) with fputs(string,stream). The fputs
4011 builtin will take take of special cases like length==1. */
4012 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4013 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4017 return expand_expr (build_function_call (fn, arglist),
4018 (ignore ? const0_rtx : target),
4023 /* Given a boolean expression ARG, return a tree representing an increment
4024 or decrement (as indicated by CODE) of ARG. The front end must check for
4025 invalid cases (e.g., decrement in C++). */
4027 boolean_increment (code, arg)
4028 enum tree_code code;
4032 tree true_res = (c_language == clk_cplusplus
4034 : c_bool_true_node);
4035 arg = stabilize_reference (arg);
4038 case PREINCREMENT_EXPR:
4039 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4041 case POSTINCREMENT_EXPR:
4042 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4043 arg = save_expr (arg);
4044 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4045 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4047 case PREDECREMENT_EXPR:
4048 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4050 case POSTDECREMENT_EXPR:
4051 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4052 arg = save_expr (arg);
4053 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4054 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4059 TREE_SIDE_EFFECTS (val) = 1;
4063 /* Handle C and C++ default attributes. */
4065 enum built_in_attribute
4067 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4068 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4069 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4070 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4071 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
4072 #include "builtin-attrs.def"
4073 #undef DEF_ATTR_NULL_TREE
4075 #undef DEF_ATTR_IDENT
4076 #undef DEF_ATTR_TREE_LIST
4081 static tree built_in_attributes[(int) ATTR_LAST];
4083 static bool c_attrs_initialized = false;
4085 static void c_init_attributes PARAMS ((void));
4087 /* Common initialization before parsing options. */
4089 c_common_init_options (lang)
4090 enum c_language_kind lang;
4093 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
4094 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
4096 /* Mark as "unspecified" (see c_common_post_options). */
4097 flag_bounds_check = -1;
4100 /* Post-switch processing. */
4102 c_common_post_options ()
4104 cpp_post_options (parse_in);
4106 /* Save no-inline information we may clobber below. */
4107 flag_really_no_inline = flag_no_inline;
4109 flag_inline_trees = 1;
4111 /* Use tree inlining if possible. Function instrumentation is only
4112 done in the RTL level, so we disable tree inlining. */
4113 if (! flag_instrument_function_entry_exit)
4115 if (!flag_no_inline)
4117 if (flag_inline_functions)
4119 flag_inline_trees = 2;
4120 flag_inline_functions = 0;
4124 /* If still "unspecified", make it match -fbounded-pointers. */
4125 if (flag_bounds_check == -1)
4126 flag_bounds_check = flag_bounded_pointers;
4128 /* Special format checking options don't work without -Wformat; warn if
4130 if (warn_format_y2k && !warn_format)
4131 warning ("-Wformat-y2k ignored without -Wformat");
4132 if (warn_format_extra_args && !warn_format)
4133 warning ("-Wformat-extra-args ignored without -Wformat");
4134 if (warn_format_nonliteral && !warn_format)
4135 warning ("-Wformat-nonliteral ignored without -Wformat");
4136 if (warn_format_security && !warn_format)
4137 warning ("-Wformat-security ignored without -Wformat");
4138 if (warn_missing_format_attribute && !warn_format)
4139 warning ("-Wmissing-format-attribute ignored without -Wformat");
4142 /* Front end initialization common to C, ObjC and C++. */
4144 c_common_init (filename)
4145 const char *filename;
4147 /* NULL is passed up to toplev.c and we exit quickly. */
4148 if (flag_preprocess_only)
4150 cpp_preprocess_file (parse_in);
4154 /* Do this before initializing pragmas, as then cpplib's hash table
4156 filename = init_c_lex (filename);
4160 if (!c_attrs_initialized)
4161 c_init_attributes ();
4166 /* Common finish hook for the C, ObjC and C++ front ends. */
4170 cpp_finish (parse_in);
4172 /* For performance, avoid tearing down cpplib's internal structures.
4173 Call cpp_errors () instead of cpp_destroy (). */
4174 errorcount += cpp_errors (parse_in);
4178 c_init_attributes ()
4180 /* Fill in the built_in_attributes array. */
4181 #define DEF_ATTR_NULL_TREE(ENUM) \
4182 built_in_attributes[(int) ENUM] = NULL_TREE;
4183 #define DEF_ATTR_INT(ENUM, VALUE) \
4184 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4185 #define DEF_ATTR_IDENT(ENUM, STRING) \
4186 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4187 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4188 built_in_attributes[(int) ENUM] \
4189 = tree_cons (built_in_attributes[(int) PURPOSE], \
4190 built_in_attributes[(int) VALUE], \
4191 built_in_attributes[(int) CHAIN]);
4192 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4193 #include "builtin-attrs.def"
4194 #undef DEF_ATTR_NULL_TREE
4196 #undef DEF_ATTR_IDENT
4197 #undef DEF_ATTR_TREE_LIST
4199 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4200 c_attrs_initialized = true;
4203 /* Depending on the name of DECL, apply default attributes to it. */
4206 c_common_insert_default_attributes (decl)
4209 tree name = DECL_NAME (decl);
4211 if (!c_attrs_initialized)
4212 c_init_attributes ();
4214 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4215 #define DEF_ATTR_INT(ENUM, VALUE)
4216 #define DEF_ATTR_IDENT(ENUM, STRING)
4217 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4218 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4219 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4220 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4221 ATTR_FLAG_BUILT_IN);
4222 #include "builtin-attrs.def"
4223 #undef DEF_ATTR_NULL_TREE
4225 #undef DEF_ATTR_IDENT
4226 #undef DEF_ATTR_TREE_LIST
4230 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4231 additionally give the location of the previous declaration DECL. */
4233 shadow_warning (msgid, name, decl)
4237 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4238 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4239 DECL_SOURCE_LINE (decl),
4240 "shadowed declaration is here");