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 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
42 cpp_reader
*parse_in
; /* Declared in c-lex.h. */
44 /* We let tm.h override the types used here, to handle trivial differences
45 such as the choice of unsigned int or long unsigned int for size_t.
46 When machines start needing nontrivial differences in the size type,
47 it would be best to do something here to figure out automatically
48 from other information what type to use. */
51 #define SIZE_TYPE "long unsigned int"
55 #define WCHAR_TYPE "int"
58 /* WCHAR_TYPE gets overridden by -fshort-wchar. */
59 #define MODIFIED_WCHAR_TYPE \
60 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
63 #define PTRDIFF_TYPE "long int"
67 #define WINT_TYPE "unsigned int"
71 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
73 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
79 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
81 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
82 ? "long unsigned int" \
83 : "long long unsigned int"))
86 #ifndef STDC_0_IN_SYSTEM_HEADERS
87 #define STDC_0_IN_SYSTEM_HEADERS 0
90 #ifndef REGISTER_PREFIX
91 #define REGISTER_PREFIX ""
94 /* The variant of the C language being processed. */
96 enum c_language_kind c_language
;
98 /* The following symbols are subsumed in the c_global_trees array, and
99 listed here individually for documentation purposes.
101 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
103 tree short_integer_type_node;
104 tree long_integer_type_node;
105 tree long_long_integer_type_node;
107 tree short_unsigned_type_node;
108 tree long_unsigned_type_node;
109 tree long_long_unsigned_type_node;
111 tree boolean_type_node;
112 tree boolean_false_node;
113 tree boolean_true_node;
115 tree ptrdiff_type_node;
117 tree unsigned_char_type_node;
118 tree signed_char_type_node;
119 tree wchar_type_node;
120 tree signed_wchar_type_node;
121 tree unsigned_wchar_type_node;
123 tree float_type_node;
124 tree double_type_node;
125 tree long_double_type_node;
127 tree complex_integer_type_node;
128 tree complex_float_type_node;
129 tree complex_double_type_node;
130 tree complex_long_double_type_node;
132 tree intQI_type_node;
133 tree intHI_type_node;
134 tree intSI_type_node;
135 tree intDI_type_node;
136 tree intTI_type_node;
138 tree unsigned_intQI_type_node;
139 tree unsigned_intHI_type_node;
140 tree unsigned_intSI_type_node;
141 tree unsigned_intDI_type_node;
142 tree unsigned_intTI_type_node;
144 tree widest_integer_literal_type_node;
145 tree widest_unsigned_literal_type_node;
147 Nodes for types `void *' and `const void *'.
149 tree ptr_type_node, const_ptr_type_node;
151 Nodes for types `char *' and `const char *'.
153 tree string_type_node, const_string_type_node;
155 Type `char[SOMENUMBER]'.
156 Used when an array of char is needed and the size is irrelevant.
158 tree char_array_type_node;
160 Type `int[SOMENUMBER]' or something like it.
161 Used when an array of int needed and the size is irrelevant.
163 tree int_array_type_node;
165 Type `wchar_t[SOMENUMBER]' or something like it.
166 Used when a wide string literal is created.
168 tree wchar_array_type_node;
170 Type `int ()' -- used for implicit declaration of functions.
172 tree default_function_type;
174 A VOID_TYPE node, packaged in a TREE_LIST.
178 The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
179 and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
180 VAR_DECLS, but C++ does.)
182 tree function_name_decl_node;
183 tree pretty_function_name_decl_node;
184 tree c99_function_name_decl_node;
186 Stack of nested function name VAR_DECLs.
188 tree saved_function_name_decls;
192 tree c_global_trees
[CTI_MAX
];
194 /* Nonzero if prepreprocessing only. */
195 int flag_preprocess_only
;
197 /* Nonzero if an ISO standard was selected. It rejects macros in the
201 /* Nonzero if -undef was given. It suppresses target built-in macros
205 /* Nonzero means don't recognize the non-ANSI builtin functions. */
209 /* Nonzero means don't recognize the non-ANSI builtin functions.
212 int flag_no_nonansi_builtin
;
214 /* Nonzero means give `double' the same size as `float'. */
216 int flag_short_double
;
218 /* Nonzero means give `wchar_t' the same size as `short'. */
220 int flag_short_wchar
;
222 /* Nonzero means warn about use of multicharacter literals. */
224 int warn_multichar
= 1;
226 /* Nonzero means warn about possible violations of sequence point rules. */
228 int warn_sequence_point
;
230 /* Nonzero means to warn about compile-time division by zero. */
231 int warn_div_by_zero
= 1;
233 /* The elements of `ridpointers' are identifier nodes for the reserved
234 type names and storage classes. It is indexed by a RID_... value. */
237 tree (*make_fname_decl
) PARAMS ((tree
, int));
239 /* If non-NULL, the address of a language-specific function that
240 returns 1 for language-specific statement codes. */
241 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
243 /* If non-NULL, the address of a language-specific function that takes
244 any action required right before expand_function_end is called. */
245 void (*lang_expand_function_end
) PARAMS ((void));
247 /* Nonzero means the expression being parsed will never be evaluated.
248 This is a count, since unevaluated expressions can nest. */
251 /* Information about how a function name is generated. */
254 tree
*const decl
; /* pointer to the VAR_DECL. */
255 const unsigned rid
; /* RID number for the identifier. */
256 const int pretty
; /* How pretty is it? */
259 /* The three ways of getting then name of the current function. */
261 const struct fname_var_t fname_vars
[] =
263 /* C99 compliant __func__, must be first. */
264 {&c99_function_name_decl_node
, RID_C99_FUNCTION_NAME
, 0},
265 /* GCC __FUNCTION__ compliant. */
266 {&function_name_decl_node
, RID_FUNCTION_NAME
, 0},
267 /* GCC __PRETTY_FUNCTION__ compliant. */
268 {&pretty_function_name_decl_node
, RID_PRETTY_FUNCTION_NAME
, 1},
272 static int constant_fits_type_p
PARAMS ((tree
, tree
));
274 /* Keep a stack of if statements. We record the number of compound
275 statements seen up to the if keyword, as well as the line number
276 and file of the if. If a potentially ambiguous else is seen, that
277 fact is recorded; the warning is issued when we can be sure that
278 the enclosing if statement does not have an else branch. */
288 static if_elt
*if_stack
;
290 /* Amount of space in the if statement stack. */
291 static int if_stack_space
= 0;
294 static int if_stack_pointer
= 0;
296 static void cb_register_builtins
PARAMS ((cpp_reader
*));
298 static tree handle_packed_attribute
PARAMS ((tree
*, tree
, tree
, int,
300 static tree handle_nocommon_attribute
PARAMS ((tree
*, tree
, tree
, int,
302 static tree handle_common_attribute
PARAMS ((tree
*, tree
, tree
, int,
304 static tree handle_noreturn_attribute
PARAMS ((tree
*, tree
, tree
, int,
306 static tree handle_noinline_attribute
PARAMS ((tree
*, tree
, tree
, int,
308 static tree handle_always_inline_attribute
PARAMS ((tree
*, tree
, tree
, int,
310 static tree handle_used_attribute
PARAMS ((tree
*, tree
, tree
, int,
312 static tree handle_unused_attribute
PARAMS ((tree
*, tree
, tree
, int,
314 static tree handle_const_attribute
PARAMS ((tree
*, tree
, tree
, int,
316 static tree handle_transparent_union_attribute
PARAMS ((tree
*, tree
, tree
,
318 static tree handle_constructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
320 static tree handle_destructor_attribute
PARAMS ((tree
*, tree
, tree
, int,
322 static tree handle_mode_attribute
PARAMS ((tree
*, tree
, tree
, int,
324 static tree handle_section_attribute
PARAMS ((tree
*, tree
, tree
, int,
326 static tree handle_aligned_attribute
PARAMS ((tree
*, tree
, tree
, int,
328 static tree handle_weak_attribute
PARAMS ((tree
*, tree
, tree
, int,
330 static tree handle_alias_attribute
PARAMS ((tree
*, tree
, tree
, int,
332 static tree handle_visibility_attribute
PARAMS ((tree
*, tree
, tree
, int,
334 static tree handle_no_instrument_function_attribute
PARAMS ((tree
*, tree
,
337 static tree handle_malloc_attribute
PARAMS ((tree
*, tree
, tree
, int,
339 static tree handle_no_limit_stack_attribute
PARAMS ((tree
*, tree
, tree
, int,
341 static tree handle_pure_attribute
PARAMS ((tree
*, tree
, tree
, int,
343 static tree handle_deprecated_attribute
PARAMS ((tree
*, tree
, tree
, int,
345 static tree handle_vector_size_attribute
PARAMS ((tree
*, tree
, tree
, int,
347 static tree vector_size_helper
PARAMS ((tree
, tree
));
349 /* Table of machine-independent attributes common to all C-like languages. */
350 const struct attribute_spec c_common_attribute_table
[] =
352 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
353 { "packed", 0, 0, false, false, false,
354 handle_packed_attribute
},
355 { "nocommon", 0, 0, true, false, false,
356 handle_nocommon_attribute
},
357 { "common", 0, 0, true, false, false,
358 handle_common_attribute
},
359 /* FIXME: logically, noreturn attributes should be listed as
360 "false, true, true" and apply to function types. But implementing this
361 would require all the places in the compiler that use TREE_THIS_VOLATILE
362 on a decl to identify non-returning functions to be located and fixed
363 to check the function type instead. */
364 { "noreturn", 0, 0, true, false, false,
365 handle_noreturn_attribute
},
366 { "volatile", 0, 0, true, false, false,
367 handle_noreturn_attribute
},
368 { "noinline", 0, 0, true, false, false,
369 handle_noinline_attribute
},
370 { "always_inline", 0, 0, true, false, false,
371 handle_always_inline_attribute
},
372 { "used", 0, 0, true, false, false,
373 handle_used_attribute
},
374 { "unused", 0, 0, false, false, false,
375 handle_unused_attribute
},
376 /* The same comments as for noreturn attributes apply to const ones. */
377 { "const", 0, 0, true, false, false,
378 handle_const_attribute
},
379 { "transparent_union", 0, 0, false, false, false,
380 handle_transparent_union_attribute
},
381 { "constructor", 0, 0, true, false, false,
382 handle_constructor_attribute
},
383 { "destructor", 0, 0, true, false, false,
384 handle_destructor_attribute
},
385 { "mode", 1, 1, false, true, false,
386 handle_mode_attribute
},
387 { "section", 1, 1, true, false, false,
388 handle_section_attribute
},
389 { "aligned", 0, 1, false, false, false,
390 handle_aligned_attribute
},
391 { "weak", 0, 0, true, false, false,
392 handle_weak_attribute
},
393 { "alias", 1, 1, true, false, false,
394 handle_alias_attribute
},
395 { "no_instrument_function", 0, 0, true, false, false,
396 handle_no_instrument_function_attribute
},
397 { "malloc", 0, 0, true, false, false,
398 handle_malloc_attribute
},
399 { "no_stack_limit", 0, 0, true, false, false,
400 handle_no_limit_stack_attribute
},
401 { "pure", 0, 0, true, false, false,
402 handle_pure_attribute
},
403 { "deprecated", 0, 0, false, false, false,
404 handle_deprecated_attribute
},
405 { "vector_size", 1, 1, false, true, false,
406 handle_vector_size_attribute
},
407 { "visibility", 1, 1, true, false, false,
408 handle_visibility_attribute
},
409 { NULL
, 0, 0, false, false, false, NULL
}
412 /* Give the specifications for the format attributes, used by C and all
415 const struct attribute_spec c_common_format_attribute_table
[] =
417 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
418 { "format", 3, 3, false, true, true,
419 handle_format_attribute
},
420 { "format_arg", 1, 1, false, true, true,
421 handle_format_arg_attribute
},
422 { NULL
, 0, 0, false, false, false, NULL
}
425 /* Record the start of an if-then, and record the start of it
426 for ambiguous else detection.
428 COND is the condition for the if-then statement.
430 IF_STMT is the statement node that has already been created for
431 this if-then statement. It is created before parsing the
432 condition to keep line number information accurate. */
435 c_expand_start_cond (cond
, compstmt_count
, if_stmt
)
440 /* Make sure there is enough space on the stack. */
441 if (if_stack_space
== 0)
444 if_stack
= (if_elt
*) xmalloc (10 * sizeof (if_elt
));
446 else if (if_stack_space
== if_stack_pointer
)
448 if_stack_space
+= 10;
449 if_stack
= (if_elt
*) xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
452 IF_COND (if_stmt
) = cond
;
455 /* Record this if statement. */
456 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
457 if_stack
[if_stack_pointer
].file
= input_filename
;
458 if_stack
[if_stack_pointer
].line
= lineno
;
459 if_stack
[if_stack_pointer
].needs_warning
= 0;
460 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
464 /* Called after the then-clause for an if-statement is processed. */
469 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
470 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
473 /* Record the end of an if-then. Optionally warn if a nested
474 if statement had an ambiguous else clause. */
480 if (if_stack
[if_stack_pointer
].needs_warning
)
481 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
482 if_stack
[if_stack_pointer
].line
,
483 "suggest explicit braces to avoid ambiguous `else'");
484 last_expr_type
= NULL_TREE
;
487 /* Called between the then-clause and the else-clause
488 of an if-then-else. */
491 c_expand_start_else ()
493 /* An ambiguous else warning must be generated for the enclosing if
494 statement, unless we see an else branch for that one, too. */
496 && if_stack_pointer
> 1
497 && (if_stack
[if_stack_pointer
- 1].compstmt_count
498 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
499 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
501 /* Even if a nested if statement had an else branch, it can't be
502 ambiguous if this one also has an else. So don't warn in that
503 case. Also don't warn for any if statements nested in this else. */
504 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
505 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
508 /* Called after the else-clause for an if-statement is processed. */
513 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
514 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
517 /* Begin an if-statement. Returns a newly created IF_STMT if
520 Unlike the C++ front-end, we do not call add_stmt here; it is
521 probably safe to do so, but I am not very familiar with this
522 code so I am being extra careful not to change its behavior
523 beyond what is strictly necessary for correctness. */
529 r
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
533 /* Begin a while statement. Returns a newly created WHILE_STMT if
536 Unlike the C++ front-end, we do not call add_stmt here; it is
537 probably safe to do so, but I am not very familiar with this
538 code so I am being extra careful not to change its behavior
539 beyond what is strictly necessary for correctness. */
542 c_begin_while_stmt ()
545 r
= build_stmt (WHILE_STMT
, NULL_TREE
, NULL_TREE
);
550 c_finish_while_stmt_cond (cond
, while_stmt
)
554 WHILE_COND (while_stmt
) = cond
;
557 /* Push current bindings for the function name VAR_DECLS. */
563 tree saved
= NULL_TREE
;
565 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
567 tree decl
= *fname_vars
[ix
].decl
;
571 saved
= tree_cons (decl
, build_int_2 (ix
, 0), saved
);
572 *fname_vars
[ix
].decl
= NULL_TREE
;
575 if (saved
|| saved_function_name_decls
)
576 /* Normally they'll have been NULL, so only push if we've got a
577 stack, or they are non-NULL. */
578 saved_function_name_decls
= tree_cons (saved
, NULL_TREE
,
579 saved_function_name_decls
);
582 /* Finish up the current bindings, adding them into the
583 current function's statement tree. This is done by wrapping the
584 function's body in a COMPOUND_STMT containing these decls too. This
585 must be done _before_ finish_stmt_tree is called. If there is no
586 current function, we must be at file scope and no statements are
587 involved. Pop the previous bindings. */
590 finish_fname_decls ()
593 tree body
= NULL_TREE
;
594 tree stack
= saved_function_name_decls
;
596 for (; stack
&& TREE_VALUE (stack
); stack
= TREE_CHAIN (stack
))
597 body
= chainon (TREE_VALUE (stack
), body
);
601 /* They were called into existence, so add to statement tree. */
602 body
= chainon (body
,
603 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)));
604 body
= build_stmt (COMPOUND_STMT
, body
);
606 COMPOUND_STMT_NO_SCOPE (body
) = 1;
607 TREE_CHAIN (DECL_SAVED_TREE (current_function_decl
)) = body
;
610 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
611 *fname_vars
[ix
].decl
= NULL_TREE
;
615 /* We had saved values, restore them. */
618 for (saved
= TREE_PURPOSE (stack
); saved
; saved
= TREE_CHAIN (saved
))
620 tree decl
= TREE_PURPOSE (saved
);
621 unsigned ix
= TREE_INT_CST_LOW (TREE_VALUE (saved
));
623 *fname_vars
[ix
].decl
= decl
;
625 stack
= TREE_CHAIN (stack
);
627 saved_function_name_decls
= stack
;
630 /* Return the text name of the current function, suitable prettified
634 fname_as_string (pretty_p
)
637 const char *name
= NULL
;
640 name
= (current_function_decl
641 ? (*lang_hooks
.decl_printable_name
) (current_function_decl
, 2)
643 else if (current_function_decl
&& DECL_NAME (current_function_decl
))
644 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
650 /* Return the text name of the current function, formatted as
651 required by the supplied RID value. */
659 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
660 if (fname_vars
[ix
].rid
== rid
)
662 return fname_as_string (fname_vars
[ix
].pretty
);
665 /* Return the VAR_DECL for a const char array naming the current
666 function. If the VAR_DECL has not yet been created, create it
667 now. RID indicates how it should be formatted and IDENTIFIER_NODE
668 ID is its name (unfortunately C and C++ hold the RID values of
669 keywords in different places, so we can't derive RID from ID in
670 this language independent code. */
678 tree decl
= NULL_TREE
;
680 for (ix
= 0; fname_vars
[ix
].decl
; ix
++)
681 if (fname_vars
[ix
].rid
== rid
)
684 decl
= *fname_vars
[ix
].decl
;
687 tree saved_last_tree
= last_tree
;
689 decl
= (*make_fname_decl
) (id
, fname_vars
[ix
].pretty
);
690 if (last_tree
!= saved_last_tree
)
692 /* We created some statement tree for the decl. This belongs
693 at the start of the function, so remove it now and reinsert
694 it after the function is complete. */
695 tree stmts
= TREE_CHAIN (saved_last_tree
);
697 TREE_CHAIN (saved_last_tree
) = NULL_TREE
;
698 last_tree
= saved_last_tree
;
699 saved_function_name_decls
= tree_cons (decl
, stmts
,
700 saved_function_name_decls
);
702 *fname_vars
[ix
].decl
= decl
;
704 if (!ix
&& !current_function_decl
)
705 pedwarn_with_decl (decl
, "`%s' is not defined outside of function scope");
710 /* Given a STRING_CST, give it a suitable array-of-chars data type. */
713 fix_string_type (value
)
716 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
717 const int wide_flag
= TREE_TYPE (value
) == wchar_array_type_node
;
718 const int nchars_max
= flag_isoc99
? 4095 : 509;
719 int length
= TREE_STRING_LENGTH (value
);
722 /* Compute the number of elements, for the array type. */
723 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
725 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
726 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
727 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
729 /* Create the array type for the string constant.
730 -Wwrite-strings says make the string constant an array of const char
731 so that copying it to a non-const pointer will get a warning.
732 For C++, this is the standard behavior. */
733 if (flag_const_strings
&& ! flag_writable_strings
)
736 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
739 = build_array_type (elements
,
740 build_index_type (build_int_2 (nchars
- 1, 0)));
744 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
745 build_index_type (build_int_2 (nchars
- 1, 0)));
747 TREE_CONSTANT (value
) = 1;
748 TREE_READONLY (value
) = ! flag_writable_strings
;
749 TREE_STATIC (value
) = 1;
753 /* Given a VARRAY of STRING_CST nodes, concatenate them into one
757 combine_strings (strings
)
760 const int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
761 const int nstrings
= VARRAY_ACTIVE_SIZE (strings
);
769 /* Don't include the \0 at the end of each substring. Count wide
770 strings and ordinary strings separately. */
771 for (i
= 0; i
< nstrings
; ++i
)
773 t
= VARRAY_TREE (strings
, i
);
775 if (TREE_TYPE (t
) == wchar_array_type_node
)
777 wide_length
+= TREE_STRING_LENGTH (t
) - wchar_bytes
;
782 length
+= (TREE_STRING_LENGTH (t
) - 1);
783 if (C_ARTIFICIAL_STRING_P (t
) && !in_system_header
)
784 warning ("concatenation of string literals with __FUNCTION__ is deprecated");
788 /* If anything is wide, the non-wides will be converted,
789 which makes them take more space. */
791 length
= length
* wchar_bytes
+ wide_length
;
793 p
= xmalloc (length
);
795 /* Copy the individual strings into the new combined string.
796 If the combined string is wide, convert the chars to ints
797 for any individual strings that are not wide. */
800 for (i
= 0; i
< nstrings
; ++i
)
804 t
= VARRAY_TREE (strings
, i
);
805 this_wide
= TREE_TYPE (t
) == wchar_array_type_node
;
806 len
= TREE_STRING_LENGTH (t
) - (this_wide
? wchar_bytes
: 1);
807 if (this_wide
== wide_flag
)
809 memcpy (q
, TREE_STRING_POINTER (t
), len
);
814 const int nzeros
= (TYPE_PRECISION (wchar_type_node
)
815 / BITS_PER_UNIT
) - 1;
818 if (BYTES_BIG_ENDIAN
)
820 for (k
= 0; k
< len
; k
++)
822 for (j
= 0; j
< nzeros
; j
++)
824 *q
++ = TREE_STRING_POINTER (t
)[k
];
829 for (k
= 0; k
< len
; k
++)
831 *q
++ = TREE_STRING_POINTER (t
)[k
];
832 for (j
= 0; j
< nzeros
; j
++)
839 /* Nul terminate the string. */
842 for (i
= 0; i
< wchar_bytes
; i
++)
848 value
= build_string (length
, p
);
852 TREE_TYPE (value
) = wchar_array_type_node
;
854 TREE_TYPE (value
) = char_array_type_node
;
859 static int is_valid_printf_arglist
PARAMS ((tree
));
860 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
861 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
862 enum expand_modifier
, int, int));
863 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
864 enum expand_modifier
, int, int));
866 /* Print a warning if a constant expression had overflow in folding.
867 Invoke this function on every expression that the language
868 requires to be a constant expression.
869 Note the ANSI C standard says it is erroneous for a
870 constant expression to overflow. */
873 constant_expression_warning (value
)
876 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
877 || TREE_CODE (value
) == VECTOR_CST
878 || TREE_CODE (value
) == COMPLEX_CST
)
879 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
880 pedwarn ("overflow in constant expression");
883 /* Print a warning if an expression had overflow in folding.
884 Invoke this function on every expression that
885 (1) appears in the source code, and
886 (2) might be a constant expression that overflowed, and
887 (3) is not already checked by convert_and_check;
888 however, do not invoke this function on operands of explicit casts. */
891 overflow_warning (value
)
894 if ((TREE_CODE (value
) == INTEGER_CST
895 || (TREE_CODE (value
) == COMPLEX_CST
896 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
897 && TREE_OVERFLOW (value
))
899 TREE_OVERFLOW (value
) = 0;
900 if (skip_evaluation
== 0)
901 warning ("integer overflow in expression");
903 else if ((TREE_CODE (value
) == REAL_CST
904 || (TREE_CODE (value
) == COMPLEX_CST
905 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
906 && TREE_OVERFLOW (value
))
908 TREE_OVERFLOW (value
) = 0;
909 if (skip_evaluation
== 0)
910 warning ("floating point overflow in expression");
912 else if (TREE_CODE (value
) == VECTOR_CST
&& TREE_OVERFLOW (value
))
914 TREE_OVERFLOW (value
) = 0;
915 if (skip_evaluation
== 0)
916 warning ("vector overflow in expression");
920 /* Print a warning if a large constant is truncated to unsigned,
921 or if -Wconversion is used and a constant < 0 is converted to unsigned.
922 Invoke this function on every expression that might be implicitly
923 converted to an unsigned type. */
926 unsigned_conversion_warning (result
, operand
)
927 tree result
, operand
;
929 tree type
= TREE_TYPE (result
);
931 if (TREE_CODE (operand
) == INTEGER_CST
932 && TREE_CODE (type
) == INTEGER_TYPE
933 && TREE_UNSIGNED (type
)
934 && skip_evaluation
== 0
935 && !int_fits_type_p (operand
, type
))
937 if (!int_fits_type_p (operand
, c_common_signed_type (type
)))
938 /* This detects cases like converting -129 or 256 to unsigned char. */
939 warning ("large integer implicitly truncated to unsigned type");
940 else if (warn_conversion
)
941 warning ("negative integer implicitly converted to unsigned type");
945 /* Nonzero if constant C has a value that is permissible
946 for type TYPE (an INTEGER_TYPE). */
949 constant_fits_type_p (c
, type
)
952 if (TREE_CODE (c
) == INTEGER_CST
)
953 return int_fits_type_p (c
, type
);
955 c
= convert (type
, c
);
956 return !TREE_OVERFLOW (c
);
959 /* Convert EXPR to TYPE, warning about conversion problems with constants.
960 Invoke this function on every expression that is converted implicitly,
961 i.e. because of language rules and not because of an explicit cast. */
964 convert_and_check (type
, expr
)
967 tree t
= convert (type
, expr
);
968 if (TREE_CODE (t
) == INTEGER_CST
)
970 if (TREE_OVERFLOW (t
))
972 TREE_OVERFLOW (t
) = 0;
974 /* Do not diagnose overflow in a constant expression merely
975 because a conversion overflowed. */
976 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
978 /* No warning for converting 0x80000000 to int. */
979 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
980 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
981 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
982 /* If EXPR fits in the unsigned version of TYPE,
983 don't warn unless pedantic. */
985 || TREE_UNSIGNED (type
)
986 || ! constant_fits_type_p (expr
,
987 c_common_unsigned_type (type
)))
988 && skip_evaluation
== 0)
989 warning ("overflow in implicit constant conversion");
992 unsigned_conversion_warning (t
, expr
);
997 /* A node in a list that describes references to variables (EXPR), which are
998 either read accesses if WRITER is zero, or write accesses, in which case
999 WRITER is the parent of EXPR. */
1006 /* Used to implement a cache the results of a call to verify_tree. We only
1007 use this for SAVE_EXPRs. */
1010 struct tlist_cache
*next
;
1011 struct tlist
*cache_before_sp
;
1012 struct tlist
*cache_after_sp
;
1016 /* Obstack to use when allocating tlist structures, and corresponding
1018 static struct obstack tlist_obstack
;
1019 static char *tlist_firstobj
= 0;
1021 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1023 static struct tlist
*warned_ids
;
1024 /* SAVE_EXPRs need special treatment. We process them only once and then
1025 cache the results. */
1026 static struct tlist_cache
*save_expr_cache
;
1028 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1029 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1030 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1031 static int warning_candidate_p
PARAMS ((tree
));
1032 static void warn_for_collisions
PARAMS ((struct tlist
*));
1033 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1034 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1035 static void verify_sequence_points
PARAMS ((tree
));
1037 /* Create a new struct tlist and fill in its fields. */
1038 static struct tlist
*
1039 new_tlist (next
, t
, writer
)
1045 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1052 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1053 is nonnull, we ignore any node we find which has a writer equal to it. */
1056 add_tlist (to
, add
, exclude_writer
, copy
)
1059 tree exclude_writer
;
1064 struct tlist
*next
= add
->next
;
1067 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1068 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1073 /* Merge the nodes of ADD into TO. This merging process is done so that for
1074 each variable that already exists in TO, no new node is added; however if
1075 there is a write access recorded in ADD, and an occurrence on TO is only
1076 a read access, then the occurrence in TO will be modified to record the
1080 merge_tlist (to
, add
, copy
)
1085 struct tlist
**end
= to
;
1088 end
= &(*end
)->next
;
1094 struct tlist
*next
= add
->next
;
1096 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1097 if (tmp2
->expr
== add
->expr
)
1101 tmp2
->writer
= add
->writer
;
1105 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1106 end
= &(*end
)->next
;
1113 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1114 references in list LIST conflict with it, excluding reads if ONLY writers
1118 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1119 tree written
, writer
;
1125 /* Avoid duplicate warnings. */
1126 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1127 if (tmp
->expr
== written
)
1132 if (list
->expr
== written
1133 && list
->writer
!= writer
1134 && (! only_writes
|| list
->writer
))
1136 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1137 warning ("operation on `%s' may be undefined",
1138 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1144 /* Given a list LIST of references to variables, find whether any of these
1145 can cause conflicts due to missing sequence points. */
1148 warn_for_collisions (list
)
1153 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1156 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1160 /* Return nonzero if X is a tree that can be verified by the sequence point
1163 warning_candidate_p (x
)
1166 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1169 /* Walk the tree X, and record accesses to variables. If X is written by the
1170 parent tree, WRITER is the parent.
1171 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1172 expression or its only operand forces a sequence point, then everything up
1173 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1175 Once we return, we will have emitted warnings if any subexpression before
1176 such a sequence point could be undefined. On a higher level, however, the
1177 sequence point may not be relevant, and we'll merge the two lists.
1179 Example: (b++, a) + b;
1180 The call that processes the COMPOUND_EXPR will store the increment of B
1181 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1182 processes the PLUS_EXPR will need to merge the two lists so that
1183 eventually, all accesses end up on the same list (and we'll warn about the
1184 unordered subexpressions b++ and b.
1186 A note on merging. If we modify the former example so that our expression
1189 care must be taken not simply to add all three expressions into the final
1190 PNO_SP list. The function merge_tlist takes care of that by merging the
1191 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1192 way, so that no more than one access to B is recorded. */
1195 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1197 struct tlist
**pbefore_sp
, **pno_sp
;
1200 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1201 enum tree_code code
;
1204 /* X may be NULL if it is the operand of an empty statement expression
1210 code
= TREE_CODE (x
);
1211 class = TREE_CODE_CLASS (code
);
1213 if (warning_candidate_p (x
))
1215 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1225 case TRUTH_ANDIF_EXPR
:
1226 case TRUTH_ORIF_EXPR
:
1227 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1228 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1229 warn_for_collisions (tmp_nosp
);
1230 merge_tlist (pbefore_sp
, tmp_before
, 0);
1231 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1232 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1233 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1237 tmp_before
= tmp_list2
= 0;
1238 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1239 warn_for_collisions (tmp_list2
);
1240 merge_tlist (pbefore_sp
, tmp_before
, 0);
1241 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1243 tmp_list3
= tmp_nosp
= 0;
1244 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1245 warn_for_collisions (tmp_nosp
);
1246 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1248 tmp_list3
= tmp_list2
= 0;
1249 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1250 warn_for_collisions (tmp_list2
);
1251 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1252 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1253 two first, to avoid warning for (a ? b++ : b++). */
1254 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1255 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1258 case PREDECREMENT_EXPR
:
1259 case PREINCREMENT_EXPR
:
1260 case POSTDECREMENT_EXPR
:
1261 case POSTINCREMENT_EXPR
:
1262 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1266 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1267 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1268 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1269 /* Expressions inside the LHS are not ordered wrt. the sequence points
1270 in the RHS. Example:
1272 Despite the fact that the modification of "a" is in the before_sp
1273 list (tmp_before), it conflicts with the use of "a" in the LHS.
1274 We can handle this by adding the contents of tmp_list3
1275 to those of tmp_before, and redoing the collision warnings for that
1277 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1278 warn_for_collisions (tmp_before
);
1279 /* Exclude the LHS itself here; we first have to merge it into the
1280 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1281 didn't exclude the LHS, we'd get it twice, once as a read and once
1283 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1284 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1286 merge_tlist (pbefore_sp
, tmp_before
, 0);
1287 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1288 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1289 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1293 /* We need to warn about conflicts among arguments and conflicts between
1294 args and the function address. Side effects of the function address,
1295 however, are not ordered by the sequence point of the call. */
1296 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1297 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1298 if (TREE_OPERAND (x
, 1))
1299 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1300 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1301 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1302 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1303 warn_for_collisions (tmp_before
);
1304 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1308 /* Scan all the list, e.g. indices of multi dimensional array. */
1311 tmp_before
= tmp_nosp
= 0;
1312 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1313 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1314 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1321 struct tlist_cache
*t
;
1322 for (t
= save_expr_cache
; t
; t
= t
->next
)
1328 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1330 t
->next
= save_expr_cache
;
1332 save_expr_cache
= t
;
1334 tmp_before
= tmp_nosp
= 0;
1335 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1336 warn_for_collisions (tmp_nosp
);
1341 struct tlist
*t
= tmp_nosp
;
1343 merge_tlist (&tmp_list3
, t
, 0);
1345 t
->cache_before_sp
= tmp_before
;
1346 t
->cache_after_sp
= tmp_list3
;
1348 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1349 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1358 if (first_rtl_op (code
) == 0)
1360 x
= TREE_OPERAND (x
, 0);
1376 int max
= first_rtl_op (TREE_CODE (x
));
1377 for (lp
= 0; lp
< max
; lp
++)
1379 tmp_before
= tmp_nosp
= 0;
1380 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1381 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1382 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1389 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1393 verify_sequence_points (expr
)
1396 struct tlist
*before_sp
= 0, *after_sp
= 0;
1399 save_expr_cache
= 0;
1400 if (tlist_firstobj
== 0)
1402 gcc_obstack_init (&tlist_obstack
);
1403 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1406 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1407 warn_for_collisions (after_sp
);
1408 obstack_free (&tlist_obstack
, tlist_firstobj
);
1412 c_expand_expr_stmt (expr
)
1415 /* Do default conversion if safe and possibly important,
1416 in case within ({...}). */
1417 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
1418 && (flag_isoc99
|| lvalue_p (expr
)))
1419 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1420 expr
= default_conversion (expr
);
1422 if (warn_sequence_point
)
1423 verify_sequence_points (expr
);
1425 if (TREE_TYPE (expr
) != error_mark_node
1426 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1427 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1428 error ("expression statement has incomplete type");
1430 last_expr_type
= TREE_TYPE (expr
);
1431 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1434 /* Validate the expression after `case' and apply default promotions. */
1437 check_case_value (value
)
1440 if (value
== NULL_TREE
)
1443 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1444 STRIP_TYPE_NOPS (value
);
1445 /* In C++, the following is allowed:
1448 switch (...) { case i: ... }
1450 So, we try to reduce the VALUE to a constant that way. */
1451 if (c_language
== clk_cplusplus
)
1453 value
= decl_constant_value (value
);
1454 STRIP_TYPE_NOPS (value
);
1455 value
= fold (value
);
1458 if (TREE_CODE (value
) != INTEGER_CST
1459 && value
!= error_mark_node
)
1461 error ("case label does not reduce to an integer constant");
1462 value
= error_mark_node
;
1465 /* Promote char or short to int. */
1466 value
= default_conversion (value
);
1468 constant_expression_warning (value
);
1473 /* Return an integer type with BITS bits of precision,
1474 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1477 c_common_type_for_size (bits
, unsignedp
)
1481 if (bits
== TYPE_PRECISION (integer_type_node
))
1482 return unsignedp
? unsigned_type_node
: integer_type_node
;
1484 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1485 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1487 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1488 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1490 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1491 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1493 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1494 return (unsignedp
? long_long_unsigned_type_node
1495 : long_long_integer_type_node
);
1497 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1498 return (unsignedp
? widest_unsigned_literal_type_node
1499 : widest_integer_literal_type_node
);
1501 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1502 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1504 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1505 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1507 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1508 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1510 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1511 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1516 /* Return a data type that has machine mode MODE.
1517 If the mode is an integer,
1518 then UNSIGNEDP selects between signed and unsigned types. */
1521 c_common_type_for_mode (mode
, unsignedp
)
1522 enum machine_mode mode
;
1525 if (mode
== TYPE_MODE (integer_type_node
))
1526 return unsignedp
? unsigned_type_node
: integer_type_node
;
1528 if (mode
== TYPE_MODE (signed_char_type_node
))
1529 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1531 if (mode
== TYPE_MODE (short_integer_type_node
))
1532 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1534 if (mode
== TYPE_MODE (long_integer_type_node
))
1535 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1537 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1538 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1540 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1541 return unsignedp
? widest_unsigned_literal_type_node
1542 : widest_integer_literal_type_node
;
1545 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1548 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1551 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1554 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1556 #if HOST_BITS_PER_WIDE_INT >= 64
1557 if (mode
== TYPE_MODE (intTI_type_node
))
1558 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1561 if (mode
== TYPE_MODE (float_type_node
))
1562 return float_type_node
;
1564 if (mode
== TYPE_MODE (double_type_node
))
1565 return double_type_node
;
1567 if (mode
== TYPE_MODE (long_double_type_node
))
1568 return long_double_type_node
;
1570 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1571 return build_pointer_type (char_type_node
);
1573 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1574 return build_pointer_type (integer_type_node
);
1576 #ifdef VECTOR_MODE_SUPPORTED_P
1577 if (VECTOR_MODE_SUPPORTED_P (mode
))
1582 return unsignedp
? unsigned_V16QI_type_node
: V16QI_type_node
;
1584 return unsignedp
? unsigned_V8HI_type_node
: V8HI_type_node
;
1586 return unsignedp
? unsigned_V4SI_type_node
: V4SI_type_node
;
1588 return unsignedp
? unsigned_V2DI_type_node
: V2DI_type_node
;
1590 return unsignedp
? unsigned_V2SI_type_node
: V2SI_type_node
;
1592 return unsignedp
? unsigned_V4HI_type_node
: V4HI_type_node
;
1594 return unsignedp
? unsigned_V8QI_type_node
: V8QI_type_node
;
1596 return V16SF_type_node
;
1598 return V4SF_type_node
;
1600 return V2SF_type_node
;
1602 return V2DF_type_node
;
1612 /* Return an unsigned type the same as TYPE in other respects. */
1614 c_common_unsigned_type (type
)
1617 tree type1
= TYPE_MAIN_VARIANT (type
);
1618 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1619 return unsigned_char_type_node
;
1620 if (type1
== integer_type_node
)
1621 return unsigned_type_node
;
1622 if (type1
== short_integer_type_node
)
1623 return short_unsigned_type_node
;
1624 if (type1
== long_integer_type_node
)
1625 return long_unsigned_type_node
;
1626 if (type1
== long_long_integer_type_node
)
1627 return long_long_unsigned_type_node
;
1628 if (type1
== widest_integer_literal_type_node
)
1629 return widest_unsigned_literal_type_node
;
1630 #if HOST_BITS_PER_WIDE_INT >= 64
1631 if (type1
== intTI_type_node
)
1632 return unsigned_intTI_type_node
;
1634 if (type1
== intDI_type_node
)
1635 return unsigned_intDI_type_node
;
1636 if (type1
== intSI_type_node
)
1637 return unsigned_intSI_type_node
;
1638 if (type1
== intHI_type_node
)
1639 return unsigned_intHI_type_node
;
1640 if (type1
== intQI_type_node
)
1641 return unsigned_intQI_type_node
;
1643 return c_common_signed_or_unsigned_type (1, type
);
1646 /* Return a signed type the same as TYPE in other respects. */
1649 c_common_signed_type (type
)
1652 tree type1
= TYPE_MAIN_VARIANT (type
);
1653 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1654 return signed_char_type_node
;
1655 if (type1
== unsigned_type_node
)
1656 return integer_type_node
;
1657 if (type1
== short_unsigned_type_node
)
1658 return short_integer_type_node
;
1659 if (type1
== long_unsigned_type_node
)
1660 return long_integer_type_node
;
1661 if (type1
== long_long_unsigned_type_node
)
1662 return long_long_integer_type_node
;
1663 if (type1
== widest_unsigned_literal_type_node
)
1664 return widest_integer_literal_type_node
;
1665 #if HOST_BITS_PER_WIDE_INT >= 64
1666 if (type1
== unsigned_intTI_type_node
)
1667 return intTI_type_node
;
1669 if (type1
== unsigned_intDI_type_node
)
1670 return intDI_type_node
;
1671 if (type1
== unsigned_intSI_type_node
)
1672 return intSI_type_node
;
1673 if (type1
== unsigned_intHI_type_node
)
1674 return intHI_type_node
;
1675 if (type1
== unsigned_intQI_type_node
)
1676 return intQI_type_node
;
1678 return c_common_signed_or_unsigned_type (0, type
);
1681 /* Return a type the same as TYPE except unsigned or
1682 signed according to UNSIGNEDP. */
1685 c_common_signed_or_unsigned_type (unsignedp
, type
)
1689 if (! INTEGRAL_TYPE_P (type
)
1690 || TREE_UNSIGNED (type
) == unsignedp
)
1693 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1694 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1695 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1696 return unsignedp
? unsigned_type_node
: integer_type_node
;
1697 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1698 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1699 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1700 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1701 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1702 return (unsignedp
? long_long_unsigned_type_node
1703 : long_long_integer_type_node
);
1704 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1705 return (unsignedp
? widest_unsigned_literal_type_node
1706 : widest_integer_literal_type_node
);
1708 #if HOST_BITS_PER_WIDE_INT >= 64
1709 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intTI_type_node
))
1710 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1712 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intDI_type_node
))
1713 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1714 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intSI_type_node
))
1715 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1716 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intHI_type_node
))
1717 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1718 if (TYPE_PRECISION (type
) == TYPE_PRECISION (intQI_type_node
))
1719 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1724 /* Return the minimum number of bits needed to represent VALUE in a
1725 signed or unsigned type, UNSIGNEDP says which. */
1728 min_precision (value
, unsignedp
)
1734 /* If the value is negative, compute its negative minus 1. The latter
1735 adjustment is because the absolute value of the largest negative value
1736 is one larger than the largest positive value. This is equivalent to
1737 a bit-wise negation, so use that operation instead. */
1739 if (tree_int_cst_sgn (value
) < 0)
1740 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1742 /* Return the number of bits needed, taking into account the fact
1743 that we need one more bit for a signed than unsigned type. */
1745 if (integer_zerop (value
))
1748 log
= tree_floor_log2 (value
);
1750 return log
+ 1 + ! unsignedp
;
1753 /* Print an error message for invalid operands to arith operation
1754 CODE. NOP_EXPR is used as a special case (see
1755 c_common_truthvalue_conversion). */
1758 binary_op_error (code
)
1759 enum tree_code code
;
1766 error ("invalid truth-value expression");
1770 opname
= "+"; break;
1772 opname
= "-"; break;
1774 opname
= "*"; break;
1776 opname
= "max"; break;
1778 opname
= "min"; break;
1780 opname
= "=="; break;
1782 opname
= "!="; break;
1784 opname
= "<="; break;
1786 opname
= ">="; break;
1788 opname
= "<"; break;
1790 opname
= ">"; break;
1792 opname
= "<<"; break;
1794 opname
= ">>"; break;
1795 case TRUNC_MOD_EXPR
:
1796 case FLOOR_MOD_EXPR
:
1797 opname
= "%"; break;
1798 case TRUNC_DIV_EXPR
:
1799 case FLOOR_DIV_EXPR
:
1800 opname
= "/"; break;
1802 opname
= "&"; break;
1804 opname
= "|"; break;
1805 case TRUTH_ANDIF_EXPR
:
1806 opname
= "&&"; break;
1807 case TRUTH_ORIF_EXPR
:
1808 opname
= "||"; break;
1810 opname
= "^"; break;
1813 opname
= "rotate"; break;
1815 opname
= "unknown"; break;
1817 error ("invalid operands to binary %s", opname
);
1820 /* Subroutine of build_binary_op, used for comparison operations.
1821 See if the operands have both been converted from subword integer types
1822 and, if so, perhaps change them both back to their original type.
1823 This function is also responsible for converting the two operands
1824 to the proper common type for comparison.
1826 The arguments of this function are all pointers to local variables
1827 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1828 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1830 If this function returns nonzero, it means that the comparison has
1831 a constant value. What this function returns is an expression for
1835 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1836 tree
*op0_ptr
, *op1_ptr
;
1838 enum tree_code
*rescode_ptr
;
1841 tree op0
= *op0_ptr
;
1842 tree op1
= *op1_ptr
;
1843 int unsignedp0
, unsignedp1
;
1845 tree primop0
, primop1
;
1846 enum tree_code code
= *rescode_ptr
;
1848 /* Throw away any conversions to wider types
1849 already present in the operands. */
1851 primop0
= get_narrower (op0
, &unsignedp0
);
1852 primop1
= get_narrower (op1
, &unsignedp1
);
1854 /* Handle the case that OP0 does not *contain* a conversion
1855 but it *requires* conversion to FINAL_TYPE. */
1857 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1858 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1859 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1860 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1862 /* If one of the operands must be floated, we cannot optimize. */
1863 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1864 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1866 /* If first arg is constant, swap the args (changing operation
1867 so value is preserved), for canonicalization. Don't do this if
1868 the second arg is 0. */
1870 if (TREE_CONSTANT (primop0
)
1871 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1874 int temi
= unsignedp0
;
1882 unsignedp0
= unsignedp1
;
1905 *rescode_ptr
= code
;
1908 /* If comparing an integer against a constant more bits wide,
1909 maybe we can deduce a value of 1 or 0 independent of the data.
1910 Or else truncate the constant now
1911 rather than extend the variable at run time.
1913 This is only interesting if the constant is the wider arg.
1914 Also, it is not safe if the constant is unsigned and the
1915 variable arg is signed, since in this case the variable
1916 would be sign-extended and then regarded as unsigned.
1917 Our technique fails in this case because the lowest/highest
1918 possible unsigned results don't follow naturally from the
1919 lowest/highest possible values of the variable operand.
1920 For just EQ_EXPR and NE_EXPR there is another technique that
1921 could be used: see if the constant can be faithfully represented
1922 in the other operand's type, by truncating it and reextending it
1923 and see if that preserves the constant's value. */
1925 if (!real1
&& !real2
1926 && TREE_CODE (primop1
) == INTEGER_CST
1927 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1929 int min_gt
, max_gt
, min_lt
, max_lt
;
1930 tree maxval
, minval
;
1931 /* 1 if comparison is nominally unsigned. */
1932 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1935 type
= c_common_signed_or_unsigned_type (unsignedp0
,
1936 TREE_TYPE (primop0
));
1938 /* If TYPE is an enumeration, then we need to get its min/max
1939 values from it's underlying integral type, not the enumerated
1941 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
1942 type
= c_common_type_for_size (TYPE_PRECISION (type
), unsignedp0
);
1944 maxval
= TYPE_MAX_VALUE (type
);
1945 minval
= TYPE_MIN_VALUE (type
);
1947 if (unsignedp
&& !unsignedp0
)
1948 *restype_ptr
= c_common_signed_type (*restype_ptr
);
1950 if (TREE_TYPE (primop1
) != *restype_ptr
)
1951 primop1
= convert (*restype_ptr
, primop1
);
1952 if (type
!= *restype_ptr
)
1954 minval
= convert (*restype_ptr
, minval
);
1955 maxval
= convert (*restype_ptr
, maxval
);
1958 if (unsignedp
&& unsignedp0
)
1960 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1961 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1962 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1963 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1967 min_gt
= INT_CST_LT (primop1
, minval
);
1968 max_gt
= INT_CST_LT (primop1
, maxval
);
1969 min_lt
= INT_CST_LT (minval
, primop1
);
1970 max_lt
= INT_CST_LT (maxval
, primop1
);
1974 /* This used to be a switch, but Genix compiler can't handle that. */
1975 if (code
== NE_EXPR
)
1977 if (max_lt
|| min_gt
)
1978 val
= boolean_true_node
;
1980 else if (code
== EQ_EXPR
)
1982 if (max_lt
|| min_gt
)
1983 val
= boolean_false_node
;
1985 else if (code
== LT_EXPR
)
1988 val
= boolean_true_node
;
1990 val
= boolean_false_node
;
1992 else if (code
== GT_EXPR
)
1995 val
= boolean_true_node
;
1997 val
= boolean_false_node
;
1999 else if (code
== LE_EXPR
)
2002 val
= boolean_true_node
;
2004 val
= boolean_false_node
;
2006 else if (code
== GE_EXPR
)
2009 val
= boolean_true_node
;
2011 val
= boolean_false_node
;
2014 /* If primop0 was sign-extended and unsigned comparison specd,
2015 we did a signed comparison above using the signed type bounds.
2016 But the comparison we output must be unsigned.
2018 Also, for inequalities, VAL is no good; but if the signed
2019 comparison had *any* fixed result, it follows that the
2020 unsigned comparison just tests the sign in reverse
2021 (positive values are LE, negative ones GE).
2022 So we can generate an unsigned comparison
2023 against an extreme value of the signed type. */
2025 if (unsignedp
&& !unsignedp0
)
2032 primop1
= TYPE_MIN_VALUE (type
);
2038 primop1
= TYPE_MAX_VALUE (type
);
2045 type
= c_common_unsigned_type (type
);
2048 if (TREE_CODE (primop0
) != INTEGER_CST
)
2050 if (val
== boolean_false_node
)
2051 warning ("comparison is always false due to limited range of data type");
2052 if (val
== boolean_true_node
)
2053 warning ("comparison is always true due to limited range of data type");
2058 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2059 if (TREE_SIDE_EFFECTS (primop0
))
2060 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2064 /* Value is not predetermined, but do the comparison
2065 in the type of the operand that is not constant.
2066 TYPE is already properly set. */
2068 else if (real1
&& real2
2069 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2070 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2071 type
= TREE_TYPE (primop0
);
2073 /* If args' natural types are both narrower than nominal type
2074 and both extend in the same manner, compare them
2075 in the type of the wider arg.
2076 Otherwise must actually extend both to the nominal
2077 common type lest different ways of extending
2079 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2081 else if (unsignedp0
== unsignedp1
&& real1
== real2
2082 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2083 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2085 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2086 type
= c_common_signed_or_unsigned_type (unsignedp0
2087 || TREE_UNSIGNED (*restype_ptr
),
2089 /* Make sure shorter operand is extended the right way
2090 to match the longer operand. */
2092 = convert (c_common_signed_or_unsigned_type (unsignedp0
,
2093 TREE_TYPE (primop0
)),
2096 = convert (c_common_signed_or_unsigned_type (unsignedp1
,
2097 TREE_TYPE (primop1
)),
2102 /* Here we must do the comparison on the nominal type
2103 using the args exactly as we received them. */
2104 type
= *restype_ptr
;
2108 if (!real1
&& !real2
&& integer_zerop (primop1
)
2109 && TREE_UNSIGNED (*restype_ptr
))
2115 /* All unsigned values are >= 0, so we warn if extra warnings
2116 are requested. However, if OP0 is a constant that is
2117 >= 0, the signedness of the comparison isn't an issue,
2118 so suppress the warning. */
2119 if (extra_warnings
&& !in_system_header
2120 && ! (TREE_CODE (primop0
) == INTEGER_CST
2121 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2123 warning ("comparison of unsigned expression >= 0 is always true");
2124 value
= boolean_true_node
;
2128 if (extra_warnings
&& !in_system_header
2129 && ! (TREE_CODE (primop0
) == INTEGER_CST
2130 && ! TREE_OVERFLOW (convert (c_common_signed_type (type
),
2132 warning ("comparison of unsigned expression < 0 is always false");
2133 value
= boolean_false_node
;
2142 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2143 if (TREE_SIDE_EFFECTS (primop0
))
2144 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2151 *op0_ptr
= convert (type
, primop0
);
2152 *op1_ptr
= convert (type
, primop1
);
2154 *restype_ptr
= boolean_type_node
;
2159 /* Return a tree for the sum or difference (RESULTCODE says which)
2160 of pointer PTROP and integer INTOP. */
2163 pointer_int_sum (resultcode
, ptrop
, intop
)
2164 enum tree_code resultcode
;
2172 /* The result is a pointer of the same type that is being added. */
2174 tree result_type
= TREE_TYPE (ptrop
);
2176 if (TREE_CODE (TREE_TYPE (result_type
)) == VOID_TYPE
)
2178 if (pedantic
|| warn_pointer_arith
)
2179 pedwarn ("pointer of type `void *' used in arithmetic");
2180 size_exp
= integer_one_node
;
2182 else if (TREE_CODE (TREE_TYPE (result_type
)) == FUNCTION_TYPE
)
2184 if (pedantic
|| warn_pointer_arith
)
2185 pedwarn ("pointer to a function used in arithmetic");
2186 size_exp
= integer_one_node
;
2188 else if (TREE_CODE (TREE_TYPE (result_type
)) == METHOD_TYPE
)
2190 if (pedantic
|| warn_pointer_arith
)
2191 pedwarn ("pointer to member function used in arithmetic");
2192 size_exp
= integer_one_node
;
2194 else if (TREE_CODE (TREE_TYPE (result_type
)) == OFFSET_TYPE
)
2196 if (pedantic
|| warn_pointer_arith
)
2197 pedwarn ("pointer to a member used in arithmetic");
2198 size_exp
= integer_one_node
;
2201 size_exp
= size_in_bytes (TREE_TYPE (result_type
));
2203 /* If what we are about to multiply by the size of the elements
2204 contains a constant term, apply distributive law
2205 and multiply that constant term separately.
2206 This helps produce common subexpressions. */
2208 if ((TREE_CODE (intop
) == PLUS_EXPR
|| TREE_CODE (intop
) == MINUS_EXPR
)
2209 && ! TREE_CONSTANT (intop
)
2210 && TREE_CONSTANT (TREE_OPERAND (intop
, 1))
2211 && TREE_CONSTANT (size_exp
)
2212 /* If the constant comes from pointer subtraction,
2213 skip this optimization--it would cause an error. */
2214 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop
, 0))) == INTEGER_TYPE
2215 /* If the constant is unsigned, and smaller than the pointer size,
2216 then we must skip this optimization. This is because it could cause
2217 an overflow error if the constant is negative but INTOP is not. */
2218 && (! TREE_UNSIGNED (TREE_TYPE (intop
))
2219 || (TYPE_PRECISION (TREE_TYPE (intop
))
2220 == TYPE_PRECISION (TREE_TYPE (ptrop
)))))
2222 enum tree_code subcode
= resultcode
;
2223 tree int_type
= TREE_TYPE (intop
);
2224 if (TREE_CODE (intop
) == MINUS_EXPR
)
2225 subcode
= (subcode
== PLUS_EXPR
? MINUS_EXPR
: PLUS_EXPR
);
2226 /* Convert both subexpression types to the type of intop,
2227 because weird cases involving pointer arithmetic
2228 can result in a sum or difference with different type args. */
2229 ptrop
= build_binary_op (subcode
, ptrop
,
2230 convert (int_type
, TREE_OPERAND (intop
, 1)), 1);
2231 intop
= convert (int_type
, TREE_OPERAND (intop
, 0));
2234 /* Convert the integer argument to a type the same size as sizetype
2235 so the multiply won't overflow spuriously. */
2237 if (TYPE_PRECISION (TREE_TYPE (intop
)) != TYPE_PRECISION (sizetype
)
2238 || TREE_UNSIGNED (TREE_TYPE (intop
)) != TREE_UNSIGNED (sizetype
))
2239 intop
= convert (c_common_type_for_size (TYPE_PRECISION (sizetype
),
2240 TREE_UNSIGNED (sizetype
)), intop
);
2242 /* Replace the integer argument with a suitable product by the object size.
2243 Do this multiplication as signed, then convert to the appropriate
2244 pointer type (actually unsigned integral). */
2246 intop
= convert (result_type
,
2247 build_binary_op (MULT_EXPR
, intop
,
2248 convert (TREE_TYPE (intop
), size_exp
), 1));
2250 /* Create the sum or difference. */
2252 result
= build (resultcode
, result_type
, ptrop
, intop
);
2254 folded
= fold (result
);
2255 if (folded
== result
)
2256 TREE_CONSTANT (folded
) = TREE_CONSTANT (ptrop
) & TREE_CONSTANT (intop
);
2260 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2261 or validate its data type for an `if' or `while' statement or ?..: exp.
2263 This preparation consists of taking the ordinary
2264 representation of an expression expr and producing a valid tree
2265 boolean expression describing whether expr is nonzero. We could
2266 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2267 but we optimize comparisons, &&, ||, and !.
2269 The resulting type should always be `boolean_type_node'. */
2272 c_common_truthvalue_conversion (expr
)
2275 if (TREE_CODE (expr
) == ERROR_MARK
)
2278 #if 0 /* This appears to be wrong for C++. */
2279 /* These really should return error_mark_node after 2.4 is stable.
2280 But not all callers handle ERROR_MARK properly. */
2281 switch (TREE_CODE (TREE_TYPE (expr
)))
2284 error ("struct type value used where scalar is required");
2285 return boolean_false_node
;
2288 error ("union type value used where scalar is required");
2289 return boolean_false_node
;
2292 error ("array type value used where scalar is required");
2293 return boolean_false_node
;
2300 switch (TREE_CODE (expr
))
2303 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2304 case TRUTH_ANDIF_EXPR
:
2305 case TRUTH_ORIF_EXPR
:
2306 case TRUTH_AND_EXPR
:
2308 case TRUTH_XOR_EXPR
:
2309 case TRUTH_NOT_EXPR
:
2310 TREE_TYPE (expr
) = boolean_type_node
;
2317 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2320 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2323 /* If we are taking the address of an external decl, it might be zero
2324 if it is weak, so we cannot optimize. */
2325 if (DECL_P (TREE_OPERAND (expr
, 0))
2326 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2329 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2330 return build (COMPOUND_EXPR
, boolean_type_node
,
2331 TREE_OPERAND (expr
, 0), boolean_true_node
);
2333 return boolean_true_node
;
2336 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2337 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2338 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2339 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2346 /* These don't change whether an object is non-zero or zero. */
2347 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2351 /* These don't change whether an object is zero or non-zero, but
2352 we can't ignore them if their second arg has side-effects. */
2353 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2354 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2355 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2357 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2360 /* Distribute the conversion into the arms of a COND_EXPR. */
2361 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2362 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2363 c_common_truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2366 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2367 since that affects how `default_conversion' will behave. */
2368 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2369 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2371 /* fall through... */
2373 /* If this is widening the argument, we can ignore it. */
2374 if (TYPE_PRECISION (TREE_TYPE (expr
))
2375 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2376 return c_common_truthvalue_conversion (TREE_OPERAND (expr
, 0));
2380 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2381 aren't guaranteed to the be same for modes that can represent
2382 infinity, since if x and y are both +infinity, or both
2383 -infinity, then x - y is not a number.
2385 Note that this transformation is safe when x or y is NaN.
2386 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2388 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr
, 0)))))
2390 /* fall through... */
2392 /* This and MINUS_EXPR can be changed into a comparison of the
2394 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2395 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2396 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2397 TREE_OPERAND (expr
, 1), 1);
2398 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2399 fold (build1 (NOP_EXPR
,
2400 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2401 TREE_OPERAND (expr
, 1))), 1);
2404 if (integer_onep (TREE_OPERAND (expr
, 1))
2405 && TREE_TYPE (expr
) != boolean_type_node
)
2406 /* Using convert here would cause infinite recursion. */
2407 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2411 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2412 warning ("suggest parentheses around assignment used as truth value");
2419 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2421 tree t
= save_expr (expr
);
2422 return (build_binary_op
2423 ((TREE_SIDE_EFFECTS (expr
)
2424 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2425 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR
, t
, 0)),
2426 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, t
, 0)),
2430 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2433 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2434 int, enum built_in_class
, int, int,
2437 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2438 down to the element type of an array. */
2441 c_build_qualified_type (type
, type_quals
)
2445 /* A restrict-qualified pointer type must be a pointer to object or
2446 incomplete type. Note that the use of POINTER_TYPE_P also allows
2447 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2448 the C++ front-end also use POINTER_TYPE for pointer-to-member
2449 values, so even though it should be illegal to use `restrict'
2450 with such an entity we don't flag that here. Thus, special case
2451 code for that case is required in the C++ front-end. */
2452 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2453 && (!POINTER_TYPE_P (type
)
2454 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2456 error ("invalid use of `restrict'");
2457 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2460 if (TREE_CODE (type
) == ARRAY_TYPE
)
2461 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2463 TYPE_DOMAIN (type
));
2464 return build_qualified_type (type
, type_quals
);
2467 /* Apply the TYPE_QUALS to the new DECL. */
2470 c_apply_type_quals_to_decl (type_quals
, decl
)
2474 if ((type_quals
& TYPE_QUAL_CONST
)
2475 || (TREE_TYPE (decl
)
2476 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2477 TREE_READONLY (decl
) = 1;
2478 if (type_quals
& TYPE_QUAL_VOLATILE
)
2480 TREE_SIDE_EFFECTS (decl
) = 1;
2481 TREE_THIS_VOLATILE (decl
) = 1;
2483 if (type_quals
& TYPE_QUAL_RESTRICT
)
2485 if (!TREE_TYPE (decl
)
2486 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2487 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2488 error ("invalid use of `restrict'");
2489 else if (flag_strict_aliasing
)
2490 /* Indicate we need to make a unique alias set for this pointer.
2491 We can't do it here because it might be pointing to an
2493 DECL_POINTER_ALIAS_SET (decl
) = -2;
2497 /* Return the typed-based alias set for T, which may be an expression
2498 or a type. Return -1 if we don't do anything special. */
2501 c_common_get_alias_set (t
)
2506 /* We know nothing about vector types */
2507 if (TREE_CODE (t
) == VECTOR_TYPE
)
2510 /* Permit type-punning when accessing a union, provided the access
2511 is directly through the union. For example, this code does not
2512 permit taking the address of a union member and then storing
2513 through it. Even the type-punning allowed here is a GCC
2514 extension, albeit a common and useful one; the C standard says
2515 that such accesses have implementation-defined behavior. */
2517 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2518 u
= TREE_OPERAND (u
, 0))
2519 if (TREE_CODE (u
) == COMPONENT_REF
2520 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2523 /* If this is a char *, the ANSI C standard says it can alias
2524 anything. Note that all references need do this. */
2525 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2526 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2527 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2530 /* That's all the expressions we handle specially. */
2534 /* The C standard specifically allows aliasing between signed and
2535 unsigned variants of the same type. We treat the signed
2536 variant as canonical. */
2537 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2539 tree t1
= c_common_signed_type (t
);
2541 /* t1 == t can happen for boolean nodes which are always unsigned. */
2543 return get_alias_set (t1
);
2545 else if (POINTER_TYPE_P (t
))
2549 /* Unfortunately, there is no canonical form of a pointer type.
2550 In particular, if we have `typedef int I', then `int *', and
2551 `I *' are different types. So, we have to pick a canonical
2552 representative. We do this below.
2554 Technically, this approach is actually more conservative that
2555 it needs to be. In particular, `const int *' and `int *'
2556 should be in different alias sets, according to the C and C++
2557 standard, since their types are not the same, and so,
2558 technically, an `int **' and `const int **' cannot point at
2561 But, the standard is wrong. In particular, this code is
2566 const int* const* cipp = &ipp;
2568 And, it doesn't make sense for that to be legal unless you
2569 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2570 the pointed-to types. This issue has been reported to the
2572 t1
= build_type_no_quals (t
);
2574 return get_alias_set (t1
);
2580 /* Implement the __alignof keyword: Return the minimum required
2581 alignment of TYPE, measured in bytes. */
2587 enum tree_code code
= TREE_CODE (type
);
2590 /* In C++, sizeof applies to the referent. Handle alignof the same way. */
2591 if (code
== REFERENCE_TYPE
)
2593 type
= TREE_TYPE (type
);
2594 code
= TREE_CODE (type
);
2597 if (code
== FUNCTION_TYPE
)
2598 t
= size_int (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
2599 else if (code
== VOID_TYPE
|| code
== ERROR_MARK
)
2601 else if (!COMPLETE_TYPE_P (type
))
2603 error ("__alignof__ applied to an incomplete type");
2607 t
= size_int (TYPE_ALIGN (type
) / BITS_PER_UNIT
);
2609 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2612 /* Implement the __alignof keyword: Return the minimum required
2613 alignment of EXPR, measured in bytes. For VAR_DECL's and
2614 FIELD_DECL's return DECL_ALIGN (which can be set from an
2615 "aligned" __attribute__ specification). */
2618 c_alignof_expr (expr
)
2623 if (TREE_CODE (expr
) == VAR_DECL
)
2624 t
= size_int (DECL_ALIGN (expr
) / BITS_PER_UNIT
);
2626 else if (TREE_CODE (expr
) == COMPONENT_REF
2627 && DECL_C_BIT_FIELD (TREE_OPERAND (expr
, 1)))
2629 error ("`__alignof' applied to a bit-field");
2632 else if (TREE_CODE (expr
) == COMPONENT_REF
2633 && TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
)
2634 t
= size_int (DECL_ALIGN (TREE_OPERAND (expr
, 1)) / BITS_PER_UNIT
);
2636 else if (TREE_CODE (expr
) == INDIRECT_REF
)
2638 tree t
= TREE_OPERAND (expr
, 0);
2640 int bestalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2642 while (TREE_CODE (t
) == NOP_EXPR
2643 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t
, 0))) == POINTER_TYPE
)
2647 t
= TREE_OPERAND (t
, 0);
2648 thisalign
= TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t
)));
2649 if (thisalign
> bestalign
)
2650 best
= t
, bestalign
= thisalign
;
2652 return c_alignof (TREE_TYPE (TREE_TYPE (best
)));
2655 return c_alignof (TREE_TYPE (expr
));
2657 return fold (build1 (NOP_EXPR
, c_size_type_node
, t
));
2660 /* Build tree nodes and builtin functions common to both C and C++ language
2664 c_common_nodes_and_builtins ()
2668 #define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
2669 #define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
2670 #define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
2671 #define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
2672 #define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
2673 #define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
2674 #define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
2675 #define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
2676 #define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
2677 #define DEF_POINTER_TYPE(NAME, TYPE) NAME,
2678 #include "builtin-types.def"
2679 #undef DEF_PRIMITIVE_TYPE
2680 #undef DEF_FUNCTION_TYPE_0
2681 #undef DEF_FUNCTION_TYPE_1
2682 #undef DEF_FUNCTION_TYPE_2
2683 #undef DEF_FUNCTION_TYPE_3
2684 #undef DEF_FUNCTION_TYPE_4
2685 #undef DEF_FUNCTION_TYPE_VAR_0
2686 #undef DEF_FUNCTION_TYPE_VAR_1
2687 #undef DEF_FUNCTION_TYPE_VAR_2
2688 #undef DEF_POINTER_TYPE
2692 typedef enum builtin_type builtin_type
;
2694 tree builtin_types
[(int) BT_LAST
];
2695 int wchar_type_size
;
2696 tree array_domain_type
;
2697 tree va_list_ref_type_node
;
2698 tree va_list_arg_type_node
;
2700 /* Define `int' and `char' first so that dbx will output them first. */
2701 record_builtin_type (RID_INT
, NULL
, integer_type_node
);
2702 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2704 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2705 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2706 but not C. Are the conditionals here needed? */
2707 if (c_language
== clk_cplusplus
)
2708 record_builtin_type (RID_SIGNED
, NULL
, integer_type_node
);
2709 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2710 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2711 record_builtin_type (RID_MAX
, "long unsigned int",
2712 long_unsigned_type_node
);
2713 if (c_language
== clk_cplusplus
)
2714 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2715 record_builtin_type (RID_MAX
, "long long int",
2716 long_long_integer_type_node
);
2717 record_builtin_type (RID_MAX
, "long long unsigned int",
2718 long_long_unsigned_type_node
);
2719 if (c_language
== clk_cplusplus
)
2720 record_builtin_type (RID_MAX
, "long long unsigned",
2721 long_long_unsigned_type_node
);
2722 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2723 record_builtin_type (RID_MAX
, "short unsigned int",
2724 short_unsigned_type_node
);
2725 if (c_language
== clk_cplusplus
)
2726 record_builtin_type (RID_MAX
, "unsigned short",
2727 short_unsigned_type_node
);
2729 /* Define both `signed char' and `unsigned char'. */
2730 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2731 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2733 /* These are types that c_common_type_for_size and
2734 c_common_type_for_mode use. */
2735 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2737 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2739 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2741 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2743 #if HOST_BITS_PER_WIDE_INT >= 64
2744 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2745 get_identifier ("__int128_t"),
2748 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2749 unsigned_intQI_type_node
));
2750 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2751 unsigned_intHI_type_node
));
2752 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2753 unsigned_intSI_type_node
));
2754 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2755 unsigned_intDI_type_node
));
2756 #if HOST_BITS_PER_WIDE_INT >= 64
2757 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2758 get_identifier ("__uint128_t"),
2759 unsigned_intTI_type_node
));
2762 /* Create the widest literal types. */
2763 widest_integer_literal_type_node
2764 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2765 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2766 widest_integer_literal_type_node
));
2768 widest_unsigned_literal_type_node
2769 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2770 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
, NULL_TREE
,
2771 widest_unsigned_literal_type_node
));
2773 /* `unsigned long' is the standard type for sizeof.
2774 Note that stddef.h uses `unsigned long',
2775 and this must agree, even if long and int are the same size. */
2777 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2778 signed_size_type_node
= c_common_signed_type (c_size_type_node
);
2779 set_sizetype (c_size_type_node
);
2781 build_common_tree_nodes_2 (flag_short_double
);
2783 record_builtin_type (RID_FLOAT
, NULL
, float_type_node
);
2784 record_builtin_type (RID_DOUBLE
, NULL
, double_type_node
);
2785 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2787 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2788 get_identifier ("complex int"),
2789 complex_integer_type_node
));
2790 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2791 get_identifier ("complex float"),
2792 complex_float_type_node
));
2793 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2794 get_identifier ("complex double"),
2795 complex_double_type_node
));
2796 (*lang_hooks
.decls
.pushdecl
)
2797 (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2798 complex_long_double_type_node
));
2800 /* Types which are common to the fortran compiler and libf2c. When
2801 changing these, you also need to be concerned with f/com.h. */
2803 if (TYPE_PRECISION (float_type_node
)
2804 == TYPE_PRECISION (long_integer_type_node
))
2806 g77_integer_type_node
= long_integer_type_node
;
2807 g77_uinteger_type_node
= long_unsigned_type_node
;
2809 else if (TYPE_PRECISION (float_type_node
)
2810 == TYPE_PRECISION (integer_type_node
))
2812 g77_integer_type_node
= integer_type_node
;
2813 g77_uinteger_type_node
= unsigned_type_node
;
2816 g77_integer_type_node
= g77_uinteger_type_node
= NULL_TREE
;
2818 if (g77_integer_type_node
!= NULL_TREE
)
2820 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2821 get_identifier ("__g77_integer"),
2822 g77_integer_type_node
));
2823 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2824 get_identifier ("__g77_uinteger"),
2825 g77_uinteger_type_node
));
2828 if (TYPE_PRECISION (float_type_node
) * 2
2829 == TYPE_PRECISION (long_integer_type_node
))
2831 g77_longint_type_node
= long_integer_type_node
;
2832 g77_ulongint_type_node
= long_unsigned_type_node
;
2834 else if (TYPE_PRECISION (float_type_node
) * 2
2835 == TYPE_PRECISION (long_long_integer_type_node
))
2837 g77_longint_type_node
= long_long_integer_type_node
;
2838 g77_ulongint_type_node
= long_long_unsigned_type_node
;
2841 g77_longint_type_node
= g77_ulongint_type_node
= NULL_TREE
;
2843 if (g77_longint_type_node
!= NULL_TREE
)
2845 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2846 get_identifier ("__g77_longint"),
2847 g77_longint_type_node
));
2848 (*lang_hooks
.decls
.pushdecl
) (build_decl (TYPE_DECL
,
2849 get_identifier ("__g77_ulongint"),
2850 g77_ulongint_type_node
));
2853 record_builtin_type (RID_VOID
, NULL
, void_type_node
);
2855 void_zero_node
= build_int_2 (0, 0);
2856 TREE_TYPE (void_zero_node
) = void_type_node
;
2858 void_list_node
= build_void_list_node ();
2860 /* Make a type to be the domain of a few array types
2861 whose domains don't really matter.
2862 200 is small enough that it always fits in size_t
2863 and large enough that it can hold most function names for the
2864 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2865 array_domain_type
= build_index_type (size_int (200));
2867 /* Make a type for arrays of characters.
2868 With luck nothing will ever really depend on the length of this
2870 char_array_type_node
2871 = build_array_type (char_type_node
, array_domain_type
);
2873 /* Likewise for arrays of ints. */
2875 = build_array_type (integer_type_node
, array_domain_type
);
2877 string_type_node
= build_pointer_type (char_type_node
);
2878 const_string_type_node
2879 = build_pointer_type (build_qualified_type
2880 (char_type_node
, TYPE_QUAL_CONST
));
2882 (*targetm
.init_builtins
) ();
2884 /* This is special for C++ so functions can be overloaded. */
2885 wchar_type_node
= get_identifier (MODIFIED_WCHAR_TYPE
);
2886 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2887 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2888 if (c_language
== clk_cplusplus
)
2890 if (TREE_UNSIGNED (wchar_type_node
))
2891 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2893 wchar_type_node
= make_signed_type (wchar_type_size
);
2894 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2898 signed_wchar_type_node
= c_common_signed_type (wchar_type_node
);
2899 unsigned_wchar_type_node
= c_common_unsigned_type (wchar_type_node
);
2902 /* This is for wide string constants. */
2903 wchar_array_type_node
2904 = build_array_type (wchar_type_node
, array_domain_type
);
2907 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2910 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2912 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2914 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2916 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2917 unsigned_ptrdiff_type_node
= c_common_unsigned_type (ptrdiff_type_node
);
2919 (*lang_hooks
.decls
.pushdecl
)
2920 (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2921 va_list_type_node
));
2923 (*lang_hooks
.decls
.pushdecl
)
2924 (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2925 ptrdiff_type_node
));
2927 (*lang_hooks
.decls
.pushdecl
)
2928 (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2931 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2933 va_list_arg_type_node
= va_list_ref_type_node
=
2934 build_pointer_type (TREE_TYPE (va_list_type_node
));
2938 va_list_arg_type_node
= va_list_type_node
;
2939 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2942 #define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
2943 builtin_types[(int) ENUM] = VALUE;
2944 #define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
2945 builtin_types[(int) ENUM] \
2946 = build_function_type (builtin_types[(int) RETURN], \
2948 #define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
2949 builtin_types[(int) ENUM] \
2950 = build_function_type (builtin_types[(int) RETURN], \
2951 tree_cons (NULL_TREE, \
2952 builtin_types[(int) ARG1], \
2954 #define DEF_FUNCTION_TYPE_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_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
2964 builtin_types[(int) ENUM] \
2965 = build_function_type \
2966 (builtin_types[(int) RETURN], \
2967 tree_cons (NULL_TREE, \
2968 builtin_types[(int) ARG1], \
2969 tree_cons (NULL_TREE, \
2970 builtin_types[(int) ARG2], \
2971 tree_cons (NULL_TREE, \
2972 builtin_types[(int) ARG3], \
2974 #define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
2975 builtin_types[(int) ENUM] \
2976 = build_function_type \
2977 (builtin_types[(int) RETURN], \
2978 tree_cons (NULL_TREE, \
2979 builtin_types[(int) ARG1], \
2980 tree_cons (NULL_TREE, \
2981 builtin_types[(int) ARG2], \
2984 builtin_types[(int) ARG3], \
2985 tree_cons (NULL_TREE, \
2986 builtin_types[(int) ARG4], \
2987 void_list_node)))));
2988 #define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
2989 builtin_types[(int) ENUM] \
2990 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
2991 #define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
2992 builtin_types[(int) ENUM] \
2993 = build_function_type (builtin_types[(int) RETURN], \
2994 tree_cons (NULL_TREE, \
2995 builtin_types[(int) ARG1], \
2998 #define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
2999 builtin_types[(int) ENUM] \
3000 = build_function_type \
3001 (builtin_types[(int) RETURN], \
3002 tree_cons (NULL_TREE, \
3003 builtin_types[(int) ARG1], \
3004 tree_cons (NULL_TREE, \
3005 builtin_types[(int) ARG2], \
3007 #define DEF_POINTER_TYPE(ENUM, TYPE) \
3008 builtin_types[(int) ENUM] \
3009 = build_pointer_type (builtin_types[(int) TYPE]);
3010 #include "builtin-types.def"
3011 #undef DEF_PRIMITIVE_TYPE
3012 #undef DEF_FUNCTION_TYPE_1
3013 #undef DEF_FUNCTION_TYPE_2
3014 #undef DEF_FUNCTION_TYPE_3
3015 #undef DEF_FUNCTION_TYPE_4
3016 #undef DEF_FUNCTION_TYPE_VAR_0
3017 #undef DEF_FUNCTION_TYPE_VAR_1
3018 #undef DEF_POINTER_TYPE
3020 #define DEF_BUILTIN(ENUM, NAME, CLASS, \
3021 TYPE, LIBTYPE, BOTH_P, FALLBACK_P, NONANSI_P) \
3026 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3030 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3033 ? (NAME + strlen ("__builtin_")) \
3036 decl = builtin_function_2 (NAME, \
3037 NAME + strlen ("__builtin_"), \
3038 builtin_types[TYPE], \
3039 builtin_types[LIBTYPE], \
3044 /*noreturn_p=*/0); \
3046 built_in_decls[(int) ENUM] = decl; \
3048 #include "builtins.def"
3051 /* Declare _exit and _Exit just to mark them as non-returning. */
3052 builtin_function_2 (NULL
, "_exit", NULL_TREE
,
3053 builtin_types
[BT_FN_VOID_INT
],
3054 0, NOT_BUILT_IN
, 0, 1, 1);
3055 builtin_function_2 (NULL
, "_Exit", NULL_TREE
,
3056 builtin_types
[BT_FN_VOID_INT
],
3057 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
3059 /* Declare these functions non-returning
3060 to avoid spurious "control drops through" warnings. */
3061 builtin_function_2 (NULL
, "abort",
3062 NULL_TREE
, ((c_language
== clk_cplusplus
)
3063 ? builtin_types
[BT_FN_VOID
]
3064 : builtin_types
[BT_FN_VOID_VAR
]),
3065 0, NOT_BUILT_IN
, 0, 0, 1);
3067 builtin_function_2 (NULL
, "exit",
3068 NULL_TREE
, ((c_language
== clk_cplusplus
)
3069 ? builtin_types
[BT_FN_VOID_INT
]
3070 : builtin_types
[BT_FN_VOID_VAR
]),
3071 0, NOT_BUILT_IN
, 0, 0, 1);
3073 main_identifier_node
= get_identifier ("main");
3077 build_va_arg (expr
, type
)
3080 return build1 (VA_ARG_EXPR
, type
, expr
);
3084 /* Linked list of disabled built-in functions. */
3086 typedef struct disabled_builtin
3089 struct disabled_builtin
*next
;
3091 static disabled_builtin
*disabled_builtins
= NULL
;
3093 static bool builtin_function_disabled_p
PARAMS ((const char *));
3095 /* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3096 begins with "__builtin_", give an error. */
3099 disable_builtin_function (name
)
3102 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
3103 error ("cannot disable built-in function `%s'", name
);
3106 disabled_builtin
*new = xmalloc (sizeof (disabled_builtin
));
3108 new->next
= disabled_builtins
;
3109 disabled_builtins
= new;
3114 /* Return true if the built-in function NAME has been disabled, false
3118 builtin_function_disabled_p (name
)
3121 disabled_builtin
*p
;
3122 for (p
= disabled_builtins
; p
!= NULL
; p
= p
->next
)
3124 if (strcmp (name
, p
->name
) == 0)
3131 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3132 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3133 of these may be NULL (though both being NULL is useless).
3134 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3135 TYPE is the type of the function with the ordinary name. These
3136 may differ if the ordinary name is declared with a looser type to avoid
3137 conflicts with headers. FUNCTION_CODE and CLASS are as for
3138 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3139 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3140 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3141 NORETURN_P is nonzero, the function is marked as non-returning.
3142 Returns the declaration of BUILTIN_NAME, if any, otherwise
3143 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3144 or if NONANSI_P and flag_no_nonansi_builtin. */
3147 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3148 class, library_name_p
, nonansi_p
, noreturn_p
)
3149 const char *builtin_name
;
3154 enum built_in_class
class;
3159 tree bdecl
= NULL_TREE
;
3160 tree decl
= NULL_TREE
;
3161 if (builtin_name
!= 0)
3163 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3164 class, library_name_p
? name
: NULL
);
3167 TREE_THIS_VOLATILE (bdecl
) = 1;
3168 TREE_SIDE_EFFECTS (bdecl
) = 1;
3171 if (name
!= 0 && !flag_no_builtin
&& !builtin_function_disabled_p (name
)
3172 && !(nonansi_p
&& flag_no_nonansi_builtin
))
3174 decl
= builtin_function (name
, type
, function_code
, class, NULL
);
3176 DECL_BUILT_IN_NONANSI (decl
) = 1;
3179 TREE_THIS_VOLATILE (decl
) = 1;
3180 TREE_SIDE_EFFECTS (decl
) = 1;
3183 return (bdecl
!= 0 ? bdecl
: decl
);
3186 /* Nonzero if the type T promotes to int. This is (nearly) the
3187 integral promotions defined in ISO C99 6.3.1.1/2. */
3190 c_promoting_integer_type_p (t
)
3193 switch (TREE_CODE (t
))
3196 return (TYPE_MAIN_VARIANT (t
) == char_type_node
3197 || TYPE_MAIN_VARIANT (t
) == signed_char_type_node
3198 || TYPE_MAIN_VARIANT (t
) == unsigned_char_type_node
3199 || TYPE_MAIN_VARIANT (t
) == short_integer_type_node
3200 || TYPE_MAIN_VARIANT (t
) == short_unsigned_type_node
3201 || TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
));
3204 /* ??? Technically all enumerations not larger than an int
3205 promote to an int. But this is used along code paths
3206 that only want to notice a size change. */
3207 return TYPE_PRECISION (t
) < TYPE_PRECISION (integer_type_node
);
3217 /* Return 1 if PARMS specifies a fixed number of parameters
3218 and none of their types is affected by default promotions. */
3221 self_promoting_args_p (parms
)
3225 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3227 tree type
= TREE_VALUE (t
);
3229 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3235 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3238 if (c_promoting_integer_type_p (type
))
3244 /* Recursively examines the array elements of TYPE, until a non-array
3245 element type is found. */
3248 strip_array_types (type
)
3251 while (TREE_CODE (type
) == ARRAY_TYPE
)
3252 type
= TREE_TYPE (type
);
3257 static tree expand_unordered_cmp
PARAMS ((tree
, tree
, enum tree_code
,
3260 /* Expand a call to an unordered comparison function such as
3261 __builtin_isgreater(). FUNCTION is the function's declaration and
3262 PARAMS a list of the values passed. For __builtin_isunordered(),
3263 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3264 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3265 that give the opposite of the desired result. UNORDERED_CODE is
3266 used for modes that can hold NaNs and ORDERED_CODE is used for the
3270 expand_unordered_cmp (function
, params
, unordered_code
, ordered_code
)
3271 tree function
, params
;
3272 enum tree_code unordered_code
, ordered_code
;
3274 tree arg0
, arg1
, type
;
3275 enum tree_code code0
, code1
;
3277 /* Check that we have exactly two arguments. */
3278 if (params
== 0 || TREE_CHAIN (params
) == 0)
3280 error ("too few arguments to function `%s'",
3281 IDENTIFIER_POINTER (DECL_NAME (function
)));
3282 return error_mark_node
;
3284 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3286 error ("too many arguments to function `%s'",
3287 IDENTIFIER_POINTER (DECL_NAME (function
)));
3288 return error_mark_node
;
3291 arg0
= TREE_VALUE (params
);
3292 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3294 code0
= TREE_CODE (TREE_TYPE (arg0
));
3295 code1
= TREE_CODE (TREE_TYPE (arg1
));
3297 /* Make sure that the arguments have a common type of REAL. */
3299 if ((code0
== INTEGER_TYPE
|| code0
== REAL_TYPE
)
3300 && (code1
== INTEGER_TYPE
|| code1
== REAL_TYPE
))
3301 type
= common_type (TREE_TYPE (arg0
), TREE_TYPE (arg1
));
3303 if (type
== 0 || TREE_CODE (type
) != REAL_TYPE
)
3305 error ("non-floating-point argument to function `%s'",
3306 IDENTIFIER_POINTER (DECL_NAME (function
)));
3307 return error_mark_node
;
3310 if (unordered_code
== UNORDERED_EXPR
)
3312 if (MODE_HAS_NANS (TYPE_MODE (type
)))
3313 return build_binary_op (unordered_code
,
3314 convert (type
, arg0
),
3315 convert (type
, arg1
),
3318 return integer_zero_node
;
3321 return build_unary_op (TRUTH_NOT_EXPR
,
3322 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type
))
3325 convert (type
, arg0
),
3326 convert (type
, arg1
),
3332 /* Recognize certain built-in functions so we can make tree-codes
3333 other than CALL_EXPR. We do this when it enables fold-const.c
3334 to do something useful. */
3335 /* ??? By rights this should go in builtins.c, but only C and C++
3336 implement build_{binary,unary}_op. Not exactly sure what bits
3337 of functionality are actually needed from those functions, or
3338 where the similar functionality exists in the other front ends. */
3341 expand_tree_builtin (function
, params
, coerced_params
)
3342 tree function
, params
, coerced_params
;
3344 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3347 switch (DECL_FUNCTION_CODE (function
))
3351 case BUILT_IN_LLABS
:
3352 case BUILT_IN_IMAXABS
:
3354 case BUILT_IN_FABSL
:
3355 case BUILT_IN_FABSF
:
3356 if (coerced_params
== 0)
3357 return integer_zero_node
;
3358 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3361 case BUILT_IN_CONJF
:
3362 case BUILT_IN_CONJL
:
3363 if (coerced_params
== 0)
3364 return integer_zero_node
;
3365 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3367 case BUILT_IN_CREAL
:
3368 case BUILT_IN_CREALF
:
3369 case BUILT_IN_CREALL
:
3370 if (coerced_params
== 0)
3371 return integer_zero_node
;
3372 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3374 case BUILT_IN_CIMAG
:
3375 case BUILT_IN_CIMAGF
:
3376 case BUILT_IN_CIMAGL
:
3377 if (coerced_params
== 0)
3378 return integer_zero_node
;
3379 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3381 case BUILT_IN_ISGREATER
:
3382 return expand_unordered_cmp (function
, params
, UNLE_EXPR
, LE_EXPR
);
3384 case BUILT_IN_ISGREATEREQUAL
:
3385 return expand_unordered_cmp (function
, params
, UNLT_EXPR
, LT_EXPR
);
3387 case BUILT_IN_ISLESS
:
3388 return expand_unordered_cmp (function
, params
, UNGE_EXPR
, GE_EXPR
);
3390 case BUILT_IN_ISLESSEQUAL
:
3391 return expand_unordered_cmp (function
, params
, UNGT_EXPR
, GT_EXPR
);
3393 case BUILT_IN_ISLESSGREATER
:
3394 return expand_unordered_cmp (function
, params
, UNEQ_EXPR
, EQ_EXPR
);
3396 case BUILT_IN_ISUNORDERED
:
3397 return expand_unordered_cmp (function
, params
, UNORDERED_EXPR
, NOP_EXPR
);
3406 /* Returns non-zero if CODE is the code for a statement. */
3409 statement_code_p (code
)
3410 enum tree_code code
;
3435 if (lang_statement_code_p
)
3436 return (*lang_statement_code_p
) (code
);
3441 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3442 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3443 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3444 value, the traversal is aborted, and the value returned by FUNC is
3445 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3446 the node being visited are not walked.
3448 We don't need a without_duplicates variant of this one because the
3449 statement tree is a tree, not a graph. */
3452 walk_stmt_tree (tp
, func
, data
)
3457 enum tree_code code
;
3462 #define WALK_SUBTREE(NODE) \
3465 result = walk_stmt_tree (&(NODE), func, data); \
3471 /* Skip empty subtrees. */
3475 /* Skip subtrees below non-statement nodes. */
3476 if (!statement_code_p (TREE_CODE (*tp
)))
3479 /* Call the function. */
3481 result
= (*func
) (tp
, &walk_subtrees
, data
);
3483 /* If we found something, return it. */
3487 /* FUNC may have modified the tree, recheck that we're looking at a
3489 code
= TREE_CODE (*tp
);
3490 if (!statement_code_p (code
))
3493 /* Visit the subtrees unless FUNC decided that there was nothing
3494 interesting below this point in the tree. */
3497 /* Walk over all the sub-trees of this operand. Statement nodes
3498 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3499 len
= TREE_CODE_LENGTH (code
);
3501 /* Go through the subtrees. We need to do this in forward order so
3502 that the scope of a FOR_EXPR is handled properly. */
3503 for (i
= 0; i
< len
; ++i
)
3504 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3507 /* Finally visit the chain. This can be tail-recursion optimized if
3508 we write it this way. */
3509 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3514 /* Used to compare case labels. K1 and K2 are actually tree nodes
3515 representing case labels, or NULL_TREE for a `default' label.
3516 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3517 K2, and 0 if K1 and K2 are equal. */
3520 case_compare (k1
, k2
)
3524 /* Consider a NULL key (such as arises with a `default' label) to be
3525 smaller than anything else. */
3531 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3534 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3535 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3536 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3537 case label was declared using the usual C/C++ syntax, rather than
3538 the GNU case range extension. CASES is a tree containing all the
3539 case ranges processed so far; COND is the condition for the
3540 switch-statement itself. Returns the CASE_LABEL created, or
3541 ERROR_MARK_NODE if no CASE_LABEL is created. */
3544 c_add_case_label (cases
, cond
, low_value
, high_value
)
3553 splay_tree_node node
;
3555 /* Create the LABEL_DECL itself. */
3556 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3557 DECL_CONTEXT (label
) = current_function_decl
;
3559 /* If there was an error processing the switch condition, bail now
3560 before we get more confused. */
3561 if (!cond
|| cond
== error_mark_node
)
3563 /* Add a label anyhow so that the back-end doesn't think that
3564 the beginning of the switch is unreachable. */
3566 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3567 return error_mark_node
;
3570 if ((low_value
&& TREE_TYPE (low_value
)
3571 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3572 || (high_value
&& TREE_TYPE (high_value
)
3573 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3574 error ("pointers are not permitted as case values");
3576 /* Case ranges are a GNU extension. */
3577 if (high_value
&& pedantic
)
3579 if (c_language
== clk_cplusplus
)
3580 pedwarn ("ISO C++ forbids range expressions in switch statements");
3582 pedwarn ("ISO C forbids range expressions in switch statements");
3585 type
= TREE_TYPE (cond
);
3588 low_value
= check_case_value (low_value
);
3589 low_value
= convert_and_check (type
, low_value
);
3593 high_value
= check_case_value (high_value
);
3594 high_value
= convert_and_check (type
, high_value
);
3597 /* If an error has occurred, bail out now. */
3598 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3601 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3602 return error_mark_node
;
3605 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3606 really a case range, even though it was written that way. Remove
3607 the HIGH_VALUE to simplify later processing. */
3608 if (tree_int_cst_equal (low_value
, high_value
))
3609 high_value
= NULL_TREE
;
3610 if (low_value
&& high_value
3611 && !tree_int_cst_lt (low_value
, high_value
))
3612 warning ("empty range specified");
3614 /* Look up the LOW_VALUE in the table of case labels we already
3616 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3617 /* If there was not an exact match, check for overlapping ranges.
3618 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3619 that's a `default' label and the only overlap is an exact match. */
3620 if (!node
&& (low_value
|| high_value
))
3622 splay_tree_node low_bound
;
3623 splay_tree_node high_bound
;
3625 /* Even though there wasn't an exact match, there might be an
3626 overlap between this case range and another case range.
3627 Since we've (inductively) not allowed any overlapping case
3628 ranges, we simply need to find the greatest low case label
3629 that is smaller that LOW_VALUE, and the smallest low case
3630 label that is greater than LOW_VALUE. If there is an overlap
3631 it will occur in one of these two ranges. */
3632 low_bound
= splay_tree_predecessor (cases
,
3633 (splay_tree_key
) low_value
);
3634 high_bound
= splay_tree_successor (cases
,
3635 (splay_tree_key
) low_value
);
3637 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3638 the LOW_VALUE, so there is no need to check unless the
3639 LOW_BOUND is in fact itself a case range. */
3641 && CASE_HIGH ((tree
) low_bound
->value
)
3642 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3645 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3646 range is bigger than the low end of the current range, so we
3647 are only interested if the current range is a real range, and
3648 not an ordinary case label. */
3651 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3656 /* If there was an overlap, issue an error. */
3659 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3663 error ("duplicate (or overlapping) case value");
3664 error_with_decl (duplicate
,
3665 "this is the first entry overlapping that value");
3669 error ("duplicate case value") ;
3670 error_with_decl (duplicate
, "previously used here");
3674 error ("multiple default labels in one switch");
3675 error_with_decl (duplicate
, "this is the first default label");
3678 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3681 /* Add a CASE_LABEL to the statement-tree. */
3682 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
3683 /* Register this case label in the splay tree. */
3684 splay_tree_insert (cases
,
3685 (splay_tree_key
) low_value
,
3686 (splay_tree_value
) case_label
);
3691 /* Finish an expression taking the address of LABEL. Returns an
3692 expression for the address. */
3695 finish_label_address_expr (label
)
3702 if (c_language
== clk_cplusplus
)
3703 pedwarn ("ISO C++ forbids taking the address of a label");
3705 pedwarn ("ISO C forbids taking the address of a label");
3708 label
= lookup_label (label
);
3709 if (label
== NULL_TREE
)
3710 result
= null_pointer_node
;
3713 TREE_USED (label
) = 1;
3714 result
= build1 (ADDR_EXPR
, ptr_type_node
, label
);
3715 TREE_CONSTANT (result
) = 1;
3716 /* The current function in not necessarily uninlinable.
3717 Computed gotos are incompatible with inlining, but the value
3718 here could be used only in a diagnostic, for example. */
3724 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
3725 parameter allows this function to be used as a GC-marking
3732 stmt_tree st
= (stmt_tree
) p
;
3734 ggc_mark_tree (st
->x_last_stmt
);
3735 ggc_mark_tree (st
->x_last_expr_type
);
3738 /* Mark LD for GC. */
3741 c_mark_lang_decl (c
)
3742 struct c_lang_decl
*c ATTRIBUTE_UNUSED
;
3746 /* Mark F for GC. */
3749 mark_c_language_function (f
)
3750 struct language_function
*f
;
3755 mark_stmt_tree (&f
->x_stmt_tree
);
3756 ggc_mark_tree (f
->x_scope_stmt_stack
);
3759 /* Hook used by expand_expr to expand language-specific tree codes. */
3762 c_expand_expr (exp
, target
, tmode
, modifier
)
3765 enum machine_mode tmode
;
3766 int modifier
; /* Actually enum_modifier. */
3768 switch (TREE_CODE (exp
))
3774 bool preserve_result
= false;
3776 /* Since expand_expr_stmt calls free_temp_slots after every
3777 expression statement, we must call push_temp_slots here.
3778 Otherwise, any temporaries in use now would be considered
3779 out-of-scope after the first EXPR_STMT from within the
3782 rtl_expr
= expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp
));
3784 /* If we want the result of this expression, find the last
3785 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
3786 if (target
!= const0_rtx
3787 && TREE_CODE (STMT_EXPR_STMT (exp
)) == COMPOUND_STMT
3788 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp
))) == SCOPE_STMT
)
3790 tree expr
= COMPOUND_BODY (STMT_EXPR_STMT (exp
));
3791 tree last
= TREE_CHAIN (expr
);
3793 while (TREE_CHAIN (last
))
3796 last
= TREE_CHAIN (last
);
3799 if (TREE_CODE (last
) == SCOPE_STMT
3800 && TREE_CODE (expr
) == EXPR_STMT
)
3802 TREE_ADDRESSABLE (expr
) = 1;
3803 preserve_result
= true;
3807 expand_stmt (STMT_EXPR_STMT (exp
));
3808 expand_end_stmt_expr (rtl_expr
);
3810 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
3811 if (preserve_result
&& GET_CODE (result
) == MEM
)
3813 if (GET_MODE (result
) != BLKmode
)
3814 result
= copy_to_reg (result
);
3816 preserve_temp_slots (result
);
3819 /* If the statment-expression does not have a scope, then the
3820 new temporaries we created within it must live beyond the
3821 statement-expression. */
3822 if (STMT_EXPR_NO_SCOPE (exp
))
3823 preserve_temp_slots (NULL_RTX
);
3832 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
3833 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3835 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3836 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
3837 == BUILT_IN_FRONTEND
))
3838 return c_expand_builtin (exp
, target
, tmode
, modifier
);
3844 case COMPOUND_LITERAL_EXPR
:
3846 /* Initialize the anonymous variable declared in the compound
3847 literal, then return the variable. */
3848 tree decl
= COMPOUND_LITERAL_EXPR_DECL (exp
);
3849 emit_local_var (decl
);
3850 return expand_expr (decl
, target
, tmode
, modifier
);
3861 /* Hook used by safe_from_p to handle language-specific tree codes. */
3864 c_safe_from_p (target
, exp
)
3868 /* We can see statements here when processing the body of a
3869 statement-expression. For a declaration statement declaring a
3870 variable, look at the variable's initializer. */
3871 if (TREE_CODE (exp
) == DECL_STMT
)
3873 tree decl
= DECL_STMT_DECL (exp
);
3875 if (TREE_CODE (decl
) == VAR_DECL
3876 && DECL_INITIAL (decl
)
3877 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
3881 /* For any statement, we must follow the statement-chain. */
3882 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
3883 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
3885 /* Assume everything else is safe. */
3889 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
3892 c_common_unsafe_for_reeval (exp
)
3895 /* Statement expressions may not be reevaluated, likewise compound
3897 if (TREE_CODE (exp
) == STMT_EXPR
3898 || TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
)
3901 /* Walk all other expressions. */
3905 /* Hook used by staticp to handle language-specific tree codes. */
3911 if (TREE_CODE (exp
) == COMPOUND_LITERAL_EXPR
3912 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp
)))
3917 #define CALLED_AS_BUILT_IN(NODE) \
3918 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
3921 c_expand_builtin (exp
, target
, tmode
, modifier
)
3924 enum machine_mode tmode
;
3925 enum expand_modifier modifier
;
3927 tree type
= TREE_TYPE (exp
);
3928 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
3929 tree arglist
= TREE_OPERAND (exp
, 1);
3930 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
3931 enum tree_code code
= TREE_CODE (exp
);
3932 const int ignore
= (target
== const0_rtx
3933 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
3934 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
3935 || code
== COND_EXPR
)
3936 && TREE_CODE (type
) == VOID_TYPE
));
3938 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
3939 return expand_call (exp
, target
, ignore
);
3943 case BUILT_IN_PRINTF
:
3944 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3945 modifier
, ignore
, /*unlocked=*/ 0);
3950 case BUILT_IN_PRINTF_UNLOCKED
:
3951 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
3952 modifier
, ignore
, /*unlocked=*/ 1);
3957 case BUILT_IN_FPRINTF
:
3958 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3959 modifier
, ignore
, /*unlocked=*/ 0);
3964 case BUILT_IN_FPRINTF_UNLOCKED
:
3965 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
3966 modifier
, ignore
, /*unlocked=*/ 1);
3971 default: /* just do library call, if unknown builtin */
3972 error ("built-in function `%s' not currently supported",
3973 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
3976 /* The switch statement above can drop through to cause the function
3977 to be called normally. */
3978 return expand_call (exp
, target
, ignore
);
3981 /* Check an arglist to *printf for problems. The arglist should start
3982 at the format specifier, with the remaining arguments immediately
3985 is_valid_printf_arglist (arglist
)
3988 /* Save this value so we can restore it later. */
3989 const int SAVE_pedantic
= pedantic
;
3990 int diagnostic_occurred
= 0;
3993 /* Set this to a known value so the user setting won't affect code
3996 /* Check to make sure there are no format specifier errors. */
3997 attrs
= tree_cons (get_identifier ("format"),
3998 tree_cons (NULL_TREE
,
3999 get_identifier ("printf"),
4000 tree_cons (NULL_TREE
,
4002 tree_cons (NULL_TREE
,
4006 check_function_format (&diagnostic_occurred
, attrs
, arglist
);
4008 /* Restore the value of `pedantic'. */
4009 pedantic
= SAVE_pedantic
;
4011 /* If calling `check_function_format_ptr' produces a warning, we
4012 return false, otherwise we return true. */
4013 return ! diagnostic_occurred
;
4016 /* If the arguments passed to printf are suitable for optimizations,
4017 we attempt to transform the call. */
4019 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4022 enum machine_mode tmode
;
4023 enum expand_modifier modifier
;
4027 tree fn_putchar
= unlocked
?
4028 built_in_decls
[BUILT_IN_PUTCHAR_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTCHAR
];
4029 tree fn_puts
= unlocked
?
4030 built_in_decls
[BUILT_IN_PUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_PUTS
];
4031 tree fn
, format_arg
, stripped_string
;
4033 /* If the return value is used, or the replacement _DECL isn't
4034 initialized, don't do the transformation. */
4035 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4038 /* Verify the required arguments in the original call. */
4040 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4043 /* Check the specifier vs. the parameters. */
4044 if (!is_valid_printf_arglist (arglist
))
4047 format_arg
= TREE_VALUE (arglist
);
4048 stripped_string
= format_arg
;
4049 STRIP_NOPS (stripped_string
);
4050 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4051 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4053 /* If the format specifier isn't a STRING_CST, punt. */
4054 if (TREE_CODE (stripped_string
) != STRING_CST
)
4057 /* OK! We can attempt optimization. */
4059 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4060 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4062 arglist
= TREE_CHAIN (arglist
);
4065 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4066 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4068 arglist
= TREE_CHAIN (arglist
);
4073 /* We can't handle anything else with % args or %% ... yet. */
4074 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4077 /* If the resulting constant string has a length of 1, call
4078 putchar. Note, TREE_STRING_LENGTH includes the terminating
4079 NULL in its count. */
4080 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4082 /* Given printf("c"), (where c is any one character,)
4083 convert "c"[0] to an int and pass that to the replacement
4085 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4086 arglist
= build_tree_list (NULL_TREE
, arglist
);
4090 /* If the resulting constant was "string\n", call
4091 __builtin_puts("string"). Ensure "string" has at least one
4092 character besides the trailing \n. Note, TREE_STRING_LENGTH
4093 includes the terminating NULL in its count. */
4094 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4095 && TREE_STRING_POINTER (stripped_string
)
4096 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4098 /* Create a NULL-terminated string that's one char shorter
4099 than the original, stripping off the trailing '\n'. */
4100 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4101 char *newstr
= (char *) alloca (newlen
);
4102 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4103 newstr
[newlen
- 1] = 0;
4105 arglist
= fix_string_type (build_string (newlen
, newstr
));
4106 arglist
= build_tree_list (NULL_TREE
, arglist
);
4110 /* We'd like to arrange to call fputs(string) here, but we
4111 need stdout and don't have a way to get it ... yet. */
4115 return expand_expr (build_function_call (fn
, arglist
),
4116 (ignore
? const0_rtx
: target
),
4120 /* If the arguments passed to fprintf are suitable for optimizations,
4121 we attempt to transform the call. */
4123 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
, unlocked
)
4126 enum machine_mode tmode
;
4127 enum expand_modifier modifier
;
4131 tree fn_fputc
= unlocked
?
4132 built_in_decls
[BUILT_IN_FPUTC_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTC
];
4133 tree fn_fputs
= unlocked
?
4134 built_in_decls
[BUILT_IN_FPUTS_UNLOCKED
] : built_in_decls
[BUILT_IN_FPUTS
];
4135 tree fn
, format_arg
, stripped_string
;
4137 /* If the return value is used, or the replacement _DECL isn't
4138 initialized, don't do the transformation. */
4139 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4142 /* Verify the required arguments in the original call. */
4144 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4145 || (TREE_CHAIN (arglist
) == 0)
4146 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4150 /* Check the specifier vs. the parameters. */
4151 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4154 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4155 stripped_string
= format_arg
;
4156 STRIP_NOPS (stripped_string
);
4157 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4158 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4160 /* If the format specifier isn't a STRING_CST, punt. */
4161 if (TREE_CODE (stripped_string
) != STRING_CST
)
4164 /* OK! We can attempt optimization. */
4166 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4167 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4169 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4170 arglist
= tree_cons (NULL_TREE
,
4171 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4175 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4176 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4178 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4179 arglist
= tree_cons (NULL_TREE
,
4180 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4186 /* We can't handle anything else with % args or %% ... yet. */
4187 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4190 /* When "string" doesn't contain %, replace all cases of
4191 fprintf(stream,string) with fputs(string,stream). The fputs
4192 builtin will take take of special cases like length==1. */
4193 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4194 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4198 return expand_expr (build_function_call (fn
, arglist
),
4199 (ignore
? const0_rtx
: target
),
4204 /* Given a boolean expression ARG, return a tree representing an increment
4205 or decrement (as indicated by CODE) of ARG. The front end must check for
4206 invalid cases (e.g., decrement in C++). */
4208 boolean_increment (code
, arg
)
4209 enum tree_code code
;
4213 tree true_res
= (c_language
== clk_cplusplus
4215 : c_bool_true_node
);
4216 arg
= stabilize_reference (arg
);
4219 case PREINCREMENT_EXPR
:
4220 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4222 case POSTINCREMENT_EXPR
:
4223 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4224 arg
= save_expr (arg
);
4225 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4226 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4228 case PREDECREMENT_EXPR
:
4229 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4231 case POSTDECREMENT_EXPR
:
4232 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4233 arg
= save_expr (arg
);
4234 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4235 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4240 TREE_SIDE_EFFECTS (val
) = 1;
4244 /* Handle C and C++ default attributes. */
4246 enum built_in_attribute
4248 #define DEF_ATTR_NULL_TREE(ENUM) ENUM,
4249 #define DEF_ATTR_INT(ENUM, VALUE) ENUM,
4250 #define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
4251 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
4252 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No entry needed in enum. */
4253 #include "builtin-attrs.def"
4254 #undef DEF_ATTR_NULL_TREE
4256 #undef DEF_ATTR_IDENT
4257 #undef DEF_ATTR_TREE_LIST
4262 static tree built_in_attributes
[(int) ATTR_LAST
];
4264 static bool c_attrs_initialized
= false;
4266 static void c_init_attributes
PARAMS ((void));
4268 /* Common initialization before parsing options. */
4270 c_common_init_options (lang
)
4271 enum c_language_kind lang
;
4274 parse_in
= cpp_create_reader (lang
== clk_c
|| lang
== clk_objective_c
4275 ? CLK_GNUC89
: CLK_GNUCXX
);
4276 if (lang
== clk_objective_c
)
4277 cpp_get_options (parse_in
)->objc
= 1;
4279 /* Mark as "unspecified" (see c_common_post_options). */
4280 flag_bounds_check
= -1;
4283 /* Post-switch processing. */
4285 c_common_post_options ()
4287 cpp_post_options (parse_in
);
4289 flag_inline_trees
= 1;
4291 /* Use tree inlining if possible. Function instrumentation is only
4292 done in the RTL level, so we disable tree inlining. */
4293 if (! flag_instrument_function_entry_exit
)
4295 if (!flag_no_inline
)
4297 if (flag_inline_functions
)
4299 flag_inline_trees
= 2;
4300 flag_inline_functions
= 0;
4304 /* If still "unspecified", make it match -fbounded-pointers. */
4305 if (flag_bounds_check
== -1)
4306 flag_bounds_check
= flag_bounded_pointers
;
4308 /* Special format checking options don't work without -Wformat; warn if
4310 if (warn_format_y2k
&& !warn_format
)
4311 warning ("-Wformat-y2k ignored without -Wformat");
4312 if (warn_format_extra_args
&& !warn_format
)
4313 warning ("-Wformat-extra-args ignored without -Wformat");
4314 if (warn_format_zero_length
&& !warn_format
)
4315 warning ("-Wformat-zero-length ignored without -Wformat");
4316 if (warn_format_nonliteral
&& !warn_format
)
4317 warning ("-Wformat-nonliteral ignored without -Wformat");
4318 if (warn_format_security
&& !warn_format
)
4319 warning ("-Wformat-security ignored without -Wformat");
4320 if (warn_missing_format_attribute
&& !warn_format
)
4321 warning ("-Wmissing-format-attribute ignored without -Wformat");
4324 /* Hook that registers front end and target-specific built-ins. */
4326 cb_register_builtins (pfile
)
4329 /* -undef turns off target-specific built-ins. */
4333 if (c_language
== clk_cplusplus
)
4335 if (SUPPORTS_ONE_ONLY
)
4336 cpp_define (pfile
, "__GXX_WEAK__=1");
4338 cpp_define (pfile
, "__GXX_WEAK__=0");
4341 /* libgcc needs to know this. */
4342 if (USING_SJLJ_EXCEPTIONS
)
4343 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
4345 /* stddef.h needs to know these. */
4346 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE
, 0);
4347 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE
, 0);
4348 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE
, 0);
4349 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE
, 0);
4351 /* For use in assembly language. */
4352 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
4353 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
4356 builtin_define_with_value ("__VERSION__", version_string
, 1);
4358 /* Other target-independent built-ins determined by command-line
4361 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
4363 cpp_define (pfile
, "__OPTIMIZE__");
4366 cpp_define (pfile
, "__STDC_HOSTED__=1");
4368 cpp_define (pfile
, "__STDC_HOSTED__=0");
4370 if (fast_math_flags_set_p ())
4371 cpp_define (pfile
, "__FAST_MATH__");
4373 cpp_define (pfile
, "__NO_INLINE__");
4375 /* A straightforward target hook doesn't work, because of problems
4376 linking that hook's body when part of non-C front ends. */
4377 TARGET_CPU_CPP_BUILTINS ();
4378 TARGET_OS_CPP_BUILTINS ();
4381 /* Pass an object-like macro. If it doesn't lie in the user's
4382 namespace, defines it unconditionally. Otherwise define a version
4383 with two leading underscores, and another version with two leading
4384 and trailing underscores, and define the original only if an ISO
4385 standard was not nominated.
4387 e.g. passing "unix" defines "__unix", "__unix__" and possibly
4388 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
4391 builtin_define_std (macro
)
4394 size_t len
= strlen (macro
);
4395 char *buff
= alloca (len
+ 5);
4399 /* prepend __ (or maybe just _) if in user's namespace. */
4400 memcpy (p
, macro
, len
+ 1);
4403 if (p
[1] != '_' && !ISUPPER (p
[1]))
4405 cpp_define (parse_in
, p
);
4407 /* If it was in user's namespace... */
4410 /* Define the original macro if permitted. */
4412 cpp_define (parse_in
, macro
);
4414 /* Define the macro with leading and following __. */
4420 cpp_define (parse_in
, p
);
4424 /* Pass an object-like macro and a value to define it to. The third
4425 parameter says whether or not to turn the value into a string
4428 builtin_define_with_value (macro
, expansion
, is_str
)
4430 const char *expansion
;
4434 size_t mlen
= strlen (macro
);
4435 size_t elen
= strlen (expansion
);
4436 size_t extra
= 2; /* space for an = and a NUL */
4439 extra
+= 2; /* space for two quote marks */
4441 buf
= alloca (mlen
+ elen
+ extra
);
4443 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
4445 sprintf (buf
, "%s=%s", macro
, expansion
);
4447 cpp_define (parse_in
, buf
);
4450 /* Front end initialization common to C, ObjC and C++. */
4452 c_common_init (filename
)
4453 const char *filename
;
4455 cpp_options
*options
= cpp_get_options (parse_in
);
4457 /* Set up preprocessor arithmetic. Must be done after call to
4458 c_common_nodes_and_builtins for wchar_type_node to be good. */
4459 options
->char_precision
= TYPE_PRECISION (char_type_node
);
4460 options
->int_precision
= TYPE_PRECISION (integer_type_node
);
4461 options
->wchar_precision
= TYPE_PRECISION (wchar_type_node
);
4462 options
->unsigned_wchar
= TREE_UNSIGNED (wchar_type_node
);
4463 /* This can be uncommented when 1) This all happens before
4464 cpp_post_options() (needed for __CHAR_UNSIGNED__ builtin), which
4465 in turn requires wchat_type_node to be set up properly by then,
4466 and 2) tradcpp is integrated, so that the preprocessors don't
4467 need to handle the command-line options and the specs in gcc.c
4470 options->unsigned_char = !flag_signed_char; */
4472 options
->warn_multichar
= warn_multichar
;
4473 options
->stdc_0_in_system_headers
= STDC_0_IN_SYSTEM_HEADERS
;
4475 /* Register preprocessor built-ins before calls to
4477 cpp_get_callbacks (parse_in
)->register_builtins
= cb_register_builtins
;
4479 /* NULL is passed up to toplev.c and we exit quickly. */
4480 if (flag_preprocess_only
)
4482 cpp_preprocess_file (parse_in
);
4486 /* Do this before initializing pragmas, as then cpplib's hash table
4488 filename
= init_c_lex (filename
);
4492 if (!c_attrs_initialized
)
4493 c_init_attributes ();
4498 /* Common finish hook for the C, ObjC and C++ front ends. */
4502 cpp_finish (parse_in
);
4504 /* For performance, avoid tearing down cpplib's internal structures.
4505 Call cpp_errors () instead of cpp_destroy (). */
4506 errorcount
+= cpp_errors (parse_in
);
4510 c_init_attributes ()
4512 /* Fill in the built_in_attributes array. */
4513 #define DEF_ATTR_NULL_TREE(ENUM) \
4514 built_in_attributes[(int) ENUM] = NULL_TREE;
4515 #define DEF_ATTR_INT(ENUM, VALUE) \
4516 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4517 #define DEF_ATTR_IDENT(ENUM, STRING) \
4518 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4519 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4520 built_in_attributes[(int) ENUM] \
4521 = tree_cons (built_in_attributes[(int) PURPOSE], \
4522 built_in_attributes[(int) VALUE], \
4523 built_in_attributes[(int) CHAIN]);
4524 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) /* No initialization needed. */
4525 #include "builtin-attrs.def"
4526 #undef DEF_ATTR_NULL_TREE
4528 #undef DEF_ATTR_IDENT
4529 #undef DEF_ATTR_TREE_LIST
4531 ggc_add_tree_root (built_in_attributes
, (int) ATTR_LAST
);
4532 c_attrs_initialized
= true;
4535 /* Depending on the name of DECL, apply default attributes to it. */
4538 c_common_insert_default_attributes (decl
)
4541 tree name
= DECL_NAME (decl
);
4543 if (!c_attrs_initialized
)
4544 c_init_attributes ();
4546 #define DEF_ATTR_NULL_TREE(ENUM) /* Nothing needed after initialization. */
4547 #define DEF_ATTR_INT(ENUM, VALUE)
4548 #define DEF_ATTR_IDENT(ENUM, STRING)
4549 #define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN)
4550 #define DEF_FN_ATTR(NAME, ATTRS, PREDICATE) \
4551 if ((PREDICATE) && name == built_in_attributes[(int) NAME]) \
4552 decl_attributes (&decl, built_in_attributes[(int) ATTRS], \
4553 ATTR_FLAG_BUILT_IN);
4554 #include "builtin-attrs.def"
4555 #undef DEF_ATTR_NULL_TREE
4557 #undef DEF_ATTR_IDENT
4558 #undef DEF_ATTR_TREE_LIST
4562 /* Output a -Wshadow warning MSGID about NAME, an IDENTIFIER_NODE, and
4563 additionally give the location of the previous declaration DECL. */
4565 shadow_warning (msgid
, name
, decl
)
4569 warning ("declaration of `%s' shadows %s", IDENTIFIER_POINTER (name
), msgid
);
4570 warning_with_file_and_line (DECL_SOURCE_FILE (decl
),
4571 DECL_SOURCE_LINE (decl
),
4572 "shadowed declaration is here");
4575 /* Attribute handlers common to C front ends. */
4577 /* Handle a "packed" attribute; arguments as in
4578 struct attribute_spec.handler. */
4581 handle_packed_attribute (node
, name
, args
, flags
, no_add_attrs
)
4584 tree args ATTRIBUTE_UNUSED
;
4591 if (TREE_CODE (*node
) == TYPE_DECL
)
4592 type
= &TREE_TYPE (*node
);
4599 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4600 *type
= build_type_copy (*type
);
4601 TYPE_PACKED (*type
) = 1;
4603 else if (TREE_CODE (*node
) == FIELD_DECL
)
4604 DECL_PACKED (*node
) = 1;
4605 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4606 used for DECL_REGISTER. It wouldn't mean anything anyway. */
4609 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4610 *no_add_attrs
= true;
4616 /* Handle a "nocommon" attribute; arguments as in
4617 struct attribute_spec.handler. */
4620 handle_nocommon_attribute (node
, name
, args
, flags
, no_add_attrs
)
4623 tree args ATTRIBUTE_UNUSED
;
4624 int flags ATTRIBUTE_UNUSED
;
4627 if (TREE_CODE (*node
) == VAR_DECL
)
4628 DECL_COMMON (*node
) = 0;
4631 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4632 *no_add_attrs
= true;
4638 /* Handle a "common" attribute; arguments as in
4639 struct attribute_spec.handler. */
4642 handle_common_attribute (node
, name
, args
, flags
, no_add_attrs
)
4645 tree args ATTRIBUTE_UNUSED
;
4646 int flags ATTRIBUTE_UNUSED
;
4649 if (TREE_CODE (*node
) == VAR_DECL
)
4650 DECL_COMMON (*node
) = 1;
4653 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4654 *no_add_attrs
= true;
4660 /* Handle a "noreturn" attribute; arguments as in
4661 struct attribute_spec.handler. */
4664 handle_noreturn_attribute (node
, name
, args
, flags
, no_add_attrs
)
4667 tree args ATTRIBUTE_UNUSED
;
4668 int flags ATTRIBUTE_UNUSED
;
4671 tree type
= TREE_TYPE (*node
);
4673 /* See FIXME comment in c_common_attribute_table. */
4674 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4675 TREE_THIS_VOLATILE (*node
) = 1;
4676 else if (TREE_CODE (type
) == POINTER_TYPE
4677 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4679 = build_pointer_type
4680 (build_type_variant (TREE_TYPE (type
),
4681 TREE_READONLY (TREE_TYPE (type
)), 1));
4684 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4685 *no_add_attrs
= true;
4691 /* Handle a "noinline" attribute; arguments as in
4692 struct attribute_spec.handler. */
4695 handle_noinline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4698 tree args ATTRIBUTE_UNUSED
;
4699 int flags ATTRIBUTE_UNUSED
;
4702 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4703 DECL_UNINLINABLE (*node
) = 1;
4706 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4707 *no_add_attrs
= true;
4713 /* Handle a "always_inline" attribute; arguments as in
4714 struct attribute_spec.handler. */
4717 handle_always_inline_attribute (node
, name
, args
, flags
, no_add_attrs
)
4720 tree args ATTRIBUTE_UNUSED
;
4721 int flags ATTRIBUTE_UNUSED
;
4724 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4726 /* Do nothing else, just set the attribute. We'll get at
4727 it later with lookup_attribute. */
4731 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4732 *no_add_attrs
= true;
4738 /* Handle a "used" attribute; arguments as in
4739 struct attribute_spec.handler. */
4742 handle_used_attribute (node
, name
, args
, flags
, no_add_attrs
)
4745 tree args ATTRIBUTE_UNUSED
;
4746 int flags ATTRIBUTE_UNUSED
;
4749 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4750 TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (*node
))
4751 = TREE_USED (*node
) = 1;
4754 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4755 *no_add_attrs
= true;
4761 /* Handle a "unused" attribute; arguments as in
4762 struct attribute_spec.handler. */
4765 handle_unused_attribute (node
, name
, args
, flags
, no_add_attrs
)
4768 tree args ATTRIBUTE_UNUSED
;
4776 if (TREE_CODE (decl
) == PARM_DECL
4777 || TREE_CODE (decl
) == VAR_DECL
4778 || TREE_CODE (decl
) == FUNCTION_DECL
4779 || TREE_CODE (decl
) == LABEL_DECL
4780 || TREE_CODE (decl
) == TYPE_DECL
)
4781 TREE_USED (decl
) = 1;
4784 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4785 *no_add_attrs
= true;
4790 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4791 *node
= build_type_copy (*node
);
4792 TREE_USED (*node
) = 1;
4798 /* Handle a "const" attribute; arguments as in
4799 struct attribute_spec.handler. */
4802 handle_const_attribute (node
, name
, args
, flags
, no_add_attrs
)
4805 tree args ATTRIBUTE_UNUSED
;
4806 int flags ATTRIBUTE_UNUSED
;
4809 tree type
= TREE_TYPE (*node
);
4811 /* See FIXME comment on noreturn in c_common_attribute_table. */
4812 if (TREE_CODE (*node
) == FUNCTION_DECL
)
4813 TREE_READONLY (*node
) = 1;
4814 else if (TREE_CODE (type
) == POINTER_TYPE
4815 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
4817 = build_pointer_type
4818 (build_type_variant (TREE_TYPE (type
), 1,
4819 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
4822 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4823 *no_add_attrs
= true;
4829 /* Handle a "transparent_union" attribute; arguments as in
4830 struct attribute_spec.handler. */
4833 handle_transparent_union_attribute (node
, name
, args
, flags
, no_add_attrs
)
4836 tree args ATTRIBUTE_UNUSED
;
4840 tree decl
= NULL_TREE
;
4847 type
= &TREE_TYPE (decl
);
4848 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
4850 else if (TYPE_P (*node
))
4851 type
= node
, is_type
= 1;
4854 && TREE_CODE (*type
) == UNION_TYPE
4856 || (TYPE_FIELDS (*type
) != 0
4857 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))))
4859 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
4860 *type
= build_type_copy (*type
);
4861 TYPE_TRANSPARENT_UNION (*type
) = 1;
4863 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
4864 && TREE_CODE (*type
) == UNION_TYPE
4865 && TYPE_MODE (*type
) == DECL_MODE (TYPE_FIELDS (*type
)))
4866 DECL_TRANSPARENT_UNION (decl
) = 1;
4869 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4870 *no_add_attrs
= true;
4876 /* Handle a "constructor" attribute; arguments as in
4877 struct attribute_spec.handler. */
4880 handle_constructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
4883 tree args ATTRIBUTE_UNUSED
;
4884 int flags ATTRIBUTE_UNUSED
;
4888 tree type
= TREE_TYPE (decl
);
4890 if (TREE_CODE (decl
) == FUNCTION_DECL
4891 && TREE_CODE (type
) == FUNCTION_TYPE
4892 && decl_function_context (decl
) == 0)
4894 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
4895 TREE_USED (decl
) = 1;
4899 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4900 *no_add_attrs
= true;
4906 /* Handle a "destructor" attribute; arguments as in
4907 struct attribute_spec.handler. */
4910 handle_destructor_attribute (node
, name
, args
, flags
, no_add_attrs
)
4913 tree args ATTRIBUTE_UNUSED
;
4914 int flags ATTRIBUTE_UNUSED
;
4918 tree type
= TREE_TYPE (decl
);
4920 if (TREE_CODE (decl
) == FUNCTION_DECL
4921 && TREE_CODE (type
) == FUNCTION_TYPE
4922 && decl_function_context (decl
) == 0)
4924 DECL_STATIC_DESTRUCTOR (decl
) = 1;
4925 TREE_USED (decl
) = 1;
4929 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4930 *no_add_attrs
= true;
4936 /* Handle a "mode" attribute; arguments as in
4937 struct attribute_spec.handler. */
4940 handle_mode_attribute (node
, name
, args
, flags
, no_add_attrs
)
4944 int flags ATTRIBUTE_UNUSED
;
4949 *no_add_attrs
= true;
4951 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
4952 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
4956 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
4957 int len
= strlen (p
);
4958 enum machine_mode mode
= VOIDmode
;
4961 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
4962 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
4964 char *newp
= (char *) alloca (len
- 1);
4966 strcpy (newp
, &p
[2]);
4967 newp
[len
- 4] = '\0';
4971 /* Change this type to have a type with the specified mode.
4972 First check for the special modes. */
4973 if (! strcmp (p
, "byte"))
4975 else if (!strcmp (p
, "word"))
4977 else if (! strcmp (p
, "pointer"))
4980 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
4981 if (!strcmp (p
, GET_MODE_NAME (j
)))
4982 mode
= (enum machine_mode
) j
;
4984 if (mode
== VOIDmode
)
4985 error ("unknown machine mode `%s'", p
);
4986 else if (0 == (typefm
= (*lang_hooks
.types
.type_for_mode
)
4987 (mode
, TREE_UNSIGNED (type
))))
4988 error ("no data type for mode `%s'", p
);
4991 /* No need to layout the type here. The caller should do this. */
4997 /* Handle a "section" attribute; arguments as in
4998 struct attribute_spec.handler. */
5001 handle_section_attribute (node
, name
, args
, flags
, no_add_attrs
)
5003 tree name ATTRIBUTE_UNUSED
;
5005 int flags ATTRIBUTE_UNUSED
;
5010 if (targetm
.have_named_sections
)
5012 if ((TREE_CODE (decl
) == FUNCTION_DECL
5013 || TREE_CODE (decl
) == VAR_DECL
)
5014 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
5016 if (TREE_CODE (decl
) == VAR_DECL
5017 && current_function_decl
!= NULL_TREE
5018 && ! TREE_STATIC (decl
))
5020 error_with_decl (decl
,
5021 "section attribute cannot be specified for local variables");
5022 *no_add_attrs
= true;
5025 /* The decl may have already been given a section attribute
5026 from a previous declaration. Ensure they match. */
5027 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
5028 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
5029 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
5031 error_with_decl (*node
,
5032 "section of `%s' conflicts with previous declaration");
5033 *no_add_attrs
= true;
5036 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
5040 error_with_decl (*node
,
5041 "section attribute not allowed for `%s'");
5042 *no_add_attrs
= true;
5047 error_with_decl (*node
,
5048 "section attributes are not supported for this target");
5049 *no_add_attrs
= true;
5055 /* Handle a "aligned" attribute; arguments as in
5056 struct attribute_spec.handler. */
5059 handle_aligned_attribute (node
, name
, args
, flags
, no_add_attrs
)
5061 tree name ATTRIBUTE_UNUSED
;
5066 tree decl
= NULL_TREE
;
5069 tree align_expr
= (args
? TREE_VALUE (args
)
5070 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
5076 type
= &TREE_TYPE (decl
);
5077 is_type
= TREE_CODE (*node
) == TYPE_DECL
;
5079 else if (TYPE_P (*node
))
5080 type
= node
, is_type
= 1;
5082 /* Strip any NOPs of any kind. */
5083 while (TREE_CODE (align_expr
) == NOP_EXPR
5084 || TREE_CODE (align_expr
) == CONVERT_EXPR
5085 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
5086 align_expr
= TREE_OPERAND (align_expr
, 0);
5088 if (TREE_CODE (align_expr
) != INTEGER_CST
)
5090 error ("requested alignment is not a constant");
5091 *no_add_attrs
= true;
5093 else if ((i
= tree_log2 (align_expr
)) == -1)
5095 error ("requested alignment is not a power of 2");
5096 *no_add_attrs
= true;
5098 else if (i
> HOST_BITS_PER_INT
- 2)
5100 error ("requested alignment is too large");
5101 *no_add_attrs
= true;
5105 /* If we have a TYPE_DECL, then copy the type, so that we
5106 don't accidentally modify a builtin type. See pushdecl. */
5107 if (decl
&& TREE_TYPE (decl
) != error_mark_node
5108 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
5110 tree tt
= TREE_TYPE (decl
);
5111 *type
= build_type_copy (*type
);
5112 DECL_ORIGINAL_TYPE (decl
) = tt
;
5113 TYPE_NAME (*type
) = decl
;
5114 TREE_USED (*type
) = TREE_USED (decl
);
5115 TREE_TYPE (decl
) = *type
;
5117 else if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5118 *type
= build_type_copy (*type
);
5120 TYPE_ALIGN (*type
) = (1 << i
) * BITS_PER_UNIT
;
5121 TYPE_USER_ALIGN (*type
) = 1;
5123 else if (TREE_CODE (decl
) != VAR_DECL
5124 && TREE_CODE (decl
) != FIELD_DECL
)
5126 error_with_decl (decl
,
5127 "alignment may not be specified for `%s'");
5128 *no_add_attrs
= true;
5132 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
5133 DECL_USER_ALIGN (decl
) = 1;
5139 /* Handle a "weak" attribute; arguments as in
5140 struct attribute_spec.handler. */
5143 handle_weak_attribute (node
, name
, args
, flags
, no_add_attrs
)
5145 tree name ATTRIBUTE_UNUSED
;
5146 tree args ATTRIBUTE_UNUSED
;
5147 int flags ATTRIBUTE_UNUSED
;
5148 bool *no_add_attrs ATTRIBUTE_UNUSED
;
5150 declare_weak (*node
);
5155 /* Handle an "alias" attribute; arguments as in
5156 struct attribute_spec.handler. */
5159 handle_alias_attribute (node
, name
, args
, flags
, no_add_attrs
)
5163 int flags ATTRIBUTE_UNUSED
;
5168 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
5169 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
5171 error_with_decl (decl
,
5172 "`%s' defined both normally and as an alias");
5173 *no_add_attrs
= true;
5175 else if (decl_function_context (decl
) == 0)
5179 id
= TREE_VALUE (args
);
5180 if (TREE_CODE (id
) != STRING_CST
)
5182 error ("alias arg not a string");
5183 *no_add_attrs
= true;
5186 id
= get_identifier (TREE_STRING_POINTER (id
));
5187 /* This counts as a use of the object pointed to. */
5190 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5191 DECL_INITIAL (decl
) = error_mark_node
;
5193 DECL_EXTERNAL (decl
) = 0;
5197 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5198 *no_add_attrs
= true;
5204 /* Handle an "visibility" attribute; arguments as in
5205 struct attribute_spec.handler. */
5208 handle_visibility_attribute (node
, name
, args
, flags
, no_add_attrs
)
5212 int flags ATTRIBUTE_UNUSED
;
5217 if (decl_function_context (decl
) != 0 || ! TREE_PUBLIC (decl
))
5219 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5220 *no_add_attrs
= true;
5226 id
= TREE_VALUE (args
);
5227 if (TREE_CODE (id
) != STRING_CST
)
5229 error ("visibility arg not a string");
5230 *no_add_attrs
= true;
5233 if (strcmp (TREE_STRING_POINTER (id
), "hidden")
5234 && strcmp (TREE_STRING_POINTER (id
), "protected")
5235 && strcmp (TREE_STRING_POINTER (id
), "internal"))
5237 error ("visibility arg must be one of \"hidden\", \"protected\" or \"internal\"");
5238 *no_add_attrs
= true;
5246 /* Handle a "no_instrument_function" attribute; arguments as in
5247 struct attribute_spec.handler. */
5250 handle_no_instrument_function_attribute (node
, name
, args
, flags
, no_add_attrs
)
5253 tree args ATTRIBUTE_UNUSED
;
5254 int flags ATTRIBUTE_UNUSED
;
5259 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5261 error_with_decl (decl
,
5262 "`%s' attribute applies only to functions",
5263 IDENTIFIER_POINTER (name
));
5264 *no_add_attrs
= true;
5266 else if (DECL_INITIAL (decl
))
5268 error_with_decl (decl
,
5269 "can't set `%s' attribute after definition",
5270 IDENTIFIER_POINTER (name
));
5271 *no_add_attrs
= true;
5274 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
5279 /* Handle a "malloc" attribute; arguments as in
5280 struct attribute_spec.handler. */
5283 handle_malloc_attribute (node
, name
, args
, flags
, no_add_attrs
)
5286 tree args ATTRIBUTE_UNUSED
;
5287 int flags ATTRIBUTE_UNUSED
;
5290 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5291 DECL_IS_MALLOC (*node
) = 1;
5292 /* ??? TODO: Support types. */
5295 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5296 *no_add_attrs
= true;
5302 /* Handle a "no_limit_stack" attribute; arguments as in
5303 struct attribute_spec.handler. */
5306 handle_no_limit_stack_attribute (node
, name
, args
, flags
, no_add_attrs
)
5309 tree args ATTRIBUTE_UNUSED
;
5310 int flags ATTRIBUTE_UNUSED
;
5315 if (TREE_CODE (decl
) != FUNCTION_DECL
)
5317 error_with_decl (decl
,
5318 "`%s' attribute applies only to functions",
5319 IDENTIFIER_POINTER (name
));
5320 *no_add_attrs
= true;
5322 else if (DECL_INITIAL (decl
))
5324 error_with_decl (decl
,
5325 "can't set `%s' attribute after definition",
5326 IDENTIFIER_POINTER (name
));
5327 *no_add_attrs
= true;
5330 DECL_NO_LIMIT_STACK (decl
) = 1;
5335 /* Handle a "pure" attribute; arguments as in
5336 struct attribute_spec.handler. */
5339 handle_pure_attribute (node
, name
, args
, flags
, no_add_attrs
)
5342 tree args ATTRIBUTE_UNUSED
;
5343 int flags ATTRIBUTE_UNUSED
;
5346 if (TREE_CODE (*node
) == FUNCTION_DECL
)
5347 DECL_IS_PURE (*node
) = 1;
5348 /* ??? TODO: Support types. */
5351 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5352 *no_add_attrs
= true;
5358 /* Handle a "deprecated" attribute; arguments as in
5359 struct attribute_spec.handler. */
5362 handle_deprecated_attribute (node
, name
, args
, flags
, no_add_attrs
)
5365 tree args ATTRIBUTE_UNUSED
;
5369 tree type
= NULL_TREE
;
5371 const char *what
= NULL
;
5376 type
= TREE_TYPE (decl
);
5378 if (TREE_CODE (decl
) == TYPE_DECL
5379 || TREE_CODE (decl
) == PARM_DECL
5380 || TREE_CODE (decl
) == VAR_DECL
5381 || TREE_CODE (decl
) == FUNCTION_DECL
5382 || TREE_CODE (decl
) == FIELD_DECL
)
5383 TREE_DEPRECATED (decl
) = 1;
5387 else if (TYPE_P (*node
))
5389 if (!(flags
& (int) ATTR_FLAG_TYPE_IN_PLACE
))
5390 *node
= build_type_copy (*node
);
5391 TREE_DEPRECATED (*node
) = 1;
5399 *no_add_attrs
= true;
5400 if (type
&& TYPE_NAME (type
))
5402 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
5403 what
= IDENTIFIER_POINTER (TYPE_NAME (*node
));
5404 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
5405 && DECL_NAME (TYPE_NAME (type
)))
5406 what
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
5409 warning ("`%s' attribute ignored for `%s'",
5410 IDENTIFIER_POINTER (name
), what
);
5412 warning ("`%s' attribute ignored",
5413 IDENTIFIER_POINTER (name
));
5419 /* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5420 to prevent us from duplicating type nodes unnecessarily.
5421 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5422 since we want to distinguish types that are essentially identical (except
5423 for their debug representation), we use a local list here. */
5424 static tree vector_type_node_list
= 0;
5426 /* Handle a "vector_size" attribute; arguments as in
5427 struct attribute_spec.handler. */
5430 handle_vector_size_attribute (node
, name
, args
, flags
, no_add_attrs
)
5434 int flags ATTRIBUTE_UNUSED
;
5437 unsigned HOST_WIDE_INT vecsize
, nunits
;
5438 enum machine_mode mode
, orig_mode
, new_mode
;
5439 tree type
= *node
, new_type
= NULL_TREE
;
5440 tree type_list_node
;
5442 *no_add_attrs
= true;
5444 if (! host_integerp (TREE_VALUE (args
), 1))
5446 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
5450 /* Get the vector size (in bytes). */
5451 vecsize
= tree_low_cst (TREE_VALUE (args
), 1);
5453 /* We need to provide for vector pointers, vector arrays, and
5454 functions returning vectors. For example:
5456 __attribute__((vector_size(16))) short *foo;
5458 In this case, the mode is SI, but the type being modified is
5459 HI, so we need to look further. */
5461 while (POINTER_TYPE_P (type
)
5462 || TREE_CODE (type
) == FUNCTION_TYPE
5463 || TREE_CODE (type
) == ARRAY_TYPE
)
5464 type
= TREE_TYPE (type
);
5466 /* Get the mode of the type being modified. */
5467 orig_mode
= TYPE_MODE (type
);
5469 if (TREE_CODE (type
) == RECORD_TYPE
5470 || (GET_MODE_CLASS (orig_mode
) != MODE_FLOAT
5471 && GET_MODE_CLASS (orig_mode
) != MODE_INT
)
5472 || ! host_integerp (TYPE_SIZE_UNIT (type
), 1))
5474 error ("invalid vector type for attribute `%s'",
5475 IDENTIFIER_POINTER (name
));
5479 /* Calculate how many units fit in the vector. */
5480 nunits
= vecsize
/ tree_low_cst (TYPE_SIZE_UNIT (type
), 1);
5482 /* Find a suitably sized vector. */
5483 new_mode
= VOIDmode
;
5484 for (mode
= GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode
) == MODE_INT
5486 : MODE_VECTOR_FLOAT
);
5488 mode
= GET_MODE_WIDER_MODE (mode
))
5489 if (vecsize
== GET_MODE_SIZE (mode
)
5490 && nunits
== (unsigned HOST_WIDE_INT
) GET_MODE_NUNITS (mode
))
5496 if (new_mode
== VOIDmode
)
5498 error ("no vector mode with the size and type specified could be found");
5502 for (type_list_node
= vector_type_node_list
; type_list_node
;
5503 type_list_node
= TREE_CHAIN (type_list_node
))
5505 tree other_type
= TREE_VALUE (type_list_node
);
5506 tree record
= TYPE_DEBUG_REPRESENTATION_TYPE (other_type
);
5507 tree fields
= TYPE_FIELDS (record
);
5508 tree field_type
= TREE_TYPE (fields
);
5509 tree array_type
= TREE_TYPE (field_type
);
5510 if (TREE_CODE (fields
) != FIELD_DECL
5511 || TREE_CODE (field_type
) != ARRAY_TYPE
)
5514 if (TYPE_MODE (other_type
) == mode
&& type
== array_type
)
5516 new_type
= other_type
;
5521 if (new_type
== NULL_TREE
)
5523 tree index
, array
, rt
, list_node
;
5525 new_type
= (*lang_hooks
.types
.type_for_mode
) (new_mode
,
5526 TREE_UNSIGNED (type
));
5530 error ("no vector mode with the size and type specified could be found");
5534 new_type
= build_type_copy (new_type
);
5536 /* Set the debug information here, because this is the only
5537 place where we know the underlying type for a vector made
5538 with vector_size. For debugging purposes we pretend a vector
5539 is an array within a structure. */
5540 index
= build_int_2 (TYPE_VECTOR_SUBPARTS (new_type
) - 1, 0);
5541 array
= build_array_type (type
, build_index_type (index
));
5542 rt
= make_node (RECORD_TYPE
);
5544 TYPE_FIELDS (rt
) = build_decl (FIELD_DECL
, get_identifier ("f"), array
);
5545 DECL_CONTEXT (TYPE_FIELDS (rt
)) = rt
;
5547 TYPE_DEBUG_REPRESENTATION_TYPE (new_type
) = rt
;
5549 list_node
= build_tree_list (NULL
, new_type
);
5550 TREE_CHAIN (list_node
) = vector_type_node_list
;
5551 vector_type_node_list
= list_node
;
5554 /* Build back pointers if needed. */
5555 *node
= vector_size_helper (*node
, new_type
);
5560 /* HACK. GROSS. This is absolutely disgusting. I wish there was a
5563 If we requested a pointer to a vector, build up the pointers that
5564 we stripped off while looking for the inner type. Similarly for
5565 return values from functions.
5567 The argument "type" is the top of the chain, and "bottom" is the
5568 new type which we will point to. */
5571 vector_size_helper (type
, bottom
)
5576 if (POINTER_TYPE_P (type
))
5578 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5579 outer
= build_pointer_type (inner
);
5581 else if (TREE_CODE (type
) == ARRAY_TYPE
)
5583 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5584 outer
= build_array_type (inner
, TYPE_VALUES (type
));
5586 else if (TREE_CODE (type
) == FUNCTION_TYPE
)
5588 inner
= vector_size_helper (TREE_TYPE (type
), bottom
);
5589 outer
= build_function_type (inner
, TYPE_VALUES (type
));
5594 TREE_READONLY (outer
) = TREE_READONLY (type
);
5595 TREE_THIS_VOLATILE (outer
) = TREE_THIS_VOLATILE (type
);