1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
36 cpp_reader
*parse_in
; /* Declared in c-lex.h. */
38 #undef WCHAR_TYPE_SIZE
39 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
41 /* We let tm.h override the types used here, to handle trivial differences
42 such as the choice of unsigned int or long unsigned int for size_t.
43 When machines start needing nontrivial differences in the size type,
44 it would be best to do something here to figure out automatically
45 from other information what type to use. */
48 #define SIZE_TYPE "long unsigned int"
52 #define WCHAR_TYPE "int"
56 #define PTRDIFF_TYPE "long int"
60 #define WINT_TYPE "unsigned int"
64 #define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
66 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
72 #define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
74 : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
75 ? "long unsigned int" \
76 : "long long unsigned int"))
79 /* The following symbols are subsumed in the c_global_trees array, and
80 listed here individually for documentation purposes.
82 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
84 tree short_integer_type_node;
85 tree long_integer_type_node;
86 tree long_long_integer_type_node;
88 tree short_unsigned_type_node;
89 tree long_unsigned_type_node;
90 tree long_long_unsigned_type_node;
92 tree boolean_type_node;
93 tree boolean_false_node;
94 tree boolean_true_node;
96 tree ptrdiff_type_node;
98 tree unsigned_char_type_node;
99 tree signed_char_type_node;
100 tree wchar_type_node;
101 tree signed_wchar_type_node;
102 tree unsigned_wchar_type_node;
104 tree float_type_node;
105 tree double_type_node;
106 tree long_double_type_node;
108 tree complex_integer_type_node;
109 tree complex_float_type_node;
110 tree complex_double_type_node;
111 tree complex_long_double_type_node;
113 tree intQI_type_node;
114 tree intHI_type_node;
115 tree intSI_type_node;
116 tree intDI_type_node;
117 tree intTI_type_node;
119 tree unsigned_intQI_type_node;
120 tree unsigned_intHI_type_node;
121 tree unsigned_intSI_type_node;
122 tree unsigned_intDI_type_node;
123 tree unsigned_intTI_type_node;
125 tree widest_integer_literal_type_node;
126 tree widest_unsigned_literal_type_node;
128 Nodes for types `void *' and `const void *'.
130 tree ptr_type_node, const_ptr_type_node;
132 Nodes for types `char *' and `const char *'.
134 tree string_type_node, const_string_type_node;
136 Type `char[SOMENUMBER]'.
137 Used when an array of char is needed and the size is irrelevant.
139 tree char_array_type_node;
141 Type `int[SOMENUMBER]' or something like it.
142 Used when an array of int needed and the size is irrelevant.
144 tree int_array_type_node;
146 Type `wchar_t[SOMENUMBER]' or something like it.
147 Used when a wide string literal is created.
149 tree wchar_array_type_node;
151 Type `int ()' -- used for implicit declaration of functions.
153 tree default_function_type;
155 Function types `int (int)', etc.
161 tree ptr_ftype_sizetype;
163 A VOID_TYPE node, packaged in a TREE_LIST.
167 The identifiers __FUNCTION__, __PRETTY_FUNCTION__, and __func__.
169 tree function_id_node;
170 tree pretty_function_id_node;
175 tree c_global_trees
[CTI_MAX
];
177 /* Nonzero means don't recognize the non-ANSI builtin functions. */
181 /* Nonzero means don't recognize the non-ANSI builtin functions.
184 int flag_no_nonansi_builtin
;
186 /* Nonzero means give `double' the same size as `float'. */
188 int flag_short_double
;
190 /* Nonzero means give `wchar_t' the same size as `short'. */
192 int flag_short_wchar
;
194 /* If non-NULL, dump the tree structure for the entire translation
195 unit to this file. */
197 const char *flag_dump_translation_unit
;
199 /* Nonzero means warn about possible violations of sequence point rules. */
201 int warn_sequence_point
;
203 /* The elements of `ridpointers' are identifier nodes for the reserved
204 type names and storage classes. It is indexed by a RID_... value. */
207 tree (*make_fname_decl
) PARAMS ((tree
, const char *, int));
209 /* If non-NULL, the address of a language-specific function that
210 returns 1 for language-specific statement codes. */
211 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
213 /* If non-NULL, the address of a language-specific function that takes
214 any action required right before expand_function_end is called. */
215 void (*lang_expand_function_end
) PARAMS ((void));
217 /* If this variable is defined to a non-NULL value, it will be called
218 after the file has been completely parsed. */
219 void (*back_end_hook
) PARAMS ((tree
));
221 /* Nonzero means the expression being parsed will never be evaluated.
222 This is a count, since unevaluated expressions can nest. */
225 enum attrs
{A_PACKED
, A_NOCOMMON
, A_COMMON
, A_NORETURN
, A_CONST
, A_T_UNION
,
226 A_NO_CHECK_MEMORY_USAGE
, A_NO_INSTRUMENT_FUNCTION
,
227 A_CONSTRUCTOR
, A_DESTRUCTOR
, A_MODE
, A_SECTION
, A_ALIGNED
,
228 A_UNUSED
, A_FORMAT
, A_FORMAT_ARG
, A_WEAK
, A_ALIAS
, A_MALLOC
,
229 A_NO_LIMIT_STACK
, A_PURE
};
231 static void add_attribute
PARAMS ((enum attrs
, const char *,
233 static void init_attributes
PARAMS ((void));
234 static int default_valid_lang_attribute
PARAMS ((tree
, tree
, tree
, tree
));
235 static int constant_fits_type_p
PARAMS ((tree
, tree
));
237 /* Keep a stack of if statements. We record the number of compound
238 statements seen up to the if keyword, as well as the line number
239 and file of the if. If a potentially ambiguous else is seen, that
240 fact is recorded; the warning is issued when we can be sure that
241 the enclosing if statement does not have an else branch. */
251 static if_elt
*if_stack
;
253 /* Amount of space in the if statement stack. */
254 static int if_stack_space
= 0;
257 static int if_stack_pointer
= 0;
259 /* Record the start of an if-then, and record the start of it
260 for ambiguous else detection. */
263 c_expand_start_cond (cond
, compstmt_count
)
269 /* Make sure there is enough space on the stack. */
270 if (if_stack_space
== 0)
273 if_stack
= (if_elt
*)xmalloc (10 * sizeof (if_elt
));
275 else if (if_stack_space
== if_stack_pointer
)
277 if_stack_space
+= 10;
278 if_stack
= (if_elt
*)xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
281 if_stmt
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
282 IF_COND (if_stmt
) = cond
;
285 /* Record this if statement. */
286 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
287 if_stack
[if_stack_pointer
].file
= input_filename
;
288 if_stack
[if_stack_pointer
].line
= lineno
;
289 if_stack
[if_stack_pointer
].needs_warning
= 0;
290 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
294 /* Called after the then-clause for an if-statement is processed. */
299 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
300 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
303 /* Record the end of an if-then. Optionally warn if a nested
304 if statement had an ambiguous else clause. */
310 if (if_stack
[if_stack_pointer
].needs_warning
)
311 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
312 if_stack
[if_stack_pointer
].line
,
313 "suggest explicit braces to avoid ambiguous `else'");
314 last_expr_type
= NULL_TREE
;
317 /* Called between the then-clause and the else-clause
318 of an if-then-else. */
321 c_expand_start_else ()
323 /* An ambiguous else warning must be generated for the enclosing if
324 statement, unless we see an else branch for that one, too. */
326 && if_stack_pointer
> 1
327 && (if_stack
[if_stack_pointer
- 1].compstmt_count
328 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
329 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
331 /* Even if a nested if statement had an else branch, it can't be
332 ambiguous if this one also has an else. So don't warn in that
333 case. Also don't warn for any if statements nested in this else. */
334 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
335 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
338 /* Called after the else-clause for an if-statement is processed. */
343 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
344 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
347 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__. */
350 declare_function_name ()
352 const char *name
, *printable_name
;
354 if (current_function_decl
== NULL
)
357 printable_name
= "top level";
361 /* Allow functions to be nameless (such as artificial ones). */
362 if (DECL_NAME (current_function_decl
))
363 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
366 printable_name
= (*decl_printable_name
) (current_function_decl
, 2);
368 /* ISO C99 defines __func__, which is a variable, not a string
369 constant, and which is not a defined symbol at file scope. */
370 (*make_fname_decl
) (func_id_node
, name
, 0);
373 (*make_fname_decl
) (function_id_node
, name
, 0);
374 (*make_fname_decl
) (pretty_function_id_node
, printable_name
, 1);
377 /* Given a chain of STRING_CST nodes,
378 concatenate them into one STRING_CST
379 and give it a suitable array-of-chars data type. */
382 combine_strings (strings
)
385 register tree value
, t
;
386 register int length
= 1;
389 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
391 const int nchars_max
= flag_isoc99
? 4095 : 509;
393 if (TREE_CHAIN (strings
))
395 /* More than one in the chain, so concatenate. */
396 register char *p
, *q
;
398 /* Don't include the \0 at the end of each substring,
399 except for the last one.
400 Count wide strings and ordinary strings separately. */
401 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
403 if (TREE_TYPE (t
) == wchar_array_type_node
)
405 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
409 length
+= (TREE_STRING_LENGTH (t
) - 1);
412 /* If anything is wide, the non-wides will be converted,
413 which makes them take more space. */
415 length
= length
* wchar_bytes
+ wide_length
;
419 /* Copy the individual strings into the new combined string.
420 If the combined string is wide, convert the chars to ints
421 for any individual strings that are not wide. */
424 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
426 int len
= (TREE_STRING_LENGTH (t
)
427 - ((TREE_TYPE (t
) == wchar_array_type_node
)
429 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
431 memcpy (q
, TREE_STRING_POINTER (t
), len
);
437 for (i
= 0; i
< len
; i
++)
439 if (WCHAR_TYPE_SIZE
== HOST_BITS_PER_SHORT
)
440 ((short *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
442 ((int *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
444 q
+= len
* wchar_bytes
;
450 for (i
= 0; i
< wchar_bytes
; i
++)
456 value
= build_string (length
, p
);
461 length
= TREE_STRING_LENGTH (value
);
462 if (TREE_TYPE (value
) == wchar_array_type_node
)
466 /* Compute the number of elements, for the array type. */
467 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
469 if (pedantic
&& nchars
- 1 > nchars_max
&& c_language
== clk_c
)
470 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
471 nchars
- 1, nchars_max
, flag_isoc99
? 99 : 89);
473 /* Create the array type for the string constant.
474 -Wwrite-strings says make the string constant an array of const char
475 so that copying it to a non-const pointer will get a warning.
476 For C++, this is the standard behavior. */
477 if (flag_const_strings
478 && (! flag_traditional
&& ! flag_writable_strings
))
481 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
484 = build_array_type (elements
,
485 build_index_type (build_int_2 (nchars
- 1, 0)));
489 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
490 build_index_type (build_int_2 (nchars
- 1, 0)));
492 TREE_CONSTANT (value
) = 1;
493 TREE_READONLY (value
) = ! flag_writable_strings
;
494 TREE_STATIC (value
) = 1;
498 /* To speed up processing of attributes, we maintain an array of
499 IDENTIFIER_NODES and the corresponding attribute types. */
501 /* Array to hold attribute information. */
503 static struct {enum attrs id
; tree name
; int min
, max
, decl_req
;} attrtab
[50];
505 static int attrtab_idx
= 0;
507 /* Add an entry to the attribute table above. */
510 add_attribute (id
, string
, min_len
, max_len
, decl_req
)
513 int min_len
, max_len
;
518 attrtab
[attrtab_idx
].id
= id
;
519 attrtab
[attrtab_idx
].name
= get_identifier (string
);
520 attrtab
[attrtab_idx
].min
= min_len
;
521 attrtab
[attrtab_idx
].max
= max_len
;
522 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
524 sprintf (buf
, "__%s__", string
);
526 attrtab
[attrtab_idx
].id
= id
;
527 attrtab
[attrtab_idx
].name
= get_identifier (buf
);
528 attrtab
[attrtab_idx
].min
= min_len
;
529 attrtab
[attrtab_idx
].max
= max_len
;
530 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
533 /* Initialize attribute table. */
538 add_attribute (A_PACKED
, "packed", 0, 0, 0);
539 add_attribute (A_NOCOMMON
, "nocommon", 0, 0, 1);
540 add_attribute (A_COMMON
, "common", 0, 0, 1);
541 add_attribute (A_NORETURN
, "noreturn", 0, 0, 1);
542 add_attribute (A_NORETURN
, "volatile", 0, 0, 1);
543 add_attribute (A_UNUSED
, "unused", 0, 0, 0);
544 add_attribute (A_CONST
, "const", 0, 0, 1);
545 add_attribute (A_T_UNION
, "transparent_union", 0, 0, 0);
546 add_attribute (A_CONSTRUCTOR
, "constructor", 0, 0, 1);
547 add_attribute (A_DESTRUCTOR
, "destructor", 0, 0, 1);
548 add_attribute (A_MODE
, "mode", 1, 1, 1);
549 add_attribute (A_SECTION
, "section", 1, 1, 1);
550 add_attribute (A_ALIGNED
, "aligned", 0, 1, 0);
551 add_attribute (A_FORMAT
, "format", 3, 3, 1);
552 add_attribute (A_FORMAT_ARG
, "format_arg", 1, 1, 1);
553 add_attribute (A_WEAK
, "weak", 0, 0, 1);
554 add_attribute (A_ALIAS
, "alias", 1, 1, 1);
555 add_attribute (A_NO_INSTRUMENT_FUNCTION
, "no_instrument_function", 0, 0, 1);
556 add_attribute (A_NO_CHECK_MEMORY_USAGE
, "no_check_memory_usage", 0, 0, 1);
557 add_attribute (A_MALLOC
, "malloc", 0, 0, 1);
558 add_attribute (A_NO_LIMIT_STACK
, "no_stack_limit", 0, 0, 1);
559 add_attribute (A_PURE
, "pure", 0, 0, 1);
562 /* Default implementation of valid_lang_attribute, below. By default, there
563 are no language-specific attributes. */
566 default_valid_lang_attribute (attr_name
, attr_args
, decl
, type
)
567 tree attr_name ATTRIBUTE_UNUSED
;
568 tree attr_args ATTRIBUTE_UNUSED
;
569 tree decl ATTRIBUTE_UNUSED
;
570 tree type ATTRIBUTE_UNUSED
;
575 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
576 attribute for either declaration DECL or type TYPE and 0 otherwise. */
578 int (*valid_lang_attribute
) PARAMS ((tree
, tree
, tree
, tree
))
579 = default_valid_lang_attribute
;
581 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
582 and install them in NODE, which is either a DECL (including a TYPE_DECL)
583 or a TYPE. PREFIX_ATTRIBUTES can appear after the declaration specifiers
584 and declaration modifiers but before the declaration proper. */
587 decl_attributes (node
, attributes
, prefix_attributes
)
588 tree node
, attributes
, prefix_attributes
;
590 tree decl
= 0, type
= 0;
594 if (attrtab_idx
== 0)
600 type
= TREE_TYPE (decl
);
601 is_type
= TREE_CODE (node
) == TYPE_DECL
;
603 else if (TYPE_P (node
))
604 type
= node
, is_type
= 1;
606 #ifdef PRAGMA_INSERT_ATTRIBUTES
607 /* If the code in c-pragma.c wants to insert some attributes then
608 allow it to do so. Do this before allowing machine back ends to
609 insert attributes, so that they have the opportunity to override
610 anything done here. */
611 PRAGMA_INSERT_ATTRIBUTES (node
, & attributes
, & prefix_attributes
);
614 #ifdef INSERT_ATTRIBUTES
615 INSERT_ATTRIBUTES (node
, & attributes
, & prefix_attributes
);
618 attributes
= chainon (prefix_attributes
, attributes
);
620 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
622 tree name
= TREE_PURPOSE (a
);
623 tree args
= TREE_VALUE (a
);
627 for (i
= 0; i
< attrtab_idx
; i
++)
628 if (attrtab
[i
].name
== name
)
631 if (i
== attrtab_idx
)
633 if (! valid_machine_attribute (name
, args
, decl
, type
)
634 && ! (* valid_lang_attribute
) (name
, args
, decl
, type
))
635 warning ("`%s' attribute directive ignored",
636 IDENTIFIER_POINTER (name
));
638 type
= TREE_TYPE (decl
);
641 else if (attrtab
[i
].decl_req
&& decl
== 0)
643 warning ("`%s' attribute does not apply to types",
644 IDENTIFIER_POINTER (name
));
647 else if (list_length (args
) < attrtab
[i
].min
648 || list_length (args
) > attrtab
[i
].max
)
650 error ("wrong number of arguments specified for `%s' attribute",
651 IDENTIFIER_POINTER (name
));
660 TYPE_PACKED (type
) = 1;
661 else if (TREE_CODE (decl
) == FIELD_DECL
)
662 DECL_PACKED (decl
) = 1;
663 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
664 used for DECL_REGISTER. It wouldn't mean anything anyway. */
666 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
670 if (TREE_CODE (decl
) == VAR_DECL
)
671 DECL_COMMON (decl
) = 0;
673 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
677 if (TREE_CODE (decl
) == VAR_DECL
)
678 DECL_COMMON (decl
) = 1;
680 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
684 if (TREE_CODE (decl
) == FUNCTION_DECL
)
685 TREE_THIS_VOLATILE (decl
) = 1;
686 else if (TREE_CODE (type
) == POINTER_TYPE
687 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
688 TREE_TYPE (decl
) = type
690 (build_type_variant (TREE_TYPE (type
),
691 TREE_READONLY (TREE_TYPE (type
)), 1));
693 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
697 if (TREE_CODE (decl
) == FUNCTION_DECL
)
698 DECL_IS_MALLOC (decl
) = 1;
699 /* ??? TODO: Support types. */
701 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
707 TREE_USED (decl
) = 1;
709 TREE_USED (type
) = 1;
710 else if (TREE_CODE (decl
) == PARM_DECL
711 || TREE_CODE (decl
) == VAR_DECL
712 || TREE_CODE (decl
) == FUNCTION_DECL
713 || TREE_CODE (decl
) == LABEL_DECL
)
714 TREE_USED (decl
) = 1;
716 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
720 if (TREE_CODE (decl
) == FUNCTION_DECL
)
721 TREE_READONLY (decl
) = 1;
722 else if (TREE_CODE (type
) == POINTER_TYPE
723 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
724 TREE_TYPE (decl
) = type
726 (build_type_variant (TREE_TYPE (type
), 1,
727 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
729 warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name
));
733 if (TREE_CODE (decl
) == FUNCTION_DECL
)
734 DECL_IS_PURE (decl
) = 1;
735 /* ??? TODO: Support types. */
737 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
743 && TREE_CODE (type
) == UNION_TYPE
745 || (TYPE_FIELDS (type
) != 0
746 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))))
747 TYPE_TRANSPARENT_UNION (type
) = 1;
748 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
749 && TREE_CODE (type
) == UNION_TYPE
750 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))
751 DECL_TRANSPARENT_UNION (decl
) = 1;
753 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
757 if (TREE_CODE (decl
) == FUNCTION_DECL
758 && TREE_CODE (type
) == FUNCTION_TYPE
759 && decl_function_context (decl
) == 0)
761 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
762 TREE_USED (decl
) = 1;
765 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
769 if (TREE_CODE (decl
) == FUNCTION_DECL
770 && TREE_CODE (type
) == FUNCTION_TYPE
771 && decl_function_context (decl
) == 0)
773 DECL_STATIC_DESTRUCTOR (decl
) = 1;
774 TREE_USED (decl
) = 1;
777 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
781 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
782 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
786 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
787 int len
= strlen (p
);
788 enum machine_mode mode
= VOIDmode
;
791 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
792 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
794 char *newp
= (char *) alloca (len
- 1);
796 strcpy (newp
, &p
[2]);
797 newp
[len
- 4] = '\0';
801 /* Give this decl a type with the specified mode.
802 First check for the special modes. */
803 if (! strcmp (p
, "byte"))
805 else if (!strcmp (p
, "word"))
807 else if (! strcmp (p
, "pointer"))
810 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
811 if (!strcmp (p
, GET_MODE_NAME (j
)))
812 mode
= (enum machine_mode
) j
;
814 if (mode
== VOIDmode
)
815 error ("unknown machine mode `%s'", p
);
816 else if (0 == (typefm
= type_for_mode (mode
,
817 TREE_UNSIGNED (type
))))
818 error ("no data type for mode `%s'", p
);
821 if (TYPE_PRECISION (typefm
) > (TREE_UNSIGNED (type
)
822 ? TYPE_PRECISION(uintmax_type_node
)
823 : TYPE_PRECISION(intmax_type_node
))
825 pedwarn ("type with more precision than %s",
826 TREE_UNSIGNED (type
) ? "uintmax_t" : "intmax_t");
827 TREE_TYPE (decl
) = type
= typefm
;
828 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
829 layout_decl (decl
, 0);
835 #ifdef ASM_OUTPUT_SECTION_NAME
836 if ((TREE_CODE (decl
) == FUNCTION_DECL
837 || TREE_CODE (decl
) == VAR_DECL
)
838 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
840 if (TREE_CODE (decl
) == VAR_DECL
841 && current_function_decl
!= NULL_TREE
842 && ! TREE_STATIC (decl
))
843 error_with_decl (decl
,
844 "section attribute cannot be specified for local variables");
845 /* The decl may have already been given a section attribute from
846 a previous declaration. Ensure they match. */
847 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
848 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
849 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
850 error_with_decl (node
,
851 "section of `%s' conflicts with previous declaration");
853 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
856 error_with_decl (node
,
857 "section attribute not allowed for `%s'");
859 error_with_decl (node
,
860 "section attributes are not supported for this target");
867 = (args
? TREE_VALUE (args
)
868 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
871 /* Strip any NOPs of any kind. */
872 while (TREE_CODE (align_expr
) == NOP_EXPR
873 || TREE_CODE (align_expr
) == CONVERT_EXPR
874 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
875 align_expr
= TREE_OPERAND (align_expr
, 0);
877 if (TREE_CODE (align_expr
) != INTEGER_CST
)
879 error ("requested alignment is not a constant");
883 if ((i
= tree_log2 (align_expr
)) == -1)
884 error ("requested alignment is not a power of 2");
885 else if (i
> HOST_BITS_PER_INT
- 2)
886 error ("requested alignment is too large");
889 /* If we have a TYPE_DECL, then copy the type, so that we
890 don't accidentally modify a builtin type. See pushdecl. */
891 if (decl
&& TREE_TYPE (decl
) != error_mark_node
892 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
894 tree tt
= TREE_TYPE (decl
);
895 DECL_ORIGINAL_TYPE (decl
) = tt
;
896 tt
= build_type_copy (tt
);
897 TYPE_NAME (tt
) = decl
;
898 TREE_USED (tt
) = TREE_USED (decl
);
899 TREE_TYPE (decl
) = tt
;
903 TYPE_ALIGN (type
) = (1 << i
) * BITS_PER_UNIT
;
904 TYPE_USER_ALIGN (type
) = 1;
906 else if (TREE_CODE (decl
) != VAR_DECL
907 && TREE_CODE (decl
) != FIELD_DECL
)
908 error_with_decl (decl
,
909 "alignment may not be specified for `%s'");
912 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
913 DECL_USER_ALIGN (decl
) = 1;
919 decl_handle_format_attribute (decl
, args
);
923 decl_handle_format_arg_attribute (decl
, args
);
931 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
932 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
933 error_with_decl (decl
,
934 "`%s' defined both normally and as an alias");
935 else if (decl_function_context (decl
) == 0)
939 id
= TREE_VALUE (args
);
940 if (TREE_CODE (id
) != STRING_CST
)
942 error ("alias arg not a string");
945 id
= get_identifier (TREE_STRING_POINTER (id
));
946 /* This counts as a use of the object pointed to. */
949 if (TREE_CODE (decl
) == FUNCTION_DECL
)
950 DECL_INITIAL (decl
) = error_mark_node
;
952 DECL_EXTERNAL (decl
) = 0;
953 assemble_alias (decl
, id
);
956 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
959 case A_NO_CHECK_MEMORY_USAGE
:
960 if (TREE_CODE (decl
) != FUNCTION_DECL
)
962 error_with_decl (decl
,
963 "`%s' attribute applies only to functions",
964 IDENTIFIER_POINTER (name
));
966 else if (DECL_INITIAL (decl
))
968 error_with_decl (decl
,
969 "can't set `%s' attribute after definition",
970 IDENTIFIER_POINTER (name
));
973 DECL_NO_CHECK_MEMORY_USAGE (decl
) = 1;
976 case A_NO_INSTRUMENT_FUNCTION
:
977 if (TREE_CODE (decl
) != FUNCTION_DECL
)
979 error_with_decl (decl
,
980 "`%s' attribute applies only to functions",
981 IDENTIFIER_POINTER (name
));
983 else if (DECL_INITIAL (decl
))
985 error_with_decl (decl
,
986 "can't set `%s' attribute after definition",
987 IDENTIFIER_POINTER (name
));
990 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
993 case A_NO_LIMIT_STACK
:
994 if (TREE_CODE (decl
) != FUNCTION_DECL
)
996 error_with_decl (decl
,
997 "`%s' attribute applies only to functions",
998 IDENTIFIER_POINTER (name
));
1000 else if (DECL_INITIAL (decl
))
1002 error_with_decl (decl
,
1003 "can't set `%s' attribute after definition",
1004 IDENTIFIER_POINTER (name
));
1007 DECL_NO_LIMIT_STACK (decl
) = 1;
1013 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1014 lists. SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1016 The head of the declspec list is stored in DECLSPECS.
1017 The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1019 Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1020 the list elements. We drop the containing TREE_LIST nodes and link the
1021 resulting attributes together the way decl_attributes expects them. */
1024 split_specs_attrs (specs_attrs
, declspecs
, prefix_attributes
)
1026 tree
*declspecs
, *prefix_attributes
;
1028 tree t
, s
, a
, next
, specs
, attrs
;
1030 /* This can happen after an __extension__ in pedantic mode. */
1031 if (specs_attrs
!= NULL_TREE
1032 && TREE_CODE (specs_attrs
) == INTEGER_CST
)
1034 *declspecs
= NULL_TREE
;
1035 *prefix_attributes
= NULL_TREE
;
1039 /* This can happen in c++ (eg: decl: typespec initdecls ';'). */
1040 if (specs_attrs
!= NULL_TREE
1041 && TREE_CODE (specs_attrs
) != TREE_LIST
)
1043 *declspecs
= specs_attrs
;
1044 *prefix_attributes
= NULL_TREE
;
1048 /* Remember to keep the lists in the same order, element-wise. */
1050 specs
= s
= NULL_TREE
;
1051 attrs
= a
= NULL_TREE
;
1052 for (t
= specs_attrs
; t
; t
= next
)
1054 next
= TREE_CHAIN (t
);
1055 /* Declspecs have a non-NULL TREE_VALUE. */
1056 if (TREE_VALUE (t
) != NULL_TREE
)
1058 if (specs
== NULL_TREE
)
1068 if (attrs
== NULL_TREE
)
1069 attrs
= a
= TREE_PURPOSE (t
);
1072 TREE_CHAIN (a
) = TREE_PURPOSE (t
);
1073 a
= TREE_PURPOSE (t
);
1075 /* More attrs can be linked here, move A to the end. */
1076 while (TREE_CHAIN (a
) != NULL_TREE
)
1081 /* Terminate the lists. */
1083 TREE_CHAIN (s
) = NULL_TREE
;
1085 TREE_CHAIN (a
) = NULL_TREE
;
1089 *prefix_attributes
= attrs
;
1092 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1093 This function is used by the parser when a rule will accept attributes
1094 in a particular position, but we don't want to support that just yet.
1096 A warning is issued for every ignored attribute. */
1099 strip_attrs (specs_attrs
)
1104 split_specs_attrs (specs_attrs
, &specs
, &attrs
);
1108 warning ("`%s' attribute ignored",
1109 IDENTIFIER_POINTER (TREE_PURPOSE (attrs
)));
1110 attrs
= TREE_CHAIN (attrs
);
1116 static int is_valid_printf_arglist
PARAMS ((tree
));
1117 static rtx c_expand_builtin
PARAMS ((tree
, rtx
, enum machine_mode
, enum expand_modifier
));
1118 static rtx c_expand_builtin_printf
PARAMS ((tree
, rtx
, enum machine_mode
,
1119 enum expand_modifier
, int));
1120 static rtx c_expand_builtin_fprintf
PARAMS ((tree
, rtx
, enum machine_mode
,
1121 enum expand_modifier
, int));
1123 /* Print a warning if a constant expression had overflow in folding.
1124 Invoke this function on every expression that the language
1125 requires to be a constant expression.
1126 Note the ANSI C standard says it is erroneous for a
1127 constant expression to overflow. */
1130 constant_expression_warning (value
)
1133 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1134 || TREE_CODE (value
) == COMPLEX_CST
)
1135 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1136 pedwarn ("overflow in constant expression");
1139 /* Print a warning if an expression had overflow in folding.
1140 Invoke this function on every expression that
1141 (1) appears in the source code, and
1142 (2) might be a constant expression that overflowed, and
1143 (3) is not already checked by convert_and_check;
1144 however, do not invoke this function on operands of explicit casts. */
1147 overflow_warning (value
)
1150 if ((TREE_CODE (value
) == INTEGER_CST
1151 || (TREE_CODE (value
) == COMPLEX_CST
1152 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1153 && TREE_OVERFLOW (value
))
1155 TREE_OVERFLOW (value
) = 0;
1156 if (skip_evaluation
== 0)
1157 warning ("integer overflow in expression");
1159 else if ((TREE_CODE (value
) == REAL_CST
1160 || (TREE_CODE (value
) == COMPLEX_CST
1161 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1162 && TREE_OVERFLOW (value
))
1164 TREE_OVERFLOW (value
) = 0;
1165 if (skip_evaluation
== 0)
1166 warning ("floating point overflow in expression");
1170 /* Print a warning if a large constant is truncated to unsigned,
1171 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1172 Invoke this function on every expression that might be implicitly
1173 converted to an unsigned type. */
1176 unsigned_conversion_warning (result
, operand
)
1177 tree result
, operand
;
1179 if (TREE_CODE (operand
) == INTEGER_CST
1180 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
1181 && TREE_UNSIGNED (TREE_TYPE (result
))
1182 && skip_evaluation
== 0
1183 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
1185 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
1186 /* This detects cases like converting -129 or 256 to unsigned char. */
1187 warning ("large integer implicitly truncated to unsigned type");
1188 else if (warn_conversion
)
1189 warning ("negative integer implicitly converted to unsigned type");
1193 /* Nonzero if constant C has a value that is permissible
1194 for type TYPE (an INTEGER_TYPE). */
1197 constant_fits_type_p (c
, type
)
1200 if (TREE_CODE (c
) == INTEGER_CST
)
1201 return int_fits_type_p (c
, type
);
1203 c
= convert (type
, c
);
1204 return !TREE_OVERFLOW (c
);
1207 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1208 Invoke this function on every expression that is converted implicitly,
1209 i.e. because of language rules and not because of an explicit cast. */
1212 convert_and_check (type
, expr
)
1215 tree t
= convert (type
, expr
);
1216 if (TREE_CODE (t
) == INTEGER_CST
)
1218 if (TREE_OVERFLOW (t
))
1220 TREE_OVERFLOW (t
) = 0;
1222 /* Do not diagnose overflow in a constant expression merely
1223 because a conversion overflowed. */
1224 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1226 /* No warning for converting 0x80000000 to int. */
1227 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1228 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1229 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1230 /* If EXPR fits in the unsigned version of TYPE,
1231 don't warn unless pedantic. */
1233 || TREE_UNSIGNED (type
)
1234 || ! constant_fits_type_p (expr
, unsigned_type (type
)))
1235 && skip_evaluation
== 0)
1236 warning ("overflow in implicit constant conversion");
1239 unsigned_conversion_warning (t
, expr
);
1244 /* A node in a list that describes references to variables (EXPR), which are
1245 either read accesses if WRITER is zero, or write accesses, in which case
1246 WRITER is the parent of EXPR. */
1253 /* Used to implement a cache the results of a call to verify_tree. We only
1254 use this for SAVE_EXPRs. */
1257 struct tlist_cache
*next
;
1258 struct tlist
*cache_before_sp
;
1259 struct tlist
*cache_after_sp
;
1263 /* Obstack to use when allocating tlist structures, and corresponding
1265 static struct obstack tlist_obstack
;
1266 static char *tlist_firstobj
= 0;
1268 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
1270 static struct tlist
*warned_ids
;
1271 /* SAVE_EXPRs need special treatment. We process them only once and then
1272 cache the results. */
1273 static struct tlist_cache
*save_expr_cache
;
1275 static void add_tlist
PARAMS ((struct tlist
**, struct tlist
*, tree
, int));
1276 static void merge_tlist
PARAMS ((struct tlist
**, struct tlist
*, int));
1277 static void verify_tree
PARAMS ((tree
, struct tlist
**, struct tlist
**, tree
));
1278 static int warning_candidate_p
PARAMS ((tree
));
1279 static void warn_for_collisions
PARAMS ((struct tlist
*));
1280 static void warn_for_collisions_1
PARAMS ((tree
, tree
, struct tlist
*, int));
1281 static struct tlist
*new_tlist
PARAMS ((struct tlist
*, tree
, tree
));
1282 static void verify_sequence_points
PARAMS ((tree
));
1284 /* Create a new struct tlist and fill in its fields. */
1285 static struct tlist
*
1286 new_tlist (next
, t
, writer
)
1292 l
= (struct tlist
*) obstack_alloc (&tlist_obstack
, sizeof *l
);
1299 /* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1300 is nonnull, we ignore any node we find which has a writer equal to it. */
1303 add_tlist (to
, add
, exclude_writer
, copy
)
1306 tree exclude_writer
;
1311 struct tlist
*next
= add
->next
;
1314 if (! exclude_writer
|| add
->writer
!= exclude_writer
)
1315 *to
= copy
? new_tlist (*to
, add
->expr
, add
->writer
) : add
;
1320 /* Merge the nodes of ADD into TO. This merging process is done so that for
1321 each variable that already exists in TO, no new node is added; however if
1322 there is a write access recorded in ADD, and an occurrence on TO is only
1323 a read access, then the occurrence in TO will be modified to record the
1327 merge_tlist (to
, add
, copy
)
1332 struct tlist
**end
= to
;
1335 end
= &(*end
)->next
;
1341 struct tlist
*next
= add
->next
;
1343 for (tmp2
= *to
; tmp2
; tmp2
= tmp2
->next
)
1344 if (tmp2
->expr
== add
->expr
)
1348 tmp2
->writer
= add
->writer
;
1352 *end
= copy
? add
: new_tlist (NULL
, add
->expr
, add
->writer
);
1353 end
= &(*end
)->next
;
1360 /* WRITTEN is a variable, WRITER is its parent. Warn if any of the variable
1361 references in list LIST conflict with it, excluding reads if ONLY writers
1365 warn_for_collisions_1 (written
, writer
, list
, only_writes
)
1366 tree written
, writer
;
1372 /* Avoid duplicate warnings. */
1373 for (tmp
= warned_ids
; tmp
; tmp
= tmp
->next
)
1374 if (tmp
->expr
== written
)
1379 if (list
->expr
== written
1380 && list
->writer
!= writer
1381 && (! only_writes
|| list
->writer
))
1383 warned_ids
= new_tlist (warned_ids
, written
, NULL_TREE
);
1384 warning ("operation on `%s' may be undefined",
1385 IDENTIFIER_POINTER (DECL_NAME (list
->expr
)));
1391 /* Given a list LIST of references to variables, find whether any of these
1392 can cause conflicts due to missing sequence points. */
1395 warn_for_collisions (list
)
1400 for (tmp
= list
; tmp
; tmp
= tmp
->next
)
1403 warn_for_collisions_1 (tmp
->expr
, tmp
->writer
, list
, 0);
1407 /* Return nonzero if X is a tree that can be verified by the sequence poitn
1410 warning_candidate_p (x
)
1413 return TREE_CODE (x
) == VAR_DECL
|| TREE_CODE (x
) == PARM_DECL
;
1416 /* Walk the tree X, and record accesses to variables. If X is written by the
1417 parent tree, WRITER is the parent.
1418 We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP. If this
1419 expression or its only operand forces a sequence point, then everything up
1420 to the sequence point is stored in PBEFORE_SP. Everything else gets stored
1422 Once we return, we will have emitted warnings if any subexpression before
1423 such a sequence point could be undefined. On a higher level, however, the
1424 sequence point may not be relevant, and we'll merge the two lists.
1426 Example: (b++, a) + b;
1427 The call that processes the COMPOUND_EXPR will store the increment of B
1428 in PBEFORE_SP, and the use of A in PNO_SP. The higher-level call that
1429 processes the PLUS_EXPR will need to merge the two lists so that
1430 eventually, all accesses end up on the same list (and we'll warn about the
1431 unordered subexpressions b++ and b.
1433 A note on merging. If we modify the former example so that our expression
1436 care must be taken not simply to add all three expressions into the final
1437 PNO_SP list. The function merge_tlist takes care of that by merging the
1438 before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1439 way, so that no more than one access to B is recorded. */
1442 verify_tree (x
, pbefore_sp
, pno_sp
, writer
)
1444 struct tlist
**pbefore_sp
, **pno_sp
;
1447 struct tlist
*tmp_before
, *tmp_nosp
, *tmp_list2
, *tmp_list3
;
1448 enum tree_code code
;
1452 code
= TREE_CODE (x
);
1453 class = TREE_CODE_CLASS (code
);
1455 if (warning_candidate_p (x
))
1457 *pno_sp
= new_tlist (*pno_sp
, x
, writer
);
1467 case TRUTH_ANDIF_EXPR
:
1468 case TRUTH_ORIF_EXPR
:
1469 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1470 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1471 warn_for_collisions (tmp_nosp
);
1472 merge_tlist (pbefore_sp
, tmp_before
, 0);
1473 merge_tlist (pbefore_sp
, tmp_nosp
, 0);
1474 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, pno_sp
, NULL_TREE
);
1475 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1479 tmp_before
= tmp_list2
= 0;
1480 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_list2
, NULL_TREE
);
1481 warn_for_collisions (tmp_list2
);
1482 merge_tlist (pbefore_sp
, tmp_before
, 0);
1483 merge_tlist (pbefore_sp
, tmp_list2
, 1);
1485 tmp_list3
= tmp_nosp
= 0;
1486 verify_tree (TREE_OPERAND (x
, 1), &tmp_list3
, &tmp_nosp
, NULL_TREE
);
1487 warn_for_collisions (tmp_nosp
);
1488 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1490 tmp_list3
= tmp_list2
= 0;
1491 verify_tree (TREE_OPERAND (x
, 2), &tmp_list3
, &tmp_list2
, NULL_TREE
);
1492 warn_for_collisions (tmp_list2
);
1493 merge_tlist (pbefore_sp
, tmp_list3
, 0);
1494 /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1495 two first, to avoid warning for (a ? b++ : b++). */
1496 merge_tlist (&tmp_nosp
, tmp_list2
, 0);
1497 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1500 case PREDECREMENT_EXPR
:
1501 case PREINCREMENT_EXPR
:
1502 case POSTDECREMENT_EXPR
:
1503 case POSTINCREMENT_EXPR
:
1504 verify_tree (TREE_OPERAND (x
, 0), pno_sp
, pno_sp
, x
);
1508 tmp_before
= tmp_nosp
= tmp_list3
= 0;
1509 verify_tree (TREE_OPERAND (x
, 1), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1510 verify_tree (TREE_OPERAND (x
, 0), &tmp_list3
, &tmp_list3
, x
);
1511 /* Expressions inside the LHS are not ordered wrt. the sequence points
1512 in the RHS. Example:
1514 Despite the fact that the modification of "a" is in the before_sp
1515 list (tmp_before), it conflicts with the use of "a" in the LHS.
1516 We can handle this by adding the contents of tmp_list3
1517 to those of tmp_before, and redoing the collision warnings for that
1519 add_tlist (&tmp_before
, tmp_list3
, x
, 1);
1520 warn_for_collisions (tmp_before
);
1521 /* Exclude the LHS itself here; we first have to merge it into the
1522 tmp_nosp list. This is done to avoid warning for "a = a"; if we
1523 didn't exclude the LHS, we'd get it twice, once as a read and once
1525 add_tlist (pno_sp
, tmp_list3
, x
, 0);
1526 warn_for_collisions_1 (TREE_OPERAND (x
, 0), x
, tmp_nosp
, 1);
1528 merge_tlist (pbefore_sp
, tmp_before
, 0);
1529 if (warning_candidate_p (TREE_OPERAND (x
, 0)))
1530 merge_tlist (&tmp_nosp
, new_tlist (NULL
, TREE_OPERAND (x
, 0), x
), 0);
1531 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 1);
1535 /* We need to warn about conflicts among arguments and conflicts between
1536 args and the function address. Side effects of the function address,
1537 however, are not ordered by the sequence point of the call. */
1538 tmp_before
= tmp_nosp
= tmp_list2
= tmp_list3
= 0;
1539 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1540 if (TREE_OPERAND (x
, 1))
1541 verify_tree (TREE_OPERAND (x
, 1), &tmp_list2
, &tmp_list3
, NULL_TREE
);
1542 merge_tlist (&tmp_list3
, tmp_list2
, 0);
1543 add_tlist (&tmp_before
, tmp_list3
, NULL_TREE
, 0);
1544 add_tlist (&tmp_before
, tmp_nosp
, NULL_TREE
, 0);
1545 warn_for_collisions (tmp_before
);
1546 add_tlist (pbefore_sp
, tmp_before
, NULL_TREE
, 0);
1550 /* Scan all the list, e.g. indices of multi dimensional array. */
1553 tmp_before
= tmp_nosp
= 0;
1554 verify_tree (TREE_VALUE (x
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1555 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1556 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1563 struct tlist_cache
*t
;
1564 for (t
= save_expr_cache
; t
; t
= t
->next
)
1570 t
= (struct tlist_cache
*) obstack_alloc (&tlist_obstack
,
1572 t
->next
= save_expr_cache
;
1574 save_expr_cache
= t
;
1576 tmp_before
= tmp_nosp
= 0;
1577 verify_tree (TREE_OPERAND (x
, 0), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1578 warn_for_collisions (tmp_nosp
);
1583 struct tlist
*t
= tmp_nosp
;
1585 merge_tlist (&tmp_list3
, t
, 0);
1587 t
->cache_before_sp
= tmp_before
;
1588 t
->cache_after_sp
= tmp_list3
;
1590 merge_tlist (pbefore_sp
, t
->cache_before_sp
, 1);
1591 add_tlist (pno_sp
, t
->cache_after_sp
, NULL_TREE
, 1);
1600 if (first_rtl_op (code
) == 0)
1602 x
= TREE_OPERAND (x
, 0);
1618 int max
= first_rtl_op (TREE_CODE (x
));
1619 for (lp
= 0; lp
< max
; lp
++)
1621 tmp_before
= tmp_nosp
= 0;
1622 verify_tree (TREE_OPERAND (x
, lp
), &tmp_before
, &tmp_nosp
, NULL_TREE
);
1623 merge_tlist (&tmp_nosp
, tmp_before
, 0);
1624 add_tlist (pno_sp
, tmp_nosp
, NULL_TREE
, 0);
1631 /* Try to warn for undefined behaviour in EXPR due to missing sequence
1635 verify_sequence_points (expr
)
1638 struct tlist
*before_sp
= 0, *after_sp
= 0;
1641 save_expr_cache
= 0;
1642 if (tlist_firstobj
== 0)
1644 gcc_obstack_init (&tlist_obstack
);
1645 tlist_firstobj
= obstack_alloc (&tlist_obstack
, 0);
1648 verify_tree (expr
, &before_sp
, &after_sp
, 0);
1649 warn_for_collisions (after_sp
);
1650 obstack_free (&tlist_obstack
, tlist_firstobj
);
1654 c_expand_expr_stmt (expr
)
1657 /* Do default conversion if safe and possibly important,
1658 in case within ({...}). */
1659 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1660 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1661 expr
= default_conversion (expr
);
1663 if (warn_sequence_point
)
1664 verify_sequence_points (expr
);
1666 if (TREE_TYPE (expr
) != error_mark_node
1667 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
1668 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1669 error ("expression statement has incomplete type");
1671 last_expr_type
= TREE_TYPE (expr
);
1672 return add_stmt (build_stmt (EXPR_STMT
, expr
));
1675 /* Validate the expression after `case' and apply default promotions. */
1678 check_case_value (value
)
1681 if (value
== NULL_TREE
)
1684 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1685 STRIP_TYPE_NOPS (value
);
1686 /* In C++, the following is allowed:
1689 switch (...) { case i: ... }
1691 So, we try to reduce the VALUE to a constant that way. */
1692 if (c_language
== clk_cplusplus
)
1694 value
= decl_constant_value (value
);
1695 STRIP_TYPE_NOPS (value
);
1696 value
= fold (value
);
1699 if (TREE_CODE (value
) != INTEGER_CST
1700 && value
!= error_mark_node
)
1702 error ("case label does not reduce to an integer constant");
1703 value
= error_mark_node
;
1706 /* Promote char or short to int. */
1707 value
= default_conversion (value
);
1709 constant_expression_warning (value
);
1714 /* Return an integer type with BITS bits of precision,
1715 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1718 type_for_size (bits
, unsignedp
)
1722 if (bits
== TYPE_PRECISION (integer_type_node
))
1723 return unsignedp
? unsigned_type_node
: integer_type_node
;
1725 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1726 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1728 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1729 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1731 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1732 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1734 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1735 return (unsignedp
? long_long_unsigned_type_node
1736 : long_long_integer_type_node
);
1738 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
1739 return (unsignedp
? widest_unsigned_literal_type_node
1740 : widest_integer_literal_type_node
);
1742 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1743 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1745 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1746 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1748 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1749 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1751 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1752 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1757 /* Return a data type that has machine mode MODE.
1758 If the mode is an integer,
1759 then UNSIGNEDP selects between signed and unsigned types. */
1762 type_for_mode (mode
, unsignedp
)
1763 enum machine_mode mode
;
1766 if (mode
== TYPE_MODE (integer_type_node
))
1767 return unsignedp
? unsigned_type_node
: integer_type_node
;
1769 if (mode
== TYPE_MODE (signed_char_type_node
))
1770 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1772 if (mode
== TYPE_MODE (short_integer_type_node
))
1773 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1775 if (mode
== TYPE_MODE (long_integer_type_node
))
1776 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1778 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1779 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1781 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
1782 return unsignedp
? widest_unsigned_literal_type_node
1783 : widest_integer_literal_type_node
;
1785 if (mode
== TYPE_MODE (intQI_type_node
))
1786 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1788 if (mode
== TYPE_MODE (intHI_type_node
))
1789 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1791 if (mode
== TYPE_MODE (intSI_type_node
))
1792 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1794 if (mode
== TYPE_MODE (intDI_type_node
))
1795 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1797 #if HOST_BITS_PER_WIDE_INT >= 64
1798 if (mode
== TYPE_MODE (intTI_type_node
))
1799 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
1802 if (mode
== TYPE_MODE (float_type_node
))
1803 return float_type_node
;
1805 if (mode
== TYPE_MODE (double_type_node
))
1806 return double_type_node
;
1808 if (mode
== TYPE_MODE (long_double_type_node
))
1809 return long_double_type_node
;
1811 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1812 return build_pointer_type (char_type_node
);
1814 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1815 return build_pointer_type (integer_type_node
);
1817 #ifdef VECTOR_MODE_SUPPORTED_P
1818 if (mode
== TYPE_MODE (V4SF_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1819 return V4SF_type_node
;
1820 if (mode
== TYPE_MODE (V4SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1821 return V4SI_type_node
;
1822 if (mode
== TYPE_MODE (V2SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1823 return V2SI_type_node
;
1824 if (mode
== TYPE_MODE (V4HI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1825 return V4HI_type_node
;
1826 if (mode
== TYPE_MODE (V8QI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
1827 return V8QI_type_node
;
1833 /* Return an unsigned type the same as TYPE in other respects. */
1835 unsigned_type (type
)
1838 tree type1
= TYPE_MAIN_VARIANT (type
);
1839 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
1840 return unsigned_char_type_node
;
1841 if (type1
== integer_type_node
)
1842 return unsigned_type_node
;
1843 if (type1
== short_integer_type_node
)
1844 return short_unsigned_type_node
;
1845 if (type1
== long_integer_type_node
)
1846 return long_unsigned_type_node
;
1847 if (type1
== long_long_integer_type_node
)
1848 return long_long_unsigned_type_node
;
1849 if (type1
== widest_integer_literal_type_node
)
1850 return widest_unsigned_literal_type_node
;
1851 #if HOST_BITS_PER_WIDE_INT >= 64
1852 if (type1
== intTI_type_node
)
1853 return unsigned_intTI_type_node
;
1855 if (type1
== intDI_type_node
)
1856 return unsigned_intDI_type_node
;
1857 if (type1
== intSI_type_node
)
1858 return unsigned_intSI_type_node
;
1859 if (type1
== intHI_type_node
)
1860 return unsigned_intHI_type_node
;
1861 if (type1
== intQI_type_node
)
1862 return unsigned_intQI_type_node
;
1864 return signed_or_unsigned_type (1, type
);
1867 /* Return a signed type the same as TYPE in other respects. */
1873 tree type1
= TYPE_MAIN_VARIANT (type
);
1874 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
1875 return signed_char_type_node
;
1876 if (type1
== unsigned_type_node
)
1877 return integer_type_node
;
1878 if (type1
== short_unsigned_type_node
)
1879 return short_integer_type_node
;
1880 if (type1
== long_unsigned_type_node
)
1881 return long_integer_type_node
;
1882 if (type1
== long_long_unsigned_type_node
)
1883 return long_long_integer_type_node
;
1884 if (type1
== widest_unsigned_literal_type_node
)
1885 return widest_integer_literal_type_node
;
1886 #if HOST_BITS_PER_WIDE_INT >= 64
1887 if (type1
== unsigned_intTI_type_node
)
1888 return intTI_type_node
;
1890 if (type1
== unsigned_intDI_type_node
)
1891 return intDI_type_node
;
1892 if (type1
== unsigned_intSI_type_node
)
1893 return intSI_type_node
;
1894 if (type1
== unsigned_intHI_type_node
)
1895 return intHI_type_node
;
1896 if (type1
== unsigned_intQI_type_node
)
1897 return intQI_type_node
;
1899 return signed_or_unsigned_type (0, type
);
1902 /* Return a type the same as TYPE except unsigned or
1903 signed according to UNSIGNEDP. */
1906 signed_or_unsigned_type (unsignedp
, type
)
1910 if (! INTEGRAL_TYPE_P (type
)
1911 || TREE_UNSIGNED (type
) == unsignedp
)
1914 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
1915 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1916 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1917 return unsignedp
? unsigned_type_node
: integer_type_node
;
1918 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
1919 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1920 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
1921 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1922 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
1923 return (unsignedp
? long_long_unsigned_type_node
1924 : long_long_integer_type_node
);
1925 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
1926 return (unsignedp
? widest_unsigned_literal_type_node
1927 : widest_integer_literal_type_node
);
1931 /* Return the minimum number of bits needed to represent VALUE in a
1932 signed or unsigned type, UNSIGNEDP says which. */
1935 min_precision (value
, unsignedp
)
1941 /* If the value is negative, compute its negative minus 1. The latter
1942 adjustment is because the absolute value of the largest negative value
1943 is one larger than the largest positive value. This is equivalent to
1944 a bit-wise negation, so use that operation instead. */
1946 if (tree_int_cst_sgn (value
) < 0)
1947 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1949 /* Return the number of bits needed, taking into account the fact
1950 that we need one more bit for a signed than unsigned type. */
1952 if (integer_zerop (value
))
1955 log
= tree_floor_log2 (value
);
1957 return log
+ 1 + ! unsignedp
;
1960 /* Print an error message for invalid operands to arith operation CODE.
1961 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1964 binary_op_error (code
)
1965 enum tree_code code
;
1967 register const char *opname
;
1972 error ("invalid truth-value expression");
1976 opname
= "+"; break;
1978 opname
= "-"; break;
1980 opname
= "*"; break;
1982 opname
= "max"; break;
1984 opname
= "min"; break;
1986 opname
= "=="; break;
1988 opname
= "!="; break;
1990 opname
= "<="; break;
1992 opname
= ">="; break;
1994 opname
= "<"; break;
1996 opname
= ">"; break;
1998 opname
= "<<"; break;
2000 opname
= ">>"; break;
2001 case TRUNC_MOD_EXPR
:
2002 case FLOOR_MOD_EXPR
:
2003 opname
= "%"; break;
2004 case TRUNC_DIV_EXPR
:
2005 case FLOOR_DIV_EXPR
:
2006 opname
= "/"; break;
2008 opname
= "&"; break;
2010 opname
= "|"; break;
2011 case TRUTH_ANDIF_EXPR
:
2012 opname
= "&&"; break;
2013 case TRUTH_ORIF_EXPR
:
2014 opname
= "||"; break;
2016 opname
= "^"; break;
2019 opname
= "rotate"; break;
2021 opname
= "unknown"; break;
2023 error ("invalid operands to binary %s", opname
);
2026 /* Subroutine of build_binary_op, used for comparison operations.
2027 See if the operands have both been converted from subword integer types
2028 and, if so, perhaps change them both back to their original type.
2029 This function is also responsible for converting the two operands
2030 to the proper common type for comparison.
2032 The arguments of this function are all pointers to local variables
2033 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2034 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2036 If this function returns nonzero, it means that the comparison has
2037 a constant value. What this function returns is an expression for
2041 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
2042 tree
*op0_ptr
, *op1_ptr
;
2044 enum tree_code
*rescode_ptr
;
2047 tree op0
= *op0_ptr
;
2048 tree op1
= *op1_ptr
;
2049 int unsignedp0
, unsignedp1
;
2051 tree primop0
, primop1
;
2052 enum tree_code code
= *rescode_ptr
;
2054 /* Throw away any conversions to wider types
2055 already present in the operands. */
2057 primop0
= get_narrower (op0
, &unsignedp0
);
2058 primop1
= get_narrower (op1
, &unsignedp1
);
2060 /* Handle the case that OP0 does not *contain* a conversion
2061 but it *requires* conversion to FINAL_TYPE. */
2063 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
2064 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
2065 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
2066 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
2068 /* If one of the operands must be floated, we cannot optimize. */
2069 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
2070 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
2072 /* If first arg is constant, swap the args (changing operation
2073 so value is preserved), for canonicalization. Don't do this if
2074 the second arg is 0. */
2076 if (TREE_CONSTANT (primop0
)
2077 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
2079 register tree tem
= primop0
;
2080 register int temi
= unsignedp0
;
2088 unsignedp0
= unsignedp1
;
2111 *rescode_ptr
= code
;
2114 /* If comparing an integer against a constant more bits wide,
2115 maybe we can deduce a value of 1 or 0 independent of the data.
2116 Or else truncate the constant now
2117 rather than extend the variable at run time.
2119 This is only interesting if the constant is the wider arg.
2120 Also, it is not safe if the constant is unsigned and the
2121 variable arg is signed, since in this case the variable
2122 would be sign-extended and then regarded as unsigned.
2123 Our technique fails in this case because the lowest/highest
2124 possible unsigned results don't follow naturally from the
2125 lowest/highest possible values of the variable operand.
2126 For just EQ_EXPR and NE_EXPR there is another technique that
2127 could be used: see if the constant can be faithfully represented
2128 in the other operand's type, by truncating it and reextending it
2129 and see if that preserves the constant's value. */
2131 if (!real1
&& !real2
2132 && TREE_CODE (primop1
) == INTEGER_CST
2133 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
2135 int min_gt
, max_gt
, min_lt
, max_lt
;
2136 tree maxval
, minval
;
2137 /* 1 if comparison is nominally unsigned. */
2138 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
2141 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
2143 /* If TYPE is an enumeration, then we need to get its min/max
2144 values from it's underlying integral type, not the enumerated
2146 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
2147 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
2149 maxval
= TYPE_MAX_VALUE (type
);
2150 minval
= TYPE_MIN_VALUE (type
);
2152 if (unsignedp
&& !unsignedp0
)
2153 *restype_ptr
= signed_type (*restype_ptr
);
2155 if (TREE_TYPE (primop1
) != *restype_ptr
)
2156 primop1
= convert (*restype_ptr
, primop1
);
2157 if (type
!= *restype_ptr
)
2159 minval
= convert (*restype_ptr
, minval
);
2160 maxval
= convert (*restype_ptr
, maxval
);
2163 if (unsignedp
&& unsignedp0
)
2165 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
2166 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
2167 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
2168 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
2172 min_gt
= INT_CST_LT (primop1
, minval
);
2173 max_gt
= INT_CST_LT (primop1
, maxval
);
2174 min_lt
= INT_CST_LT (minval
, primop1
);
2175 max_lt
= INT_CST_LT (maxval
, primop1
);
2179 /* This used to be a switch, but Genix compiler can't handle that. */
2180 if (code
== NE_EXPR
)
2182 if (max_lt
|| min_gt
)
2183 val
= boolean_true_node
;
2185 else if (code
== EQ_EXPR
)
2187 if (max_lt
|| min_gt
)
2188 val
= boolean_false_node
;
2190 else if (code
== LT_EXPR
)
2193 val
= boolean_true_node
;
2195 val
= boolean_false_node
;
2197 else if (code
== GT_EXPR
)
2200 val
= boolean_true_node
;
2202 val
= boolean_false_node
;
2204 else if (code
== LE_EXPR
)
2207 val
= boolean_true_node
;
2209 val
= boolean_false_node
;
2211 else if (code
== GE_EXPR
)
2214 val
= boolean_true_node
;
2216 val
= boolean_false_node
;
2219 /* If primop0 was sign-extended and unsigned comparison specd,
2220 we did a signed comparison above using the signed type bounds.
2221 But the comparison we output must be unsigned.
2223 Also, for inequalities, VAL is no good; but if the signed
2224 comparison had *any* fixed result, it follows that the
2225 unsigned comparison just tests the sign in reverse
2226 (positive values are LE, negative ones GE).
2227 So we can generate an unsigned comparison
2228 against an extreme value of the signed type. */
2230 if (unsignedp
&& !unsignedp0
)
2237 primop1
= TYPE_MIN_VALUE (type
);
2243 primop1
= TYPE_MAX_VALUE (type
);
2250 type
= unsigned_type (type
);
2253 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
2255 /* This is the case of (char)x >?< 0x80, which people used to use
2256 expecting old C compilers to change the 0x80 into -0x80. */
2257 if (val
== boolean_false_node
)
2258 warning ("comparison is always false due to limited range of data type");
2259 if (val
== boolean_true_node
)
2260 warning ("comparison is always true due to limited range of data type");
2263 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
2265 /* This is the case of (unsigned char)x >?< -1 or < 0. */
2266 if (val
== boolean_false_node
)
2267 warning ("comparison is always false due to limited range of data type");
2268 if (val
== boolean_true_node
)
2269 warning ("comparison is always true due to limited range of data type");
2274 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2275 if (TREE_SIDE_EFFECTS (primop0
))
2276 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
2280 /* Value is not predetermined, but do the comparison
2281 in the type of the operand that is not constant.
2282 TYPE is already properly set. */
2284 else if (real1
&& real2
2285 && (TYPE_PRECISION (TREE_TYPE (primop0
))
2286 == TYPE_PRECISION (TREE_TYPE (primop1
))))
2287 type
= TREE_TYPE (primop0
);
2289 /* If args' natural types are both narrower than nominal type
2290 and both extend in the same manner, compare them
2291 in the type of the wider arg.
2292 Otherwise must actually extend both to the nominal
2293 common type lest different ways of extending
2295 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2297 else if (unsignedp0
== unsignedp1
&& real1
== real2
2298 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
2299 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
2301 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
2302 type
= signed_or_unsigned_type (unsignedp0
2303 || TREE_UNSIGNED (*restype_ptr
),
2305 /* Make sure shorter operand is extended the right way
2306 to match the longer operand. */
2307 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
2309 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
2314 /* Here we must do the comparison on the nominal type
2315 using the args exactly as we received them. */
2316 type
= *restype_ptr
;
2320 if (!real1
&& !real2
&& integer_zerop (primop1
)
2321 && TREE_UNSIGNED (*restype_ptr
))
2327 /* All unsigned values are >= 0, so we warn if extra warnings
2328 are requested. However, if OP0 is a constant that is
2329 >= 0, the signedness of the comparison isn't an issue,
2330 so suppress the warning. */
2331 if (extra_warnings
&& !in_system_header
2332 && ! (TREE_CODE (primop0
) == INTEGER_CST
2333 && ! TREE_OVERFLOW (convert (signed_type (type
),
2335 warning ("comparison of unsigned expression >= 0 is always true");
2336 value
= boolean_true_node
;
2340 if (extra_warnings
&& !in_system_header
2341 && ! (TREE_CODE (primop0
) == INTEGER_CST
2342 && ! TREE_OVERFLOW (convert (signed_type (type
),
2344 warning ("comparison of unsigned expression < 0 is always false");
2345 value
= boolean_false_node
;
2354 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2355 if (TREE_SIDE_EFFECTS (primop0
))
2356 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
2363 *op0_ptr
= convert (type
, primop0
);
2364 *op1_ptr
= convert (type
, primop1
);
2366 *restype_ptr
= boolean_type_node
;
2371 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2372 or validate its data type for an `if' or `while' statement or ?..: exp.
2374 This preparation consists of taking the ordinary
2375 representation of an expression expr and producing a valid tree
2376 boolean expression describing whether expr is nonzero. We could
2377 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
2378 but we optimize comparisons, &&, ||, and !.
2380 The resulting type should always be `boolean_type_node'. */
2383 truthvalue_conversion (expr
)
2386 if (TREE_CODE (expr
) == ERROR_MARK
)
2389 #if 0 /* This appears to be wrong for C++. */
2390 /* These really should return error_mark_node after 2.4 is stable.
2391 But not all callers handle ERROR_MARK properly. */
2392 switch (TREE_CODE (TREE_TYPE (expr
)))
2395 error ("struct type value used where scalar is required");
2396 return boolean_false_node
;
2399 error ("union type value used where scalar is required");
2400 return boolean_false_node
;
2403 error ("array type value used where scalar is required");
2404 return boolean_false_node
;
2411 switch (TREE_CODE (expr
))
2414 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2415 case TRUTH_ANDIF_EXPR
:
2416 case TRUTH_ORIF_EXPR
:
2417 case TRUTH_AND_EXPR
:
2419 case TRUTH_XOR_EXPR
:
2420 case TRUTH_NOT_EXPR
:
2421 TREE_TYPE (expr
) = boolean_type_node
;
2428 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2431 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2434 /* If we are taking the address of a external decl, it might be zero
2435 if it is weak, so we cannot optimize. */
2436 if (DECL_P (TREE_OPERAND (expr
, 0))
2437 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
2440 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2441 return build (COMPOUND_EXPR
, boolean_type_node
,
2442 TREE_OPERAND (expr
, 0), boolean_true_node
);
2444 return boolean_true_node
;
2447 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2448 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2449 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2450 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2457 /* These don't change whether an object is non-zero or zero. */
2458 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2462 /* These don't change whether an object is zero or non-zero, but
2463 we can't ignore them if their second arg has side-effects. */
2464 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2465 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2466 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2468 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2471 /* Distribute the conversion into the arms of a COND_EXPR. */
2472 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2473 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2474 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2477 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2478 since that affects how `default_conversion' will behave. */
2479 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2480 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2482 /* fall through... */
2484 /* If this is widening the argument, we can ignore it. */
2485 if (TYPE_PRECISION (TREE_TYPE (expr
))
2486 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2487 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2491 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2493 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2494 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2496 /* fall through... */
2498 /* This and MINUS_EXPR can be changed into a comparison of the
2500 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2501 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2502 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2503 TREE_OPERAND (expr
, 1), 1);
2504 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2505 fold (build1 (NOP_EXPR
,
2506 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2507 TREE_OPERAND (expr
, 1))), 1);
2510 if (integer_onep (TREE_OPERAND (expr
, 1))
2511 && TREE_TYPE (expr
) != boolean_type_node
)
2512 /* Using convert here would cause infinite recursion. */
2513 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2517 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2518 warning ("suggest parentheses around assignment used as truth value");
2525 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2527 tree tem
= save_expr (expr
);
2528 return (build_binary_op
2529 ((TREE_SIDE_EFFECTS (expr
)
2530 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2531 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
2532 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
2536 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2539 static tree builtin_function_2
PARAMS ((const char *, const char *, tree
, tree
,
2540 int, enum built_in_class
, int, int,
2543 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2544 down to the element type of an array. */
2547 c_build_qualified_type (type
, type_quals
)
2551 /* A restrict-qualified pointer type must be a pointer to object or
2552 incomplete type. Note that the use of POINTER_TYPE_P also allows
2553 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
2554 the C++ front-end also use POINTER_TYPE for pointer-to-member
2555 values, so even though it should be illegal to use `restrict'
2556 with such an entity we don't flag that here. Thus, special case
2557 code for that case is required in the C++ front-end. */
2558 if ((type_quals
& TYPE_QUAL_RESTRICT
)
2559 && (!POINTER_TYPE_P (type
)
2560 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
2562 error ("invalid use of `restrict'");
2563 type_quals
&= ~TYPE_QUAL_RESTRICT
;
2566 if (TREE_CODE (type
) == ARRAY_TYPE
)
2567 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
2569 TYPE_DOMAIN (type
));
2570 return build_qualified_type (type
, type_quals
);
2573 /* Apply the TYPE_QUALS to the new DECL. */
2576 c_apply_type_quals_to_decl (type_quals
, decl
)
2580 if ((type_quals
& TYPE_QUAL_CONST
)
2581 || (TREE_TYPE (decl
)
2582 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
2583 TREE_READONLY (decl
) = 1;
2584 if (type_quals
& TYPE_QUAL_VOLATILE
)
2586 TREE_SIDE_EFFECTS (decl
) = 1;
2587 TREE_THIS_VOLATILE (decl
) = 1;
2589 if (type_quals
& TYPE_QUAL_RESTRICT
)
2591 if (!TREE_TYPE (decl
)
2592 || !POINTER_TYPE_P (TREE_TYPE (decl
))
2593 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
2594 error ("invalid use of `restrict'");
2595 else if (flag_strict_aliasing
)
2597 /* No two restricted pointers can point at the same thing.
2598 However, a restricted pointer can point at the same thing
2599 as an unrestricted pointer, if that unrestricted pointer
2600 is based on the restricted pointer. So, we make the
2601 alias set for the restricted pointer a subset of the
2602 alias set for the type pointed to by the type of the
2605 HOST_WIDE_INT pointed_to_alias_set
2606 = get_alias_set (TREE_TYPE (TREE_TYPE (decl
)));
2608 if (pointed_to_alias_set
== 0)
2609 /* It's not legal to make a subset of alias set zero. */
2613 DECL_POINTER_ALIAS_SET (decl
) = new_alias_set ();
2614 record_alias_subset (pointed_to_alias_set
,
2615 DECL_POINTER_ALIAS_SET (decl
));
2622 /* Return the typed-based alias set for T, which may be an expression
2623 or a type. Return -1 if we don't do anything special. */
2626 lang_get_alias_set (t
)
2631 /* We know nothing about vector types */
2632 if (TREE_CODE (t
) == VECTOR_TYPE
)
2635 /* Permit type-punning when accessing a union, provided the access
2636 is directly through the union. For example, this code does not
2637 permit taking the address of a union member and then storing
2638 through it. Even the type-punning allowed here is a GCC
2639 extension, albeit a common and useful one; the C standard says
2640 that such accesses have implementation-defined behavior. */
2642 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
2643 u
= TREE_OPERAND (u
, 0))
2644 if (TREE_CODE (u
) == COMPONENT_REF
2645 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
2648 /* If this is a char *, the ANSI C standard says it can alias
2649 anything. Note that all references need do this. */
2650 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
2651 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
2652 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
2655 /* That's all the expressions we handle specially. */
2659 /* The C standard specifically allows aliasing between signed and
2660 unsigned variants of the same type. We treat the signed
2661 variant as canonical. */
2662 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
2664 tree t1
= signed_type (t
);
2666 /* t1 == t can happen for boolean nodes which are always unsigned. */
2668 return get_alias_set (t1
);
2670 else if (POINTER_TYPE_P (t
))
2674 /* Unfortunately, there is no canonical form of a pointer type.
2675 In particular, if we have `typedef int I', then `int *', and
2676 `I *' are different types. So, we have to pick a canonical
2677 representative. We do this below.
2679 Technically, this approach is actually more conservative that
2680 it needs to be. In particular, `const int *' and `int *'
2681 chould be in different alias sets, according to the C and C++
2682 standard, since their types are not the same, and so,
2683 technically, an `int **' and `const int **' cannot point at
2686 But, the standard is wrong. In particular, this code is
2691 const int* const* cipp = &ip;
2693 And, it doesn't make sense for that to be legal unless you
2694 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2695 the pointed-to types. This issue has been reported to the
2697 t1
= build_type_no_quals (t
);
2699 return get_alias_set (t1
);
2701 /* It's not yet safe to use alias sets for classes in C++ because
2702 the TYPE_FIELDs list for a class doesn't mention base classes. */
2703 else if (c_language
== clk_cplusplus
&& AGGREGATE_TYPE_P (t
))
2709 /* Build tree nodes and builtin functions common to both C and C++ language
2713 c_common_nodes_and_builtins ()
2715 int wchar_type_size
;
2716 tree array_domain_type
;
2718 tree memcpy_ftype
, memset_ftype
, strlen_ftype
;
2719 tree bzero_ftype
, bcmp_ftype
, puts_ftype
, printf_ftype
;
2720 tree fputs_ftype
, fputc_ftype
, fwrite_ftype
, fprintf_ftype
;
2721 tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
2722 tree cstring_endlink
, sizetype_endlink
;
2723 tree ptr_ftype
, ptr_ftype_unsigned
;
2724 tree void_ftype_any
, void_ftype_int
, int_ftype_any
;
2725 tree double_ftype_double
, double_ftype_double_double
;
2726 tree float_ftype_float
, ldouble_ftype_ldouble
;
2727 tree cfloat_ftype_cfloat
, cdouble_ftype_cdouble
, cldouble_ftype_cldouble
;
2728 tree float_ftype_cfloat
, double_ftype_cdouble
, ldouble_ftype_cldouble
;
2729 tree int_ftype_cptr_cptr_sizet
, sizet_ftype_cstring_cstring
;
2730 tree int_ftype_cstring_cstring
, string_ftype_string_cstring
;
2731 tree string_ftype_cstring_int
, string_ftype_cstring_cstring
;
2732 tree string_ftype_string_cstring_sizet
, int_ftype_cstring_cstring_sizet
;
2733 tree long_ftype_long
;
2734 tree longlong_ftype_longlong
;
2735 tree intmax_ftype_intmax
;
2736 /* Either char* or void*. */
2737 tree traditional_ptr_type_node
;
2738 /* Either const char* or const void*. */
2739 tree traditional_cptr_type_node
;
2740 tree traditional_len_type_node
;
2741 tree traditional_len_endlink
;
2742 tree va_list_ref_type_node
;
2743 tree va_list_arg_type_node
;
2745 /* Define `int' and `char' first so that dbx will output them first. */
2746 record_builtin_type (RID_INT
, NULL_PTR
, integer_type_node
);
2747 record_builtin_type (RID_CHAR
, "char", char_type_node
);
2749 /* `signed' is the same as `int'. FIXME: the declarations of "signed",
2750 "unsigned long", "long long unsigned" and "unsigned short" were in C++
2751 but not C. Are the conditionals here needed? */
2752 if (c_language
== clk_cplusplus
)
2753 record_builtin_type (RID_SIGNED
, NULL_PTR
, integer_type_node
);
2754 record_builtin_type (RID_LONG
, "long int", long_integer_type_node
);
2755 record_builtin_type (RID_UNSIGNED
, "unsigned int", unsigned_type_node
);
2756 record_builtin_type (RID_MAX
, "long unsigned int",
2757 long_unsigned_type_node
);
2758 if (c_language
== clk_cplusplus
)
2759 record_builtin_type (RID_MAX
, "unsigned long", long_unsigned_type_node
);
2760 record_builtin_type (RID_MAX
, "long long int",
2761 long_long_integer_type_node
);
2762 record_builtin_type (RID_MAX
, "long long unsigned int",
2763 long_long_unsigned_type_node
);
2764 if (c_language
== clk_cplusplus
)
2765 record_builtin_type (RID_MAX
, "long long unsigned",
2766 long_long_unsigned_type_node
);
2767 record_builtin_type (RID_SHORT
, "short int", short_integer_type_node
);
2768 record_builtin_type (RID_MAX
, "short unsigned int",
2769 short_unsigned_type_node
);
2770 if (c_language
== clk_cplusplus
)
2771 record_builtin_type (RID_MAX
, "unsigned short",
2772 short_unsigned_type_node
);
2774 /* Define both `signed char' and `unsigned char'. */
2775 record_builtin_type (RID_MAX
, "signed char", signed_char_type_node
);
2776 record_builtin_type (RID_MAX
, "unsigned char", unsigned_char_type_node
);
2778 /* These are types that type_for_size and type_for_mode use. */
2779 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intQI_type_node
));
2780 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intHI_type_node
));
2781 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intSI_type_node
));
2782 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, intDI_type_node
));
2783 #if HOST_BITS_PER_WIDE_INT >= 64
2784 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__int128_t"), intTI_type_node
));
2786 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intQI_type_node
));
2787 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intHI_type_node
));
2788 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intSI_type_node
));
2789 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
, unsigned_intDI_type_node
));
2790 #if HOST_BITS_PER_WIDE_INT >= 64
2791 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__uint128_t"), unsigned_intTI_type_node
));
2794 /* Create the widest literal types. */
2795 widest_integer_literal_type_node
2796 = make_signed_type (HOST_BITS_PER_WIDE_INT
* 2);
2797 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2798 widest_integer_literal_type_node
));
2800 widest_unsigned_literal_type_node
2801 = make_unsigned_type (HOST_BITS_PER_WIDE_INT
* 2);
2802 pushdecl (build_decl (TYPE_DECL
, NULL_TREE
,
2803 widest_unsigned_literal_type_node
));
2805 /* `unsigned long' is the standard type for sizeof.
2806 Note that stddef.h uses `unsigned long',
2807 and this must agree, even if long and int are the same size. */
2809 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE
)));
2810 signed_size_type_node
= signed_type (c_size_type_node
);
2811 if (flag_traditional
)
2812 c_size_type_node
= signed_size_type_node
;
2813 set_sizetype (c_size_type_node
);
2815 build_common_tree_nodes_2 (flag_short_double
);
2817 record_builtin_type (RID_FLOAT
, NULL_PTR
, float_type_node
);
2818 record_builtin_type (RID_DOUBLE
, NULL_PTR
, double_type_node
);
2819 record_builtin_type (RID_MAX
, "long double", long_double_type_node
);
2821 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex int"),
2822 complex_integer_type_node
));
2823 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex float"),
2824 complex_float_type_node
));
2825 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex double"),
2826 complex_double_type_node
));
2827 pushdecl (build_decl (TYPE_DECL
, get_identifier ("complex long double"),
2828 complex_long_double_type_node
));
2830 record_builtin_type (RID_VOID
, NULL_PTR
, void_type_node
);
2832 void_list_node
= build_void_list_node ();
2834 /* Make a type to be the domain of a few array types
2835 whose domains don't really matter.
2836 200 is small enough that it always fits in size_t
2837 and large enough that it can hold most function names for the
2838 initializations of __FUNCTION__ and __PRETTY_FUNCTION__. */
2839 array_domain_type
= build_index_type (size_int (200));
2841 /* Make a type for arrays of characters.
2842 With luck nothing will ever really depend on the length of this
2844 char_array_type_node
2845 = build_array_type (char_type_node
, array_domain_type
);
2847 /* Likewise for arrays of ints. */
2849 = build_array_type (integer_type_node
, array_domain_type
);
2851 #ifdef MD_INIT_BUILTINS
2855 /* This is special for C++ so functions can be overloaded. */
2856 wchar_type_node
= get_identifier (flag_short_wchar
2857 ? "short unsigned int"
2859 wchar_type_node
= TREE_TYPE (identifier_global_value (wchar_type_node
));
2860 wchar_type_size
= TYPE_PRECISION (wchar_type_node
);
2861 if (c_language
== clk_cplusplus
)
2863 if (TREE_UNSIGNED (wchar_type_node
))
2864 wchar_type_node
= make_unsigned_type (wchar_type_size
);
2866 wchar_type_node
= make_signed_type (wchar_type_size
);
2867 record_builtin_type (RID_WCHAR
, "wchar_t", wchar_type_node
);
2871 signed_wchar_type_node
= signed_type (wchar_type_node
);
2872 unsigned_wchar_type_node
= unsigned_type (wchar_type_node
);
2875 /* This is for wide string constants. */
2876 wchar_array_type_node
2877 = build_array_type (wchar_type_node
, array_domain_type
);
2879 string_type_node
= build_pointer_type (char_type_node
);
2880 const_string_type_node
2881 = build_pointer_type (build_type_variant (char_type_node
, 1, 0));
2884 TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE
)));
2887 TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE
)));
2889 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE
)));
2891 default_function_type
= build_function_type (integer_type_node
, NULL_TREE
);
2893 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE
)));
2894 unsigned_ptrdiff_type_node
= unsigned_type (ptrdiff_type_node
);
2896 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
2897 va_list_type_node
));
2899 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
2900 ptrdiff_type_node
));
2902 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
2905 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
2907 va_list_arg_type_node
= va_list_ref_type_node
=
2908 build_pointer_type (TREE_TYPE (va_list_type_node
));
2912 va_list_arg_type_node
= va_list_type_node
;
2913 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
2916 endlink
= void_list_node
;
2917 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
2918 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
2919 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
2920 cstring_endlink
= tree_cons (NULL_TREE
, const_string_type_node
, endlink
);
2922 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
2923 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
2924 sizetype_endlink
= tree_cons (NULL_TREE
, TYPE_DOMAIN (sizetype
), endlink
);
2925 /* We realloc here because sizetype could be int or unsigned. S'ok. */
2926 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
2928 int_ftype_any
= build_function_type (integer_type_node
, NULL_TREE
);
2929 void_ftype_any
= build_function_type (void_type_node
, NULL_TREE
);
2930 void_ftype
= build_function_type (void_type_node
, endlink
);
2931 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
2933 = build_function_type (void_type_node
,
2934 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
2937 = build_function_type (float_type_node
,
2938 tree_cons (NULL_TREE
, float_type_node
, endlink
));
2941 = build_function_type (double_type_node
, double_endlink
);
2943 ldouble_ftype_ldouble
2944 = build_function_type (long_double_type_node
,
2945 tree_cons (NULL_TREE
, long_double_type_node
,
2948 double_ftype_double_double
2949 = build_function_type (double_type_node
,
2950 tree_cons (NULL_TREE
, double_type_node
,
2954 = build_function_type (complex_float_type_node
,
2955 tree_cons (NULL_TREE
, complex_float_type_node
,
2957 cdouble_ftype_cdouble
2958 = build_function_type (complex_double_type_node
,
2959 tree_cons (NULL_TREE
, complex_double_type_node
,
2961 cldouble_ftype_cldouble
2962 = build_function_type (complex_long_double_type_node
,
2963 tree_cons (NULL_TREE
, complex_long_double_type_node
,
2967 = build_function_type (float_type_node
,
2968 tree_cons (NULL_TREE
, complex_float_type_node
,
2970 double_ftype_cdouble
2971 = build_function_type (double_type_node
,
2972 tree_cons (NULL_TREE
, complex_double_type_node
,
2974 ldouble_ftype_cldouble
2975 = build_function_type (long_double_type_node
,
2976 tree_cons (NULL_TREE
, complex_long_double_type_node
,
2980 = build_function_type (integer_type_node
, int_endlink
);
2983 = build_function_type (long_integer_type_node
,
2984 tree_cons (NULL_TREE
, long_integer_type_node
,
2987 longlong_ftype_longlong
2988 = build_function_type (long_long_integer_type_node
,
2989 tree_cons (NULL_TREE
, long_long_integer_type_node
,
2993 = build_function_type (intmax_type_node
,
2994 tree_cons (NULL_TREE
, intmax_type_node
,
2997 int_ftype_cptr_cptr_sizet
2998 = build_function_type (integer_type_node
,
2999 tree_cons (NULL_TREE
, const_ptr_type_node
,
3000 tree_cons (NULL_TREE
,
3001 const_ptr_type_node
,
3002 sizetype_endlink
)));
3004 void_zero_node
= build_int_2 (0, 0);
3005 TREE_TYPE (void_zero_node
) = void_type_node
;
3007 /* Prototype for strcpy/strcat. */
3008 string_ftype_string_cstring
3009 = build_function_type (string_type_node
,
3010 tree_cons (NULL_TREE
, string_type_node
,
3013 /* Prototype for strncpy/strncat. */
3014 string_ftype_string_cstring_sizet
3015 = build_function_type (string_type_node
,
3016 tree_cons (NULL_TREE
, string_type_node
,
3017 tree_cons (NULL_TREE
,
3018 const_string_type_node
,
3019 sizetype_endlink
)));
3021 traditional_len_type_node
= ((flag_traditional
&&
3022 c_language
!= clk_cplusplus
)
3023 ? integer_type_node
: sizetype
);
3024 traditional_len_endlink
= tree_cons (NULL_TREE
, traditional_len_type_node
,
3027 /* Prototype for strcmp. */
3028 int_ftype_cstring_cstring
3029 = build_function_type (integer_type_node
,
3030 tree_cons (NULL_TREE
, const_string_type_node
,
3033 /* Prototype for strspn/strcspn. */
3034 sizet_ftype_cstring_cstring
3035 = build_function_type (c_size_type_node
,
3036 tree_cons (NULL_TREE
, const_string_type_node
,
3039 /* Prototype for strncmp. */
3040 int_ftype_cstring_cstring_sizet
3041 = build_function_type (integer_type_node
,
3042 tree_cons (NULL_TREE
, const_string_type_node
,
3043 tree_cons (NULL_TREE
,
3044 const_string_type_node
,
3045 sizetype_endlink
)));
3047 /* Prototype for strstr, strpbrk, etc. */
3048 string_ftype_cstring_cstring
3049 = build_function_type (string_type_node
,
3050 tree_cons (NULL_TREE
, const_string_type_node
,
3053 /* Prototype for strchr. */
3054 string_ftype_cstring_int
3055 = build_function_type (string_type_node
,
3056 tree_cons (NULL_TREE
, const_string_type_node
,
3059 /* Prototype for strlen. */
3061 = build_function_type (traditional_len_type_node
, cstring_endlink
);
3063 traditional_ptr_type_node
= ((flag_traditional
&&
3064 c_language
!= clk_cplusplus
)
3065 ? string_type_node
: ptr_type_node
);
3066 traditional_cptr_type_node
= ((flag_traditional
&&
3067 c_language
!= clk_cplusplus
)
3068 ? const_string_type_node
: const_ptr_type_node
);
3070 /* Prototype for memcpy. */
3072 = build_function_type (traditional_ptr_type_node
,
3073 tree_cons (NULL_TREE
, ptr_type_node
,
3074 tree_cons (NULL_TREE
, const_ptr_type_node
,
3075 sizetype_endlink
)));
3077 /* Prototype for memset. */
3079 = build_function_type (traditional_ptr_type_node
,
3080 tree_cons (NULL_TREE
, ptr_type_node
,
3081 tree_cons (NULL_TREE
, integer_type_node
,
3082 sizetype_endlink
)));
3084 /* Prototype for bzero. */
3086 = build_function_type (void_type_node
,
3087 tree_cons (NULL_TREE
, traditional_ptr_type_node
,
3088 traditional_len_endlink
));
3090 /* Prototype for bcmp. */
3092 = build_function_type (integer_type_node
,
3093 tree_cons (NULL_TREE
, traditional_cptr_type_node
,
3094 tree_cons (NULL_TREE
,
3095 traditional_cptr_type_node
,
3096 traditional_len_endlink
)));
3098 /* Prototype for puts. */
3100 = build_function_type (integer_type_node
, cstring_endlink
);
3102 /* Prototype for printf. */
3104 = build_function_type (integer_type_node
,
3105 tree_cons (NULL_TREE
, const_string_type_node
,
3108 /* These stdio prototypes are declared using void* in place of
3109 FILE*. They are only used for __builtin_ style calls, regular
3110 style builtin prototypes omit the arguments and merge those
3111 provided by stdio.h. */
3112 /* Prototype for fwrite. */
3114 = build_function_type (c_size_type_node
,
3115 tree_cons (NULL_TREE
, const_ptr_type_node
,
3116 tree_cons (NULL_TREE
, c_size_type_node
,
3117 tree_cons (NULL_TREE
, c_size_type_node
,
3118 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)))));
3120 /* Prototype for fputc. */
3122 = build_function_type (integer_type_node
,
3123 tree_cons (NULL_TREE
, integer_type_node
,
3124 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
3126 /* Prototype for fputs. */
3128 = build_function_type (integer_type_node
,
3129 tree_cons (NULL_TREE
, const_string_type_node
,
3130 tree_cons (NULL_TREE
, ptr_type_node
, endlink
)));
3132 /* Prototype for fprintf. */
3134 = build_function_type (integer_type_node
,
3135 tree_cons (NULL_TREE
, ptr_type_node
,
3136 tree_cons (NULL_TREE
,
3137 const_string_type_node
,
3140 builtin_function ("__builtin_constant_p", default_function_type
,
3141 BUILT_IN_CONSTANT_P
, BUILT_IN_NORMAL
, NULL_PTR
);
3143 builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
3144 BUILT_IN_RETURN_ADDRESS
, BUILT_IN_NORMAL
, NULL_PTR
);
3146 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
3147 BUILT_IN_FRAME_ADDRESS
, BUILT_IN_NORMAL
, NULL_PTR
);
3149 #ifdef EH_RETURN_DATA_REGNO
3150 builtin_function ("__builtin_eh_return_data_regno", int_ftype_int
,
3151 BUILT_IN_EH_RETURN_DATA_REGNO
, BUILT_IN_NORMAL
, NULL_PTR
);
3154 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
3155 BUILT_IN_ALLOCA
, BUILT_IN_NORMAL
, "alloca");
3156 builtin_function_2 ("__builtin_ffs", "ffs",
3157 int_ftype_int
, int_ftype_int
,
3158 BUILT_IN_FFS
, BUILT_IN_NORMAL
, 0, 1, 0);
3159 /* Define alloca as builtin, unless SMALL_STACK. */
3161 builtin_function_2 (NULL_PTR
, "alloca", NULL_TREE
, ptr_ftype_sizetype
,
3162 BUILT_IN_ALLOCA
, BUILT_IN_NORMAL
, 0, 1, 0);
3164 /* Declare _exit and _Exit just to mark them as non-returning. */
3165 builtin_function_2 (NULL_PTR
, "_exit", NULL_TREE
, void_ftype_int
,
3166 0, NOT_BUILT_IN
, 0, 1, 1);
3167 builtin_function_2 (NULL_PTR
, "_Exit", NULL_TREE
, void_ftype_int
,
3168 0, NOT_BUILT_IN
, 0, !flag_isoc99
, 1);
3170 builtin_function_2 ("__builtin_index", "index",
3171 string_ftype_cstring_int
, string_ftype_cstring_int
,
3172 BUILT_IN_INDEX
, BUILT_IN_NORMAL
, 1, 1, 0);
3173 builtin_function_2 ("__builtin_rindex", "rindex",
3174 string_ftype_cstring_int
, string_ftype_cstring_int
,
3175 BUILT_IN_RINDEX
, BUILT_IN_NORMAL
, 1, 1, 0);
3177 /* The system prototypes for these functions have many
3178 variations, so don't specify parameters to avoid conflicts.
3179 The expand_* functions check the argument types anyway. */
3180 builtin_function_2 ("__builtin_bzero", "bzero",
3181 bzero_ftype
, void_ftype_any
,
3182 BUILT_IN_BZERO
, BUILT_IN_NORMAL
, 1, 1, 0);
3183 builtin_function_2 ("__builtin_bcmp", "bcmp",
3184 bcmp_ftype
, int_ftype_any
,
3185 BUILT_IN_BCMP
, BUILT_IN_NORMAL
, 1, 1, 0);
3187 builtin_function_2 ("__builtin_abs", "abs",
3188 int_ftype_int
, int_ftype_int
,
3189 BUILT_IN_ABS
, BUILT_IN_NORMAL
, 0, 0, 0);
3190 builtin_function_2 ("__builtin_fabsf", "fabsf",
3191 float_ftype_float
, float_ftype_float
,
3192 BUILT_IN_FABS
, BUILT_IN_NORMAL
, 0, 0, 0);
3193 builtin_function_2 ("__builtin_fabs", "fabs",
3194 double_ftype_double
, double_ftype_double
,
3195 BUILT_IN_FABS
, BUILT_IN_NORMAL
, 0, 0, 0);
3196 builtin_function_2 ("__builtin_fabsl", "fabsl",
3197 ldouble_ftype_ldouble
, ldouble_ftype_ldouble
,
3198 BUILT_IN_FABS
, BUILT_IN_NORMAL
, 0, 0, 0);
3199 builtin_function_2 ("__builtin_labs", "labs",
3200 long_ftype_long
, long_ftype_long
,
3201 BUILT_IN_ABS
, BUILT_IN_NORMAL
, 0, 0, 0);
3202 builtin_function_2 ("__builtin_llabs", "llabs",
3203 longlong_ftype_longlong
, longlong_ftype_longlong
,
3204 BUILT_IN_ABS
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3205 builtin_function_2 ("__builtin_imaxabs", "imaxabs",
3206 intmax_ftype_intmax
, intmax_ftype_intmax
,
3207 BUILT_IN_ABS
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3209 builtin_function ("__builtin_saveregs", ptr_ftype
, BUILT_IN_SAVEREGS
,
3210 BUILT_IN_NORMAL
, NULL_PTR
);
3211 builtin_function ("__builtin_classify_type", default_function_type
,
3212 BUILT_IN_CLASSIFY_TYPE
, BUILT_IN_NORMAL
, NULL_PTR
);
3213 builtin_function ("__builtin_next_arg", ptr_ftype
, BUILT_IN_NEXT_ARG
,
3214 BUILT_IN_NORMAL
, NULL_PTR
);
3215 builtin_function ("__builtin_args_info", int_ftype_int
, BUILT_IN_ARGS_INFO
,
3216 BUILT_IN_NORMAL
, NULL_PTR
);
3217 builtin_function ("__builtin_setjmp",
3218 build_function_type (integer_type_node
,
3219 tree_cons (NULL_TREE
, ptr_type_node
,
3221 BUILT_IN_SETJMP
, BUILT_IN_NORMAL
, NULL_PTR
);
3222 builtin_function ("__builtin_longjmp",
3223 build_function_type (void_type_node
,
3224 tree_cons (NULL_TREE
, ptr_type_node
,
3226 BUILT_IN_LONGJMP
, BUILT_IN_NORMAL
, NULL_PTR
);
3227 builtin_function ("__builtin_trap", void_ftype
, BUILT_IN_TRAP
,
3228 BUILT_IN_NORMAL
, NULL_PTR
);
3230 /* ISO C99 IEEE Unordered compares. */
3231 builtin_function ("__builtin_isgreater", default_function_type
,
3232 BUILT_IN_ISGREATER
, BUILT_IN_NORMAL
, NULL_PTR
);
3233 builtin_function ("__builtin_isgreaterequal", default_function_type
,
3234 BUILT_IN_ISGREATEREQUAL
, BUILT_IN_NORMAL
, NULL_PTR
);
3235 builtin_function ("__builtin_isless", default_function_type
,
3236 BUILT_IN_ISLESS
, BUILT_IN_NORMAL
, NULL_PTR
);
3237 builtin_function ("__builtin_islessequal", default_function_type
,
3238 BUILT_IN_ISLESSEQUAL
, BUILT_IN_NORMAL
, NULL_PTR
);
3239 builtin_function ("__builtin_islessgreater", default_function_type
,
3240 BUILT_IN_ISLESSGREATER
, BUILT_IN_NORMAL
, NULL_PTR
);
3241 builtin_function ("__builtin_isunordered", default_function_type
,
3242 BUILT_IN_ISUNORDERED
, BUILT_IN_NORMAL
, NULL_PTR
);
3244 /* Untyped call and return. */
3245 builtin_function ("__builtin_apply_args", ptr_ftype
,
3246 BUILT_IN_APPLY_ARGS
, BUILT_IN_NORMAL
, NULL_PTR
);
3248 temp
= tree_cons (NULL_TREE
,
3249 build_pointer_type (build_function_type (void_type_node
,
3251 tree_cons (NULL_TREE
, ptr_type_node
, sizetype_endlink
));
3252 builtin_function ("__builtin_apply",
3253 build_function_type (ptr_type_node
, temp
),
3254 BUILT_IN_APPLY
, BUILT_IN_NORMAL
, NULL_PTR
);
3255 builtin_function ("__builtin_return", void_ftype_ptr
,
3256 BUILT_IN_RETURN
, BUILT_IN_NORMAL
, NULL_PTR
);
3258 /* Support for varargs.h and stdarg.h. */
3259 builtin_function ("__builtin_varargs_start",
3260 build_function_type (void_type_node
,
3261 tree_cons (NULL_TREE
,
3262 va_list_ref_type_node
,
3264 BUILT_IN_VARARGS_START
, BUILT_IN_NORMAL
, NULL_PTR
);
3266 builtin_function ("__builtin_stdarg_start",
3267 build_function_type (void_type_node
,
3268 tree_cons (NULL_TREE
,
3269 va_list_ref_type_node
,
3271 BUILT_IN_STDARG_START
, BUILT_IN_NORMAL
, NULL_PTR
);
3273 builtin_function ("__builtin_va_end",
3274 build_function_type (void_type_node
,
3275 tree_cons (NULL_TREE
,
3276 va_list_ref_type_node
,
3278 BUILT_IN_VA_END
, BUILT_IN_NORMAL
, NULL_PTR
);
3280 builtin_function ("__builtin_va_copy",
3281 build_function_type (void_type_node
,
3282 tree_cons (NULL_TREE
,
3283 va_list_ref_type_node
,
3284 tree_cons (NULL_TREE
,
3285 va_list_arg_type_node
,
3287 BUILT_IN_VA_COPY
, BUILT_IN_NORMAL
, NULL_PTR
);
3289 /* ??? Ought to be `T __builtin_expect(T, T)' for any type T. */
3290 builtin_function ("__builtin_expect",
3291 build_function_type (long_integer_type_node
,
3292 tree_cons (NULL_TREE
,
3293 long_integer_type_node
,
3294 tree_cons (NULL_TREE
,
3295 long_integer_type_node
,
3297 BUILT_IN_EXPECT
, BUILT_IN_NORMAL
, NULL_PTR
);
3299 /* Currently under experimentation. */
3300 builtin_function_2 ("__builtin_memcpy", "memcpy",
3301 memcpy_ftype
, memcpy_ftype
,
3302 BUILT_IN_MEMCPY
, BUILT_IN_NORMAL
, 1, 0, 0);
3303 builtin_function_2 ("__builtin_memcmp", "memcmp",
3304 int_ftype_cptr_cptr_sizet
, int_ftype_cptr_cptr_sizet
,
3305 BUILT_IN_MEMCMP
, BUILT_IN_NORMAL
, 1, 0, 0);
3306 builtin_function_2 ("__builtin_memset", "memset",
3307 memset_ftype
, memset_ftype
,
3308 BUILT_IN_MEMSET
, BUILT_IN_NORMAL
, 1, 0, 0);
3309 built_in_decls
[BUILT_IN_STRCMP
] =
3310 builtin_function_2 ("__builtin_strcmp", "strcmp",
3311 int_ftype_cstring_cstring
, int_ftype_cstring_cstring
,
3312 BUILT_IN_STRCMP
, BUILT_IN_NORMAL
, 1, 0, 0);
3313 builtin_function_2 ("__builtin_strncmp", "strncmp",
3314 int_ftype_cstring_cstring_sizet
,
3315 int_ftype_cstring_cstring_sizet
,
3316 BUILT_IN_STRNCMP
, BUILT_IN_NORMAL
, 1, 0, 0);
3317 builtin_function_2 ("__builtin_strstr", "strstr",
3318 string_ftype_cstring_cstring
, string_ftype_cstring_cstring
,
3319 BUILT_IN_STRSTR
, BUILT_IN_NORMAL
, 1, 0, 0);
3320 builtin_function_2 ("__builtin_strpbrk", "strpbrk",
3321 string_ftype_cstring_cstring
, string_ftype_cstring_cstring
,
3322 BUILT_IN_STRPBRK
, BUILT_IN_NORMAL
, 1, 0, 0);
3323 built_in_decls
[BUILT_IN_STRCHR
] =
3324 builtin_function_2 ("__builtin_strchr", "strchr",
3325 string_ftype_cstring_int
, string_ftype_cstring_int
,
3326 BUILT_IN_STRCHR
, BUILT_IN_NORMAL
, 1, 0, 0);
3327 builtin_function_2 ("__builtin_strrchr", "strrchr",
3328 string_ftype_cstring_int
, string_ftype_cstring_int
,
3329 BUILT_IN_STRRCHR
, BUILT_IN_NORMAL
, 1, 0, 0);
3330 builtin_function_2 ("__builtin_strcpy", "strcpy",
3331 string_ftype_string_cstring
, string_ftype_string_cstring
,
3332 BUILT_IN_STRCPY
, BUILT_IN_NORMAL
, 1, 0, 0);
3333 builtin_function_2 ("__builtin_strncpy", "strncpy",
3334 string_ftype_string_cstring_sizet
,
3335 string_ftype_string_cstring_sizet
,
3336 BUILT_IN_STRNCPY
, BUILT_IN_NORMAL
, 1, 0, 0);
3337 built_in_decls
[BUILT_IN_STRCAT
] =
3338 builtin_function_2 ("__builtin_strcat", "strcat",
3339 string_ftype_string_cstring
,
3340 string_ftype_string_cstring
,
3341 BUILT_IN_STRCAT
, BUILT_IN_NORMAL
, 1, 0, 0);
3342 builtin_function_2 ("__builtin_strncat", "strncat",
3343 string_ftype_string_cstring_sizet
,
3344 string_ftype_string_cstring_sizet
,
3345 BUILT_IN_STRNCAT
, BUILT_IN_NORMAL
, 1, 0, 0);
3346 builtin_function_2 ("__builtin_strspn", "strspn",
3347 sizet_ftype_cstring_cstring
, sizet_ftype_cstring_cstring
,
3348 BUILT_IN_STRSPN
, BUILT_IN_NORMAL
, 1, 0, 0);
3349 builtin_function_2 ("__builtin_strcspn", "strcspn",
3350 sizet_ftype_cstring_cstring
, sizet_ftype_cstring_cstring
,
3351 BUILT_IN_STRCSPN
, BUILT_IN_NORMAL
, 1, 0, 0);
3352 built_in_decls
[BUILT_IN_STRLEN
] =
3353 builtin_function_2 ("__builtin_strlen", "strlen",
3354 strlen_ftype
, strlen_ftype
,
3355 BUILT_IN_STRLEN
, BUILT_IN_NORMAL
, 1, 0, 0);
3357 builtin_function_2 ("__builtin_sqrtf", "sqrtf",
3358 float_ftype_float
, float_ftype_float
,
3359 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, 1, 0, 0);
3360 builtin_function_2 ("__builtin_fsqrt", "sqrt",
3361 double_ftype_double
, double_ftype_double
,
3362 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, 1, 0, 0);
3363 builtin_function_2 ("__builtin_sqrtl", "sqrtl",
3364 ldouble_ftype_ldouble
, ldouble_ftype_ldouble
,
3365 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, 1, 0, 0);
3366 builtin_function_2 ("__builtin_sinf", "sinf",
3367 float_ftype_float
, float_ftype_float
,
3368 BUILT_IN_SIN
, BUILT_IN_NORMAL
, 1, 0, 0);
3369 builtin_function_2 ("__builtin_sin", "sin",
3370 double_ftype_double
, double_ftype_double
,
3371 BUILT_IN_SIN
, BUILT_IN_NORMAL
, 1, 0, 0);
3372 builtin_function_2 ("__builtin_sinl", "sinl",
3373 ldouble_ftype_ldouble
, ldouble_ftype_ldouble
,
3374 BUILT_IN_SIN
, BUILT_IN_NORMAL
, 1, 0, 0);
3375 builtin_function_2 ("__builtin_cosf", "cosf",
3376 float_ftype_float
, float_ftype_float
,
3377 BUILT_IN_COS
, BUILT_IN_NORMAL
, 1, 0, 0);
3378 builtin_function_2 ("__builtin_cos", "cos",
3379 double_ftype_double
, double_ftype_double
,
3380 BUILT_IN_COS
, BUILT_IN_NORMAL
, 1, 0, 0);
3381 builtin_function_2 ("__builtin_cosl", "cosl",
3382 ldouble_ftype_ldouble
, ldouble_ftype_ldouble
,
3383 BUILT_IN_COS
, BUILT_IN_NORMAL
, 1, 0, 0);
3385 /* ISO C99 complex arithmetic functions. */
3386 builtin_function_2 ("__builtin_conjf", "conjf",
3387 cfloat_ftype_cfloat
, cfloat_ftype_cfloat
,
3388 BUILT_IN_CONJ
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3389 builtin_function_2 ("__builtin_conj", "conj",
3390 cdouble_ftype_cdouble
, cdouble_ftype_cdouble
,
3391 BUILT_IN_CONJ
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3392 builtin_function_2 ("__builtin_conjl", "conjl",
3393 cldouble_ftype_cldouble
, cldouble_ftype_cldouble
,
3394 BUILT_IN_CONJ
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3395 builtin_function_2 ("__builtin_crealf", "crealf",
3396 float_ftype_cfloat
, float_ftype_cfloat
,
3397 BUILT_IN_CREAL
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3398 builtin_function_2 ("__builtin_creal", "creal",
3399 double_ftype_cdouble
, double_ftype_cdouble
,
3400 BUILT_IN_CREAL
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3401 builtin_function_2 ("__builtin_creall", "creall",
3402 ldouble_ftype_cldouble
, ldouble_ftype_cldouble
,
3403 BUILT_IN_CREAL
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3404 builtin_function_2 ("__builtin_cimagf", "cimagf",
3405 float_ftype_cfloat
, float_ftype_cfloat
,
3406 BUILT_IN_CIMAG
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3407 builtin_function_2 ("__builtin_cimag", "cimag",
3408 double_ftype_cdouble
, double_ftype_cdouble
,
3409 BUILT_IN_CIMAG
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3410 builtin_function_2 ("__builtin_cimagl", "cimagl",
3411 ldouble_ftype_cldouble
, ldouble_ftype_cldouble
,
3412 BUILT_IN_CIMAG
, BUILT_IN_NORMAL
, 0, !flag_isoc99
, 0);
3414 built_in_decls
[BUILT_IN_PUTCHAR
] =
3415 builtin_function ("__builtin_putchar", int_ftype_int
,
3416 BUILT_IN_PUTCHAR
, BUILT_IN_NORMAL
, "putchar");
3417 built_in_decls
[BUILT_IN_PUTS
] =
3418 builtin_function ("__builtin_puts", puts_ftype
,
3419 BUILT_IN_PUTS
, BUILT_IN_NORMAL
, "puts");
3420 builtin_function_2 ("__builtin_printf", "printf",
3421 printf_ftype
, printf_ftype
,
3422 BUILT_IN_PRINTF
, BUILT_IN_FRONTEND
, 1, 0, 0);
3423 builtin_function_2 ("__builtin_fprintf", "fprintf",
3424 fprintf_ftype
, fprintf_ftype
,
3425 BUILT_IN_FPRINTF
, BUILT_IN_FRONTEND
, 1, 0, 0);
3426 built_in_decls
[BUILT_IN_FWRITE
] =
3427 builtin_function ("__builtin_fwrite", fwrite_ftype
,
3428 BUILT_IN_FWRITE
, BUILT_IN_NORMAL
, "fwrite");
3429 built_in_decls
[BUILT_IN_FPUTC
] =
3430 builtin_function ("__builtin_fputc", fputc_ftype
,
3431 BUILT_IN_FPUTC
, BUILT_IN_NORMAL
, "fputc");
3432 /* Declare the __builtin_ style with arguments and the regular style
3433 without them. We rely on stdio.h to supply the arguments for the
3434 regular style declaration since we had to use void* instead of
3435 FILE* in the __builtin_ prototype supplied here. */
3436 built_in_decls
[BUILT_IN_FPUTS
] =
3437 builtin_function_2 ("__builtin_fputs", "fputs",
3438 fputs_ftype
, int_ftype_any
,
3439 BUILT_IN_FPUTS
, BUILT_IN_NORMAL
, 1, 0, 0);
3441 /* Declare these functions non-returning
3442 to avoid spurious "control drops through" warnings. */
3443 builtin_function_2 (NULL_PTR
, "abort",
3444 NULL_TREE
, ((c_language
== clk_cplusplus
)
3445 ? void_ftype
: void_ftype_any
),
3446 0, NOT_BUILT_IN
, 0, 0, 1);
3448 builtin_function_2 (NULL_PTR
, "exit",
3449 NULL_TREE
, ((c_language
== clk_cplusplus
)
3450 ? void_ftype_int
: void_ftype_any
),
3451 0, NOT_BUILT_IN
, 0, 0, 1);
3454 /* Support for these has not been written in either expand_builtin
3455 or build_function_call. */
3456 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
,
3457 BUILT_IN_NORMAL
, NULL_PTR
);
3458 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
,
3459 BUILT_IN_NORMAL
, NULL_PTR
);
3460 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
3461 BUILT_IN_NORMAL
, NULL_PTR
);
3462 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
3463 BUILT_IN_NORMAL
, NULL_PTR
);
3464 builtin_function ("__builtin_fmod", double_ftype_double_double
,
3465 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, NULL_PTR
);
3466 builtin_function ("__builtin_frem", double_ftype_double_double
,
3467 BUILT_IN_FREM
, BUILT_IN_NORMAL
, NULL_PTR
);
3468 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
3469 BUILT_IN_NORMAL
, NULL_PTR
);
3470 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
3471 BUILT_IN_NORMAL
, NULL_PTR
);
3474 main_identifier_node
= get_identifier ("main");
3476 /* ??? Perhaps there's a better place to do this. But it is related
3477 to __builtin_va_arg, so it isn't that off-the-wall. */
3478 lang_type_promotes_to
= simple_type_promotes_to
;
3482 build_va_arg (expr
, type
)
3485 return build1 (VA_ARG_EXPR
, type
, expr
);
3489 /* Possibly define a builtin function with one or two names. BUILTIN_NAME
3490 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3491 of these may be NULL (though both being NULL is useless).
3492 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3493 TYPE is the type of the function with the ordinary name. These
3494 may differ if the ordinary name is declared with a looser type to avoid
3495 conflicts with headers. FUNCTION_CODE and CLASS are as for
3496 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3497 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3498 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name; if
3499 NORETURN_P is nonzero, the function is marked as non-returning.
3500 Returns the declaration of BUILTIN_NAME, if any, otherwise
3501 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3502 or if NONANSI_P and flag_no_nonansi_builtin. */
3505 builtin_function_2 (builtin_name
, name
, builtin_type
, type
, function_code
,
3506 class, library_name_p
, nonansi_p
, noreturn_p
)
3507 const char *builtin_name
;
3512 enum built_in_class
class;
3517 tree bdecl
= NULL_TREE
;
3518 tree decl
= NULL_TREE
;
3519 if (builtin_name
!= 0)
3521 bdecl
= builtin_function (builtin_name
, builtin_type
, function_code
,
3522 class, library_name_p
? name
: NULL_PTR
);
3525 TREE_THIS_VOLATILE (bdecl
) = 1;
3526 TREE_SIDE_EFFECTS (bdecl
) = 1;
3529 if (name
!= 0 && !flag_no_builtin
&& !(nonansi_p
&& flag_no_nonansi_builtin
))
3531 decl
= builtin_function (name
, type
, function_code
, class, NULL_PTR
);
3533 DECL_BUILT_IN_NONANSI (decl
) = 1;
3536 TREE_THIS_VOLATILE (decl
) = 1;
3537 TREE_SIDE_EFFECTS (decl
) = 1;
3540 return (bdecl
!= 0 ? bdecl
: decl
);
3543 /* Given a type, apply default promotions wrt unnamed function arguments
3544 and return the new type. Return NULL_TREE if no change. */
3545 /* ??? There is a function of the same name in the C++ front end that
3546 does something similar, but is more thorough and does not return NULL
3547 if no change. We could perhaps share code, but it would make the
3548 self_promoting_type property harder to identify. */
3551 simple_type_promotes_to (type
)
3554 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3555 return double_type_node
;
3557 if (C_PROMOTING_INTEGER_TYPE_P (type
))
3559 /* Traditionally, unsignedness is preserved in default promotions.
3560 Also preserve unsignedness if not really getting any wider. */
3561 if (TREE_UNSIGNED (type
)
3562 && (flag_traditional
3563 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
3564 return unsigned_type_node
;
3565 return integer_type_node
;
3571 /* Return 1 if PARMS specifies a fixed number of parameters
3572 and none of their types is affected by default promotions. */
3575 self_promoting_args_p (parms
)
3579 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
3581 register tree type
= TREE_VALUE (t
);
3583 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
3589 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
3592 if (C_PROMOTING_INTEGER_TYPE_P (type
))
3598 /* Recursively examines the array elements of TYPE, until a non-array
3599 element type is found. */
3602 strip_array_types (type
)
3605 while (TREE_CODE (type
) == ARRAY_TYPE
)
3606 type
= TREE_TYPE (type
);
3611 /* Recognize certain built-in functions so we can make tree-codes
3612 other than CALL_EXPR. We do this when it enables fold-const.c
3613 to do something useful. */
3614 /* ??? By rights this should go in builtins.c, but only C and C++
3615 implement build_{binary,unary}_op. Not exactly sure what bits
3616 of functionality are actually needed from those functions, or
3617 where the similar functionality exists in the other front ends. */
3620 expand_tree_builtin (function
, params
, coerced_params
)
3621 tree function
, params
, coerced_params
;
3623 enum tree_code code
;
3625 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
3628 switch (DECL_FUNCTION_CODE (function
))
3632 if (coerced_params
== 0)
3633 return integer_zero_node
;
3634 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
3637 if (coerced_params
== 0)
3638 return integer_zero_node
;
3639 return build_unary_op (CONJ_EXPR
, TREE_VALUE (coerced_params
), 0);
3641 case BUILT_IN_CREAL
:
3642 if (coerced_params
== 0)
3643 return integer_zero_node
;
3644 return build_unary_op (REALPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3646 case BUILT_IN_CIMAG
:
3647 if (coerced_params
== 0)
3648 return integer_zero_node
;
3649 return build_unary_op (IMAGPART_EXPR
, TREE_VALUE (coerced_params
), 0);
3651 case BUILT_IN_ISGREATER
:
3652 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3658 case BUILT_IN_ISGREATEREQUAL
:
3659 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3665 case BUILT_IN_ISLESS
:
3666 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3672 case BUILT_IN_ISLESSEQUAL
:
3673 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3679 case BUILT_IN_ISLESSGREATER
:
3680 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
3686 case BUILT_IN_ISUNORDERED
:
3687 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
3688 return integer_zero_node
;
3689 code
= UNORDERED_EXPR
;
3697 || TREE_CHAIN (params
) == 0)
3699 error ("too few arguments to function `%s'",
3700 IDENTIFIER_POINTER (DECL_NAME (function
)));
3701 return error_mark_node
;
3703 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
3705 error ("too many arguments to function `%s'",
3706 IDENTIFIER_POINTER (DECL_NAME (function
)));
3707 return error_mark_node
;
3710 arg0
= TREE_VALUE (params
);
3711 arg1
= TREE_VALUE (TREE_CHAIN (params
));
3712 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
3713 if (code
!= UNORDERED_EXPR
)
3714 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
3726 /* Returns non-zero if CODE is the code for a statement. */
3729 statement_code_p (code
)
3730 enum tree_code code
;
3753 if (lang_statement_code_p
)
3754 return (*lang_statement_code_p
) (code
);
3759 /* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3760 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3761 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3762 value, the traversal is aborted, and the value returned by FUNC is
3763 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3764 the node being visited are not walked.
3766 We don't need a without_duplicates variant of this one because the
3767 statement tree is a tree, not a graph. */
3770 walk_stmt_tree (tp
, func
, data
)
3775 enum tree_code code
;
3780 #define WALK_SUBTREE(NODE) \
3783 result = walk_stmt_tree (&(NODE), func, data); \
3789 /* Skip empty subtrees. */
3793 /* Skip subtrees below non-statement nodes. */
3794 if (!statement_code_p (TREE_CODE (*tp
)))
3797 /* Call the function. */
3799 result
= (*func
) (tp
, &walk_subtrees
, data
);
3801 /* If we found something, return it. */
3805 /* FUNC may have modified the tree, recheck that we're looking at a
3807 code
= TREE_CODE (*tp
);
3808 if (!statement_code_p (code
))
3811 /* Visit the subtrees unless FUNC decided that there was nothing
3812 interesting below this point in the tree. */
3815 /* Walk over all the sub-trees of this operand. Statement nodes
3816 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3817 len
= TREE_CODE_LENGTH (code
);
3819 /* Go through the subtrees. We need to do this in forward order so
3820 that the scope of a FOR_EXPR is handled properly. */
3821 for (i
= 0; i
< len
; ++i
)
3822 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
3825 /* Finally visit the chain. This can be tail-recursion optimized if
3826 we write it this way. */
3827 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
3832 /* Used to compare case labels. K1 and K2 are actually tree nodes
3833 representing case labels, or NULL_TREE for a `default' label.
3834 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3835 K2, and 0 if K1 and K2 are equal. */
3838 case_compare (k1
, k2
)
3842 /* Consider a NULL key (such as arises with a `default' label) to be
3843 smaller than anything else. */
3849 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
3852 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3853 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3854 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3855 case label was declared using the usual C/C++ syntax, rather than
3856 the GNU case range extension. CASES is a tree containing all the
3857 case ranges processed so far; COND is the condition for the
3858 switch-statement itself. Returns the CASE_LABEL created, or
3859 ERROR_MARK_NODE if no CASE_LABEL is created. */
3862 c_add_case_label (cases
, cond
, low_value
, high_value
)
3871 splay_tree_node node
;
3873 /* Create the LABEL_DECL itself. */
3874 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
3875 DECL_CONTEXT (label
) = current_function_decl
;
3877 /* If there was an error processing the switch condition, bail now
3878 before we get more confused. */
3879 if (!cond
|| cond
== error_mark_node
)
3881 /* Add a label anyhow so that the back-end doesn't think that
3882 the beginning of the switch is unreachable. */
3884 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3885 return error_mark_node
;
3888 if ((low_value
&& TREE_TYPE (low_value
)
3889 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
3890 || (high_value
&& TREE_TYPE (high_value
)
3891 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
3892 error ("pointers are not permitted as case values");
3894 /* Case ranges are a GNU extension. */
3895 if (high_value
&& pedantic
)
3897 if (c_language
== clk_cplusplus
)
3898 pedwarn ("ISO C++ forbids range expressions in switch statements");
3900 pedwarn ("ISO C forbids range expressions in switch statements");
3903 type
= TREE_TYPE (cond
);
3906 low_value
= check_case_value (low_value
);
3907 low_value
= convert_and_check (type
, low_value
);
3911 high_value
= check_case_value (high_value
);
3912 high_value
= convert_and_check (type
, high_value
);
3915 /* If an error has occurred, bail out now. */
3916 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
3919 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3920 return error_mark_node
;
3923 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3924 really a case range, even though it was written that way. Remove
3925 the HIGH_VALUE to simplify later processing. */
3926 if (tree_int_cst_equal (low_value
, high_value
))
3927 high_value
= NULL_TREE
;
3928 if (low_value
&& high_value
3929 && !tree_int_cst_lt (low_value
, high_value
))
3930 warning ("empty range specified");
3932 /* Look up the LOW_VALUE in the table of case labels we already
3934 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
3935 /* If there was not an exact match, check for overlapping ranges.
3936 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3937 that's a `default' label and the only overlap is an exact match. */
3938 if (!node
&& (low_value
|| high_value
))
3940 splay_tree_node low_bound
;
3941 splay_tree_node high_bound
;
3943 /* Even though there wasn't an exact match, there might be an
3944 overlap between this case range and another case range.
3945 Since we've (inductively) not allowed any overlapping case
3946 ranges, we simply need to find the greatest low case label
3947 that is smaller that LOW_VALUE, and the smallest low case
3948 label that is greater than LOW_VALUE. If there is an overlap
3949 it will occur in one of these two ranges. */
3950 low_bound
= splay_tree_predecessor (cases
,
3951 (splay_tree_key
) low_value
);
3952 high_bound
= splay_tree_successor (cases
,
3953 (splay_tree_key
) low_value
);
3955 /* Check to see if the LOW_BOUND overlaps. It is smaller than
3956 the LOW_VALUE, so there is no need to check unless the
3957 LOW_BOUND is in fact itself a case range. */
3959 && CASE_HIGH ((tree
) low_bound
->value
)
3960 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
3963 /* Check to see if the HIGH_BOUND overlaps. The low end of that
3964 range is bigger than the low end of the current range, so we
3965 are only interested if the current range is a real range, and
3966 not an ordinary case label. */
3969 && (tree_int_cst_compare ((tree
) high_bound
->key
,
3974 /* If there was an overlap, issue an error. */
3977 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
3981 error ("duplicate (or overlapping) case value");
3982 error_with_decl (duplicate
,
3983 "this is the first entry overlapping that value");
3987 error ("duplicate case value") ;
3988 error_with_decl (duplicate
, "previously used here");
3992 error ("multiple default labels in one switch");
3993 error_with_decl (duplicate
, "this is the first default label");
3996 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
3999 /* Add a CASE_LABEL to the statement-tree. */
4000 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4001 /* Register this case label in the splay tree. */
4002 splay_tree_insert (cases
,
4003 (splay_tree_key
) low_value
,
4004 (splay_tree_value
) case_label
);
4009 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
4010 parameter allows this function to be used as a GC-marking
4017 stmt_tree st
= (stmt_tree
) p
;
4019 ggc_mark_tree (st
->x_last_stmt
);
4020 ggc_mark_tree (st
->x_last_expr_type
);
4023 /* Mark LD for GC. */
4026 c_mark_lang_decl (c
)
4027 struct c_lang_decl
*c
;
4029 ggc_mark_tree (c
->saved_tree
);
4032 /* Mark F for GC. */
4035 mark_c_language_function (f
)
4036 struct language_function
*f
;
4041 mark_stmt_tree (&f
->x_stmt_tree
);
4042 ggc_mark_tree (f
->x_scope_stmt_stack
);
4045 /* Hook used by expand_expr to expand language-specific tree codes. */
4048 c_expand_expr (exp
, target
, tmode
, modifier
)
4051 enum machine_mode tmode
;
4052 enum expand_modifier modifier
;
4054 switch (TREE_CODE (exp
))
4061 /* Since expand_expr_stmt calls free_temp_slots after every
4062 expression statement, we must call push_temp_slots here.
4063 Otherwise, any temporaries in use now would be considered
4064 out-of-scope after the first EXPR_STMT from within the
4067 rtl_expr
= expand_start_stmt_expr ();
4068 expand_stmt (STMT_EXPR_STMT (exp
));
4069 expand_end_stmt_expr (rtl_expr
);
4070 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
4078 if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
4079 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4081 && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4082 && (DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
4083 == BUILT_IN_FRONTEND
))
4084 return c_expand_builtin (exp
, target
, tmode
, modifier
);
4098 /* Hook used by safe_from_p to handle language-specific tree codes. */
4101 c_safe_from_p (target
, exp
)
4105 /* We can see statements here when processing the body of a
4106 statement-expression. For a declaration statement declaring a
4107 variable, look at the variable's initializer. */
4108 if (TREE_CODE (exp
) == DECL_STMT
)
4110 tree decl
= DECL_STMT_DECL (exp
);
4112 if (TREE_CODE (decl
) == VAR_DECL
4113 && DECL_INITIAL (decl
)
4114 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
4118 /* For any statement, we must follow the statement-chain. */
4119 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
4120 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
4122 /* Assume everything else is safe. */
4126 /* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4129 c_unsafe_for_reeval (exp
)
4132 /* Statement expressions may not be reevaluated. */
4133 if (TREE_CODE (exp
) == STMT_EXPR
)
4136 /* Walk all other expressions. */
4140 /* Tree code classes. */
4142 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
4144 static char c_tree_code_type
[] = {
4146 #include "c-common.def"
4150 /* Table indexed by tree code giving number of expression
4151 operands beyond the fixed part of the node structure.
4152 Not used for types or decls. */
4154 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
4156 static int c_tree_code_length
[] = {
4158 #include "c-common.def"
4162 /* Names of tree components.
4163 Used for printing out the tree and error messages. */
4164 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
4166 static const char *c_tree_code_name
[] = {
4168 #include "c-common.def"
4172 /* Adds the tree codes specific to the C front end to the list of all
4178 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
4180 (int)LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
4181 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
4183 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
4184 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
4186 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
4187 lang_unsafe_for_reeval
= c_unsafe_for_reeval
;
4190 #define CALLED_AS_BUILT_IN(NODE) \
4191 (!strncmp (IDENTIFIER_POINTER (DECL_NAME (NODE)), "__builtin_", 10))
4194 c_expand_builtin (exp
, target
, tmode
, modifier
)
4197 enum machine_mode tmode
;
4198 enum expand_modifier modifier
;
4200 tree type
= TREE_TYPE (exp
);
4201 tree fndecl
= TREE_OPERAND (TREE_OPERAND (exp
, 0), 0);
4202 tree arglist
= TREE_OPERAND (exp
, 1);
4203 enum built_in_function fcode
= DECL_FUNCTION_CODE (fndecl
);
4204 enum tree_code code
= TREE_CODE (exp
);
4205 const int ignore
= (target
== const0_rtx
4206 || ((code
== NON_LVALUE_EXPR
|| code
== NOP_EXPR
4207 || code
== CONVERT_EXPR
|| code
== REFERENCE_EXPR
4208 || code
== COND_EXPR
)
4209 && TREE_CODE (type
) == VOID_TYPE
));
4211 if (! optimize
&& ! CALLED_AS_BUILT_IN (fndecl
))
4212 return expand_call (exp
, target
, ignore
);
4216 case BUILT_IN_PRINTF
:
4217 target
= c_expand_builtin_printf (arglist
, target
, tmode
,
4223 case BUILT_IN_FPRINTF
:
4224 target
= c_expand_builtin_fprintf (arglist
, target
, tmode
,
4230 default: /* just do library call, if unknown builtin */
4231 error ("built-in function `%s' not currently supported",
4232 IDENTIFIER_POINTER (DECL_NAME (fndecl
)));
4235 /* The switch statement above can drop through to cause the function
4236 to be called normally. */
4237 return expand_call (exp
, target
, ignore
);
4240 /* Check an arglist to *printf for problems. The arglist should start
4241 at the format specifier, with the remaining arguments immediately
4244 is_valid_printf_arglist (arglist
)
4247 /* Save this value so we can restore it later. */
4248 const int SAVE_pedantic
= pedantic
;
4249 int diagnostic_occurred
= 0;
4251 /* Set this to a known value so the user setting won't affect code
4254 /* Check to make sure there are no format specifier errors. */
4255 check_function_format (&diagnostic_occurred
,
4256 maybe_get_identifier("printf"),
4257 NULL_TREE
, arglist
);
4259 /* Restore the value of `pedantic'. */
4260 pedantic
= SAVE_pedantic
;
4262 /* If calling `check_function_format_ptr' produces a warning, we
4263 return false, otherwise we return true. */
4264 return ! diagnostic_occurred
;
4267 /* If the arguments passed to printf are suitable for optimizations,
4268 we attempt to transform the call. */
4270 c_expand_builtin_printf (arglist
, target
, tmode
, modifier
, ignore
)
4273 enum machine_mode tmode
;
4274 enum expand_modifier modifier
;
4277 tree fn_putchar
= built_in_decls
[BUILT_IN_PUTCHAR
],
4278 fn_puts
= built_in_decls
[BUILT_IN_PUTS
];
4279 tree fn
, format_arg
, stripped_string
;
4281 /* If the return value is used, or the replacement _DECL isn't
4282 initialized, don't do the transformation. */
4283 if (!ignore
|| !fn_putchar
|| !fn_puts
)
4286 /* Verify the required arguments in the original call. */
4288 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
))
4291 /* Check the specifier vs. the parameters. */
4292 if (!is_valid_printf_arglist (arglist
))
4295 format_arg
= TREE_VALUE (arglist
);
4296 stripped_string
= format_arg
;
4297 STRIP_NOPS (stripped_string
);
4298 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4299 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4301 /* If the format specifier isn't a STRING_CST, punt. */
4302 if (TREE_CODE (stripped_string
) != STRING_CST
)
4305 /* OK! We can attempt optimization. */
4307 /* If the format specifier was "%s\n", call __builtin_puts(arg2). */
4308 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s\n") == 0)
4310 arglist
= TREE_CHAIN (arglist
);
4313 /* If the format specifier was "%c", call __builtin_putchar (arg2). */
4314 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4316 arglist
= TREE_CHAIN (arglist
);
4321 /* We can't handle anything else with % args or %% ... yet. */
4322 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4325 /* If the resulting constant string has a length of 1, call
4326 putchar. Note, TREE_STRING_LENGTH includes the terminating
4327 NULL in its count. */
4328 if (TREE_STRING_LENGTH (stripped_string
) == 2)
4330 /* Given printf("c"), (where c is any one character,)
4331 convert "c"[0] to an int and pass that to the replacement
4333 arglist
= build_int_2 (TREE_STRING_POINTER (stripped_string
)[0], 0);
4334 arglist
= build_tree_list (NULL_TREE
, arglist
);
4338 /* If the resulting constant was "string\n", call
4339 __builtin_puts("string"). Ensure "string" has at least one
4340 character besides the trailing \n. Note, TREE_STRING_LENGTH
4341 includes the terminating NULL in its count. */
4342 else if (TREE_STRING_LENGTH (stripped_string
) > 2
4343 && TREE_STRING_POINTER (stripped_string
)
4344 [TREE_STRING_LENGTH (stripped_string
) - 2] == '\n')
4346 /* Create a NULL-terminated string that's one char shorter
4347 than the original, stripping off the trailing '\n'. */
4348 const int newlen
= TREE_STRING_LENGTH (stripped_string
) - 1;
4349 char *newstr
= (char *) alloca (newlen
);
4350 memcpy (newstr
, TREE_STRING_POINTER (stripped_string
), newlen
- 1);
4351 newstr
[newlen
- 1] = 0;
4353 arglist
= combine_strings (build_string (newlen
, newstr
));
4354 arglist
= build_tree_list (NULL_TREE
, arglist
);
4358 /* We'd like to arrange to call fputs(string) here, but we
4359 need stdout and don't have a way to get it ... yet. */
4363 return expand_expr (build_function_call (fn
, arglist
),
4364 (ignore
? const0_rtx
: target
),
4368 /* If the arguments passed to fprintf are suitable for optimizations,
4369 we attempt to transform the call. */
4371 c_expand_builtin_fprintf (arglist
, target
, tmode
, modifier
, ignore
)
4374 enum machine_mode tmode
;
4375 enum expand_modifier modifier
;
4378 tree fn_fputc
= built_in_decls
[BUILT_IN_FPUTC
],
4379 fn_fputs
= built_in_decls
[BUILT_IN_FPUTS
];
4380 tree fn
, format_arg
, stripped_string
;
4382 /* If the return value is used, or the replacement _DECL isn't
4383 initialized, don't do the transformation. */
4384 if (!ignore
|| !fn_fputc
|| !fn_fputs
)
4387 /* Verify the required arguments in the original call. */
4389 || (TREE_CODE (TREE_TYPE (TREE_VALUE (arglist
))) != POINTER_TYPE
)
4390 || (TREE_CHAIN (arglist
) == 0)
4391 || (TREE_CODE (TREE_TYPE (TREE_VALUE (TREE_CHAIN (arglist
)))) !=
4395 /* Check the specifier vs. the parameters. */
4396 if (!is_valid_printf_arglist (TREE_CHAIN (arglist
)))
4399 format_arg
= TREE_VALUE (TREE_CHAIN (arglist
));
4400 stripped_string
= format_arg
;
4401 STRIP_NOPS (stripped_string
);
4402 if (stripped_string
&& TREE_CODE (stripped_string
) == ADDR_EXPR
)
4403 stripped_string
= TREE_OPERAND (stripped_string
, 0);
4405 /* If the format specifier isn't a STRING_CST, punt. */
4406 if (TREE_CODE (stripped_string
) != STRING_CST
)
4409 /* OK! We can attempt optimization. */
4411 /* If the format specifier was "%s", call __builtin_fputs(arg3, arg1). */
4412 if (strcmp (TREE_STRING_POINTER (stripped_string
), "%s") == 0)
4414 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4415 arglist
= tree_cons (NULL_TREE
,
4416 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4420 /* If the format specifier was "%c", call __builtin_fputc (arg3, arg1). */
4421 else if (strcmp (TREE_STRING_POINTER (stripped_string
), "%c") == 0)
4423 tree newarglist
= build_tree_list (NULL_TREE
, TREE_VALUE (arglist
));
4424 arglist
= tree_cons (NULL_TREE
,
4425 TREE_VALUE (TREE_CHAIN (TREE_CHAIN (arglist
))),
4431 /* We can't handle anything else with % args or %% ... yet. */
4432 if (strchr (TREE_STRING_POINTER (stripped_string
), '%'))
4435 /* When "string" doesn't contain %, replace all cases of
4436 fprintf(stream,string) with fputs(string,stream). The fputs
4437 builtin will take take of special cases like length==1. */
4438 arglist
= tree_cons (NULL_TREE
, TREE_VALUE (TREE_CHAIN (arglist
)),
4439 build_tree_list (NULL_TREE
, TREE_VALUE (arglist
)));
4443 return expand_expr (build_function_call (fn
, arglist
),
4444 (ignore
? const0_rtx
: target
),
4449 /* Given a boolean expression ARG, return a tree representing an increment
4450 or decrement (as indicated by CODE) of ARG. The front end must check for
4451 invalid cases (e.g., decrement in C++). */
4453 boolean_increment (code
, arg
)
4454 enum tree_code code
;
4458 tree true_res
= (c_language
== clk_cplusplus
4460 : c_bool_true_node
);
4461 arg
= stabilize_reference (arg
);
4464 case PREINCREMENT_EXPR
:
4465 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4467 case POSTINCREMENT_EXPR
:
4468 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, true_res
);
4469 arg
= save_expr (arg
);
4470 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4471 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4473 case PREDECREMENT_EXPR
:
4474 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4476 case POSTDECREMENT_EXPR
:
4477 val
= build (MODIFY_EXPR
, TREE_TYPE (arg
), arg
, invert_truthvalue (arg
));
4478 arg
= save_expr (arg
);
4479 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), val
, arg
);
4480 val
= build (COMPOUND_EXPR
, TREE_TYPE (arg
), arg
, val
);
4485 TREE_SIDE_EFFECTS (val
) = 1;
4490 /* Do the parts of lang_init common to C and C++. */
4492 c_common_lang_init ()
4494 /* If still "unspecified", make it match -fbounded-pointers. */
4495 if (flag_bounds_check
< 0)
4496 flag_bounds_check
= flag_bounded_pointers
;
4498 /* Special format checking options don't work without -Wformat; warn if
4500 if (warn_format_y2k
&& !warn_format
)
4501 warning ("-Wformat-y2k ignored without -Wformat");
4502 if (warn_format_extra_args
&& !warn_format
)
4503 warning ("-Wformat-extra-args ignored without -Wformat");
4504 if (warn_format_nonliteral
&& !warn_format
)
4505 warning ("-Wformat-nonliteral ignored without -Wformat");
4506 if (warn_format_security
&& !warn_format
)
4507 warning ("-Wformat-security ignored without -Wformat");
4508 if (warn_missing_format_attribute
&& !warn_format
)
4509 warning ("-Wmissing-format-attribute ignored without -Wformat");