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 static tree handle_packed_attribute PARAMS ((tree *, tree, tree, int,
276 static tree handle_nocommon_attribute PARAMS ((tree *, tree, tree, int,
278 static tree handle_common_attribute PARAMS ((tree *, tree, tree, int,
280 static tree handle_noreturn_attribute PARAMS ((tree *, tree, tree, int,
282 static tree handle_noinline_attribute PARAMS ((tree *, tree, tree, int,
284 static tree handle_always_inline_attribute PARAMS ((tree *, tree, tree, int,
286 static tree handle_used_attribute PARAMS ((tree *, tree, tree, int,
288 static tree handle_unused_attribute PARAMS ((tree *, tree, tree, int,
290 static tree handle_const_attribute PARAMS ((tree *, tree, tree, int,
292 static tree handle_transparent_union_attribute PARAMS ((tree *, tree, tree,
294 static tree handle_constructor_attribute PARAMS ((tree *, tree, tree, int,
296 static tree handle_destructor_attribute PARAMS ((tree *, tree, tree, int,
298 static tree handle_mode_attribute PARAMS ((tree *, tree, tree, int,
300 static tree handle_section_attribute PARAMS ((tree *, tree, tree, int,
302 static tree handle_aligned_attribute PARAMS ((tree *, tree, tree, int,
304 static tree handle_weak_attribute PARAMS ((tree *, tree, tree, int,
306 static tree handle_alias_attribute PARAMS ((tree *, tree, tree, int,
308 static tree handle_visibility_attribute PARAMS ((tree *, tree, tree, int,
310 static tree handle_no_instrument_function_attribute PARAMS ((tree *, tree,
313 static tree handle_malloc_attribute PARAMS ((tree *, tree, tree, int,
315 static tree handle_no_limit_stack_attribute PARAMS ((tree *, tree, tree, int,
317 static tree handle_pure_attribute PARAMS ((tree *, tree, tree, int,
319 static tree handle_deprecated_attribute PARAMS ((tree *, tree, tree, int,
321 static tree handle_vector_size_attribute PARAMS ((tree *, tree, tree, int,
323 static tree vector_size_helper PARAMS ((tree, tree));
325 /* Table of machine-independent attributes common to all C-like languages. */
326 const struct attribute_spec c_common_attribute_table[] =
328 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
329 { "packed", 0, 0, false, false, false,
330 handle_packed_attribute },
331 { "nocommon", 0, 0, true, false, false,
332 handle_nocommon_attribute },
333 { "common", 0, 0, true, false, false,
334 handle_common_attribute },
335 /* FIXME: logically, noreturn attributes should be listed as
336 "false, true, true" and apply to function types. But implementing this
337 would require all the places in the compiler that use TREE_THIS_VOLATILE
338 on a decl to identify non-returning functions to be located and fixed
339 to check the function type instead. */
340 { "noreturn", 0, 0, true, false, false,
341 handle_noreturn_attribute },
342 { "volatile", 0, 0, true, false, false,
343 handle_noreturn_attribute },
344 { "noinline", 0, 0, true, false, false,
345 handle_noinline_attribute },
346 { "always_inline", 0, 0, true, false, false,
347 handle_always_inline_attribute },
348 { "used", 0, 0, true, false, false,
349 handle_used_attribute },
350 { "unused", 0, 0, false, false, false,
351 handle_unused_attribute },
352 /* The same comments as for noreturn attributes apply to const ones. */
353 { "const", 0, 0, true, false, false,
354 handle_const_attribute },
355 { "transparent_union", 0, 0, false, false, false,
356 handle_transparent_union_attribute },
357 { "constructor", 0, 0, true, false, false,
358 handle_constructor_attribute },
359 { "destructor", 0, 0, true, false, false,
360 handle_destructor_attribute },
361 { "mode", 1, 1, false, true, false,
362 handle_mode_attribute },
363 { "section", 1, 1, true, false, false,
364 handle_section_attribute },
365 { "aligned", 0, 1, false, false, false,
366 handle_aligned_attribute },
367 { "weak", 0, 0, true, false, false,
368 handle_weak_attribute },
369 { "alias", 1, 1, true, false, false,
370 handle_alias_attribute },
371 { "no_instrument_function", 0, 0, true, false, false,
372 handle_no_instrument_function_attribute },
373 { "malloc", 0, 0, true, false, false,
374 handle_malloc_attribute },
375 { "no_stack_limit", 0, 0, true, false, false,
376 handle_no_limit_stack_attribute },
377 { "pure", 0, 0, true, false, false,
378 handle_pure_attribute },
379 { "deprecated", 0, 0, false, false, false,
380 handle_deprecated_attribute },
381 { "vector_size", 1, 1, false, true, false,
382 handle_vector_size_attribute },
383 { "visibility", 1, 1, true, false, false,
384 handle_visibility_attribute },
385 { NULL, 0, 0, false, false, false, NULL }
388 /* Give the specifications for the format attributes, used by C and all
391 const struct attribute_spec c_common_format_attribute_table[] =
393 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
394 { "format", 3, 3, false, true, true,
395 handle_format_attribute },
396 { "format_arg", 1, 1, false, true, true,
397 handle_format_arg_attribute },
398 { NULL, 0, 0, false, false, false, NULL }
401 /* Record the start of an if-then, and record the start of it
402 for ambiguous else detection.
404 COND is the condition for the if-then statement.
406 IF_STMT is the statement node that has already been created for
407 this if-then statement. It is created before parsing the
408 condition to keep line number information accurate. */
411 c_expand_start_cond (cond, compstmt_count, if_stmt)
416 /* Make sure there is enough space on the stack. */
417 if (if_stack_space == 0)
420 if_stack = (if_elt *) xmalloc (10 * sizeof (if_elt));
422 else if (if_stack_space == if_stack_pointer)
424 if_stack_space += 10;
425 if_stack = (if_elt *) xrealloc (if_stack, if_stack_space * sizeof (if_elt));
428 IF_COND (if_stmt) = cond;
431 /* Record this if statement. */
432 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
433 if_stack[if_stack_pointer].file = input_filename;
434 if_stack[if_stack_pointer].line = lineno;
435 if_stack[if_stack_pointer].needs_warning = 0;
436 if_stack[if_stack_pointer].if_stmt = if_stmt;
440 /* Called after the then-clause for an if-statement is processed. */
445 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
446 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
449 /* Record the end of an if-then. Optionally warn if a nested
450 if statement had an ambiguous else clause. */
456 if (if_stack[if_stack_pointer].needs_warning)
457 warning_with_file_and_line (if_stack[if_stack_pointer].file,
458 if_stack[if_stack_pointer].line,
459 "suggest explicit braces to avoid ambiguous `else'");
460 last_expr_type = NULL_TREE;
463 /* Called between the then-clause and the else-clause
464 of an if-then-else. */
467 c_expand_start_else ()
469 /* An ambiguous else warning must be generated for the enclosing if
470 statement, unless we see an else branch for that one, too. */
472 && if_stack_pointer > 1
473 && (if_stack[if_stack_pointer - 1].compstmt_count
474 == if_stack[if_stack_pointer - 2].compstmt_count))
475 if_stack[if_stack_pointer - 2].needs_warning = 1;
477 /* Even if a nested if statement had an else branch, it can't be
478 ambiguous if this one also has an else. So don't warn in that
479 case. Also don't warn for any if statements nested in this else. */
480 if_stack[if_stack_pointer - 1].needs_warning = 0;
481 if_stack[if_stack_pointer - 1].compstmt_count--;
484 /* Called after the else-clause for an if-statement is processed. */
489 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
490 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
493 /* Begin an if-statement. Returns a newly created IF_STMT if
496 Unlike the C++ front-end, we do not call add_stmt here; it is
497 probably safe to do so, but I am not very familiar with this
498 code so I am being extra careful not to change its behavior
499 beyond what is strictly necessary for correctness. */
505 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
509 /* Begin a while statement. Returns a newly created WHILE_STMT if
512 Unlike the C++ front-end, we do not call add_stmt here; it is
513 probably safe to do so, but I am not very familiar with this
514 code so I am being extra careful not to change its behavior
515 beyond what is strictly necessary for correctness. */
518 c_begin_while_stmt ()
521 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
526 c_finish_while_stmt_cond (cond, while_stmt)
530 WHILE_COND (while_stmt) = cond;
533 /* Push current bindings for the function name VAR_DECLS. */
539 tree saved = NULL_TREE;
541 for (ix = 0; fname_vars[ix].decl; ix++)
543 tree decl = *fname_vars[ix].decl;
547 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
548 *fname_vars[ix].decl = NULL_TREE;
551 if (saved || saved_function_name_decls)
552 /* Normally they'll have been NULL, so only push if we've got a
553 stack, or they are non-NULL. */
554 saved_function_name_decls = tree_cons (saved, NULL_TREE,
555 saved_function_name_decls);
558 /* Finish up the current bindings, adding them into the
559 current function's statement tree. This is done by wrapping the
560 function's body in a COMPOUND_STMT containing these decls too. This
561 must be done _before_ finish_stmt_tree is called. If there is no
562 current function, we must be at file scope and no statements are
563 involved. Pop the previous bindings. */
566 finish_fname_decls ()
569 tree body = NULL_TREE;
570 tree stack = saved_function_name_decls;
572 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
573 body = chainon (TREE_VALUE (stack), body);
577 /* They were called into existence, so add to statement tree. */
578 body = chainon (body,
579 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)));
580 body = build_stmt (COMPOUND_STMT, body);
582 COMPOUND_STMT_NO_SCOPE (body) = 1;
583 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl)) = body;
586 for (ix = 0; fname_vars[ix].decl; ix++)
587 *fname_vars[ix].decl = NULL_TREE;
591 /* We had saved values, restore them. */
594 for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
596 tree decl = TREE_PURPOSE (saved);
597 unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
599 *fname_vars[ix].decl = decl;
601 stack = TREE_CHAIN (stack);
603 saved_function_name_decls = stack;
606 /* Return the text name of the current function, suitable prettified
610 fname_as_string (pretty_p)
613 const char *name = NULL;
616 name = (current_function_decl
617 ? (*lang_hooks.decl_printable_name) (current_function_decl, 2)
619 else if (current_function_decl && DECL_NAME (current_function_decl))
620 name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl));
626 /* Return the text name of the current function, formatted as
627 required by the supplied RID value. */
635 for (ix = 0; fname_vars[ix].decl; ix++)
636 if (fname_vars[ix].rid == rid)
638 return fname_as_string (fname_vars[ix].pretty);
641 /* Return the VAR_DECL for a const char array naming the current
642 function. If the VAR_DECL has not yet been created, create it
643 now. RID indicates how it should be formatted and IDENTIFIER_NODE
644 ID is its name (unfortunately C and C++ hold the RID values of
645 keywords in different places, so we can't derive RID from ID in
646 this language independent code. */
654 tree decl = NULL_TREE;
656 for (ix = 0; fname_vars[ix].decl; ix++)
657 if (fname_vars[ix].rid == rid)
660 decl = *fname_vars[ix].decl;
663 tree saved_last_tree = last_tree;
665 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
666 if (last_tree != saved_last_tree)
668 /* We created some statement tree for the decl. This belongs
669 at the start of the function, so remove it now and reinsert
670 it after the function is complete. */
671 tree stmts = TREE_CHAIN (saved_last_tree);
673 TREE_CHAIN (saved_last_tree) = NULL_TREE;
674 last_tree = saved_last_tree;
675 saved_function_name_decls = tree_cons (decl, stmts,
676 saved_function_name_decls);
678 *fname_vars[ix].decl = decl;
680 if (!ix && !current_function_decl)
681 pedwarn_with_decl (decl, "`%s' is not defined outside of function scope");
686 /* Given a chain of STRING_CST nodes,
687 concatenate them into one STRING_CST
688 and give it a suitable array-of-chars data type. */
691 combine_strings (strings)
698 int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
700 const int nchars_max = flag_isoc99 ? 4095 : 509;
702 if (TREE_CHAIN (strings))
704 /* More than one in the chain, so concatenate. */
707 /* Don't include the \0 at the end of each substring,
708 except for the last one.
709 Count wide strings and ordinary strings separately. */
710 for (t = strings; t; t = TREE_CHAIN (t))
712 if (TREE_TYPE (t) == wchar_array_type_node)
714 wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes);
719 length += (TREE_STRING_LENGTH (t) - 1);
720 if (C_ARTIFICIAL_STRING_P (t) && !in_system_header)
721 warning ("concatenation of string literals with __FUNCTION__ is deprecated. This feature will be removed in future");
725 /* If anything is wide, the non-wides will be converted,
726 which makes them take more space. */
728 length = length * wchar_bytes + wide_length;
732 /* Copy the individual strings into the new combined string.
733 If the combined string is wide, convert the chars to ints
734 for any individual strings that are not wide. */
737 for (t = strings; t; t = TREE_CHAIN (t))
739 int len = (TREE_STRING_LENGTH (t)
740 - ((TREE_TYPE (t) == wchar_array_type_node)
742 if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag)
744 memcpy (q, TREE_STRING_POINTER (t), len);
750 for (i = 0; i < len; i++)
752 if (BYTES_BIG_ENDIAN)
754 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
756 *q++ = TREE_STRING_POINTER (t)[i];
760 *q++ = TREE_STRING_POINTER (t)[i];
761 for (j=0; j<(WCHAR_TYPE_SIZE / BITS_PER_UNIT)-1; j++)
770 for (i = 0; i < wchar_bytes; i++)
776 value = build_string (length, p);
781 length = TREE_STRING_LENGTH (value);
782 if (TREE_TYPE (value) == wchar_array_type_node)
786 /* Compute the number of elements, for the array type. */
787 nchars = wide_flag ? length / wchar_bytes : length;
789 if (pedantic && nchars - 1 > nchars_max && c_language == clk_c)
790 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
791 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
793 /* Create the array type for the string constant.
794 -Wwrite-strings says make the string constant an array of const char
795 so that copying it to a non-const pointer will get a warning.
796 For C++, this is the standard behavior. */
797 if (flag_const_strings && ! flag_writable_strings)
800 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
803 = build_array_type (elements,
804 build_index_type (build_int_2 (nchars - 1, 0)));
808 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
809 build_index_type (build_int_2 (nchars - 1, 0)));
811 TREE_CONSTANT (value) = 1;
812 TREE_READONLY (value) = ! flag_writable_strings;
813 TREE_STATIC (value) = 1;
817 static int is_valid_printf_arglist PARAMS ((tree));
818 static rtx c_expand_builtin PARAMS ((tree, rtx, enum machine_mode, enum expand_modifier));
819 static rtx c_expand_builtin_printf PARAMS ((tree, rtx, enum machine_mode,
820 enum expand_modifier, int, int));
821 static rtx c_expand_builtin_fprintf PARAMS ((tree, rtx, enum machine_mode,
822 enum expand_modifier, int, int));
824 /* Print a warning if a constant expression had overflow in folding.
825 Invoke this function on every expression that the language
826 requires to be a constant expression.
827 Note the ANSI C standard says it is erroneous for a
828 constant expression to overflow. */
831 constant_expression_warning (value)
834 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
835 || TREE_CODE (value) == VECTOR_CST
836 || TREE_CODE (value) == COMPLEX_CST)
837 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
838 pedwarn ("overflow in constant expression");
841 /* Print a warning if an expression had overflow in folding.
842 Invoke this function on every expression that
843 (1) appears in the source code, and
844 (2) might be a constant expression that overflowed, and
845 (3) is not already checked by convert_and_check;
846 however, do not invoke this function on operands of explicit casts. */
849 overflow_warning (value)
852 if ((TREE_CODE (value) == INTEGER_CST
853 || (TREE_CODE (value) == COMPLEX_CST
854 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
855 && TREE_OVERFLOW (value))
857 TREE_OVERFLOW (value) = 0;
858 if (skip_evaluation == 0)
859 warning ("integer overflow in expression");
861 else if ((TREE_CODE (value) == REAL_CST
862 || (TREE_CODE (value) == COMPLEX_CST
863 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
864 && TREE_OVERFLOW (value))
866 TREE_OVERFLOW (value) = 0;
867 if (skip_evaluation == 0)
868 warning ("floating point overflow in expression");
870 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
872 TREE_OVERFLOW (value) = 0;
873 if (skip_evaluation == 0)
874 warning ("vector overflow in expression");
878 /* Print a warning if a large constant is truncated to unsigned,
879 or if -Wconversion is used and a constant < 0 is converted to unsigned.
880 Invoke this function on every expression that might be implicitly
881 converted to an unsigned type. */
884 unsigned_conversion_warning (result, operand)
885 tree result, operand;
887 tree type = TREE_TYPE (result);
889 if (TREE_CODE (operand) == INTEGER_CST
890 && TREE_CODE (type) == INTEGER_TYPE
891 && TREE_UNSIGNED (type)
892 && skip_evaluation == 0
893 && !int_fits_type_p (operand, type))
895 if (!int_fits_type_p (operand, c_common_signed_type (type)))
896 /* This detects cases like converting -129 or 256 to unsigned char. */
897 warning ("large integer implicitly truncated to unsigned type");
898 else if (warn_conversion)
899 warning ("negative integer implicitly converted to unsigned type");
903 /* Nonzero if constant C has a value that is permissible
904 for type TYPE (an INTEGER_TYPE). */
907 constant_fits_type_p (c, type)
910 if (TREE_CODE (c) == INTEGER_CST)
911 return int_fits_type_p (c, type);
913 c = convert (type, c);
914 return !TREE_OVERFLOW (c);
917 /* Convert EXPR to TYPE, warning about conversion problems with constants.
918 Invoke this function on every expression that is converted implicitly,
919 i.e. because of language rules and not because of an explicit cast. */
922 convert_and_check (type, expr)
925 tree t = convert (type, expr);
926 if (TREE_CODE (t) == INTEGER_CST)
928 if (TREE_OVERFLOW (t))
930 TREE_OVERFLOW (t) = 0;
932 /* Do not diagnose overflow in a constant expression merely
933 because a conversion overflowed. */
934 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
936 /* No warning for converting 0x80000000 to int. */
937 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
938 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
939 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
940 /* If EXPR fits in the unsigned version of TYPE,
941 don't warn unless pedantic. */
943 || TREE_UNSIGNED (type)
944 || ! constant_fits_type_p (expr,
945 c_common_unsigned_type (type)))
946 && skip_evaluation == 0)
947 warning ("overflow in implicit constant conversion");
950 unsigned_conversion_warning (t, expr);
955 /* A node in a list that describes references to variables (EXPR), which are
956 either read accesses if WRITER is zero, or write accesses, in which case
957 WRITER is the parent of EXPR. */
964 /* Used to implement a cache the results of a call to verify_tree. We only
965 use this for SAVE_EXPRs. */
968 struct tlist_cache *next;
969 struct tlist *cache_before_sp;
970 struct tlist *cache_after_sp;
974 /* Obstack to use when allocating tlist structures, and corresponding
976 static struct obstack tlist_obstack;
977 static char *tlist_firstobj = 0;
979 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
981 static struct tlist *warned_ids;
982 /* SAVE_EXPRs need special treatment. We process them only once and then
983 cache the results. */
984 static struct tlist_cache *save_expr_cache;
986 static void add_tlist PARAMS ((struct tlist **, struct tlist *, tree, int));
987 static void merge_tlist PARAMS ((struct tlist **, struct tlist *, int));
988 static void verify_tree PARAMS ((tree, struct tlist **, struct tlist **, tree));
989 static int warning_candidate_p PARAMS ((tree));
990 static void warn_for_collisions PARAMS ((struct tlist *));
991 static void warn_for_collisions_1 PARAMS ((tree, tree, struct tlist *, int));
992 static struct tlist *new_tlist PARAMS ((struct tlist *, tree, tree));
993 static void verify_sequence_points PARAMS ((tree));
995 /* Create a new struct tlist and fill in its fields. */
996 static struct tlist *
997 new_tlist (next, t, writer)
1003 l = (struct tlist *) obstack_alloc (&tlist_obstack, sizeof *l);
1010 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1011 is nonnull, we ignore any node we find which has a writer equal to it. */
1014 add_tlist (to, add, exclude_writer, copy)
1017 tree exclude_writer;
1022 struct tlist *next = add->next;
1025 if (! exclude_writer || add->writer != exclude_writer)
1026 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1031 /* Merge the nodes of ADD into TO. This merging process is done so that for
1032 each variable that already exists in TO, no new node is added; however if
1033 there is a write access recorded in ADD, and an occurrence on TO is only
1034 a read access, then the occurrence in TO will be modified to record the
1038 merge_tlist (to, add, copy)
1043 struct tlist **end = to;
1046 end = &(*end)->next;
1052 struct tlist *next = add->next;
1054 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1055 if (tmp2->expr == add->expr)
1059 tmp2->writer = add->writer;
1063 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1064 end = &(*end)->next;
1071 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1072 references in list LIST conflict with it, excluding reads if ONLY writers
1076 warn_for_collisions_1 (written, writer, list, only_writes)
1077 tree written, writer;
1083 /* Avoid duplicate warnings. */
1084 for (tmp = warned_ids; tmp; tmp = tmp->next)
1085 if (tmp->expr == written)
1090 if (list->expr == written
1091 && list->writer != writer
1092 && (! only_writes || list->writer))
1094 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1095 warning ("operation on `%s' may be undefined",
1096 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1102 /* Given a list LIST of references to variables, find whether any of these
1103 can cause conflicts due to missing sequence points. */
1106 warn_for_collisions (list)
1111 for (tmp = list; tmp; tmp = tmp->next)
1114 warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1118 /* Return nonzero if X is a tree that can be verified by the sequence point
1121 warning_candidate_p (x)
1124 return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1127 /* Walk the tree X, and record accesses to variables. If X is written by the
1128 parent tree, WRITER is the parent.
1129 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1130 expression or its only operand forces a sequence point, then everything up
1131 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1133 Once we return, we will have emitted warnings if any subexpression before
1134 such a sequence point could be undefined. On a higher level, however, the
1135 sequence point may not be relevant, and we'll merge the two lists.
1137 Example: (b++, a) + b;
1138 The call that processes the COMPOUND_EXPR will store the increment of B
1139 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1140 processes the PLUS_EXPR will need to merge the two lists so that
1141 eventually, all accesses end up on the same list (and we'll warn about the
1142 unordered subexpressions b++ and b.
1144 A note on merging. If we modify the former example so that our expression
1147 care must be taken not simply to add all three expressions into the final
1148 PNO_SP list. The function merge_tlist takes care of that by merging the
1149 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1150 way, so that no more than one access to B is recorded. */
1153 verify_tree (x, pbefore_sp, pno_sp, writer)
1155 struct tlist **pbefore_sp, **pno_sp;
1158 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1159 enum tree_code code;
1162 /* X may be NULL if it is the operand of an empty statement expression
1168 code = TREE_CODE (x);
1169 class = TREE_CODE_CLASS (code);
1171 if (warning_candidate_p (x))
1173 *pno_sp = new_tlist (*pno_sp, x, writer);
1183 case TRUTH_ANDIF_EXPR:
1184 case TRUTH_ORIF_EXPR:
1185 tmp_before = tmp_nosp = tmp_list3 = 0;
1186 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1187 warn_for_collisions (tmp_nosp);
1188 merge_tlist (pbefore_sp, tmp_before, 0);
1189 merge_tlist (pbefore_sp, tmp_nosp, 0);
1190 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1191 merge_tlist (pbefore_sp, tmp_list3, 0);
1195 tmp_before = tmp_list2 = 0;
1196 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1197 warn_for_collisions (tmp_list2);
1198 merge_tlist (pbefore_sp, tmp_before, 0);
1199 merge_tlist (pbefore_sp, tmp_list2, 1);
1201 tmp_list3 = tmp_nosp = 0;
1202 verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1203 warn_for_collisions (tmp_nosp);
1204 merge_tlist (pbefore_sp, tmp_list3, 0);
1206 tmp_list3 = tmp_list2 = 0;
1207 verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1208 warn_for_collisions (tmp_list2);
1209 merge_tlist (pbefore_sp, tmp_list3, 0);
1210 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1211 two first, to avoid warning for (a ? b++ : b++). */
1212 merge_tlist (&tmp_nosp, tmp_list2, 0);
1213 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1216 case PREDECREMENT_EXPR:
1217 case PREINCREMENT_EXPR:
1218 case POSTDECREMENT_EXPR:
1219 case POSTINCREMENT_EXPR:
1220 verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1224 tmp_before = tmp_nosp = tmp_list3 = 0;
1225 verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1226 verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1227 /* Expressions inside the LHS are not ordered wrt. the sequence points
1228 in the RHS. Example:
1230 Despite the fact that the modification of "a" is in the before_sp
1231 list (tmp_before), it conflicts with the use of "a" in the LHS.
1232 We can handle this by adding the contents of tmp_list3
1233 to those of tmp_before, and redoing the collision warnings for that
1235 add_tlist (&tmp_before, tmp_list3, x, 1);
1236 warn_for_collisions (tmp_before);
1237 /* Exclude the LHS itself here; we first have to merge it into the
1238 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1239 didn't exclude the LHS, we'd get it twice, once as a read and once
1241 add_tlist (pno_sp, tmp_list3, x, 0);
1242 warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1244 merge_tlist (pbefore_sp, tmp_before, 0);
1245 if (warning_candidate_p (TREE_OPERAND (x, 0)))
1246 merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1247 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1251 /* We need to warn about conflicts among arguments and conflicts between
1252 args and the function address. Side effects of the function address,
1253 however, are not ordered by the sequence point of the call. */
1254 tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1255 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1256 if (TREE_OPERAND (x, 1))
1257 verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1258 merge_tlist (&tmp_list3, tmp_list2, 0);
1259 add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1260 add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1261 warn_for_collisions (tmp_before);
1262 add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1266 /* Scan all the list, e.g. indices of multi dimensional array. */
1269 tmp_before = tmp_nosp = 0;
1270 verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1271 merge_tlist (&tmp_nosp, tmp_before, 0);
1272 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1279 struct tlist_cache *t;
1280 for (t = save_expr_cache; t; t = t->next)
1286 t = (struct tlist_cache *) obstack_alloc (&tlist_obstack,
1288 t->next = save_expr_cache;
1290 save_expr_cache = t;
1292 tmp_before = tmp_nosp = 0;
1293 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1294 warn_for_collisions (tmp_nosp);
1299 struct tlist *t = tmp_nosp;
1301 merge_tlist (&tmp_list3, t, 0);
1303 t->cache_before_sp = tmp_before;
1304 t->cache_after_sp = tmp_list3;
1306 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1307 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1316 if (first_rtl_op (code) == 0)
1318 x = TREE_OPERAND (x, 0);
1334 int max = first_rtl_op (TREE_CODE (x));
1335 for (lp = 0; lp < max; lp++)
1337 tmp_before = tmp_nosp = 0;
1338 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1339 merge_tlist (&tmp_nosp, tmp_before, 0);
1340 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1347 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1351 verify_sequence_points (expr)
1354 struct tlist *before_sp = 0, *after_sp = 0;
1357 save_expr_cache = 0;
1358 if (tlist_firstobj == 0)
1360 gcc_obstack_init (&tlist_obstack);
1361 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1364 verify_tree (expr, &before_sp, &after_sp, 0);
1365 warn_for_collisions (after_sp);
1366 obstack_free (&tlist_obstack, tlist_firstobj);
1370 c_expand_expr_stmt (expr)
1373 /* Do default conversion if safe and possibly important,
1374 in case within ({...}). */
1375 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1376 && (flag_isoc99 || lvalue_p (expr)))
1377 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1378 expr = default_conversion (expr);
1380 if (warn_sequence_point)
1381 verify_sequence_points (expr);
1383 if (TREE_TYPE (expr) != error_mark_node
1384 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1385 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1386 error ("expression statement has incomplete type");
1388 last_expr_type = TREE_TYPE (expr);
1389 return add_stmt (build_stmt (EXPR_STMT, expr));
1392 /* Validate the expression after `case' and apply default promotions. */
1395 check_case_value (value)
1398 if (value == NULL_TREE)
1401 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1402 STRIP_TYPE_NOPS (value);
1403 /* In C++, the following is allowed:
1406 switch (...) { case i: ... }
1408 So, we try to reduce the VALUE to a constant that way. */
1409 if (c_language == clk_cplusplus)
1411 value = decl_constant_value (value);
1412 STRIP_TYPE_NOPS (value);
1413 value = fold (value);
1416 if (TREE_CODE (value) != INTEGER_CST
1417 && value != error_mark_node)
1419 error ("case label does not reduce to an integer constant");
1420 value = error_mark_node;
1423 /* Promote char or short to int. */
1424 value = default_conversion (value);
1426 constant_expression_warning (value);
1431 /* Return an integer type with BITS bits of precision,
1432 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1435 c_common_type_for_size (bits, unsignedp)
1439 if (bits == TYPE_PRECISION (integer_type_node))
1440 return unsignedp ? unsigned_type_node : integer_type_node;
1442 if (bits == TYPE_PRECISION (signed_char_type_node))
1443 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1445 if (bits == TYPE_PRECISION (short_integer_type_node))
1446 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1448 if (bits == TYPE_PRECISION (long_integer_type_node))
1449 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1451 if (bits == TYPE_PRECISION (long_long_integer_type_node))
1452 return (unsignedp ? long_long_unsigned_type_node
1453 : long_long_integer_type_node);
1455 if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1456 return (unsignedp ? widest_unsigned_literal_type_node
1457 : widest_integer_literal_type_node);
1459 if (bits <= TYPE_PRECISION (intQI_type_node))
1460 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1462 if (bits <= TYPE_PRECISION (intHI_type_node))
1463 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1465 if (bits <= TYPE_PRECISION (intSI_type_node))
1466 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1468 if (bits <= TYPE_PRECISION (intDI_type_node))
1469 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1474 /* Return a data type that has machine mode MODE.
1475 If the mode is an integer,
1476 then UNSIGNEDP selects between signed and unsigned types. */
1479 c_common_type_for_mode (mode, unsignedp)
1480 enum machine_mode mode;
1483 if (mode == TYPE_MODE (integer_type_node))
1484 return unsignedp ? unsigned_type_node : integer_type_node;
1486 if (mode == TYPE_MODE (signed_char_type_node))
1487 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1489 if (mode == TYPE_MODE (short_integer_type_node))
1490 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1492 if (mode == TYPE_MODE (long_integer_type_node))
1493 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1495 if (mode == TYPE_MODE (long_long_integer_type_node))
1496 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1498 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1499 return unsignedp ? widest_unsigned_literal_type_node
1500 : widest_integer_literal_type_node;
1503 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1506 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1509 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1512 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1514 #if HOST_BITS_PER_WIDE_INT >= 64
1515 if (mode == TYPE_MODE (intTI_type_node))
1516 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1519 if (mode == TYPE_MODE (float_type_node))
1520 return float_type_node;
1522 if (mode == TYPE_MODE (double_type_node))
1523 return double_type_node;
1525 if (mode == TYPE_MODE (long_double_type_node))
1526 return long_double_type_node;
1528 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1529 return build_pointer_type (char_type_node);
1531 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1532 return build_pointer_type (integer_type_node);
1534 #ifdef VECTOR_MODE_SUPPORTED_P
1535 if (VECTOR_MODE_SUPPORTED_P (mode))
1540 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1542 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1544 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1546 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1548 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1550 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1552 return V16SF_type_node;
1554 return V4SF_type_node;
1556 return V2SF_type_node;
1566 /* Return an unsigned type the same as TYPE in other respects. */
1568 c_common_unsigned_type (type)
1571 tree type1 = TYPE_MAIN_VARIANT (type);
1572 if (type1 == signed_char_type_node || type1 == char_type_node)
1573 return unsigned_char_type_node;
1574 if (type1 == integer_type_node)
1575 return unsigned_type_node;
1576 if (type1 == short_integer_type_node)
1577 return short_unsigned_type_node;
1578 if (type1 == long_integer_type_node)
1579 return long_unsigned_type_node;
1580 if (type1 == long_long_integer_type_node)
1581 return long_long_unsigned_type_node;
1582 if (type1 == widest_integer_literal_type_node)
1583 return widest_unsigned_literal_type_node;
1584 #if HOST_BITS_PER_WIDE_INT >= 64
1585 if (type1 == intTI_type_node)
1586 return unsigned_intTI_type_node;
1588 if (type1 == intDI_type_node)
1589 return unsigned_intDI_type_node;
1590 if (type1 == intSI_type_node)
1591 return unsigned_intSI_type_node;
1592 if (type1 == intHI_type_node)
1593 return unsigned_intHI_type_node;
1594 if (type1 == intQI_type_node)
1595 return unsigned_intQI_type_node;
1597 return c_common_signed_or_unsigned_type (1, type);
1600 /* Return a signed type the same as TYPE in other respects. */
1603 c_common_signed_type (type)
1606 tree type1 = TYPE_MAIN_VARIANT (type);
1607 if (type1 == unsigned_char_type_node || type1 == char_type_node)
1608 return signed_char_type_node;
1609 if (type1 == unsigned_type_node)
1610 return integer_type_node;
1611 if (type1 == short_unsigned_type_node)
1612 return short_integer_type_node;
1613 if (type1 == long_unsigned_type_node)
1614 return long_integer_type_node;
1615 if (type1 == long_long_unsigned_type_node)
1616 return long_long_integer_type_node;
1617 if (type1 == widest_unsigned_literal_type_node)
1618 return widest_integer_literal_type_node;
1619 #if HOST_BITS_PER_WIDE_INT >= 64
1620 if (type1 == unsigned_intTI_type_node)
1621 return intTI_type_node;
1623 if (type1 == unsigned_intDI_type_node)
1624 return intDI_type_node;
1625 if (type1 == unsigned_intSI_type_node)
1626 return intSI_type_node;
1627 if (type1 == unsigned_intHI_type_node)
1628 return intHI_type_node;
1629 if (type1 == unsigned_intQI_type_node)
1630 return intQI_type_node;
1632 return c_common_signed_or_unsigned_type (0, type);
1635 /* Return a type the same as TYPE except unsigned or
1636 signed according to UNSIGNEDP. */
1639 c_common_signed_or_unsigned_type (unsignedp, type)
1643 if (! INTEGRAL_TYPE_P (type)
1644 || TREE_UNSIGNED (type) == unsignedp)
1647 if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
1648 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1649 if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1650 return unsignedp ? unsigned_type_node : integer_type_node;
1651 if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
1652 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1653 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
1654 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1655 if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
1656 return (unsignedp ? long_long_unsigned_type_node
1657 : long_long_integer_type_node);
1658 if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
1659 return (unsignedp ? widest_unsigned_literal_type_node
1660 : widest_integer_literal_type_node);
1662 #if HOST_BITS_PER_WIDE_INT >= 64
1663 if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
1664 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1666 if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
1667 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1668 if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
1669 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1670 if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
1671 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1672 if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
1673 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1678 /* Return the minimum number of bits needed to represent VALUE in a
1679 signed or unsigned type, UNSIGNEDP says which. */
1682 min_precision (value, unsignedp)
1688 /* If the value is negative, compute its negative minus 1. The latter
1689 adjustment is because the absolute value of the largest negative value
1690 is one larger than the largest positive value. This is equivalent to
1691 a bit-wise negation, so use that operation instead. */
1693 if (tree_int_cst_sgn (value) < 0)
1694 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1696 /* Return the number of bits needed, taking into account the fact
1697 that we need one more bit for a signed than unsigned type. */
1699 if (integer_zerop (value))
1702 log = tree_floor_log2 (value);
1704 return log + 1 + ! unsignedp;
1707 /* Print an error message for invalid operands to arith operation
1708 CODE. NOP_EXPR is used as a special case (see
1709 c_common_truthvalue_conversion). */
1712 binary_op_error (code)
1713 enum tree_code code;
1720 error ("invalid truth-value expression");
1724 opname = "+"; break;
1726 opname = "-"; break;
1728 opname = "*"; break;
1730 opname = "max"; break;
1732 opname = "min"; break;
1734 opname = "=="; break;
1736 opname = "!="; break;
1738 opname = "<="; break;
1740 opname = ">="; break;
1742 opname = "<"; break;
1744 opname = ">"; break;
1746 opname = "<<"; break;
1748 opname = ">>"; break;
1749 case TRUNC_MOD_EXPR:
1750 case FLOOR_MOD_EXPR:
1751 opname = "%"; break;
1752 case TRUNC_DIV_EXPR:
1753 case FLOOR_DIV_EXPR:
1754 opname = "/"; break;
1756 opname = "&"; break;
1758 opname = "|"; break;
1759 case TRUTH_ANDIF_EXPR:
1760 opname = "&&"; break;
1761 case TRUTH_ORIF_EXPR:
1762 opname = "||"; break;
1764 opname = "^"; break;
1767 opname = "rotate"; break;
1769 opname = "unknown"; break;
1771 error ("invalid operands to binary %s", opname);
1774 /* Subroutine of build_binary_op, used for comparison operations.
1775 See if the operands have both been converted from subword integer types
1776 and, if so, perhaps change them both back to their original type.
1777 This function is also responsible for converting the two operands
1778 to the proper common type for comparison.
1780 The arguments of this function are all pointers to local variables
1781 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1782 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1784 If this function returns nonzero, it means that the comparison has
1785 a constant value. What this function returns is an expression for
1789 shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr)
1790 tree *op0_ptr, *op1_ptr;
1792 enum tree_code *rescode_ptr;
1795 tree op0 = *op0_ptr;
1796 tree op1 = *op1_ptr;
1797 int unsignedp0, unsignedp1;
1799 tree primop0, primop1;
1800 enum tree_code code = *rescode_ptr;
1802 /* Throw away any conversions to wider types
1803 already present in the operands. */
1805 primop0 = get_narrower (op0, &unsignedp0);
1806 primop1 = get_narrower (op1, &unsignedp1);
1808 /* Handle the case that OP0 does not *contain* a conversion
1809 but it *requires* conversion to FINAL_TYPE. */
1811 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
1812 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
1813 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
1814 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
1816 /* If one of the operands must be floated, we cannot optimize. */
1817 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
1818 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
1820 /* If first arg is constant, swap the args (changing operation
1821 so value is preserved), for canonicalization. Don't do this if
1822 the second arg is 0. */
1824 if (TREE_CONSTANT (primop0)
1825 && ! integer_zerop (primop1) && ! real_zerop (primop1))
1828 int temi = unsignedp0;
1836 unsignedp0 = unsignedp1;
1859 *rescode_ptr = code;
1862 /* If comparing an integer against a constant more bits wide,
1863 maybe we can deduce a value of 1 or 0 independent of the data.
1864 Or else truncate the constant now
1865 rather than extend the variable at run time.
1867 This is only interesting if the constant is the wider arg.
1868 Also, it is not safe if the constant is unsigned and the
1869 variable arg is signed, since in this case the variable
1870 would be sign-extended and then regarded as unsigned.
1871 Our technique fails in this case because the lowest/highest
1872 possible unsigned results don't follow naturally from the
1873 lowest/highest possible values of the variable operand.
1874 For just EQ_EXPR and NE_EXPR there is another technique that
1875 could be used: see if the constant can be faithfully represented
1876 in the other operand's type, by truncating it and reextending it
1877 and see if that preserves the constant's value. */
1879 if (!real1 && !real2
1880 && TREE_CODE (primop1) == INTEGER_CST
1881 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
1883 int min_gt, max_gt, min_lt, max_lt;
1884 tree maxval, minval;
1885 /* 1 if comparison is nominally unsigned. */
1886 int unsignedp = TREE_UNSIGNED (*restype_ptr);
1889 type = c_common_signed_or_unsigned_type (unsignedp0,
1890 TREE_TYPE (primop0));
1892 /* If TYPE is an enumeration, then we need to get its min/max
1893 values from it's underlying integral type, not the enumerated
1895 if (TREE_CODE (type) == ENUMERAL_TYPE)
1896 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
1898 maxval = TYPE_MAX_VALUE (type);
1899 minval = TYPE_MIN_VALUE (type);
1901 if (unsignedp && !unsignedp0)
1902 *restype_ptr = c_common_signed_type (*restype_ptr);
1904 if (TREE_TYPE (primop1) != *restype_ptr)
1905 primop1 = convert (*restype_ptr, primop1);
1906 if (type != *restype_ptr)
1908 minval = convert (*restype_ptr, minval);
1909 maxval = convert (*restype_ptr, maxval);
1912 if (unsignedp && unsignedp0)
1914 min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
1915 max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
1916 min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
1917 max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
1921 min_gt = INT_CST_LT (primop1, minval);
1922 max_gt = INT_CST_LT (primop1, maxval);
1923 min_lt = INT_CST_LT (minval, primop1);
1924 max_lt = INT_CST_LT (maxval, primop1);
1928 /* This used to be a switch, but Genix compiler can't handle that. */
1929 if (code == NE_EXPR)
1931 if (max_lt || min_gt)
1932 val = boolean_true_node;
1934 else if (code == EQ_EXPR)
1936 if (max_lt || min_gt)
1937 val = boolean_false_node;
1939 else if (code == LT_EXPR)
1942 val = boolean_true_node;
1944 val = boolean_false_node;
1946 else if (code == GT_EXPR)
1949 val = boolean_true_node;
1951 val = boolean_false_node;
1953 else if (code == LE_EXPR)
1956 val = boolean_true_node;
1958 val = boolean_false_node;
1960 else if (code == GE_EXPR)
1963 val = boolean_true_node;
1965 val = boolean_false_node;
1968 /* If primop0 was sign-extended and unsigned comparison specd,
1969 we did a signed comparison above using the signed type bounds.
1970 But the comparison we output must be unsigned.
1972 Also, for inequalities, VAL is no good; but if the signed
1973 comparison had *any* fixed result, it follows that the
1974 unsigned comparison just tests the sign in reverse
1975 (positive values are LE, negative ones GE).
1976 So we can generate an unsigned comparison
1977 against an extreme value of the signed type. */
1979 if (unsignedp && !unsignedp0)
1986 primop1 = TYPE_MIN_VALUE (type);
1992 primop1 = TYPE_MAX_VALUE (type);
1999 type = c_common_unsigned_type (type);
2002 if (TREE_CODE (primop0) != INTEGER_CST)
2004 if (val == boolean_false_node)
2005 warning ("comparison is always false due to limited range of data type");
2006 if (val == boolean_true_node)
2007 warning ("comparison is always true due to limited range of data type");
2012 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2013 if (TREE_SIDE_EFFECTS (primop0))
2014 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2018 /* Value is not predetermined, but do the comparison
2019 in the type of the operand that is not constant.
2020 TYPE is already properly set. */
2022 else if (real1 && real2
2023 && (TYPE_PRECISION (TREE_TYPE (primop0))
2024 == TYPE_PRECISION (TREE_TYPE (primop1))))
2025 type = TREE_TYPE (primop0);
2027 /* If args' natural types are both narrower than nominal type
2028 and both extend in the same manner, compare them
2029 in the type of the wider arg.
2030 Otherwise must actually extend both to the nominal
2031 common type lest different ways of extending
2033 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2035 else if (unsignedp0 == unsignedp1 && real1 == real2
2036 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2037 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2039 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2040 type = c_common_signed_or_unsigned_type (unsignedp0
2041 || TREE_UNSIGNED (*restype_ptr),
2043 /* Make sure shorter operand is extended the right way
2044 to match the longer operand. */
2046 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2047 TREE_TYPE (primop0)),
2050 = convert (c_common_signed_or_unsigned_type (unsignedp1,
2051 TREE_TYPE (primop1)),
2056 /* Here we must do the comparison on the nominal type
2057 using the args exactly as we received them. */
2058 type = *restype_ptr;
2062 if (!real1 && !real2 && integer_zerop (primop1)
2063 && TREE_UNSIGNED (*restype_ptr))
2069 /* All unsigned values are >= 0, so we warn if extra warnings
2070 are requested. However, if OP0 is a constant that is
2071 >= 0, the signedness of the comparison isn't an issue,
2072 so suppress the warning. */
2073 if (extra_warnings && !in_system_header
2074 && ! (TREE_CODE (primop0) == INTEGER_CST
2075 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2077 warning ("comparison of unsigned expression >= 0 is always true");
2078 value = boolean_true_node;
2082 if (extra_warnings && !in_system_header
2083 && ! (TREE_CODE (primop0) == INTEGER_CST
2084 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2086 warning ("comparison of unsigned expression < 0 is always false");
2087 value = boolean_false_node;
2096 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2097 if (TREE_SIDE_EFFECTS (primop0))
2098 return build (COMPOUND_EXPR, TREE_TYPE (value),
2105 *op0_ptr = convert (type, primop0);
2106 *op1_ptr = convert (type, primop1);
2108 *restype_ptr = boolean_type_node;
2113 /* Return a tree for the sum or difference (RESULTCODE says which)
2114 of pointer PTROP and integer INTOP. */
2117 pointer_int_sum (resultcode, ptrop, intop)
2118 enum tree_code resultcode;
2126 /* The result is a pointer of the same type that is being added. */
2128 tree result_type = TREE_TYPE (ptrop);
2130 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2132 if (pedantic || warn_pointer_arith)
2133 pedwarn ("pointer of type `void *' used in arithmetic");
2134 size_exp = integer_one_node;
2136 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2138 if (pedantic || warn_pointer_arith)
2139 pedwarn ("pointer to a function used in arithmetic");
2140 size_exp = integer_one_node;
2142 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2144 if (pedantic || warn_pointer_arith)
2145 pedwarn ("pointer to member function used in arithmetic");
2146 size_exp = integer_one_node;
2148 else if (TREE_CODE (TREE_TYPE (result_type)) == OFFSET_TYPE)
2150 if (pedantic || warn_pointer_arith)
2151 pedwarn ("pointer to a member used in arithmetic");
2152 size_exp = integer_one_node;
2155 size_exp = size_in_bytes (TREE_TYPE (result_type));
2157 /* If what we are about to multiply by the size of the elements
2158 contains a constant term, apply distributive law
2159 and multiply that constant term separately.
2160 This helps produce common subexpressions. */
2162 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2163 && ! TREE_CONSTANT (intop)
2164 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2165 && TREE_CONSTANT (size_exp)
2166 /* If the constant comes from pointer subtraction,
2167 skip this optimization--it would cause an error. */
2168 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2169 /* If the constant is unsigned, and smaller than the pointer size,
2170 then we must skip this optimization. This is because it could cause
2171 an overflow error if the constant is negative but INTOP is not. */
2172 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2173 || (TYPE_PRECISION (TREE_TYPE (intop))
2174 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2176 enum tree_code subcode = resultcode;
2177 tree int_type = TREE_TYPE (intop);
2178 if (TREE_CODE (intop) == MINUS_EXPR)
2179 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2180 /* Convert both subexpression types to the type of intop,
2181 because weird cases involving pointer arithmetic
2182 can result in a sum or difference with different type args. */
2183 ptrop = build_binary_op (subcode, ptrop,
2184 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2185 intop = convert (int_type, TREE_OPERAND (intop, 0));
2188 /* Convert the integer argument to a type the same size as sizetype
2189 so the multiply won't overflow spuriously. */
2191 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2192 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2193 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2194 TREE_UNSIGNED (sizetype)), intop);
2196 /* Replace the integer argument with a suitable product by the object size.
2197 Do this multiplication as signed, then convert to the appropriate
2198 pointer type (actually unsigned integral). */
2200 intop = convert (result_type,
2201 build_binary_op (MULT_EXPR, intop,
2202 convert (TREE_TYPE (intop), size_exp), 1));
2204 /* Create the sum or difference. */
2206 result = build (resultcode, result_type, ptrop, intop);
2208 folded = fold (result);
2209 if (folded == result)
2210 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2214 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2215 or validate its data type for an `if' or `while' statement or ?..: exp.
2217 This preparation consists of taking the ordinary
2218 representation of an expression expr and producing a valid tree
2219 boolean expression describing whether expr is nonzero. We could
2220 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2221 but we optimize comparisons, &&, ||, and !.
2223 The resulting type should always be `boolean_type_node'. */
2226 c_common_truthvalue_conversion (expr)
2229 if (TREE_CODE (expr) == ERROR_MARK)
2232 #if 0 /* This appears to be wrong for C++. */
2233 /* These really should return error_mark_node after 2.4 is stable.
2234 But not all callers handle ERROR_MARK properly. */
2235 switch (TREE_CODE (TREE_TYPE (expr)))
2238 error ("struct type value used where scalar is required");
2239 return boolean_false_node;
2242 error ("union type value used where scalar is required");
2243 return boolean_false_node;
2246 error ("array type value used where scalar is required");
2247 return boolean_false_node;
2254 switch (TREE_CODE (expr))
2257 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2258 case TRUTH_ANDIF_EXPR:
2259 case TRUTH_ORIF_EXPR:
2260 case TRUTH_AND_EXPR:
2262 case TRUTH_XOR_EXPR:
2263 case TRUTH_NOT_EXPR:
2264 TREE_TYPE (expr) = boolean_type_node;
2271 return integer_zerop (expr) ? boolean_false_node : boolean_true_node;
2274 return real_zerop (expr) ? boolean_false_node : boolean_true_node;
2277 /* If we are taking the address of an external decl, it might be zero
2278 if it is weak, so we cannot optimize. */
2279 if (DECL_P (TREE_OPERAND (expr, 0))
2280 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2283 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2284 return build (COMPOUND_EXPR, boolean_type_node,
2285 TREE_OPERAND (expr, 0), boolean_true_node);
2287 return boolean_true_node;
2290 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2291 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2292 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2293 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2300 /* These don't change whether an object is non-zero or zero. */
2301 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2305 /* These don't change whether an object is zero or non-zero, but
2306 we can't ignore them if their second arg has side-effects. */
2307 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2308 return build (COMPOUND_EXPR, boolean_type_node, TREE_OPERAND (expr, 1),
2309 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2311 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2314 /* Distribute the conversion into the arms of a COND_EXPR. */
2315 return fold (build (COND_EXPR, boolean_type_node, TREE_OPERAND (expr, 0),
2316 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2317 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2320 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2321 since that affects how `default_conversion' will behave. */
2322 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2323 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2325 /* fall through... */
2327 /* If this is widening the argument, we can ignore it. */
2328 if (TYPE_PRECISION (TREE_TYPE (expr))
2329 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2330 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2334 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2335 aren't guaranteed to the be same for modes that can represent
2336 infinity, since if x and y are both +infinity, or both
2337 -infinity, then x - y is not a number.
2339 Note that this transformation is safe when x or y is NaN.
2340 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2342 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2344 /* fall through... */
2346 /* This and MINUS_EXPR can be changed into a comparison of the
2348 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2349 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2350 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2351 TREE_OPERAND (expr, 1), 1);
2352 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2353 fold (build1 (NOP_EXPR,
2354 TREE_TYPE (TREE_OPERAND (expr, 0)),
2355 TREE_OPERAND (expr, 1))), 1);
2358 if (integer_onep (TREE_OPERAND (expr, 1))
2359 && TREE_TYPE (expr) != boolean_type_node)
2360 /* Using convert here would cause infinite recursion. */
2361 return build1 (NOP_EXPR, boolean_type_node, expr);
2365 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2366 warning ("suggest parentheses around assignment used as truth value");
2373 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2375 tree t = save_expr (expr);
2376 return (build_binary_op
2377 ((TREE_SIDE_EFFECTS (expr)
2378 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2379 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2380 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2384 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2387 static tree builtin_function_2 PARAMS ((const char *, const char *, tree, tree,
2388 int, enum built_in_class, int, int,
2391 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2392 down to the element type of an array. */
2395 c_build_qualified_type (type, type_quals)
2399 /* A restrict-qualified pointer type must be a pointer to object or
2400 incomplete type. Note that the use of POINTER_TYPE_P also allows
2401 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2402 the C++ front-end also use POINTER_TYPE for pointer-to-member
2403 values, so even though it should be illegal to use `restrict'
2404 with such an entity we don't flag that here. Thus, special case
2405 code for that case is required in the C++ front-end. */
2406 if ((type_quals & TYPE_QUAL_RESTRICT)
2407 && (!POINTER_TYPE_P (type)
2408 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2410 error ("invalid use of `restrict'");
2411 type_quals &= ~TYPE_QUAL_RESTRICT;
2414 if (TREE_CODE (type) == ARRAY_TYPE)
2415 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2417 TYPE_DOMAIN (type));
2418 return build_qualified_type (type, type_quals);
2421 /* Apply the TYPE_QUALS to the new DECL. */
2424 c_apply_type_quals_to_decl (type_quals, decl)
2428 if ((type_quals & TYPE_QUAL_CONST)
2429 || (TREE_TYPE (decl)
2430 && TREE_CODE (TREE_TYPE (decl)) == REFERENCE_TYPE))
2431 TREE_READONLY (decl) = 1;
2432 if (type_quals & TYPE_QUAL_VOLATILE)
2434 TREE_SIDE_EFFECTS (decl) = 1;
2435 TREE_THIS_VOLATILE (decl) = 1;
2437 if (type_quals & TYPE_QUAL_RESTRICT)
2439 if (!TREE_TYPE (decl)
2440 || !POINTER_TYPE_P (TREE_TYPE (decl))
2441 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl))))
2442 error ("invalid use of `restrict'");
2443 else if (flag_strict_aliasing)
2444 /* Indicate we need to make a unique alias set for this pointer.
2445 We can't do it here because it might be pointing to an
2447 DECL_POINTER_ALIAS_SET (decl) = -2;
2451 /* Return the typed-based alias set for T, which may be an expression
2452 or a type. Return -1 if we don't do anything special. */
2455 c_common_get_alias_set (t)
2460 /* We know nothing about vector types */
2461 if (TREE_CODE (t) == VECTOR_TYPE)
2464 /* Permit type-punning when accessing a union, provided the access
2465 is directly through the union. For example, this code does not
2466 permit taking the address of a union member and then storing
2467 through it. Even the type-punning allowed here is a GCC
2468 extension, albeit a common and useful one; the C standard says
2469 that such accesses have implementation-defined behavior. */
2471 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2472 u = TREE_OPERAND (u, 0))
2473 if (TREE_CODE (u) == COMPONENT_REF
2474 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2477 /* If this is a char *, the ANSI C standard says it can alias
2478 anything. Note that all references need do this. */
2479 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'r'
2480 && TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
2481 && TYPE_PRECISION (TREE_TYPE (t)) == TYPE_PRECISION (char_type_node))
2484 /* That's all the expressions we handle specially. */
2488 /* The C standard specifically allows aliasing between signed and
2489 unsigned variants of the same type. We treat the signed
2490 variant as canonical. */
2491 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2493 tree t1 = c_common_signed_type (t);
2495 /* t1 == t can happen for boolean nodes which are always unsigned. */
2497 return get_alias_set (t1);
2499 else if (POINTER_TYPE_P (t))
2503 /* Unfortunately, there is no canonical form of a pointer type.
2504 In particular, if we have `typedef int I', then `int *', and
2505 `I *' are different types. So, we have to pick a canonical
2506 representative. We do this below.
2508 Technically, this approach is actually more conservative that
2509 it needs to be. In particular, `const int *' and `int *'
2510 should be in different alias sets, according to the C and C++
2511 standard, since their types are not the same, and so,
2512 technically, an `int **' and `const int **' cannot point at
2515 But, the standard is wrong. In particular, this code is
2520 const int* const* cipp = &ipp;
2522 And, it doesn't make sense for that to be legal unless you
2523 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2524 the pointed-to types. This issue has been reported to the
2526 t1 = build_type_no_quals (t);
2528 return get_alias_set (t1);
2534 /* Implement the __alignof keyword: Return the minimum required
2535 alignment of TYPE, measured in bytes. */
2541 enum tree_code code = TREE_CODE (type);
2544 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2545 if (code == REFERENCE_TYPE)
2547 type = TREE_TYPE (type);
2548 code = TREE_CODE (type);
2551 if (code == FUNCTION_TYPE)
2552 t = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2553 else if (code == VOID_TYPE || code == ERROR_MARK)
2555 else if (!COMPLETE_TYPE_P (type))
2557 error ("__alignof__ applied to an incomplete type");
2561 t = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2563 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2566 /* Implement the __alignof keyword: Return the minimum required
2567 alignment of EXPR, measured in bytes. For VAR_DECL's and
2568 FIELD_DECL's return DECL_ALIGN (which can be set from an
2569 "aligned" __attribute__ specification). */
2572 c_alignof_expr (expr)
2577 if (TREE_CODE (expr) == VAR_DECL)
2578 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2580 else if (TREE_CODE (expr) == COMPONENT_REF
2581 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2583 error ("`__alignof' applied to a bit-field");
2586 else if (TREE_CODE (expr) == COMPONENT_REF
2587 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2588 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2590 else if (TREE_CODE (expr) == INDIRECT_REF)
2592 tree t = TREE_OPERAND (expr, 0);
2594 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2596 while (TREE_CODE (t) == NOP_EXPR
2597 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2601 t = TREE_OPERAND (t, 0);
2602 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2603 if (thisalign > bestalign)
2604 best = t, bestalign = thisalign;
2606 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2609 return c_alignof (TREE_TYPE (expr));
2611 return fold (build1 (NOP_EXPR, c_size_type_node, t));
2614 /* Build tree nodes and builtin functions common to both C and C++ language
2618 c_common_nodes_and_builtins ()
2622 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2623 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2624 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2625 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2626 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2627 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2628 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2629 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2630 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2631 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2632 #include "builtin-types.def"
2633 #undef DEF_PRIMITIVE_TYPE
2634 #undef DEF_FUNCTION_TYPE_0
2635 #undef DEF_FUNCTION_TYPE_1
2636 #undef DEF_FUNCTION_TYPE_2
2637 #undef DEF_FUNCTION_TYPE_3
2638 #undef DEF_FUNCTION_TYPE_4
2639 #undef DEF_FUNCTION_TYPE_VAR_0
2640 #undef DEF_FUNCTION_TYPE_VAR_1
2641 #undef DEF_FUNCTION_TYPE_VAR_2
2642 #undef DEF_POINTER_TYPE
2646 typedef enum builtin_type builtin_type;
2648 tree builtin_types[(int) BT_LAST];
2649 int wchar_type_size;
2650 tree array_domain_type;
2651 tree va_list_ref_type_node;
2652 tree va_list_arg_type_node;
2654 /* Define `int' and `char' first so that dbx will output them first. */
2655 record_builtin_type (RID_INT, NULL, integer_type_node);
2656 record_builtin_type (RID_CHAR, "char", char_type_node);
2658 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2659 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2660 but not C. Are the conditionals here needed? */
2661 if (c_language == clk_cplusplus)
2662 record_builtin_type (RID_SIGNED, NULL, integer_type_node);
2663 record_builtin_type (RID_LONG, "long int", long_integer_type_node);
2664 record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
2665 record_builtin_type (RID_MAX, "long unsigned int",
2666 long_unsigned_type_node);
2667 if (c_language == clk_cplusplus)
2668 record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
2669 record_builtin_type (RID_MAX, "long long int",
2670 long_long_integer_type_node);
2671 record_builtin_type (RID_MAX, "long long unsigned int",
2672 long_long_unsigned_type_node);
2673 if (c_language == clk_cplusplus)
2674 record_builtin_type (RID_MAX, "long long unsigned",
2675 long_long_unsigned_type_node);
2676 record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
2677 record_builtin_type (RID_MAX, "short unsigned int",
2678 short_unsigned_type_node);
2679 if (c_language == clk_cplusplus)
2680 record_builtin_type (RID_MAX, "unsigned short",
2681 short_unsigned_type_node);
2683 /* Define both `signed char' and `unsigned char'. */
2684 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
2685 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
2687 /* These are types that c_common_type_for_size and
2688 c_common_type_for_mode use. */
2689 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2691 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2693 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2695 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2697 #if HOST_BITS_PER_WIDE_INT >= 64
2698 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2699 get_identifier ("__int128_t"),
2702 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2703 unsigned_intQI_type_node));
2704 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2705 unsigned_intHI_type_node));
2706 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2707 unsigned_intSI_type_node));
2708 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2709 unsigned_intDI_type_node));
2710 #if HOST_BITS_PER_WIDE_INT >= 64
2711 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2712 get_identifier ("__uint128_t"),
2713 unsigned_intTI_type_node));
2716 /* Create the widest literal types. */
2717 widest_integer_literal_type_node
2718 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
2719 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2720 widest_integer_literal_type_node));
2722 widest_unsigned_literal_type_node
2723 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
2724 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
2725 widest_unsigned_literal_type_node));
2727 /* `unsigned long' is the standard type for sizeof.
2728 Note that stddef.h uses `unsigned long',
2729 and this must agree, even if long and int are the same size. */
2731 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
2732 signed_size_type_node = c_common_signed_type (c_size_type_node);
2733 set_sizetype (c_size_type_node);
2735 build_common_tree_nodes_2 (flag_short_double);
2737 record_builtin_type (RID_FLOAT, NULL, float_type_node);
2738 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
2739 record_builtin_type (RID_MAX, "long double", long_double_type_node);
2741 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2742 get_identifier ("complex int"),
2743 complex_integer_type_node));
2744 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2745 get_identifier ("complex float"),
2746 complex_float_type_node));
2747 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2748 get_identifier ("complex double"),
2749 complex_double_type_node));
2750 (*lang_hooks.decls.pushdecl)
2751 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
2752 complex_long_double_type_node));
2754 /* Types which are common to the fortran compiler and libf2c. When
2755 changing these, you also need to be concerned with f/com.h. */
2757 if (TYPE_PRECISION (float_type_node)
2758 == TYPE_PRECISION (long_integer_type_node))
2760 g77_integer_type_node = long_integer_type_node;
2761 g77_uinteger_type_node = long_unsigned_type_node;
2763 else if (TYPE_PRECISION (float_type_node)
2764 == TYPE_PRECISION (integer_type_node))
2766 g77_integer_type_node = integer_type_node;
2767 g77_uinteger_type_node = unsigned_type_node;
2770 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
2772 if (g77_integer_type_node != NULL_TREE)
2774 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2775 get_identifier ("__g77_integer"),
2776 g77_integer_type_node));
2777 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2778 get_identifier ("__g77_uinteger"),
2779 g77_uinteger_type_node));
2782 if (TYPE_PRECISION (float_type_node) * 2
2783 == TYPE_PRECISION (long_integer_type_node))
2785 g77_longint_type_node = long_integer_type_node;
2786 g77_ulongint_type_node = long_unsigned_type_node;
2788 else if (TYPE_PRECISION (float_type_node) * 2
2789 == TYPE_PRECISION (long_long_integer_type_node))
2791 g77_longint_type_node = long_long_integer_type_node;
2792 g77_ulongint_type_node = long_long_unsigned_type_node;
2795 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
2797 if (g77_longint_type_node != NULL_TREE)
2799 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2800 get_identifier ("__g77_longint"),
2801 g77_longint_type_node));
2802 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
2803 get_identifier ("__g77_ulongint"),
2804 g77_ulongint_type_node));
2807 record_builtin_type (RID_VOID, NULL, void_type_node);
2809 void_zero_node = build_int_2 (0, 0);
2810 TREE_TYPE (void_zero_node) = void_type_node;
2812 void_list_node = build_void_list_node ();
2814 /* Make a type to be the domain of a few array types
2815 whose domains don't really matter.
2816 200 is small enough that it always fits in size_t
2817 and large enough that it can hold most function names for the
2818 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2819 array_domain_type = build_index_type (size_int (200));
2821 /* Make a type for arrays of characters.
2822 With luck nothing will ever really depend on the length of this
2824 char_array_type_node
2825 = build_array_type (char_type_node, array_domain_type);
2827 /* Likewise for arrays of ints. */
2829 = build_array_type (integer_type_node, array_domain_type);
2831 string_type_node = build_pointer_type (char_type_node);
2832 const_string_type_node
2833 = build_pointer_type (build_qualified_type
2834 (char_type_node, TYPE_QUAL_CONST));
2836 (*targetm.init_builtins) ();
2838 /* This is special for C++ so functions can be overloaded. */
2839 wchar_type_node = get_identifier (flag_short_wchar
2840 ? "short unsigned int"
2842 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
2843 wchar_type_size = TYPE_PRECISION (wchar_type_node);
2844 if (c_language == clk_cplusplus)
2846 if (TREE_UNSIGNED (wchar_type_node))
2847 wchar_type_node = make_unsigned_type (wchar_type_size);
2849 wchar_type_node = make_signed_type (wchar_type_size);
2850 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
2854 signed_wchar_type_node = c_common_signed_type (wchar_type_node);
2855 unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
2858 /* This is for wide string constants. */
2859 wchar_array_type_node
2860 = build_array_type (wchar_type_node, array_domain_type);
2863 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
2866 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
2868 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
2870 default_function_type = build_function_type (integer_type_node, NULL_TREE);
2872 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
2873 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
2875 (*lang_hooks.decls.pushdecl)
2876 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
2877 va_list_type_node));
2879 (*lang_hooks.decls.pushdecl)
2880 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
2881 ptrdiff_type_node));
2883 (*lang_hooks.decls.pushdecl)
2884 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
2887 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
2889 va_list_arg_type_node = va_list_ref_type_node =
2890 build_pointer_type (TREE_TYPE (va_list_type_node));
2894 va_list_arg_type_node = va_list_type_node;
2895 va_list_ref_type_node = build_reference_type (va_list_type_node);
2898 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2899 builtin_types[(int) ENUM] = VALUE;
2900 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2901 builtin_types[(int) ENUM] \
2902 = build_function_type (builtin_types[(int) RETURN], \
2904 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2905 builtin_types[(int) ENUM] \
2906 = build_function_type (builtin_types[(int) RETURN], \
2907 tree_cons (NULL_TREE, \
2908 builtin_types[(int) ARG1], \
2910 #define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
2911 builtin_types[(int) ENUM] \
2912 = build_function_type \
2913 (builtin_types[(int) RETURN], \
2914 tree_cons (NULL_TREE, \
2915 builtin_types[(int) ARG1], \
2916 tree_cons (NULL_TREE, \
2917 builtin_types[(int) ARG2], \
2919 #define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2920 builtin_types[(int) ENUM] \
2921 = build_function_type \
2922 (builtin_types[(int) RETURN], \
2923 tree_cons (NULL_TREE, \
2924 builtin_types[(int) ARG1], \
2925 tree_cons (NULL_TREE, \
2926 builtin_types[(int) ARG2], \
2927 tree_cons (NULL_TREE, \
2928 builtin_types[(int) ARG3], \
2930 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2931 builtin_types[(int) ENUM] \
2932 = build_function_type \
2933 (builtin_types[(int) RETURN], \
2934 tree_cons (NULL_TREE, \
2935 builtin_types[(int) ARG1], \
2936 tree_cons (NULL_TREE, \
2937 builtin_types[(int) ARG2], \
2940 builtin_types[(int) ARG3], \
2941 tree_cons (NULL_TREE, \
2942 builtin_types[(int) ARG4], \
2943 void_list_node)))));
2944 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2945 builtin_types[(int) ENUM] \
2946 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2947 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2948 builtin_types[(int) ENUM] \
2949 = build_function_type (builtin_types[(int) RETURN], \
2950 tree_cons (NULL_TREE, \
2951 builtin_types[(int) ARG1], \
2954 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2955 builtin_types[(int) ENUM] \
2956 = build_function_type \
2957 (builtin_types[(int) RETURN], \
2958 tree_cons (NULL_TREE, \
2959 builtin_types[(int) ARG1], \
2960 tree_cons (NULL_TREE, \
2961 builtin_types[(int) ARG2], \
2963 #define DEF_POINTER_TYPE(ENUM, TYPE) \
2964 builtin_types[(int) ENUM] \
2965 = build_pointer_type (builtin_types[(int) TYPE]);
2966 #include "builtin-types.def"
2967 #undef DEF_PRIMITIVE_TYPE
2968 #undef DEF_FUNCTION_TYPE_1
2969 #undef DEF_FUNCTION_TYPE_2
2970 #undef DEF_FUNCTION_TYPE_3
2971 #undef DEF_FUNCTION_TYPE_4
2972 #undef DEF_FUNCTION_TYPE_VAR_0
2973 #undef DEF_FUNCTION_TYPE_VAR_1
2974 #undef DEF_POINTER_TYPE
2976 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
2977 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
2982 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
2986 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
2989 ? (NAME + strlen ("__builtin_")) \
2992 decl = builtin_function_2 (NAME, \
2993 NAME + strlen ("__builtin_"), \
2994 builtin_types[TYPE], \
2995 builtin_types[LIBTYPE], \
3000 /*noreturn_p=*/0); \
3002 built_in_decls[(int) ENUM] = decl; \
3004 #include "builtins.def"
3007 /* Declare _exit and _Exit just to mark them as non-returning. */
3008 builtin_function_2 (NULL, "_exit", NULL_TREE,
3009 builtin_types[BT_FN_VOID_INT],
3010 0, NOT_BUILT_IN, 0, 1, 1);
3011 builtin_function_2 (NULL, "_Exit", NULL_TREE,
3012 builtin_types[BT_FN_VOID_INT],
3013 0, NOT_BUILT_IN, 0, !flag_isoc99, 1);
3015 /* Declare these functions non-returning
3016 to avoid spurious "control drops through" warnings. */
3017 builtin_function_2 (NULL, "abort",
3018 NULL_TREE, ((c_language == clk_cplusplus)
3019 ? builtin_types[BT_FN_VOID]
3020 : builtin_types[BT_FN_VOID_VAR]),
3021 0, NOT_BUILT_IN, 0, 0, 1);
3023 builtin_function_2 (NULL, "exit",
3024 NULL_TREE, ((c_language == clk_cplusplus)
3025 ? builtin_types[BT_FN_VOID_INT]
3026 : builtin_types[BT_FN_VOID_VAR]),
3027 0, NOT_BUILT_IN, 0, 0, 1);
3029 main_identifier_node = get_identifier ("main");
3033 build_va_arg (expr, type)
3036 return build1 (VA_ARG_EXPR, type, expr);
3040 /* Linked list of disabled built-in functions. */
3042 typedef struct disabled_builtin
3045 struct disabled_builtin *next;
3047 static disabled_builtin *disabled_builtins = NULL;
3049 static bool builtin_function_disabled_p PARAMS ((const char *));
3051 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3052 begins with "__builtin_", give an error. */
3055 disable_builtin_function (name)
3058 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3059 error ("cannot disable built-in function `%s'", name);
3062 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3064 new->next = disabled_builtins;
3065 disabled_builtins = new;
3070 /* Return true if the built-in function NAME has been disabled, false
3074 builtin_function_disabled_p (name)
3077 disabled_builtin *p;
3078 for (p = disabled_builtins; p != NULL; p = p->next)
3080 if (strcmp (name, p->name) == 0)
3087 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3088 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3089 of these may be NULL (though both being NULL is useless).
3090 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3091 TYPE is the type of the function with the ordinary name. These
3092 may differ if the ordinary name is declared with a looser type to avoid
3093 conflicts with headers. FUNCTION_CODE and CLASS are as for
3094 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3095 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3096 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3097 NORETURN_P is nonzero, the function is marked as non-returning.
3098 Returns the declaration of BUILTIN_NAME, if any, otherwise
3099 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3100 or if NONANSI_P and flag_no_nonansi_builtin. */
3103 builtin_function_2 (builtin_name, name, builtin_type, type, function_code,
3104 class, library_name_p, nonansi_p, noreturn_p)
3105 const char *builtin_name;
3110 enum built_in_class class;
3115 tree bdecl = NULL_TREE;
3116 tree decl = NULL_TREE;
3117 if (builtin_name != 0)
3119 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3120 class, library_name_p ? name : NULL);
3123 TREE_THIS_VOLATILE (bdecl) = 1;
3124 TREE_SIDE_EFFECTS (bdecl) = 1;
3127 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3128 && !(nonansi_p && flag_no_nonansi_builtin))
3130 decl = builtin_function (name, type, function_code, class, NULL);
3132 DECL_BUILT_IN_NONANSI (decl) = 1;
3135 TREE_THIS_VOLATILE (decl) = 1;
3136 TREE_SIDE_EFFECTS (decl) = 1;
3139 return (bdecl != 0 ? bdecl : decl);
3142 /* Nonzero if the type T promotes to int. This is (nearly) the
3143 integral promotions defined in ISO C99 6.3.1.1/2. */
3146 c_promoting_integer_type_p (t)
3149 switch (TREE_CODE (t))
3152 return (TYPE_MAIN_VARIANT (t) == char_type_node
3153 || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3154 || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3155 || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3156 || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3157 || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3160 /* ??? Technically all enumerations not larger than an int
3161 promote to an int. But this is used along code paths
3162 that only want to notice a size change. */
3163 return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3173 /* Return 1 if PARMS specifies a fixed number of parameters
3174 and none of their types is affected by default promotions. */
3177 self_promoting_args_p (parms)
3181 for (t = parms; t; t = TREE_CHAIN (t))
3183 tree type = TREE_VALUE (t);
3185 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3191 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3194 if (c_promoting_integer_type_p (type))
3200 /* Recursively examines the array elements of TYPE, until a non-array
3201 element type is found. */
3204 strip_array_types (type)
3207 while (TREE_CODE (type) == ARRAY_TYPE)
3208 type = TREE_TYPE (type);
3213 static tree expand_unordered_cmp PARAMS ((tree, tree, enum tree_code,
3216 /* Expand a call to an unordered comparison function such as
3217 __builtin_isgreater(). FUNCTION is the function's declaration and
3218 PARAMS a list of the values passed. For __builtin_isunordered(),
3219 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3220 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3221 that give the opposite of the desired result. UNORDERED_CODE is
3222 used for modes that can hold NaNs and ORDERED_CODE is used for the
3226 expand_unordered_cmp (function, params, unordered_code, ordered_code)
3227 tree function, params;
3228 enum tree_code unordered_code, ordered_code;
3230 tree arg0, arg1, type;
3231 enum tree_code code0, code1;
3233 /* Check that we have exactly two arguments. */
3234 if (params == 0 || TREE_CHAIN (params) == 0)
3236 error ("too few arguments to function `%s'",
3237 IDENTIFIER_POINTER (DECL_NAME (function)));
3238 return error_mark_node;
3240 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3242 error ("too many arguments to function `%s'",
3243 IDENTIFIER_POINTER (DECL_NAME (function)));
3244 return error_mark_node;
3247 arg0 = TREE_VALUE (params);
3248 arg1 = TREE_VALUE (TREE_CHAIN (params));
3250 code0 = TREE_CODE (TREE_TYPE (arg0));
3251 code1 = TREE_CODE (TREE_TYPE (arg1));
3253 /* Make sure that the arguments have a common type of REAL. */
3255 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3256 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3257 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3259 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3261 error ("non-floating-point argument to function `%s'",
3262 IDENTIFIER_POINTER (DECL_NAME (function)));
3263 return error_mark_node;
3266 if (unordered_code == UNORDERED_EXPR)
3268 if (MODE_HAS_NANS (TYPE_MODE (type)))
3269 return build_binary_op (unordered_code,
3270 convert (type, arg0),
3271 convert (type, arg1),
3274 return integer_zero_node;
3277 return build_unary_op (TRUTH_NOT_EXPR,
3278 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3281 convert (type, arg0),
3282 convert (type, arg1),
3288 /* Recognize certain built-in functions so we can make tree-codes
3289 other than CALL_EXPR. We do this when it enables fold-const.c
3290 to do something useful. */
3291 /* ??? By rights this should go in builtins.c, but only C and C++
3292 implement build_{binary,unary}_op. Not exactly sure what bits
3293 of functionality are actually needed from those functions, or
3294 where the similar functionality exists in the other front ends. */
3297 expand_tree_builtin (function, params, coerced_params)
3298 tree function, params, coerced_params;
3300 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3303 switch (DECL_FUNCTION_CODE (function))
3307 case BUILT_IN_LLABS:
3308 case BUILT_IN_IMAXABS:
3310 case BUILT_IN_FABSL:
3311 case BUILT_IN_FABSF:
3312 if (coerced_params == 0)
3313 return integer_zero_node;
3314 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3317 case BUILT_IN_CONJF:
3318 case BUILT_IN_CONJL:
3319 if (coerced_params == 0)
3320 return integer_zero_node;
3321 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3323 case BUILT_IN_CREAL:
3324 case BUILT_IN_CREALF:
3325 case BUILT_IN_CREALL:
3326 if (coerced_params == 0)
3327 return integer_zero_node;
3328 return build_unary_op (REALPART_EXPR, TREE_VALUE (coerced_params), 0);
3330 case BUILT_IN_CIMAG:
3331 case BUILT_IN_CIMAGF:
3332 case BUILT_IN_CIMAGL:
3333 if (coerced_params == 0)
3334 return integer_zero_node;
3335 return build_unary_op (IMAGPART_EXPR, TREE_VALUE (coerced_params), 0);
3337 case BUILT_IN_ISGREATER:
3338 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3340 case BUILT_IN_ISGREATEREQUAL:
3341 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3343 case BUILT_IN_ISLESS:
3344 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3346 case BUILT_IN_ISLESSEQUAL:
3347 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3349 case BUILT_IN_ISLESSGREATER:
3350 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3352 case BUILT_IN_ISUNORDERED:
3353 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3362 /* Returns non-zero if CODE is the code for a statement. */
3365 statement_code_p (code)
3366 enum tree_code code;
3391 if (lang_statement_code_p)
3392 return (*lang_statement_code_p) (code);
3397 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3398 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3399 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3400 value, the traversal is aborted, and the value returned by FUNC is
3401 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3402 the node being visited are not walked.
3404 We don't need a without_duplicates variant of this one because the
3405 statement tree is a tree, not a graph. */
3408 walk_stmt_tree (tp, func, data)
3413 enum tree_code code;
3418 #define WALK_SUBTREE(NODE) \
3421 result = walk_stmt_tree (&(NODE), func, data); \
3427 /* Skip empty subtrees. */
3431 /* Skip subtrees below non-statement nodes. */
3432 if (!statement_code_p (TREE_CODE (*tp)))
3435 /* Call the function. */
3437 result = (*func) (tp, &walk_subtrees, data);
3439 /* If we found something, return it. */
3443 /* FUNC may have modified the tree, recheck that we're looking at a
3445 code = TREE_CODE (*tp);
3446 if (!statement_code_p (code))
3449 /* Visit the subtrees unless FUNC decided that there was nothing
3450 interesting below this point in the tree. */
3453 /* Walk over all the sub-trees of this operand. Statement nodes
3454 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3455 len = TREE_CODE_LENGTH (code);
3457 /* Go through the subtrees. We need to do this in forward order so
3458 that the scope of a FOR_EXPR is handled properly. */
3459 for (i = 0; i < len; ++i)
3460 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3463 /* Finally visit the chain. This can be tail-recursion optimized if
3464 we write it this way. */
3465 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3470 /* Used to compare case labels. K1 and K2 are actually tree nodes
3471 representing case labels, or NULL_TREE for a `default' label.
3472 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3473 K2, and 0 if K1 and K2 are equal. */
3476 case_compare (k1, k2)
3480 /* Consider a NULL key (such as arises with a `default' label) to be
3481 smaller than anything else. */
3487 return tree_int_cst_compare ((tree) k1, (tree) k2);
3490 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3491 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3492 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3493 case label was declared using the usual C/C++ syntax, rather than
3494 the GNU case range extension. CASES is a tree containing all the
3495 case ranges processed so far; COND is the condition for the
3496 switch-statement itself. Returns the CASE_LABEL created, or
3497 ERROR_MARK_NODE if no CASE_LABEL is created. */
3500 c_add_case_label (cases, cond, low_value, high_value)
3509 splay_tree_node node;
3511 /* Create the LABEL_DECL itself. */
3512 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3513 DECL_CONTEXT (label) = current_function_decl;
3515 /* If there was an error processing the switch condition, bail now
3516 before we get more confused. */
3517 if (!cond || cond == error_mark_node)
3519 /* Add a label anyhow so that the back-end doesn't think that
3520 the beginning of the switch is unreachable. */
3522 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3523 return error_mark_node;
3526 if ((low_value && TREE_TYPE (low_value)
3527 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3528 || (high_value && TREE_TYPE (high_value)
3529 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3530 error ("pointers are not permitted as case values");
3532 /* Case ranges are a GNU extension. */
3533 if (high_value && pedantic)
3535 if (c_language == clk_cplusplus)
3536 pedwarn ("ISO C++ forbids range expressions in switch statements");
3538 pedwarn ("ISO C forbids range expressions in switch statements");
3541 type = TREE_TYPE (cond);
3544 low_value = check_case_value (low_value);
3545 low_value = convert_and_check (type, low_value);
3549 high_value = check_case_value (high_value);
3550 high_value = convert_and_check (type, high_value);
3553 /* If an error has occurred, bail out now. */
3554 if (low_value == error_mark_node || high_value == error_mark_node)
3557 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3558 return error_mark_node;
3561 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3562 really a case range, even though it was written that way. Remove
3563 the HIGH_VALUE to simplify later processing. */
3564 if (tree_int_cst_equal (low_value, high_value))
3565 high_value = NULL_TREE;
3566 if (low_value && high_value
3567 && !tree_int_cst_lt (low_value, high_value))
3568 warning ("empty range specified");
3570 /* Look up the LOW_VALUE in the table of case labels we already
3572 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3573 /* If there was not an exact match, check for overlapping ranges.
3574 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3575 that's a `default' label and the only overlap is an exact match. */
3576 if (!node && (low_value || high_value))
3578 splay_tree_node low_bound;
3579 splay_tree_node high_bound;
3581 /* Even though there wasn't an exact match, there might be an
3582 overlap between this case range and another case range.
3583 Since we've (inductively) not allowed any overlapping case
3584 ranges, we simply need to find the greatest low case label
3585 that is smaller that LOW_VALUE, and the smallest low case
3586 label that is greater than LOW_VALUE. If there is an overlap
3587 it will occur in one of these two ranges. */
3588 low_bound = splay_tree_predecessor (cases,
3589 (splay_tree_key) low_value);
3590 high_bound = splay_tree_successor (cases,
3591 (splay_tree_key) low_value);
3593 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3594 the LOW_VALUE, so there is no need to check unless the
3595 LOW_BOUND is in fact itself a case range. */
3597 && CASE_HIGH ((tree) low_bound->value)
3598 && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3601 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3602 range is bigger than the low end of the current range, so we
3603 are only interested if the current range is a real range, and
3604 not an ordinary case label. */
3607 && (tree_int_cst_compare ((tree) high_bound->key,
3612 /* If there was an overlap, issue an error. */
3615 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3619 error ("duplicate (or overlapping) case value");
3620 error_with_decl (duplicate,
3621 "this is the first entry overlapping that value");
3625 error ("duplicate case value") ;
3626 error_with_decl (duplicate, "previously used here");
3630 error ("multiple default labels in one switch");
3631 error_with_decl (duplicate, "this is the first default label");
3634 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3637 /* Add a CASE_LABEL to the statement-tree. */
3638 case_label = add_stmt (build_case_label (low_value, high_value, label));
3639 /* Register this case label in the splay tree. */
3640 splay_tree_insert (cases,
3641 (splay_tree_key) low_value,
3642 (splay_tree_value) case_label);
3647 /* Finish an expression taking the address of LABEL. Returns an
3648 expression for the address. */
3651 finish_label_address_expr (label)
3658 if (c_language == clk_cplusplus)
3659 pedwarn ("ISO C++ forbids taking the address of a label");
3661 pedwarn ("ISO C forbids taking the address of a label");
3664 label = lookup_label (label);
3665 if (label == NULL_TREE)
3666 result = null_pointer_node;
3669 TREE_USED (label) = 1;
3670 result = build1 (ADDR_EXPR, ptr_type_node, label);
3671 TREE_CONSTANT (result) = 1;
3672 /* The current function in not necessarily uninlinable.
3673 Computed gotos are incompatible with inlining, but the value
3674 here could be used only in a diagnostic, for example. */
3680 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3681 parameter allows this function to be used as a GC-marking
3688 stmt_tree st = (stmt_tree) p;
3690 ggc_mark_tree (st->x_last_stmt);
3691 ggc_mark_tree (st->x_last_expr_type);
3694 /* Mark LD for GC. */
3697 c_mark_lang_decl (c)
3698 struct c_lang_decl *c ATTRIBUTE_UNUSED;
3702 /* Mark F for GC. */
3705 mark_c_language_function (f)
3706 struct language_function *f;
3711 mark_stmt_tree (&f->x_stmt_tree);
3712 ggc_mark_tree (f->x_scope_stmt_stack);
3715 /* Hook used by expand_expr to expand language-specific tree codes. */
3718 c_expand_expr (exp, target, tmode, modifier)
3721 enum machine_mode tmode;
3722 int modifier; /* Actually enum_modifier. */
3724 switch (TREE_CODE (exp))
3730 bool preserve_result = false;
3732 /* Since expand_expr_stmt calls free_temp_slots after every
3733 expression statement, we must call push_temp_slots here.
3734 Otherwise, any temporaries in use now would be considered
3735 out-of-scope after the first EXPR_STMT from within the
3738 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
3740 /* If we want the result of this expression, find the last
3741 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3742 if (target != const0_rtx
3743 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
3744 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
3746 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
3747 tree last = TREE_CHAIN (expr);
3749 while (TREE_CHAIN (last))
3752 last = TREE_CHAIN (last);
3755 if (TREE_CODE (last) == SCOPE_STMT
3756 && TREE_CODE (expr) == EXPR_STMT)
3758 TREE_ADDRESSABLE (expr) = 1;
3759 preserve_result = true;
3763 expand_stmt (STMT_EXPR_STMT (exp));
3764 expand_end_stmt_expr (rtl_expr);
3766 result = expand_expr (rtl_expr, target, tmode, modifier);
3767 if (preserve_result && GET_CODE (result) == MEM)
3769 if (GET_MODE (result) != BLKmode)
3770 result = copy_to_reg (result);
3772 preserve_temp_slots (result);
3775 /* If the statment-expression does not have a scope, then the
3776 new temporaries we created within it must live beyond the
3777 statement-expression. */
3778 if (STMT_EXPR_NO_SCOPE (exp))
3779 preserve_temp_slots (NULL_RTX);
3788 if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
3789 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3791 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3792 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
3793 == BUILT_IN_FRONTEND))
3794 return c_expand_builtin (exp, target, tmode, modifier);
3800 case COMPOUND_LITERAL_EXPR:
3802 /* Initialize the anonymous variable declared in the compound
3803 literal, then return the variable. */
3804 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3805 emit_local_var (decl);
3806 return expand_expr (decl, target, tmode, modifier);
3817 /* Hook used by safe_from_p to handle language-specific tree codes. */
3820 c_safe_from_p (target, exp)
3824 /* We can see statements here when processing the body of a
3825 statement-expression. For a declaration statement declaring a
3826 variable, look at the variable's initializer. */
3827 if (TREE_CODE (exp) == DECL_STMT)
3829 tree decl = DECL_STMT_DECL (exp);
3831 if (TREE_CODE (decl) == VAR_DECL
3832 && DECL_INITIAL (decl)
3833 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
3837 /* For any statement, we must follow the statement-chain. */
3838 if (statement_code_p (TREE_CODE (exp)) && TREE_CHAIN (exp))
3839 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
3841 /* Assume everything else is safe. */
3845 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3848 c_common_unsafe_for_reeval (exp)
3851 /* Statement expressions may not be reevaluated, likewise compound
3853 if (TREE_CODE (exp) == STMT_EXPR
3854 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
3857 /* Walk all other expressions. */
3861 /* Hook used by staticp to handle language-specific tree codes. */
3867 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
3868 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
3873 #define CALLED_AS_BUILT_IN(NODE) \
3874 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3877 c_expand_builtin (exp, target, tmode, modifier)
3880 enum machine_mode tmode;
3881 enum expand_modifier modifier;
3883 tree type = TREE_TYPE (exp);
3884 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
3885 tree arglist = TREE_OPERAND (exp, 1);
3886 enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
3887 enum tree_code code = TREE_CODE (exp);
3888 const int ignore = (target == const0_rtx
3889 || ((code == NON_LVALUE_EXPR || code == NOP_EXPR
3890 || code == CONVERT_EXPR || code == REFERENCE_EXPR
3891 || code == COND_EXPR)
3892 && TREE_CODE (type) == VOID_TYPE));
3894 if (! optimize && ! CALLED_AS_BUILT_IN (fndecl))
3895 return expand_call (exp, target, ignore);
3899 case BUILT_IN_PRINTF:
3900 target = c_expand_builtin_printf (arglist, target, tmode,
3901 modifier, ignore, /*unlocked=*/ 0);
3906 case BUILT_IN_PRINTF_UNLOCKED:
3907 target = c_expand_builtin_printf (arglist, target, tmode,
3908 modifier, ignore, /*unlocked=*/ 1);
3913 case BUILT_IN_FPRINTF:
3914 target = c_expand_builtin_fprintf (arglist, target, tmode,
3915 modifier, ignore, /*unlocked=*/ 0);
3920 case BUILT_IN_FPRINTF_UNLOCKED:
3921 target = c_expand_builtin_fprintf (arglist, target, tmode,
3922 modifier, ignore, /*unlocked=*/ 1);
3927 default: /* just do library call, if unknown builtin */
3928 error ("built-in function `%s' not currently supported",
3929 IDENTIFIER_POINTER (DECL_NAME (fndecl)));
3932 /* The switch statement above can drop through to cause the function
3933 to be called normally. */
3934 return expand_call (exp, target, ignore);
3937 /* Check an arglist to *printf for problems. The arglist should start
3938 at the format specifier, with the remaining arguments immediately
3941 is_valid_printf_arglist (arglist)
3944 /* Save this value so we can restore it later. */
3945 const int SAVE_pedantic = pedantic;
3946 int diagnostic_occurred = 0;
3949 /* Set this to a known value so the user setting won't affect code
3952 /* Check to make sure there are no format specifier errors. */
3953 attrs = tree_cons (get_identifier ("format"),
3954 tree_cons (NULL_TREE,
3955 get_identifier ("printf"),
3956 tree_cons (NULL_TREE,
3958 tree_cons (NULL_TREE,
3962 check_function_format (&diagnostic_occurred, attrs, arglist);
3964 /* Restore the value of `pedantic'. */
3965 pedantic = SAVE_pedantic;
3967 /* If calling `check_function_format_ptr' produces a warning, we
3968 return false, otherwise we return true. */
3969 return ! diagnostic_occurred;
3972 /* If the arguments passed to printf are suitable for optimizations,
3973 we attempt to transform the call. */
3975 c_expand_builtin_printf (arglist, target, tmode, modifier, ignore, unlocked)
3978 enum machine_mode tmode;
3979 enum expand_modifier modifier;
3983 tree fn_putchar = unlocked ?
3984 built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED] : built_in_decls[BUILT_IN_PUTCHAR];
3985 tree fn_puts = unlocked ?
3986 built_in_decls[BUILT_IN_PUTS_UNLOCKED] : built_in_decls[BUILT_IN_PUTS];
3987 tree fn, format_arg, stripped_string;
3989 /* If the return value is used, or the replacement _DECL isn't
3990 initialized, don't do the transformation. */
3991 if (!ignore || !fn_putchar || !fn_puts)
3994 /* Verify the required arguments in the original call. */
3996 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE))
3999 /* Check the specifier vs. the parameters. */
4000 if (!is_valid_printf_arglist (arglist))
4003 format_arg = TREE_VALUE (arglist);
4004 stripped_string = format_arg;
4005 STRIP_NOPS (stripped_string);
4006 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4007 stripped_string = TREE_OPERAND (stripped_string, 0);
4009 /* If the format specifier isn't a STRING_CST, punt. */
4010 if (TREE_CODE (stripped_string) != STRING_CST)
4013 /* OK! We can attempt optimization. */
4015 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4016 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s\n") == 0)
4018 arglist = TREE_CHAIN (arglist);
4021 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4022 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4024 arglist = TREE_CHAIN (arglist);
4029 /* We can't handle anything else with % args or %% ... yet. */
4030 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4033 /* If the resulting constant string has a length of 1, call
4034 putchar. Note, TREE_STRING_LENGTH includes the terminating
4035 NULL in its count. */
4036 if (TREE_STRING_LENGTH (stripped_string) == 2)
4038 /* Given printf("c"), (where c is any one character,)
4039 convert "c"[0] to an int and pass that to the replacement
4041 arglist = build_int_2 (TREE_STRING_POINTER (stripped_string)[0], 0);
4042 arglist = build_tree_list (NULL_TREE, arglist);
4046 /* If the resulting constant was "string\n", call
4047 __builtin_puts("string"). Ensure "string" has at least one
4048 character besides the trailing \n. Note, TREE_STRING_LENGTH
4049 includes the terminating NULL in its count. */
4050 else if (TREE_STRING_LENGTH (stripped_string) > 2
4051 && TREE_STRING_POINTER (stripped_string)
4052 [TREE_STRING_LENGTH (stripped_string) - 2] == '\n')
4054 /* Create a NULL-terminated string that's one char shorter
4055 than the original, stripping off the trailing '\n'. */
4056 const int newlen = TREE_STRING_LENGTH (stripped_string) - 1;
4057 char *newstr = (char *) alloca (newlen);
4058 memcpy (newstr, TREE_STRING_POINTER (stripped_string), newlen - 1);
4059 newstr[newlen - 1] = 0;
4061 arglist = combine_strings (build_string (newlen, newstr));
4062 arglist = build_tree_list (NULL_TREE, arglist);
4066 /* We'd like to arrange to call fputs(string) here, but we
4067 need stdout and don't have a way to get it ... yet. */
4071 return expand_expr (build_function_call (fn, arglist),
4072 (ignore ? const0_rtx : target),
4076 /* If the arguments passed to fprintf are suitable for optimizations,
4077 we attempt to transform the call. */
4079 c_expand_builtin_fprintf (arglist, target, tmode, modifier, ignore, unlocked)
4082 enum machine_mode tmode;
4083 enum expand_modifier modifier;
4087 tree fn_fputc = unlocked ?
4088 built_in_decls[BUILT_IN_FPUTC_UNLOCKED] : built_in_decls[BUILT_IN_FPUTC];
4089 tree fn_fputs = unlocked ?
4090 built_in_decls[BUILT_IN_FPUTS_UNLOCKED] : built_in_decls[BUILT_IN_FPUTS];
4091 tree fn, format_arg, stripped_string;
4093 /* If the return value is used, or the replacement _DECL isn't
4094 initialized, don't do the transformation. */
4095 if (!ignore || !fn_fputc || !fn_fputs)
4098 /* Verify the required arguments in the original call. */
4100 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) != POINTER_TYPE)
4101 || (TREE_CHAIN (arglist) == 0)
4102 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist)))) !=
4106 /* Check the specifier vs. the parameters. */
4107 if (!is_valid_printf_arglist (TREE_CHAIN (arglist)))
4110 format_arg = TREE_VALUE (TREE_CHAIN (arglist));
4111 stripped_string = format_arg;
4112 STRIP_NOPS (stripped_string);
4113 if (stripped_string && TREE_CODE (stripped_string) == ADDR_EXPR)
4114 stripped_string = TREE_OPERAND (stripped_string, 0);
4116 /* If the format specifier isn't a STRING_CST, punt. */
4117 if (TREE_CODE (stripped_string) != STRING_CST)
4120 /* OK! We can attempt optimization. */
4122 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4123 if (strcmp (TREE_STRING_POINTER (stripped_string), "%s") == 0)
4125 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4126 arglist = tree_cons (NULL_TREE,
4127 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4131 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4132 else if (strcmp (TREE_STRING_POINTER (stripped_string), "%c") == 0)
4134 tree newarglist = build_tree_list (NULL_TREE, TREE_VALUE (arglist));
4135 arglist = tree_cons (NULL_TREE,
4136 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist))),
4142 /* We can't handle anything else with % args or %% ... yet. */
4143 if (strchr (TREE_STRING_POINTER (stripped_string), '%'))
4146 /* When "string" doesn't contain %, replace all cases of
4147 fprintf(stream,string) with fputs(string,stream). The fputs
4148 builtin will take take of special cases like length==1. */
4149 arglist = tree_cons (NULL_TREE, TREE_VALUE (TREE_CHAIN (arglist)),
4150 build_tree_list (NULL_TREE, TREE_VALUE (arglist)));
4154 return expand_expr (build_function_call (fn, arglist),
4155 (ignore ? const0_rtx : target),
4160 /* Given a boolean expression ARG, return a tree representing an increment
4161 or decrement (as indicated by CODE) of ARG. The front end must check for
4162 invalid cases (e.g., decrement in C++). */
4164 boolean_increment (code, arg)
4165 enum tree_code code;
4169 tree true_res = (c_language == clk_cplusplus
4171 : c_bool_true_node);
4172 arg = stabilize_reference (arg);
4175 case PREINCREMENT_EXPR:
4176 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4178 case POSTINCREMENT_EXPR:
4179 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4180 arg = save_expr (arg);
4181 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4182 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4184 case PREDECREMENT_EXPR:
4185 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4187 case POSTDECREMENT_EXPR:
4188 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4189 arg = save_expr (arg);
4190 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4191 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4196 TREE_SIDE_EFFECTS (val) = 1;
4200 /* Handle C and C++ default attributes. */
4202 enum built_in_attribute
4204 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4205 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4206 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4207 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4208 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
4209 #include "builtin-attrs.def"
4210 #undef DEF_ATTR_NULL_TREE
4212 #undef DEF_ATTR_IDENT
4213 #undef DEF_ATTR_TREE_LIST
4218 static tree built_in_attributes[(int) ATTR_LAST];
4220 static bool c_attrs_initialized = false;
4222 static void c_init_attributes PARAMS ((void));
4224 /* Common initialization before parsing options. */
4226 c_common_init_options (lang)
4227 enum c_language_kind lang;
4230 parse_in = cpp_create_reader (lang == clk_c ? CLK_GNUC89:
4231 lang == clk_cplusplus ? CLK_GNUCXX: CLK_OBJC);
4233 /* Mark as "unspecified" (see c_common_post_options). */
4234 flag_bounds_check = -1;
4237 /* Post-switch processing. */
4239 c_common_post_options ()
4241 cpp_post_options (parse_in);
4243 flag_inline_trees = 1;
4245 /* Use tree inlining if possible. Function instrumentation is only
4246 done in the RTL level, so we disable tree inlining. */
4247 if (! flag_instrument_function_entry_exit)
4249 if (!flag_no_inline)
4251 if (flag_inline_functions)
4253 flag_inline_trees = 2;
4254 flag_inline_functions = 0;
4258 /* If still "unspecified", make it match -fbounded-pointers. */
4259 if (flag_bounds_check == -1)
4260 flag_bounds_check = flag_bounded_pointers;
4262 /* Special format checking options don't work without -Wformat; warn if
4264 if (warn_format_y2k && !warn_format)
4265 warning ("-Wformat-y2k ignored without -Wformat");
4266 if (warn_format_extra_args && !warn_format)
4267 warning ("-Wformat-extra-args ignored without -Wformat");
4268 if (warn_format_nonliteral && !warn_format)
4269 warning ("-Wformat-nonliteral ignored without -Wformat");
4270 if (warn_format_security && !warn_format)
4271 warning ("-Wformat-security ignored without -Wformat");
4272 if (warn_missing_format_attribute && !warn_format)
4273 warning ("-Wmissing-format-attribute ignored without -Wformat");
4276 /* Front end initialization common to C, ObjC and C++. */
4278 c_common_init (filename)
4279 const char *filename;
4281 /* NULL is passed up to toplev.c and we exit quickly. */
4282 if (flag_preprocess_only)
4284 cpp_preprocess_file (parse_in);
4288 /* Do this before initializing pragmas, as then cpplib's hash table
4290 filename = init_c_lex (filename);
4294 if (!c_attrs_initialized)
4295 c_init_attributes ();
4300 /* Common finish hook for the C, ObjC and C++ front ends. */
4304 cpp_finish (parse_in);
4306 /* For performance, avoid tearing down cpplib's internal structures.
4307 Call cpp_errors () instead of cpp_destroy (). */
4308 errorcount += cpp_errors (parse_in);
4312 c_init_attributes ()
4314 /* Fill in the built_in_attributes array. */
4315 #define DEF_ATTR_NULL_TREE(ENUM) \
4316 built_in_attributes[(int) ENUM] = NULL_TREE;
4317 #define DEF_ATTR_INT(ENUM, VALUE) \
4318 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4319 #define DEF_ATTR_IDENT(ENUM, STRING) \
4320 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4321 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4322 built_in_attributes[(int) ENUM] \
4323 = tree_cons (built_in_attributes[(int) PURPOSE], \
4324 built_in_attributes[(int) VALUE], \
4325 built_in_attributes[(int) CHAIN]);
4326 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4327 #include "builtin-attrs.def"
4328 #undef DEF_ATTR_NULL_TREE
4330 #undef DEF_ATTR_IDENT
4331 #undef DEF_ATTR_TREE_LIST
4333 ggc_add_tree_root (built_in_attributes, (int) ATTR_LAST);
4334 c_attrs_initialized = true;
4337 /* Depending on the name of DECL, apply default attributes to it. */
4340 c_common_insert_default_attributes (decl)
4343 tree name = DECL_NAME (decl);
4345 if (!c_attrs_initialized)
4346 c_init_attributes ();
4348 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4349 #define DEF_ATTR_INT(ENUM, VALUE)
4350 #define DEF_ATTR_IDENT(ENUM, STRING)
4351 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4352 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4353 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4354 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4355 ATTR_FLAG_BUILT_IN);
4356 #include "builtin-attrs.def"
4357 #undef DEF_ATTR_NULL_TREE
4359 #undef DEF_ATTR_IDENT
4360 #undef DEF_ATTR_TREE_LIST
4364 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4365 additionally give the location of the previous declaration DECL. */
4367 shadow_warning (msgid, name, decl)
4371 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name), msgid);
4372 warning_with_file_and_line (DECL_SOURCE_FILE (decl),
4373 DECL_SOURCE_LINE (decl),
4374 "shadowed declaration is here");
4377 /* Attribute handlers common to C front ends. */
4379 /* Handle a "packed" attribute; arguments as in
4380 struct attribute_spec.handler. */
4383 handle_packed_attribute (node, name, args, flags, no_add_attrs)
4386 tree args ATTRIBUTE_UNUSED;
4393 if (TREE_CODE (*node) == TYPE_DECL)
4394 type = &TREE_TYPE (*node);
4401 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4402 *type = build_type_copy (*type);
4403 TYPE_PACKED (*type) = 1;
4405 else if (TREE_CODE (*node) == FIELD_DECL)
4406 DECL_PACKED (*node) = 1;
4407 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4408 used for DECL_REGISTER. It wouldn't mean anything anyway. */
4411 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4412 *no_add_attrs = true;
4418 /* Handle a "nocommon" attribute; arguments as in
4419 struct attribute_spec.handler. */
4422 handle_nocommon_attribute (node, name, args, flags, no_add_attrs)
4425 tree args ATTRIBUTE_UNUSED;
4426 int flags ATTRIBUTE_UNUSED;
4429 if (TREE_CODE (*node) == VAR_DECL)
4430 DECL_COMMON (*node) = 0;
4433 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4434 *no_add_attrs = true;
4440 /* Handle a "common" attribute; arguments as in
4441 struct attribute_spec.handler. */
4444 handle_common_attribute (node, name, args, flags, no_add_attrs)
4447 tree args ATTRIBUTE_UNUSED;
4448 int flags ATTRIBUTE_UNUSED;
4451 if (TREE_CODE (*node) == VAR_DECL)
4452 DECL_COMMON (*node) = 1;
4455 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4456 *no_add_attrs = true;
4462 /* Handle a "noreturn" attribute; arguments as in
4463 struct attribute_spec.handler. */
4466 handle_noreturn_attribute (node, name, args, flags, no_add_attrs)
4469 tree args ATTRIBUTE_UNUSED;
4470 int flags ATTRIBUTE_UNUSED;
4473 tree type = TREE_TYPE (*node);
4475 /* See FIXME comment in c_common_attribute_table. */
4476 if (TREE_CODE (*node) == FUNCTION_DECL)
4477 TREE_THIS_VOLATILE (*node) = 1;
4478 else if (TREE_CODE (type) == POINTER_TYPE
4479 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4481 = build_pointer_type
4482 (build_type_variant (TREE_TYPE (type),
4483 TREE_READONLY (TREE_TYPE (type)), 1));
4486 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4487 *no_add_attrs = true;
4493 /* Handle a "noinline" attribute; arguments as in
4494 struct attribute_spec.handler. */
4497 handle_noinline_attribute (node, name, args, flags, no_add_attrs)
4500 tree args ATTRIBUTE_UNUSED;
4501 int flags ATTRIBUTE_UNUSED;
4504 if (TREE_CODE (*node) == FUNCTION_DECL)
4505 DECL_UNINLINABLE (*node) = 1;
4508 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4509 *no_add_attrs = true;
4515 /* Handle a "always_inline" attribute; arguments as in
4516 struct attribute_spec.handler. */
4519 handle_always_inline_attribute (node, name, args, flags, no_add_attrs)
4522 tree args ATTRIBUTE_UNUSED;
4523 int flags ATTRIBUTE_UNUSED;
4526 if (TREE_CODE (*node) == FUNCTION_DECL)
4528 /* Do nothing else, just set the attribute. We'll get at
4529 it later with lookup_attribute. */
4533 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4534 *no_add_attrs = true;
4540 /* Handle a "used" attribute; arguments as in
4541 struct attribute_spec.handler. */
4544 handle_used_attribute (node, name, args, flags, no_add_attrs)
4547 tree args ATTRIBUTE_UNUSED;
4548 int flags ATTRIBUTE_UNUSED;
4551 if (TREE_CODE (*node) == FUNCTION_DECL)
4552 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node))
4553 = TREE_USED (*node) = 1;
4556 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4557 *no_add_attrs = true;
4563 /* Handle a "unused" attribute; arguments as in
4564 struct attribute_spec.handler. */
4567 handle_unused_attribute (node, name, args, flags, no_add_attrs)
4570 tree args ATTRIBUTE_UNUSED;
4578 if (TREE_CODE (decl) == PARM_DECL
4579 || TREE_CODE (decl) == VAR_DECL
4580 || TREE_CODE (decl) == FUNCTION_DECL
4581 || TREE_CODE (decl) == LABEL_DECL
4582 || TREE_CODE (decl) == TYPE_DECL)
4583 TREE_USED (decl) = 1;
4586 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4587 *no_add_attrs = true;
4592 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4593 *node = build_type_copy (*node);
4594 TREE_USED (*node) = 1;
4600 /* Handle a "const" attribute; arguments as in
4601 struct attribute_spec.handler. */
4604 handle_const_attribute (node, name, args, flags, no_add_attrs)
4607 tree args ATTRIBUTE_UNUSED;
4608 int flags ATTRIBUTE_UNUSED;
4611 tree type = TREE_TYPE (*node);
4613 /* See FIXME comment on noreturn in c_common_attribute_table. */
4614 if (TREE_CODE (*node) == FUNCTION_DECL)
4615 TREE_READONLY (*node) = 1;
4616 else if (TREE_CODE (type) == POINTER_TYPE
4617 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4619 = build_pointer_type
4620 (build_type_variant (TREE_TYPE (type), 1,
4621 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4624 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4625 *no_add_attrs = true;
4631 /* Handle a "transparent_union" attribute; arguments as in
4632 struct attribute_spec.handler. */
4635 handle_transparent_union_attribute (node, name, args, flags, no_add_attrs)
4638 tree args ATTRIBUTE_UNUSED;
4642 tree decl = NULL_TREE;
4649 type = &TREE_TYPE (decl);
4650 is_type = TREE_CODE (*node) == TYPE_DECL;
4652 else if (TYPE_P (*node))
4653 type = node, is_type = 1;
4656 && TREE_CODE (*type) == UNION_TYPE
4658 || (TYPE_FIELDS (*type) != 0
4659 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4661 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4662 *type = build_type_copy (*type);
4663 TYPE_TRANSPARENT_UNION (*type) = 1;
4665 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4666 && TREE_CODE (*type) == UNION_TYPE
4667 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4668 DECL_TRANSPARENT_UNION (decl) = 1;
4671 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4672 *no_add_attrs = true;
4678 /* Handle a "constructor" attribute; arguments as in
4679 struct attribute_spec.handler. */
4682 handle_constructor_attribute (node, name, args, flags, no_add_attrs)
4685 tree args ATTRIBUTE_UNUSED;
4686 int flags ATTRIBUTE_UNUSED;
4690 tree type = TREE_TYPE (decl);
4692 if (TREE_CODE (decl) == FUNCTION_DECL
4693 && TREE_CODE (type) == FUNCTION_TYPE
4694 && decl_function_context (decl) == 0)
4696 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4697 TREE_USED (decl) = 1;
4701 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4702 *no_add_attrs = true;
4708 /* Handle a "destructor" attribute; arguments as in
4709 struct attribute_spec.handler. */
4712 handle_destructor_attribute (node, name, args, flags, no_add_attrs)
4715 tree args ATTRIBUTE_UNUSED;
4716 int flags ATTRIBUTE_UNUSED;
4720 tree type = TREE_TYPE (decl);
4722 if (TREE_CODE (decl) == FUNCTION_DECL
4723 && TREE_CODE (type) == FUNCTION_TYPE
4724 && decl_function_context (decl) == 0)
4726 DECL_STATIC_DESTRUCTOR (decl) = 1;
4727 TREE_USED (decl) = 1;
4731 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4732 *no_add_attrs = true;
4738 /* Handle a "mode" attribute; arguments as in
4739 struct attribute_spec.handler. */
4742 handle_mode_attribute (node, name, args, flags, no_add_attrs)
4746 int flags ATTRIBUTE_UNUSED;
4751 *no_add_attrs = true;
4753 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4754 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4758 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4759 int len = strlen (p);
4760 enum machine_mode mode = VOIDmode;
4763 if (len > 4 && p[0] == '_' && p[1] == '_'
4764 && p[len - 1] == '_' && p[len - 2] == '_')
4766 char *newp = (char *) alloca (len - 1);
4768 strcpy (newp, &p[2]);
4769 newp[len - 4] = '\0';
4773 /* Change this type to have a type with the specified mode.
4774 First check for the special modes. */
4775 if (! strcmp (p, "byte"))
4777 else if (!strcmp (p, "word"))
4779 else if (! strcmp (p, "pointer"))
4782 for (j = 0; j < NUM_MACHINE_MODES; j++)
4783 if (!strcmp (p, GET_MODE_NAME (j)))
4784 mode = (enum machine_mode) j;
4786 if (mode == VOIDmode)
4787 error ("unknown machine mode `%s'", p);
4788 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
4789 (mode, TREE_UNSIGNED (type))))
4790 error ("no data type for mode `%s'", p);
4793 /* No need to layout the type here. The caller should do this. */
4799 /* Handle a "section" attribute; arguments as in
4800 struct attribute_spec.handler. */
4803 handle_section_attribute (node, name, args, flags, no_add_attrs)
4805 tree name ATTRIBUTE_UNUSED;
4807 int flags ATTRIBUTE_UNUSED;
4812 if (targetm.have_named_sections)
4814 if ((TREE_CODE (decl) == FUNCTION_DECL
4815 || TREE_CODE (decl) == VAR_DECL)
4816 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4818 if (TREE_CODE (decl) == VAR_DECL
4819 && current_function_decl != NULL_TREE
4820 && ! TREE_STATIC (decl))
4822 error_with_decl (decl,
4823 "section attribute cannot be specified for local variables");
4824 *no_add_attrs = true;
4827 /* The decl may have already been given a section attribute
4828 from a previous declaration. Ensure they match. */
4829 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4830 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4831 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4833 error_with_decl (*node,
4834 "section of `%s' conflicts with previous declaration");
4835 *no_add_attrs = true;
4838 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4842 error_with_decl (*node,
4843 "section attribute not allowed for `%s'");
4844 *no_add_attrs = true;
4849 error_with_decl (*node,
4850 "section attributes are not supported for this target");
4851 *no_add_attrs = true;
4857 /* Handle a "aligned" attribute; arguments as in
4858 struct attribute_spec.handler. */
4861 handle_aligned_attribute (node, name, args, flags, no_add_attrs)
4863 tree name ATTRIBUTE_UNUSED;
4868 tree decl = NULL_TREE;
4871 tree align_expr = (args ? TREE_VALUE (args)
4872 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4878 type = &TREE_TYPE (decl);
4879 is_type = TREE_CODE (*node) == TYPE_DECL;
4881 else if (TYPE_P (*node))
4882 type = node, is_type = 1;
4884 /* Strip any NOPs of any kind. */
4885 while (TREE_CODE (align_expr) == NOP_EXPR
4886 || TREE_CODE (align_expr) == CONVERT_EXPR
4887 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4888 align_expr = TREE_OPERAND (align_expr, 0);
4890 if (TREE_CODE (align_expr) != INTEGER_CST)
4892 error ("requested alignment is not a constant");
4893 *no_add_attrs = true;
4895 else if ((i = tree_log2 (align_expr)) == -1)
4897 error ("requested alignment is not a power of 2");
4898 *no_add_attrs = true;
4900 else if (i > HOST_BITS_PER_INT - 2)
4902 error ("requested alignment is too large");
4903 *no_add_attrs = true;
4907 /* If we have a TYPE_DECL, then copy the type, so that we
4908 don't accidentally modify a builtin type. See pushdecl. */
4909 if (decl && TREE_TYPE (decl) != error_mark_node
4910 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4912 tree tt = TREE_TYPE (decl);
4913 *type = build_type_copy (*type);
4914 DECL_ORIGINAL_TYPE (decl) = tt;
4915 TYPE_NAME (*type) = decl;
4916 TREE_USED (*type) = TREE_USED (decl);
4917 TREE_TYPE (decl) = *type;
4919 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4920 *type = build_type_copy (*type);
4922 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4923 TYPE_USER_ALIGN (*type) = 1;
4925 else if (TREE_CODE (decl) != VAR_DECL
4926 && TREE_CODE (decl) != FIELD_DECL)
4928 error_with_decl (decl,
4929 "alignment may not be specified for `%s'");
4930 *no_add_attrs = true;
4934 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4935 DECL_USER_ALIGN (decl) = 1;
4941 /* Handle a "weak" attribute; arguments as in
4942 struct attribute_spec.handler. */
4945 handle_weak_attribute (node, name, args, flags, no_add_attrs)
4947 tree name ATTRIBUTE_UNUSED;
4948 tree args ATTRIBUTE_UNUSED;
4949 int flags ATTRIBUTE_UNUSED;
4950 bool *no_add_attrs ATTRIBUTE_UNUSED;
4952 declare_weak (*node);
4957 /* Handle an "alias" attribute; arguments as in
4958 struct attribute_spec.handler. */
4961 handle_alias_attribute (node, name, args, flags, no_add_attrs)
4965 int flags ATTRIBUTE_UNUSED;
4970 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4971 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4973 error_with_decl (decl,
4974 "`%s' defined both normally and as an alias");
4975 *no_add_attrs = true;
4977 else if (decl_function_context (decl) == 0)
4981 id = TREE_VALUE (args);
4982 if (TREE_CODE (id) != STRING_CST)
4984 error ("alias arg not a string");
4985 *no_add_attrs = true;
4988 id = get_identifier (TREE_STRING_POINTER (id));
4989 /* This counts as a use of the object pointed to. */
4992 if (TREE_CODE (decl) == FUNCTION_DECL)
4993 DECL_INITIAL (decl) = error_mark_node;
4995 DECL_EXTERNAL (decl) = 0;
4999 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5000 *no_add_attrs = true;
5006 /* Handle an "visibility" attribute; arguments as in
5007 struct attribute_spec.handler. */
5010 handle_visibility_attribute (node, name, args, flags, no_add_attrs)
5014 int flags ATTRIBUTE_UNUSED;
5019 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
5021 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5022 *no_add_attrs = true;
5028 id = TREE_VALUE (args);
5029 if (TREE_CODE (id) != STRING_CST)
5031 error ("visibility arg not a string");
5032 *no_add_attrs = true;
5035 if (strcmp (TREE_STRING_POINTER (id), "hidden")
5036 && strcmp (TREE_STRING_POINTER (id), "protected")
5037 && strcmp (TREE_STRING_POINTER (id), "internal"))
5039 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5040 *no_add_attrs = true;
5048 /* Handle a "no_instrument_function" attribute; arguments as in
5049 struct attribute_spec.handler. */
5052 handle_no_instrument_function_attribute (node, name, args, flags, no_add_attrs)
5055 tree args ATTRIBUTE_UNUSED;
5056 int flags ATTRIBUTE_UNUSED;
5061 if (TREE_CODE (decl) != FUNCTION_DECL)
5063 error_with_decl (decl,
5064 "`%s' attribute applies only to functions",
5065 IDENTIFIER_POINTER (name));
5066 *no_add_attrs = true;
5068 else if (DECL_INITIAL (decl))
5070 error_with_decl (decl,
5071 "can't set `%s' attribute after definition",
5072 IDENTIFIER_POINTER (name));
5073 *no_add_attrs = true;
5076 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5081 /* Handle a "malloc" attribute; arguments as in
5082 struct attribute_spec.handler. */
5085 handle_malloc_attribute (node, name, args, flags, no_add_attrs)
5088 tree args ATTRIBUTE_UNUSED;
5089 int flags ATTRIBUTE_UNUSED;
5092 if (TREE_CODE (*node) == FUNCTION_DECL)
5093 DECL_IS_MALLOC (*node) = 1;
5094 /* ??? TODO: Support types. */
5097 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5098 *no_add_attrs = true;
5104 /* Handle a "no_limit_stack" attribute; arguments as in
5105 struct attribute_spec.handler. */
5108 handle_no_limit_stack_attribute (node, name, args, flags, no_add_attrs)
5111 tree args ATTRIBUTE_UNUSED;
5112 int flags ATTRIBUTE_UNUSED;
5117 if (TREE_CODE (decl) != FUNCTION_DECL)
5119 error_with_decl (decl,
5120 "`%s' attribute applies only to functions",
5121 IDENTIFIER_POINTER (name));
5122 *no_add_attrs = true;
5124 else if (DECL_INITIAL (decl))
5126 error_with_decl (decl,
5127 "can't set `%s' attribute after definition",
5128 IDENTIFIER_POINTER (name));
5129 *no_add_attrs = true;
5132 DECL_NO_LIMIT_STACK (decl) = 1;
5137 /* Handle a "pure" attribute; arguments as in
5138 struct attribute_spec.handler. */
5141 handle_pure_attribute (node, name, args, flags, no_add_attrs)
5144 tree args ATTRIBUTE_UNUSED;
5145 int flags ATTRIBUTE_UNUSED;
5148 if (TREE_CODE (*node) == FUNCTION_DECL)
5149 DECL_IS_PURE (*node) = 1;
5150 /* ??? TODO: Support types. */
5153 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5154 *no_add_attrs = true;
5160 /* Handle a "deprecated" attribute; arguments as in
5161 struct attribute_spec.handler. */
5164 handle_deprecated_attribute (node, name, args, flags, no_add_attrs)
5167 tree args ATTRIBUTE_UNUSED;
5171 tree type = NULL_TREE;
5173 const char *what = NULL;
5178 type = TREE_TYPE (decl);
5180 if (TREE_CODE (decl) == TYPE_DECL
5181 || TREE_CODE (decl) == PARM_DECL
5182 || TREE_CODE (decl) == VAR_DECL
5183 || TREE_CODE (decl) == FUNCTION_DECL
5184 || TREE_CODE (decl) == FIELD_DECL)
5185 TREE_DEPRECATED (decl) = 1;
5189 else if (TYPE_P (*node))
5191 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5192 *node = build_type_copy (*node);
5193 TREE_DEPRECATED (*node) = 1;
5201 *no_add_attrs = true;
5202 if (type && TYPE_NAME (type))
5204 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5205 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5206 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5207 && DECL_NAME (TYPE_NAME (type)))
5208 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5211 warning ("`%s' attribute ignored for `%s'",
5212 IDENTIFIER_POINTER (name), what);
5214 warning ("`%s' attribute ignored",
5215 IDENTIFIER_POINTER (name));
5221 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5222 to prevent us from duplicating type nodes unnecessarily.
5223 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5224 since we want to distinguish types that are essentially identical (except
5225 for their debug representation), we use a local list here. */
5226 static tree vector_type_node_list = 0;
5228 /* Handle a "vector_size" attribute; arguments as in
5229 struct attribute_spec.handler. */
5232 handle_vector_size_attribute (node, name, args, flags, no_add_attrs)
5236 int flags ATTRIBUTE_UNUSED;
5239 unsigned HOST_WIDE_INT vecsize, nunits;
5240 enum machine_mode mode, orig_mode, new_mode;
5241 tree type = *node, new_type = NULL_TREE;
5242 tree type_list_node;
5244 *no_add_attrs = true;
5246 if (! host_integerp (TREE_VALUE (args), 1))
5248 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5252 /* Get the vector size (in bytes). */
5253 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5255 /* We need to provide for vector pointers, vector arrays, and
5256 functions returning vectors. For example:
5258 __attribute__((vector_size(16))) short *foo;
5260 In this case, the mode is SI, but the type being modified is
5261 HI, so we need to look further. */
5263 while (POINTER_TYPE_P (type)
5264 || TREE_CODE (type) == FUNCTION_TYPE
5265 || TREE_CODE (type) == ARRAY_TYPE)
5266 type = TREE_TYPE (type);
5268 /* Get the mode of the type being modified. */
5269 orig_mode = TYPE_MODE (type);
5271 if (TREE_CODE (type) == RECORD_TYPE
5272 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5273 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5274 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5276 error ("invalid vector type for attribute `%s'",
5277 IDENTIFIER_POINTER (name));
5281 /* Calculate how many units fit in the vector. */
5282 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5284 /* Find a suitably sized vector. */
5285 new_mode = VOIDmode;
5286 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5288 : MODE_VECTOR_FLOAT);
5290 mode = GET_MODE_WIDER_MODE (mode))
5291 if (vecsize == GET_MODE_SIZE (mode)
5292 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5298 if (new_mode == VOIDmode)
5300 error ("no vector mode with the size and type specified could be found");
5304 for (type_list_node = vector_type_node_list; type_list_node;
5305 type_list_node = TREE_CHAIN (type_list_node))
5307 tree other_type = TREE_VALUE (type_list_node);
5308 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5309 tree fields = TYPE_FIELDS (record);
5310 tree field_type = TREE_TYPE (fields);
5311 tree array_type = TREE_TYPE (field_type);
5312 if (TREE_CODE (fields) != FIELD_DECL
5313 || TREE_CODE (field_type) != ARRAY_TYPE)
5316 if (TYPE_MODE (other_type) == mode && type == array_type)
5318 new_type = other_type;
5323 if (new_type == NULL_TREE)
5325 tree index, array, rt, list_node;
5327 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5328 TREE_UNSIGNED (type));
5332 error ("no vector mode with the size and type specified could be found");
5336 new_type = build_type_copy (new_type);
5338 /* Set the debug information here, because this is the only
5339 place where we know the underlying type for a vector made
5340 with vector_size. For debugging purposes we pretend a vector
5341 is an array within a structure. */
5342 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5343 array = build_array_type (type, build_index_type (index));
5344 rt = make_node (RECORD_TYPE);
5346 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5347 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5349 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5351 list_node = build_tree_list (NULL, new_type);
5352 TREE_CHAIN (list_node) = vector_type_node_list;
5353 vector_type_node_list = list_node;
5356 /* Build back pointers if needed. */
5357 *node = vector_size_helper (*node, new_type);
5362 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5365 If we requested a pointer to a vector, build up the pointers that
5366 we stripped off while looking for the inner type. Similarly for
5367 return values from functions.
5369 The argument "type" is the top of the chain, and "bottom" is the
5370 new type which we will point to. */
5373 vector_size_helper (type, bottom)
5378 if (POINTER_TYPE_P (type))
5380 inner = vector_size_helper (TREE_TYPE (type), bottom);
5381 outer = build_pointer_type (inner);
5383 else if (TREE_CODE (type) == ARRAY_TYPE)
5385 inner = vector_size_helper (TREE_TYPE (type), bottom);
5386 outer = build_array_type (inner, TYPE_VALUES (type));
5388 else if (TREE_CODE (type) == FUNCTION_TYPE)
5390 inner = vector_size_helper (TREE_TYPE (type), bottom);
5391 outer = build_function_type (inner, TYPE_VALUES (type));
5396 TREE_READONLY (outer) = TREE_READONLY (type);
5397 TREE_THIS_VOLATILE (outer) = TREE_THIS_VOLATILE (type);