1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000
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. */
35 #include "diagnostic.h"
42 #undef WCHAR_TYPE_SIZE
43 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
45 /* The following symbols are subsumed in the c_global_trees array, and
46 listed here individually for documentation purposes.
48 INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
50 tree short_integer_type_node;
51 tree long_integer_type_node;
52 tree long_long_integer_type_node;
54 tree short_unsigned_type_node;
55 tree long_unsigned_type_node;
56 tree long_long_unsigned_type_node;
58 tree boolean_type_node;
59 tree boolean_false_node;
60 tree boolean_true_node;
62 tree ptrdiff_type_node;
64 tree unsigned_char_type_node;
65 tree signed_char_type_node;
67 tree signed_wchar_type_node;
68 tree unsigned_wchar_type_node;
71 tree double_type_node;
72 tree long_double_type_node;
74 tree complex_integer_type_node;
75 tree complex_float_type_node;
76 tree complex_double_type_node;
77 tree complex_long_double_type_node;
85 tree unsigned_intQI_type_node;
86 tree unsigned_intHI_type_node;
87 tree unsigned_intSI_type_node;
88 tree unsigned_intDI_type_node;
89 tree unsigned_intTI_type_node;
91 tree widest_integer_literal_type_node;
92 tree widest_unsigned_literal_type_node;
94 Nodes for types `void *' and `const void *'.
96 tree ptr_type_node, const_ptr_type_node;
98 Nodes for types `char *' and `const char *'.
100 tree string_type_node, const_string_type_node;
102 Type `char[SOMENUMBER]'.
103 Used when an array of char is needed and the size is irrelevant.
105 tree char_array_type_node;
107 Type `int[SOMENUMBER]' or something like it.
108 Used when an array of int needed and the size is irrelevant.
110 tree int_array_type_node;
112 Type `wchar_t[SOMENUMBER]' or something like it.
113 Used when a wide string literal is created.
115 tree wchar_array_type_node;
117 Type `int ()' -- used for implicit declaration of functions.
119 tree default_function_type;
121 Function types `int (int)', etc.
127 tree ptr_ftype_sizetype;
129 A VOID_TYPE node, packaged in a TREE_LIST.
133 The identifiers __FUNCTION__, __PRETTY_FUNCTION__, and __func__.
135 tree function_id_node;
136 tree pretty_function_id_node;
141 tree c_global_trees
[CTI_MAX
];
143 /* The elements of `ridpointers' are identifier nodes for the reserved
144 type names and storage classes. It is indexed by a RID_... value. */
147 tree (*make_fname_decl
) PARAMS ((tree
, const char *, int));
149 /* If non-NULL, the address of a language-specific function that
150 returns 1 for language-specific statement codes. */
151 int (*lang_statement_code_p
) PARAMS ((enum tree_code
));
153 /* If non-NULL, the address of a language-specific function that takes
154 any action required right before expand_function_end is called. */
155 void (*lang_expand_function_end
) PARAMS ((void));
157 /* Nonzero means the expression being parsed will never be evaluated.
158 This is a count, since unevaluated expressions can nest. */
161 enum attrs
{A_PACKED
, A_NOCOMMON
, A_COMMON
, A_NORETURN
, A_CONST
, A_T_UNION
,
162 A_NO_CHECK_MEMORY_USAGE
, A_NO_INSTRUMENT_FUNCTION
,
163 A_CONSTRUCTOR
, A_DESTRUCTOR
, A_MODE
, A_SECTION
, A_ALIGNED
,
164 A_UNUSED
, A_FORMAT
, A_FORMAT_ARG
, A_WEAK
, A_ALIAS
, A_MALLOC
,
165 A_NO_LIMIT_STACK
, A_PURE
};
167 enum format_type
{ printf_format_type
, scanf_format_type
,
168 strftime_format_type
};
170 static void add_attribute
PARAMS ((enum attrs
, const char *,
172 static void init_attributes
PARAMS ((void));
173 static void record_function_format
PARAMS ((tree
, tree
, enum format_type
,
175 static void record_international_format
PARAMS ((tree
, tree
, int));
176 static int default_valid_lang_attribute
PARAMS ((tree
, tree
, tree
, tree
));
178 /* Keep a stack of if statements. We record the number of compound
179 statements seen up to the if keyword, as well as the line number
180 and file of the if. If a potentially ambiguous else is seen, that
181 fact is recorded; the warning is issued when we can be sure that
182 the enclosing if statement does not have an else branch. */
192 static if_elt
*if_stack
;
194 /* Amount of space in the if statement stack. */
195 static int if_stack_space
= 0;
198 static int if_stack_pointer
= 0;
200 /* Record the start of an if-then, and record the start of it
201 for ambiguous else detection. */
204 c_expand_start_cond (cond
, compstmt_count
)
210 /* Make sure there is enough space on the stack. */
211 if (if_stack_space
== 0)
214 if_stack
= (if_elt
*)xmalloc (10 * sizeof (if_elt
));
216 else if (if_stack_space
== if_stack_pointer
)
218 if_stack_space
+= 10;
219 if_stack
= (if_elt
*)xrealloc (if_stack
, if_stack_space
* sizeof (if_elt
));
222 if_stmt
= build_stmt (IF_STMT
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
223 IF_COND (if_stmt
) = cond
;
226 /* Record this if statement. */
227 if_stack
[if_stack_pointer
].compstmt_count
= compstmt_count
;
228 if_stack
[if_stack_pointer
].file
= input_filename
;
229 if_stack
[if_stack_pointer
].line
= lineno
;
230 if_stack
[if_stack_pointer
].needs_warning
= 0;
231 if_stack
[if_stack_pointer
].if_stmt
= if_stmt
;
235 /* Called after the then-clause for an if-statement is processed. */
240 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
241 RECHAIN_STMTS (if_stmt
, THEN_CLAUSE (if_stmt
));
244 /* Record the end of an if-then. Optionally warn if a nested
245 if statement had an ambiguous else clause. */
251 if (if_stack
[if_stack_pointer
].needs_warning
)
252 warning_with_file_and_line (if_stack
[if_stack_pointer
].file
,
253 if_stack
[if_stack_pointer
].line
,
254 "suggest explicit braces to avoid ambiguous `else'");
255 last_expr_type
= NULL_TREE
;
258 /* Called between the then-clause and the else-clause
259 of an if-then-else. */
262 c_expand_start_else ()
264 /* An ambiguous else warning must be generated for the enclosing if
265 statement, unless we see an else branch for that one, too. */
267 && if_stack_pointer
> 1
268 && (if_stack
[if_stack_pointer
- 1].compstmt_count
269 == if_stack
[if_stack_pointer
- 2].compstmt_count
))
270 if_stack
[if_stack_pointer
- 2].needs_warning
= 1;
272 /* Even if a nested if statement had an else branch, it can't be
273 ambiguous if this one also has an else. So don't warn in that
274 case. Also don't warn for any if statements nested in this else. */
275 if_stack
[if_stack_pointer
- 1].needs_warning
= 0;
276 if_stack
[if_stack_pointer
- 1].compstmt_count
--;
279 /* Called after the else-clause for an if-statement is processed. */
284 tree if_stmt
= if_stack
[if_stack_pointer
- 1].if_stmt
;
285 RECHAIN_STMTS (if_stmt
, ELSE_CLAUSE (if_stmt
));
288 /* Make bindings for __FUNCTION__, __PRETTY_FUNCTION__, and __func__. */
291 declare_function_name ()
293 const char *name
, *printable_name
;
295 if (current_function_decl
== NULL
)
298 printable_name
= "top level";
302 /* Allow functions to be nameless (such as artificial ones). */
303 if (DECL_NAME (current_function_decl
))
304 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
307 printable_name
= (*decl_printable_name
) (current_function_decl
, 2);
309 /* ISO C99 defines __func__, which is a variable, not a string
310 constant, and which is not a defined symbol at file scope. */
311 (*make_fname_decl
) (func_id_node
, name
, 0);
314 (*make_fname_decl
) (function_id_node
, name
, 0);
315 (*make_fname_decl
) (pretty_function_id_node
, printable_name
, 1);
318 /* Given a chain of STRING_CST nodes,
319 concatenate them into one STRING_CST
320 and give it a suitable array-of-chars data type. */
323 combine_strings (strings
)
326 register tree value
, t
;
327 register int length
= 1;
330 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
332 const int nchars_max
= flag_isoc99
? 4095 : 509;
334 if (TREE_CHAIN (strings
))
336 /* More than one in the chain, so concatenate. */
337 register char *p
, *q
;
339 /* Don't include the \0 at the end of each substring,
340 except for the last one.
341 Count wide strings and ordinary strings separately. */
342 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
344 if (TREE_TYPE (t
) == wchar_array_type_node
)
346 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
350 length
+= (TREE_STRING_LENGTH (t
) - 1);
353 /* If anything is wide, the non-wides will be converted,
354 which makes them take more space. */
356 length
= length
* wchar_bytes
+ wide_length
;
358 p
= ggc_alloc_string (NULL
, length
);
360 /* Copy the individual strings into the new combined string.
361 If the combined string is wide, convert the chars to ints
362 for any individual strings that are not wide. */
365 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
367 int len
= (TREE_STRING_LENGTH (t
)
368 - ((TREE_TYPE (t
) == wchar_array_type_node
)
370 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
372 memcpy (q
, TREE_STRING_POINTER (t
), len
);
378 for (i
= 0; i
< len
; i
++)
380 if (WCHAR_TYPE_SIZE
== HOST_BITS_PER_SHORT
)
381 ((short *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
383 ((int *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
385 q
+= len
* wchar_bytes
;
391 for (i
= 0; i
< wchar_bytes
; i
++)
397 value
= make_node (STRING_CST
);
398 TREE_STRING_POINTER (value
) = p
;
399 TREE_STRING_LENGTH (value
) = length
;
404 length
= TREE_STRING_LENGTH (value
);
405 if (TREE_TYPE (value
) == wchar_array_type_node
)
409 /* Compute the number of elements, for the array type. */
410 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
412 if (pedantic
&& nchars
> nchars_max
)
413 pedwarn ("string length `%d' is greater than the minimum length `%d' ISO C%d is required to support",
414 nchars
, nchars_max
, flag_isoc99
? 99 : 89);
416 /* Create the array type for the string constant.
417 -Wwrite-strings says make the string constant an array of const char
418 so that copying it to a non-const pointer will get a warning.
419 For C++, this is the standard behavior. */
420 if (flag_const_strings
421 && (! flag_traditional
&& ! flag_writable_strings
))
424 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
427 = build_array_type (elements
,
428 build_index_type (build_int_2 (nchars
- 1, 0)));
432 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
433 build_index_type (build_int_2 (nchars
- 1, 0)));
435 TREE_CONSTANT (value
) = 1;
436 TREE_READONLY (value
) = ! flag_writable_strings
;
437 TREE_STATIC (value
) = 1;
441 /* To speed up processing of attributes, we maintain an array of
442 IDENTIFIER_NODES and the corresponding attribute types. */
444 /* Array to hold attribute information. */
446 static struct {enum attrs id
; tree name
; int min
, max
, decl_req
;} attrtab
[50];
448 static int attrtab_idx
= 0;
450 /* Add an entry to the attribute table above. */
453 add_attribute (id
, string
, min_len
, max_len
, decl_req
)
456 int min_len
, max_len
;
461 attrtab
[attrtab_idx
].id
= id
;
462 attrtab
[attrtab_idx
].name
= get_identifier (string
);
463 attrtab
[attrtab_idx
].min
= min_len
;
464 attrtab
[attrtab_idx
].max
= max_len
;
465 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
467 sprintf (buf
, "__%s__", string
);
469 attrtab
[attrtab_idx
].id
= id
;
470 attrtab
[attrtab_idx
].name
= get_identifier (buf
);
471 attrtab
[attrtab_idx
].min
= min_len
;
472 attrtab
[attrtab_idx
].max
= max_len
;
473 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
476 /* Initialize attribute table. */
481 add_attribute (A_PACKED
, "packed", 0, 0, 0);
482 add_attribute (A_NOCOMMON
, "nocommon", 0, 0, 1);
483 add_attribute (A_COMMON
, "common", 0, 0, 1);
484 add_attribute (A_NORETURN
, "noreturn", 0, 0, 1);
485 add_attribute (A_NORETURN
, "volatile", 0, 0, 1);
486 add_attribute (A_UNUSED
, "unused", 0, 0, 0);
487 add_attribute (A_CONST
, "const", 0, 0, 1);
488 add_attribute (A_T_UNION
, "transparent_union", 0, 0, 0);
489 add_attribute (A_CONSTRUCTOR
, "constructor", 0, 0, 1);
490 add_attribute (A_DESTRUCTOR
, "destructor", 0, 0, 1);
491 add_attribute (A_MODE
, "mode", 1, 1, 1);
492 add_attribute (A_SECTION
, "section", 1, 1, 1);
493 add_attribute (A_ALIGNED
, "aligned", 0, 1, 0);
494 add_attribute (A_FORMAT
, "format", 3, 3, 1);
495 add_attribute (A_FORMAT_ARG
, "format_arg", 1, 1, 1);
496 add_attribute (A_WEAK
, "weak", 0, 0, 1);
497 add_attribute (A_ALIAS
, "alias", 1, 1, 1);
498 add_attribute (A_NO_INSTRUMENT_FUNCTION
, "no_instrument_function", 0, 0, 1);
499 add_attribute (A_NO_CHECK_MEMORY_USAGE
, "no_check_memory_usage", 0, 0, 1);
500 add_attribute (A_MALLOC
, "malloc", 0, 0, 1);
501 add_attribute (A_NO_LIMIT_STACK
, "no_stack_limit", 0, 0, 1);
502 add_attribute (A_PURE
, "pure", 0, 0, 1);
505 /* Default implementation of valid_lang_attribute, below. By default, there
506 are no language-specific attributes. */
509 default_valid_lang_attribute (attr_name
, attr_args
, decl
, type
)
510 tree attr_name ATTRIBUTE_UNUSED
;
511 tree attr_args ATTRIBUTE_UNUSED
;
512 tree decl ATTRIBUTE_UNUSED
;
513 tree type ATTRIBUTE_UNUSED
;
518 /* Return a 1 if ATTR_NAME and ATTR_ARGS denote a valid language-specific
519 attribute for either declaration DECL or type TYPE and 0 otherwise. */
521 int (*valid_lang_attribute
) PARAMS ((tree
, tree
, tree
, tree
))
522 = default_valid_lang_attribute
;
524 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
525 and install them in NODE, which is either a DECL (including a TYPE_DECL)
526 or a TYPE. PREFIX_ATTRIBUTES can appear after the declaration specifiers
527 and declaration modifiers but before the declaration proper. */
530 decl_attributes (node
, attributes
, prefix_attributes
)
531 tree node
, attributes
, prefix_attributes
;
533 tree decl
= 0, type
= 0;
537 if (attrtab_idx
== 0)
543 type
= TREE_TYPE (decl
);
544 is_type
= TREE_CODE (node
) == TYPE_DECL
;
546 else if (TYPE_P (node
))
547 type
= node
, is_type
= 1;
549 #ifdef PRAGMA_INSERT_ATTRIBUTES
550 /* If the code in c-pragma.c wants to insert some attributes then
551 allow it to do so. Do this before allowing machine back ends to
552 insert attributes, so that they have the opportunity to override
553 anything done here. */
554 PRAGMA_INSERT_ATTRIBUTES (node
, & attributes
, & prefix_attributes
);
557 #ifdef INSERT_ATTRIBUTES
558 INSERT_ATTRIBUTES (node
, & attributes
, & prefix_attributes
);
561 attributes
= chainon (prefix_attributes
, attributes
);
563 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
565 tree name
= TREE_PURPOSE (a
);
566 tree args
= TREE_VALUE (a
);
570 for (i
= 0; i
< attrtab_idx
; i
++)
571 if (attrtab
[i
].name
== name
)
574 if (i
== attrtab_idx
)
576 if (! valid_machine_attribute (name
, args
, decl
, type
)
577 && ! (* valid_lang_attribute
) (name
, args
, decl
, type
))
578 warning ("`%s' attribute directive ignored",
579 IDENTIFIER_POINTER (name
));
581 type
= TREE_TYPE (decl
);
584 else if (attrtab
[i
].decl_req
&& decl
== 0)
586 warning ("`%s' attribute does not apply to types",
587 IDENTIFIER_POINTER (name
));
590 else if (list_length (args
) < attrtab
[i
].min
591 || list_length (args
) > attrtab
[i
].max
)
593 error ("wrong number of arguments specified for `%s' attribute",
594 IDENTIFIER_POINTER (name
));
603 TYPE_PACKED (type
) = 1;
604 else if (TREE_CODE (decl
) == FIELD_DECL
)
605 DECL_PACKED (decl
) = 1;
606 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
607 used for DECL_REGISTER. It wouldn't mean anything anyway. */
609 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
613 if (TREE_CODE (decl
) == VAR_DECL
)
614 DECL_COMMON (decl
) = 0;
616 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
620 if (TREE_CODE (decl
) == VAR_DECL
)
621 DECL_COMMON (decl
) = 1;
623 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
627 if (TREE_CODE (decl
) == FUNCTION_DECL
)
628 TREE_THIS_VOLATILE (decl
) = 1;
629 else if (TREE_CODE (type
) == POINTER_TYPE
630 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
631 TREE_TYPE (decl
) = type
633 (build_type_variant (TREE_TYPE (type
),
634 TREE_READONLY (TREE_TYPE (type
)), 1));
636 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
640 if (TREE_CODE (decl
) == FUNCTION_DECL
)
641 DECL_IS_MALLOC (decl
) = 1;
642 /* ??? TODO: Support types. */
644 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
650 TREE_USED (decl
) = 1;
652 TREE_USED (type
) = 1;
653 else if (TREE_CODE (decl
) == PARM_DECL
654 || TREE_CODE (decl
) == VAR_DECL
655 || TREE_CODE (decl
) == FUNCTION_DECL
656 || TREE_CODE (decl
) == LABEL_DECL
)
657 TREE_USED (decl
) = 1;
659 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
663 if (TREE_CODE (decl
) == FUNCTION_DECL
)
664 TREE_READONLY (decl
) = 1;
665 else if (TREE_CODE (type
) == POINTER_TYPE
666 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
667 TREE_TYPE (decl
) = type
669 (build_type_variant (TREE_TYPE (type
), 1,
670 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
672 warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name
));
676 if (TREE_CODE (decl
) == FUNCTION_DECL
)
677 DECL_IS_PURE (decl
) = 1;
678 /* ??? TODO: Support types. */
680 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
686 && TREE_CODE (type
) == UNION_TYPE
688 || (TYPE_FIELDS (type
) != 0
689 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))))
690 TYPE_TRANSPARENT_UNION (type
) = 1;
691 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
692 && TREE_CODE (type
) == UNION_TYPE
693 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))
694 DECL_TRANSPARENT_UNION (decl
) = 1;
696 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
700 if (TREE_CODE (decl
) == FUNCTION_DECL
701 && TREE_CODE (type
) == FUNCTION_TYPE
702 && decl_function_context (decl
) == 0)
704 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
705 TREE_USED (decl
) = 1;
708 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
712 if (TREE_CODE (decl
) == FUNCTION_DECL
713 && TREE_CODE (type
) == FUNCTION_TYPE
714 && decl_function_context (decl
) == 0)
716 DECL_STATIC_DESTRUCTOR (decl
) = 1;
717 TREE_USED (decl
) = 1;
720 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
724 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
725 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
729 const char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
730 int len
= strlen (p
);
731 enum machine_mode mode
= VOIDmode
;
734 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
735 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
737 char *newp
= (char *) alloca (len
- 1);
739 strcpy (newp
, &p
[2]);
740 newp
[len
- 4] = '\0';
744 /* Give this decl a type with the specified mode.
745 First check for the special modes. */
746 if (! strcmp (p
, "byte"))
748 else if (!strcmp (p
, "word"))
750 else if (! strcmp (p
, "pointer"))
753 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
754 if (!strcmp (p
, GET_MODE_NAME (j
)))
755 mode
= (enum machine_mode
) j
;
757 if (mode
== VOIDmode
)
758 error ("unknown machine mode `%s'", p
);
759 else if (0 == (typefm
= type_for_mode (mode
,
760 TREE_UNSIGNED (type
))))
761 error ("no data type for mode `%s'", p
);
764 TREE_TYPE (decl
) = type
= typefm
;
765 DECL_SIZE (decl
) = DECL_SIZE_UNIT (decl
) = 0;
766 layout_decl (decl
, 0);
772 #ifdef ASM_OUTPUT_SECTION_NAME
773 if ((TREE_CODE (decl
) == FUNCTION_DECL
774 || TREE_CODE (decl
) == VAR_DECL
)
775 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
777 if (TREE_CODE (decl
) == VAR_DECL
778 && current_function_decl
!= NULL_TREE
779 && ! TREE_STATIC (decl
))
780 error_with_decl (decl
,
781 "section attribute cannot be specified for local variables");
782 /* The decl may have already been given a section attribute from
783 a previous declaration. Ensure they match. */
784 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
785 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
786 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
787 error_with_decl (node
,
788 "section of `%s' conflicts with previous declaration");
790 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
793 error_with_decl (node
,
794 "section attribute not allowed for `%s'");
796 error_with_decl (node
,
797 "section attributes are not supported for this target");
804 = (args
? TREE_VALUE (args
)
805 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
808 /* Strip any NOPs of any kind. */
809 while (TREE_CODE (align_expr
) == NOP_EXPR
810 || TREE_CODE (align_expr
) == CONVERT_EXPR
811 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
812 align_expr
= TREE_OPERAND (align_expr
, 0);
814 if (TREE_CODE (align_expr
) != INTEGER_CST
)
816 error ("requested alignment is not a constant");
820 if ((i
= tree_log2 (align_expr
)) == -1)
821 error ("requested alignment is not a power of 2");
822 else if (i
> HOST_BITS_PER_INT
- 2)
823 error ("requested alignment is too large");
826 /* If we have a TYPE_DECL, then copy the type, so that we
827 don't accidentally modify a builtin type. See pushdecl. */
828 if (decl
&& TREE_TYPE (decl
) != error_mark_node
829 && DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
)
831 tree tt
= TREE_TYPE (decl
);
832 DECL_ORIGINAL_TYPE (decl
) = tt
;
833 tt
= build_type_copy (tt
);
834 TYPE_NAME (tt
) = decl
;
835 TREE_USED (tt
) = TREE_USED (decl
);
836 TREE_TYPE (decl
) = tt
;
840 TYPE_ALIGN (type
) = (1 << i
) * BITS_PER_UNIT
;
841 TYPE_USER_ALIGN (type
) = 1;
843 else if (TREE_CODE (decl
) != VAR_DECL
844 && TREE_CODE (decl
) != FIELD_DECL
)
845 error_with_decl (decl
,
846 "alignment may not be specified for `%s'");
849 DECL_ALIGN (decl
) = (1 << i
) * BITS_PER_UNIT
;
850 DECL_USER_ALIGN (decl
) = 1;
857 tree format_type_id
= TREE_VALUE (args
);
858 tree format_num_expr
= TREE_VALUE (TREE_CHAIN (args
));
859 tree first_arg_num_expr
860 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)));
861 unsigned HOST_WIDE_INT format_num
, first_arg_num
;
862 enum format_type format_type
;
864 unsigned int arg_num
;
866 if (TREE_CODE (decl
) != FUNCTION_DECL
)
868 error_with_decl (decl
,
869 "argument format specified for non-function `%s'");
873 if (TREE_CODE (format_type_id
) != IDENTIFIER_NODE
)
875 error ("unrecognized format specifier");
880 const char *p
= IDENTIFIER_POINTER (format_type_id
);
882 if (!strcmp (p
, "printf") || !strcmp (p
, "__printf__"))
883 format_type
= printf_format_type
;
884 else if (!strcmp (p
, "scanf") || !strcmp (p
, "__scanf__"))
885 format_type
= scanf_format_type
;
886 else if (!strcmp (p
, "strftime")
887 || !strcmp (p
, "__strftime__"))
888 format_type
= strftime_format_type
;
891 warning ("`%s' is an unrecognized format function type", p
);
896 /* Strip any conversions from the string index and first arg number
897 and verify they are constants. */
898 while (TREE_CODE (format_num_expr
) == NOP_EXPR
899 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
900 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
901 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
903 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
904 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
905 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
906 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
908 if (TREE_CODE (format_num_expr
) != INTEGER_CST
909 || TREE_INT_CST_HIGH (format_num_expr
) != 0
910 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
911 || TREE_INT_CST_HIGH (first_arg_num_expr
) != 0)
913 error ("format string has invalid operand number");
917 format_num
= TREE_INT_CST_LOW (format_num_expr
);
918 first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
919 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
921 error ("format string arg follows the args to be formatted");
925 /* If a parameter list is specified, verify that the format_num
926 argument is actually a string, in case the format attribute
928 argument
= TYPE_ARG_TYPES (type
);
931 for (arg_num
= 1; argument
!= 0 && arg_num
!= format_num
;
932 ++arg_num
, argument
= TREE_CHAIN (argument
))
936 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
937 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
940 error ("format string arg not a string type");
944 else if (first_arg_num
!= 0)
946 /* Verify that first_arg_num points to the last arg,
949 arg_num
++, argument
= TREE_CHAIN (argument
);
951 if (arg_num
!= first_arg_num
)
953 error ("args to be formatted is not '...'");
959 record_function_format (DECL_NAME (decl
),
960 DECL_ASSEMBLER_NAME (decl
),
961 format_type
, format_num
, first_arg_num
);
967 tree format_num_expr
= TREE_VALUE (args
);
968 unsigned HOST_WIDE_INT format_num
;
969 unsigned int arg_num
;
972 if (TREE_CODE (decl
) != FUNCTION_DECL
)
974 error_with_decl (decl
,
975 "argument format specified for non-function `%s'");
979 /* Strip any conversions from the first arg number and verify it
981 while (TREE_CODE (format_num_expr
) == NOP_EXPR
982 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
983 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
984 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
986 if (TREE_CODE (format_num_expr
) != INTEGER_CST
987 || TREE_INT_CST_HIGH (format_num_expr
) != 0)
989 error ("format string has invalid operand number");
993 format_num
= TREE_INT_CST_LOW (format_num_expr
);
995 /* If a parameter list is specified, verify that the format_num
996 argument is actually a string, in case the format attribute
998 argument
= TYPE_ARG_TYPES (type
);
1001 for (arg_num
= 1; argument
!= 0 && arg_num
!= format_num
;
1002 ++arg_num
, argument
= TREE_CHAIN (argument
))
1006 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
1007 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
1010 error ("format string arg not a string type");
1015 if (TREE_CODE (TREE_TYPE (TREE_TYPE (decl
))) != POINTER_TYPE
1016 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (TREE_TYPE (decl
))))
1019 error ("function does not return string type");
1023 record_international_format (DECL_NAME (decl
),
1024 DECL_ASSEMBLER_NAME (decl
),
1030 declare_weak (decl
);
1034 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
1035 || (TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
)))
1036 error_with_decl (decl
,
1037 "`%s' defined both normally and as an alias");
1038 else if (decl_function_context (decl
) == 0)
1042 id
= TREE_VALUE (args
);
1043 if (TREE_CODE (id
) != STRING_CST
)
1045 error ("alias arg not a string");
1048 id
= get_identifier (TREE_STRING_POINTER (id
));
1049 /* This counts as a use of the object pointed to. */
1052 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1053 DECL_INITIAL (decl
) = error_mark_node
;
1055 DECL_EXTERNAL (decl
) = 0;
1056 assemble_alias (decl
, id
);
1059 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
1062 case A_NO_CHECK_MEMORY_USAGE
:
1063 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1065 error_with_decl (decl
,
1066 "`%s' attribute applies only to functions",
1067 IDENTIFIER_POINTER (name
));
1069 else if (DECL_INITIAL (decl
))
1071 error_with_decl (decl
,
1072 "can't set `%s' attribute after definition",
1073 IDENTIFIER_POINTER (name
));
1076 DECL_NO_CHECK_MEMORY_USAGE (decl
) = 1;
1079 case A_NO_INSTRUMENT_FUNCTION
:
1080 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1082 error_with_decl (decl
,
1083 "`%s' attribute applies only to functions",
1084 IDENTIFIER_POINTER (name
));
1086 else if (DECL_INITIAL (decl
))
1088 error_with_decl (decl
,
1089 "can't set `%s' attribute after definition",
1090 IDENTIFIER_POINTER (name
));
1093 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl
) = 1;
1096 case A_NO_LIMIT_STACK
:
1097 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1099 error_with_decl (decl
,
1100 "`%s' attribute applies only to functions",
1101 IDENTIFIER_POINTER (name
));
1103 else if (DECL_INITIAL (decl
))
1105 error_with_decl (decl
,
1106 "can't set `%s' attribute after definition",
1107 IDENTIFIER_POINTER (name
));
1110 DECL_NO_LIMIT_STACK (decl
) = 1;
1116 /* Split SPECS_ATTRS, a list of declspecs and prefix attributes, into two
1117 lists. SPECS_ATTRS may also be just a typespec (eg: RECORD_TYPE).
1119 The head of the declspec list is stored in DECLSPECS.
1120 The head of the attribute list is stored in PREFIX_ATTRIBUTES.
1122 Note that attributes in SPECS_ATTRS are stored in the TREE_PURPOSE of
1123 the list elements. We drop the containing TREE_LIST nodes and link the
1124 resulting attributes together the way decl_attributes expects them. */
1127 split_specs_attrs (specs_attrs
, declspecs
, prefix_attributes
)
1129 tree
*declspecs
, *prefix_attributes
;
1131 tree t
, s
, a
, next
, specs
, attrs
;
1133 /* This can happen after an __extension__ in pedantic mode. */
1134 if (specs_attrs
!= NULL_TREE
1135 && TREE_CODE (specs_attrs
) == INTEGER_CST
)
1137 *declspecs
= NULL_TREE
;
1138 *prefix_attributes
= NULL_TREE
;
1142 /* This can happen in c++ (eg: decl: typespec initdecls ';'). */
1143 if (specs_attrs
!= NULL_TREE
1144 && TREE_CODE (specs_attrs
) != TREE_LIST
)
1146 *declspecs
= specs_attrs
;
1147 *prefix_attributes
= NULL_TREE
;
1151 /* Remember to keep the lists in the same order, element-wise. */
1153 specs
= s
= NULL_TREE
;
1154 attrs
= a
= NULL_TREE
;
1155 for (t
= specs_attrs
; t
; t
= next
)
1157 next
= TREE_CHAIN (t
);
1158 /* Declspecs have a non-NULL TREE_VALUE. */
1159 if (TREE_VALUE (t
) != NULL_TREE
)
1161 if (specs
== NULL_TREE
)
1171 if (attrs
== NULL_TREE
)
1172 attrs
= a
= TREE_PURPOSE (t
);
1175 TREE_CHAIN (a
) = TREE_PURPOSE (t
);
1176 a
= TREE_PURPOSE (t
);
1178 /* More attrs can be linked here, move A to the end. */
1179 while (TREE_CHAIN (a
) != NULL_TREE
)
1184 /* Terminate the lists. */
1186 TREE_CHAIN (s
) = NULL_TREE
;
1188 TREE_CHAIN (a
) = NULL_TREE
;
1192 *prefix_attributes
= attrs
;
1195 /* Strip attributes from SPECS_ATTRS, a list of declspecs and attributes.
1196 This function is used by the parser when a rule will accept attributes
1197 in a particular position, but we don't want to support that just yet.
1199 A warning is issued for every ignored attribute. */
1202 strip_attrs (specs_attrs
)
1207 split_specs_attrs (specs_attrs
, &specs
, &attrs
);
1211 warning ("`%s' attribute ignored",
1212 IDENTIFIER_POINTER (TREE_PURPOSE (attrs
)));
1213 attrs
= TREE_CHAIN (attrs
);
1219 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
1220 a parameter list. */
1222 /* The meaningfully distinct length modifiers for format checking recognised
1239 /* The standard versions in which various format features appeared. */
1240 enum format_std_version
1249 /* Structure describing a length modifier supported in format checking, and
1250 possibly a doubled version such as "hh". */
1253 /* Name of the single-character length modifier. */
1255 /* Index into a format_char_info.types array. */
1256 enum format_lengths index
;
1257 /* Standard version this length appears in. */
1258 enum format_std_version std
;
1259 /* Same, if the modifier can be repeated, or NULL if it can't. */
1260 const char *double_name
;
1261 enum format_lengths double_index
;
1262 enum format_std_version double_std
;
1263 } format_length_info
;
1266 /* Structure desribing the combination of a conversion specifier
1267 (or a set of specifiers which act identically) and a length modifier. */
1270 /* The standard version this combination of length and type appeared in.
1271 This is only relevant if greater than those for length and type
1272 individually; otherwise it is ignored. */
1273 enum format_std_version std
;
1274 /* The name to use for the type, if different from that generated internally
1275 (e.g., "signed size_t"). */
1277 /* The type itself. */
1279 } format_type_detail
;
1282 /* Macros to fill out tables of these. */
1283 #define BADLEN { 0, NULL, NULL }
1284 #define NOLENGTHS { BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN, BADLEN }
1287 /* Structure desribing a format conversion specifier (or a set of specifiers
1288 which act identically), and the length modifiers used with it. */
1291 const char *format_chars
;
1293 enum format_std_version std
;
1294 /* Types accepted for each length modifier. */
1295 format_type_detail types
[FMT_LEN_MAX
];
1296 /* List of other modifier characters allowed with these specifiers.
1297 This lists flags, and additionally "w" for width, "p" for precision,
1298 "a" for scanf "a" allocation extension (not applicable in C99 mode),
1299 "*" for scanf suppression, and "E" and "O" for those strftime
1301 const char *flag_chars
;
1302 /* List of additional flags describing these conversion specifiers.
1303 "c" for generic character pointers being allowed, "2" for strftime
1304 two digit year formats, "3" for strftime formats giving two digit
1305 years in some locales, "o" if use of strftime "O"
1306 is a GNU extension beyond C99, "W" if the argument is a pointer
1307 which is dereferenced and written into, "i" for printf integer
1308 formats where the '0' flag is ignored with precision, and "["
1309 for the starting character of a scanf scanset. */
1314 /* Structure describing a particular kind of format processed by GCC. */
1317 /* The name of this kind of format, for use in diagnostics. */
1319 /* Specifications of the length modifiers accepted; possibly NULL. */
1320 const format_length_info
*length_char_specs
;
1321 /* Details of the conversion specification characters accepted. */
1322 const format_char_info
*conversion_specs
;
1326 /* Structure describing details of a type expected in format checking,
1327 and the type to check against it. */
1328 typedef struct format_wanted_type
1330 /* The type wanted. */
1332 /* The name of this type to use in diagnostics. */
1333 const char *wanted_type_name
;
1334 /* The level of indirection through pointers at which this type occurs. */
1336 /* Whether, when pointer_count is 1, to allow any character type when
1337 pedantic, rather than just the character or void type specified. */
1338 int char_lenient_flag
;
1339 /* Whether the argument, dereferenced once, is written into and so the
1340 argument must not be a pointer to a const-qualified type. */
1341 int writing_in_flag
;
1342 /* If warnings should be of the form "field precision is not type int",
1343 the name to use (in this case "field precision"), otherwise NULL,
1344 for "%s format, %s arg" type messages. If (in an extension), this
1345 is a pointer type, wanted_type_name should be set to include the
1346 terminating '*' characters of the type name to give a correct
1349 /* The actual parameter to check against the wanted type. */
1351 /* The argument number of that parameter. */
1353 /* The next type to check for this format conversion, or NULL if none. */
1354 struct format_wanted_type
*next
;
1355 } format_wanted_type
;
1358 static const format_length_info printf_length_specs
[] =
1360 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
1361 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C99
},
1362 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
1363 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
1364 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
1365 { "Z", FMT_LEN_z
, STD_EXT
, NULL
, 0, 0 },
1366 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
1367 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
1368 { NULL
, 0, 0, NULL
, 0, 0 }
1372 /* This differs from printf_length_specs only in that "Z" is not accepted. */
1373 static const format_length_info scanf_length_specs
[] =
1375 { "h", FMT_LEN_h
, STD_C89
, "hh", FMT_LEN_hh
, STD_C99
},
1376 { "l", FMT_LEN_l
, STD_C89
, "ll", FMT_LEN_ll
, STD_C99
},
1377 { "q", FMT_LEN_ll
, STD_EXT
, NULL
, 0, 0 },
1378 { "L", FMT_LEN_L
, STD_C89
, NULL
, 0, 0 },
1379 { "z", FMT_LEN_z
, STD_C99
, NULL
, 0, 0 },
1380 { "t", FMT_LEN_t
, STD_C99
, NULL
, 0, 0 },
1381 { "j", FMT_LEN_j
, STD_C99
, NULL
, 0, 0 },
1382 { NULL
, 0, 0, NULL
, 0, 0 }
1386 #define T_I &integer_type_node
1387 #define T89_I { STD_C89, NULL, T_I }
1388 #define T99_I { STD_C99, NULL, T_I }
1389 #define T_L &long_integer_type_node
1390 #define T89_L { STD_C89, NULL, T_L }
1391 #define T_LL &long_long_integer_type_node
1392 #define T99_LL { STD_C99, NULL, T_LL }
1393 #define TEX_LL { STD_EXT, NULL, T_LL }
1394 #define T_S &short_integer_type_node
1395 #define T89_S { STD_C89, NULL, T_S }
1396 #define T_UI &unsigned_type_node
1397 #define T89_UI { STD_C89, NULL, T_UI }
1398 #define T99_UI { STD_C99, NULL, T_UI }
1399 #define T_UL &long_unsigned_type_node
1400 #define T89_UL { STD_C89, NULL, T_UL }
1401 #define T_ULL &long_long_unsigned_type_node
1402 #define T99_ULL { STD_C99, NULL, T_ULL }
1403 #define TEX_ULL { STD_EXT, NULL, T_ULL }
1404 #define T_US &short_unsigned_type_node
1405 #define T89_US { STD_C89, NULL, T_US }
1406 #define T_F &float_type_node
1407 #define T89_F { STD_C89, NULL, T_F }
1408 #define T99_F { STD_C99, NULL, T_F }
1409 #define T_D &double_type_node
1410 #define T89_D { STD_C89, NULL, T_D }
1411 #define T99_D { STD_C99, NULL, T_D }
1412 #define T_LD &long_double_type_node
1413 #define T89_LD { STD_C89, NULL, T_LD }
1414 #define T99_LD { STD_C99, NULL, T_LD }
1415 #define T_C &char_type_node
1416 #define T89_C { STD_C89, NULL, T_C }
1417 #define T_SC &signed_char_type_node
1418 #define T99_SC { STD_C99, NULL, T_SC }
1419 #define T_UC &unsigned_char_type_node
1420 #define T99_UC { STD_C99, NULL, T_UC }
1421 #define T_V &void_type_node
1422 #define T89_V { STD_C89, NULL, T_V }
1423 #define T_W &wchar_type_node
1424 #define T94_W { STD_C94, "wchar_t", T_W }
1425 #define TEX_W { STD_EXT, "wchar_t", T_W }
1426 #define T_WI &wint_type_node
1427 #define T94_WI { STD_C94, "wint_t", T_WI }
1428 #define TEX_WI { STD_EXT, "wint_t", T_WI }
1429 #define T_ST &c_size_type_node
1430 #define T99_ST { STD_C99, "size_t", T_ST }
1431 #define T_SST &signed_size_type_node
1432 #define T99_SST { STD_C99, "signed size_t", T_SST }
1433 #define T_PD &ptrdiff_type_node
1434 #define T99_PD { STD_C99, "ptrdiff_t", T_PD }
1435 #define T_UPD &unsigned_ptrdiff_type_node
1436 #define T99_UPD { STD_C99, "unsigned ptrdiff_t", T_UPD }
1437 #define T_IM NULL /* intmax_t not yet implemented. */
1438 #define T99_IM { STD_C99, "intmax_t", T_IM }
1439 #define T_UIM NULL /* uintmax_t not yet implemented. */
1440 #define T99_UIM { STD_C99, "uintmax_t", T_UIM }
1442 static const format_char_info print_char_table
[] =
1444 /* C89 conversion specifiers. */
1445 { "di", 0, STD_C89
, { T89_I
, T99_I
, T89_I
, T89_L
, T99_LL
, TEX_LL
, T99_SST
, T99_PD
, T99_IM
}, "-wp0 +'I", "i" },
1446 { "oxX", 0, STD_C89
, { T89_UI
, T99_UI
, T89_UI
, T89_UL
, T99_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "-wp0#", "i" },
1447 { "u", 0, STD_C89
, { T89_UI
, T99_UI
, T89_UI
, T89_UL
, T99_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "-wp0'I", "i" },
1448 { "fgG", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
1449 { "eE", 0, STD_C89
, { T89_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
1450 { "c", 0, STD_C89
, { T89_I
, BADLEN
, BADLEN
, T94_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
1451 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "c" },
1452 { "p", 1, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "c" },
1453 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T99_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
1454 /* C99 conversion specifiers. */
1455 { "F", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#'", "" },
1456 { "aA", 0, STD_C99
, { T99_D
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "-wp0 +#", "" },
1457 /* X/Open conversion specifiers. */
1458 { "C", 0, STD_EXT
, { TEX_WI
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-w", "" },
1459 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "" },
1460 /* GNU conversion specifiers. */
1461 { "m", 0, STD_EXT
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "-wp", "" },
1462 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
1465 static const format_char_info scan_char_table
[] =
1467 /* C89 conversion specifiers. */
1468 { "di", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T99_LL
, TEX_LL
, T99_SST
, T99_PD
, T99_IM
}, "*w", "W" },
1469 { "ouxX", 1, STD_C89
, { T89_UI
, T99_UC
, T89_US
, T89_UL
, T99_ULL
, TEX_ULL
, T99_ST
, T99_UPD
, T99_UIM
}, "*w", "W" },
1470 { "efgEG", 1, STD_C89
, { T89_F
, BADLEN
, BADLEN
, T89_D
, BADLEN
, T89_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
1471 { "c", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "cW" },
1472 { "s", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW" },
1473 { "[", 1, STD_C89
, { T89_C
, BADLEN
, BADLEN
, T94_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "cW[" },
1474 { "p", 2, STD_C89
, { T89_V
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
1475 { "n", 1, STD_C89
, { T89_I
, T99_SC
, T89_S
, T89_L
, T99_LL
, BADLEN
, T99_SST
, T99_PD
, T99_IM
}, "", "W" },
1476 /* C99 conversion specifiers. */
1477 { "FaA", 1, STD_C99
, { T99_F
, BADLEN
, BADLEN
, T99_D
, BADLEN
, T99_LD
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
1478 /* X/Open conversion specifiers. */
1479 { "C", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*w", "W" },
1480 { "S", 1, STD_EXT
, { TEX_W
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
, BADLEN
}, "*aw", "W" },
1481 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
1484 static format_char_info time_char_table
[] =
1486 /* C89 conversion specifiers. */
1487 { "ABZab", 0, STD_C89
, NOLENGTHS
, "^#", "" },
1488 { "cx", 0, STD_C89
, NOLENGTHS
, "E", "3" },
1489 { "HIMSUWdmw", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "" },
1490 { "j", 0, STD_C89
, NOLENGTHS
, "-_0Ow", "o" },
1491 { "p", 0, STD_C89
, NOLENGTHS
, "#", "" },
1492 { "X", 0, STD_C89
, NOLENGTHS
, "E", "" },
1493 { "y", 0, STD_C89
, NOLENGTHS
, "EO-_0w", "2" },
1494 { "Y", 0, STD_C89
, NOLENGTHS
, "-_0EOw", "o" },
1495 { "%", 0, STD_C89
, NOLENGTHS
, "", "" },
1496 /* C99 conversion specifiers. */
1497 { "C", 0, STD_C99
, NOLENGTHS
, "-_0EOw", "o" },
1498 { "D", 0, STD_C99
, NOLENGTHS
, "", "2" },
1499 { "eVu", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "" },
1500 { "FRTnrt", 0, STD_C99
, NOLENGTHS
, "", "" },
1501 { "g", 0, STD_C99
, NOLENGTHS
, "O-_0w", "2o" },
1502 { "G", 0, STD_C99
, NOLENGTHS
, "-_0Ow", "o" },
1503 { "h", 0, STD_C99
, NOLENGTHS
, "^#", "" },
1504 { "z", 0, STD_C99
, NOLENGTHS
, "O", "o" },
1505 /* GNU conversion specifiers. */
1506 { "kls", 0, STD_EXT
, NOLENGTHS
, "-_0Ow", "" },
1507 { "P", 0, STD_EXT
, NOLENGTHS
, "", "" },
1508 { NULL
, 0, 0, NOLENGTHS
, NULL
, NULL
}
1512 /* This must be in the same order as enum format_type. */
1513 static const format_kind_info format_types
[] =
1515 { "printf", printf_length_specs
, print_char_table
},
1516 { "scanf", scanf_length_specs
, scan_char_table
},
1517 { "strftime", NULL
, time_char_table
}
1521 typedef struct function_format_info
1523 struct function_format_info
*next
; /* next structure on the list */
1524 tree name
; /* identifier such as "printf" */
1525 tree assembler_name
; /* optional mangled identifier (for C++) */
1526 enum format_type format_type
; /* type of format (printf, scanf, etc.) */
1527 int format_num
; /* number of format argument */
1528 int first_arg_num
; /* number of first arg (zero for varargs) */
1529 } function_format_info
;
1531 static function_format_info
*function_format_list
= NULL
;
1533 typedef struct international_format_info
1535 struct international_format_info
*next
; /* next structure on the list */
1536 tree name
; /* identifier such as "gettext" */
1537 tree assembler_name
; /* optional mangled identifier (for C++) */
1538 int format_num
; /* number of format argument */
1539 } international_format_info
;
1541 static international_format_info
*international_format_list
= NULL
;
1543 static void check_format_info
PARAMS ((int *, function_format_info
*, tree
));
1544 static void status_warning
PARAMS ((int *, const char *, ...))
1547 static void init_dollar_format_checking
PARAMS ((int, tree
));
1548 static int maybe_read_dollar_number
PARAMS ((int *, const char **, int,
1550 static void finish_dollar_format_checking
PARAMS ((int *));
1552 static void check_format_types
PARAMS ((int *, format_wanted_type
*));
1554 /* Initialize the table of functions to perform format checking on.
1555 The ISO C functions are always checked (whether <stdio.h> is
1556 included or not), since it is common to call printf without
1557 including <stdio.h>. There shouldn't be a problem with this,
1558 since ISO C reserves these function names whether you include the
1559 header file or not. In any case, the checking is harmless. With
1560 -ffreestanding, these default attributes are disabled, and must be
1561 specified manually if desired.
1563 Also initialize the name of function that modify the format string for
1564 internationalization purposes. */
1567 init_function_format_info ()
1571 /* Functions from ISO/IEC 9899:1990. */
1572 record_function_format (get_identifier ("printf"), NULL_TREE
,
1573 printf_format_type
, 1, 2);
1574 record_function_format (get_identifier ("__builtin_printf"), NULL_TREE
,
1575 printf_format_type
, 1, 2);
1576 record_function_format (get_identifier ("fprintf"), NULL_TREE
,
1577 printf_format_type
, 2, 3);
1578 record_function_format (get_identifier ("sprintf"), NULL_TREE
,
1579 printf_format_type
, 2, 3);
1580 record_function_format (get_identifier ("scanf"), NULL_TREE
,
1581 scanf_format_type
, 1, 2);
1582 record_function_format (get_identifier ("fscanf"), NULL_TREE
,
1583 scanf_format_type
, 2, 3);
1584 record_function_format (get_identifier ("sscanf"), NULL_TREE
,
1585 scanf_format_type
, 2, 3);
1586 record_function_format (get_identifier ("vprintf"), NULL_TREE
,
1587 printf_format_type
, 1, 0);
1588 record_function_format (get_identifier ("vfprintf"), NULL_TREE
,
1589 printf_format_type
, 2, 0);
1590 record_function_format (get_identifier ("vsprintf"), NULL_TREE
,
1591 printf_format_type
, 2, 0);
1592 record_function_format (get_identifier ("strftime"), NULL_TREE
,
1593 strftime_format_type
, 3, 0);
1596 if (flag_hosted
&& flag_isoc99
)
1598 /* ISO C99 adds the snprintf and vscanf family functions. */
1599 record_function_format (get_identifier ("snprintf"), NULL_TREE
,
1600 printf_format_type
, 3, 4);
1601 record_function_format (get_identifier ("vsnprintf"), NULL_TREE
,
1602 printf_format_type
, 3, 0);
1603 record_function_format (get_identifier ("vscanf"), NULL_TREE
,
1604 scanf_format_type
, 1, 0);
1605 record_function_format (get_identifier ("vfscanf"), NULL_TREE
,
1606 scanf_format_type
, 2, 0);
1607 record_function_format (get_identifier ("vsscanf"), NULL_TREE
,
1608 scanf_format_type
, 2, 0);
1611 if (flag_hosted
&& flag_noniso_default_format_attributes
)
1613 /* Uniforum/GNU gettext functions, not in ISO C. */
1614 record_international_format (get_identifier ("gettext"), NULL_TREE
, 1);
1615 record_international_format (get_identifier ("dgettext"), NULL_TREE
, 2);
1616 record_international_format (get_identifier ("dcgettext"), NULL_TREE
, 2);
1619 check_function_format_ptr
= check_function_format
;
1622 /* Record information for argument format checking. FUNCTION_IDENT is
1623 the identifier node for the name of the function to check (its decl
1624 need not exist yet).
1625 FORMAT_TYPE specifies the type of format checking. FORMAT_NUM is the number
1626 of the argument which is the format control string (starting from 1).
1627 FIRST_ARG_NUM is the number of the first actual argument to check
1628 against the format string, or zero if no checking is not be done
1629 (e.g. for varargs such as vfprintf). */
1632 record_function_format (name
, assembler_name
, format_type
,
1633 format_num
, first_arg_num
)
1635 tree assembler_name
;
1636 enum format_type format_type
;
1640 function_format_info
*info
;
1642 /* Re-use existing structure if it's there. */
1644 for (info
= function_format_list
; info
; info
= info
->next
)
1646 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
1651 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
1652 info
->next
= function_format_list
;
1653 function_format_list
= info
;
1656 info
->assembler_name
= assembler_name
;
1659 info
->format_type
= format_type
;
1660 info
->format_num
= format_num
;
1661 info
->first_arg_num
= first_arg_num
;
1664 /* Record information for the names of function that modify the format
1665 argument to format functions. FUNCTION_IDENT is the identifier node for
1666 the name of the function (its decl need not exist yet) and FORMAT_NUM is
1667 the number of the argument which is the format control string (starting
1671 record_international_format (name
, assembler_name
, format_num
)
1673 tree assembler_name
;
1676 international_format_info
*info
;
1678 /* Re-use existing structure if it's there. */
1680 for (info
= international_format_list
; info
; info
= info
->next
)
1682 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
1689 = (international_format_info
*)
1690 xmalloc (sizeof (international_format_info
));
1691 info
->next
= international_format_list
;
1692 international_format_list
= info
;
1695 info
->assembler_name
= assembler_name
;
1698 info
->format_num
= format_num
;
1701 /* Check the argument list of a call to printf, scanf, etc.
1702 NAME is the function identifier.
1703 ASSEMBLER_NAME is the function's assembler identifier.
1704 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
1705 PARAMS is the list of argument values. */
1708 check_function_format (status
, name
, assembler_name
, params
)
1711 tree assembler_name
;
1714 function_format_info
*info
;
1716 /* See if this function is a format function. */
1717 for (info
= function_format_list
; info
; info
= info
->next
)
1719 if (info
->assembler_name
1720 ? (info
->assembler_name
== assembler_name
)
1721 : (info
->name
== name
))
1723 /* Yup; check it. */
1724 check_format_info (status
, info
, params
);
1730 /* This function replaces `warning' inside the printf format checking
1731 functions. If the `status' parameter is non-NULL, then it is
1732 dereferenced and set to 1 whenever a warning is caught. Otherwise
1733 it warns as usual by replicating the innards of the warning
1734 function from diagnostic.c. */
1736 status_warning
VPARAMS ((int *status
, const char *msgid
, ...))
1738 #ifndef ANSI_PROTOTYPES
1743 diagnostic_context dc
;
1749 VA_START (ap
, msgid
);
1751 #ifndef ANSI_PROTOTYPES
1752 status
= va_arg (ap
, int *);
1753 msgid
= va_arg (ap
, const char *);
1756 /* This duplicates the warning function behavior. */
1757 set_diagnostic_context
1758 (&dc
, msgid
, &ap
, input_filename
, lineno
, /* warn = */ 1);
1759 report_diagnostic (&dc
);
1765 /* Variables used by the checking of $ operand number formats. */
1766 static char *dollar_arguments_used
= NULL
;
1767 static int dollar_arguments_alloc
= 0;
1768 static int dollar_arguments_count
;
1769 static int dollar_first_arg_num
;
1770 static int dollar_max_arg_used
;
1771 static int dollar_format_warned
;
1773 /* Initialize the checking for a format string that may contain $
1774 parameter number specifications; we will need to keep track of whether
1775 each parameter has been used. FIRST_ARG_NUM is the number of the first
1776 argument that is a parameter to the format, or 0 for a vprintf-style
1777 function; PARAMS is the list of arguments starting at this argument. */
1780 init_dollar_format_checking (first_arg_num
, params
)
1784 dollar_first_arg_num
= first_arg_num
;
1785 dollar_arguments_count
= 0;
1786 dollar_max_arg_used
= 0;
1787 dollar_format_warned
= 0;
1788 if (first_arg_num
> 0)
1792 dollar_arguments_count
++;
1793 params
= TREE_CHAIN (params
);
1796 if (dollar_arguments_alloc
< dollar_arguments_count
)
1798 if (dollar_arguments_used
)
1799 free (dollar_arguments_used
);
1800 dollar_arguments_alloc
= dollar_arguments_count
;
1801 dollar_arguments_used
= xmalloc (dollar_arguments_alloc
);
1803 if (dollar_arguments_alloc
)
1804 memset (dollar_arguments_used
, 0, dollar_arguments_alloc
);
1808 /* Look for a decimal number followed by a $ in *FORMAT. If DOLLAR_NEEDED
1809 is set, it is an error if one is not found; otherwise, it is OK. If
1810 such a number is found, check whether it is within range and mark that
1811 numbered operand as being used for later checking. Returns the operand
1812 number if found and within range, zero if no such number was found and
1813 this is OK, or -1 on error. PARAMS points to the first operand of the
1814 format; PARAM_PTR is made to point to the parameter referred to. If
1815 a $ format is found, *FORMAT is updated to point just after it. */
1818 maybe_read_dollar_number (status
, format
, dollar_needed
, params
, param_ptr
)
1820 const char **format
;
1827 const char *fcp
= *format
;
1828 if (*fcp
< '0' || *fcp
> '9')
1832 status_warning (status
, "missing $ operand number in format");
1840 while (*fcp
>= '0' && *fcp
<= '9')
1843 nargnum
= 10 * argnum
+ (*fcp
- '0');
1844 if (nargnum
< 0 || nargnum
/ 10 != argnum
)
1853 status_warning (status
, "missing $ operand number in format");
1860 if (pedantic
&& !dollar_format_warned
)
1862 status_warning (status
, "ISO C does not support %%n$ operand number formats");
1863 dollar_format_warned
= 1;
1865 if (overflow_flag
|| argnum
== 0
1866 || (dollar_first_arg_num
&& argnum
> dollar_arguments_count
))
1868 status_warning (status
, "operand number out of range in format");
1871 if (argnum
> dollar_max_arg_used
)
1872 dollar_max_arg_used
= argnum
;
1873 /* For vprintf-style functions we may need to allocate more memory to
1874 track which arguments are used. */
1875 while (dollar_arguments_alloc
< dollar_max_arg_used
)
1878 nalloc
= 2 * dollar_arguments_alloc
+ 16;
1879 dollar_arguments_used
= xrealloc (dollar_arguments_used
, nalloc
);
1880 memset (dollar_arguments_used
+ dollar_arguments_alloc
, 0,
1881 nalloc
- dollar_arguments_alloc
);
1882 dollar_arguments_alloc
= nalloc
;
1884 dollar_arguments_used
[argnum
- 1] = 1;
1885 if (dollar_first_arg_num
)
1888 *param_ptr
= params
;
1889 for (i
= 1; i
< argnum
&& *param_ptr
!= 0; i
++)
1890 *param_ptr
= TREE_CHAIN (*param_ptr
);
1892 if (*param_ptr
== 0)
1894 /* This case shouldn't be caught here. */
1904 /* Finish the checking for a format string that used $ operand number formats
1905 instead of non-$ formats. We check for unused operands before used ones
1906 (a serious error, since the implementation of the format function
1907 can't know what types to pass to va_arg to find the later arguments).
1908 and for unused operands at the end of the format (if we know how many
1909 arguments the format had, so not for vprintf). If there were operand
1910 numbers out of range on a non-vprintf-style format, we won't have reached
1914 finish_dollar_format_checking (status
)
1918 for (i
= 0; i
< dollar_max_arg_used
; i
++)
1920 if (!dollar_arguments_used
[i
])
1921 status_warning (status
, "format argument %d unused before used argument %d in $-style format",
1922 i
+ 1, dollar_max_arg_used
);
1924 if (dollar_first_arg_num
&& dollar_max_arg_used
< dollar_arguments_count
)
1925 status_warning (status
, "unused arguments in $-style format");
1929 /* Check the argument list of a call to printf, scanf, etc.
1930 INFO points to the function_format_info structure.
1931 PARAMS is the list of argument values. */
1934 check_format_info (status
, info
, params
)
1936 function_format_info
*info
;
1941 int suppressed
, wide
, precise
;
1942 const char *length_chars
= NULL
;
1943 enum format_lengths length_chars_val
= FMT_LEN_none
;
1944 enum format_std_version length_chars_std
= STD_C89
;
1951 tree main_arg_params
;
1952 enum format_std_version wanted_type_std
;
1953 const char *wanted_type_name
;
1954 format_wanted_type width_wanted_type
;
1955 format_wanted_type precision_wanted_type
;
1956 format_wanted_type main_wanted_type
;
1957 format_wanted_type
*first_wanted_type
;
1958 format_wanted_type
*last_wanted_type
;
1959 tree first_fillin_param
;
1960 const char *format_chars
;
1961 const format_kind_info
*fki
= NULL
;
1962 const format_length_info
*fli
= NULL
;
1963 const format_char_info
*fci
= NULL
;
1965 /* -1 if no conversions taking an operand have been found; 0 if one has
1966 and it didn't use $; 1 if $ formats are in use. */
1967 int has_operand_number
= -1;
1969 /* Skip to format argument. If the argument isn't available, there's
1970 no work for us to do; prototype checking will catch the problem. */
1971 for (arg_num
= 1; ; ++arg_num
)
1975 if (arg_num
== info
->format_num
)
1977 params
= TREE_CHAIN (params
);
1979 format_tree
= TREE_VALUE (params
);
1980 params
= TREE_CHAIN (params
);
1981 if (format_tree
== 0)
1984 /* We can only check the format if it's a string constant. */
1985 while (TREE_CODE (format_tree
) == NOP_EXPR
)
1986 format_tree
= TREE_OPERAND (format_tree
, 0); /* strip coercion */
1988 if (TREE_CODE (format_tree
) == CALL_EXPR
1989 && TREE_CODE (TREE_OPERAND (format_tree
, 0)) == ADDR_EXPR
1990 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (format_tree
, 0), 0))
1993 tree function
= TREE_OPERAND (TREE_OPERAND (format_tree
, 0), 0);
1995 /* See if this is a call to a known internationalization function
1996 that modifies the format arg. */
1997 international_format_info
*info
;
1999 for (info
= international_format_list
; info
; info
= info
->next
)
2000 if (info
->assembler_name
2001 ? (info
->assembler_name
== DECL_ASSEMBLER_NAME (function
))
2002 : (info
->name
== DECL_NAME (function
)))
2007 for (inner_args
= TREE_OPERAND (format_tree
, 1), i
= 1;
2009 inner_args
= TREE_CHAIN (inner_args
), i
++)
2010 if (i
== info
->format_num
)
2012 format_tree
= TREE_VALUE (inner_args
);
2014 while (TREE_CODE (format_tree
) == NOP_EXPR
)
2015 format_tree
= TREE_OPERAND (format_tree
, 0);
2020 if (integer_zerop (format_tree
))
2022 status_warning (status
, "null format string");
2025 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
2027 /* The user may get multiple warnings if the supplied argument
2028 isn't even a string pointer. */
2029 /* Functions taking a va_list normally pass a non-literal format
2030 string. These functions typically are declared with
2031 first_arg_num == 0, so avoid warning in those cases. */
2032 if (info
->first_arg_num
!= 0 && warn_format
> 1)
2033 status_warning (status
, "format not a string literal, argument types not checked");
2036 format_tree
= TREE_OPERAND (format_tree
, 0);
2037 if (TREE_CODE (format_tree
) != STRING_CST
)
2039 /* The user may get multiple warnings if the supplied argument
2040 isn't even a string pointer. */
2041 /* Functions taking a va_list normally pass a non-literal format
2042 string. These functions typically are declared with
2043 first_arg_num == 0, so avoid warning in those cases. */
2044 if (info
->first_arg_num
!= 0 && warn_format
> 1)
2045 status_warning (status
, "format not a string literal, argument types not checked");
2048 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (format_tree
))) != char_type_node
)
2050 status_warning (status
, "format is a wide character string");
2053 format_chars
= TREE_STRING_POINTER (format_tree
);
2054 format_length
= TREE_STRING_LENGTH (format_tree
);
2055 if (format_length
<= 1)
2056 status_warning (status
, "zero-length format string");
2057 if (format_chars
[--format_length
] != 0)
2059 status_warning (status
, "unterminated format string");
2062 /* Skip to first argument to check. */
2063 while (arg_num
+ 1 < info
->first_arg_num
)
2067 params
= TREE_CHAIN (params
);
2071 first_fillin_param
= params
;
2072 init_dollar_format_checking (info
->first_arg_num
, first_fillin_param
);
2073 fki
= &format_types
[info
->format_type
];
2077 first_wanted_type
= NULL
;
2078 last_wanted_type
= NULL
;
2079 if (*format_chars
== 0)
2081 if (format_chars
- TREE_STRING_POINTER (format_tree
) != format_length
)
2082 status_warning (status
, "embedded `\\0' in format");
2083 if (info
->first_arg_num
!= 0 && params
!= 0
2084 && has_operand_number
<= 0)
2085 status_warning (status
, "too many arguments for format");
2086 if (has_operand_number
> 0)
2087 finish_dollar_format_checking (status
);
2090 if (*format_chars
++ != '%')
2092 if (*format_chars
== 0)
2094 status_warning (status
, "spurious trailing `%%' in format");
2097 if (*format_chars
== '%')
2103 suppressed
= wide
= precise
= FALSE
;
2105 main_arg_params
= 0;
2106 if (info
->format_type
== scanf_format_type
)
2108 int non_zero_width_char
= FALSE
;
2109 suppressed
= *format_chars
== '*';
2112 else if (has_operand_number
!= 0)
2115 opnum
= maybe_read_dollar_number (status
, &format_chars
,
2116 has_operand_number
== 1,
2123 has_operand_number
= 1;
2124 main_arg_num
= opnum
+ info
->first_arg_num
- 1;
2127 has_operand_number
= 0;
2129 while (ISDIGIT (*format_chars
))
2132 if (*format_chars
!= '0')
2133 non_zero_width_char
= TRUE
;
2136 if (wide
&& !non_zero_width_char
)
2137 status_warning (status
, "zero width in scanf format");
2139 else if (info
->format_type
== strftime_format_type
)
2141 while (*format_chars
!= 0 && index ("_-0^#", *format_chars
) != 0)
2144 status_warning (status
, "ISO C does not support the strftime `%c' flag",
2146 if (index (flag_chars
, *format_chars
) != 0)
2148 status_warning (status
, "repeated `%c' flag in format",
2154 i
= strlen (flag_chars
);
2155 flag_chars
[i
++] = *format_chars
++;
2159 while (ISDIGIT ((unsigned char) *format_chars
))
2164 if (wide
&& pedantic
)
2165 status_warning (status
, "ISO C does not support strftime format width");
2166 if (*format_chars
== 'E' || *format_chars
== 'O')
2168 i
= strlen (flag_chars
);
2169 flag_chars
[i
++] = *format_chars
++;
2171 if (*format_chars
== 'E' || *format_chars
== 'O')
2173 status_warning (status
, "multiple E/O modifiers in format");
2174 while (*format_chars
== 'E' || *format_chars
== 'O')
2179 else if (info
->format_type
== printf_format_type
)
2181 if (has_operand_number
!= 0)
2184 opnum
= maybe_read_dollar_number (status
, &format_chars
,
2185 0, first_fillin_param
,
2191 has_operand_number
= 1;
2192 main_arg_num
= opnum
+ info
->first_arg_num
- 1;
2196 while (*format_chars
!= 0 && index (" +#0-'I", *format_chars
) != 0)
2198 if (index (flag_chars
, *format_chars
) != 0)
2199 status_warning (status
, "repeated `%c' flag in format", *format_chars
++);
2202 i
= strlen (flag_chars
);
2203 flag_chars
[i
++] = *format_chars
++;
2207 /* "If the space and + flags both appear,
2208 the space flag will be ignored." */
2209 if (index (flag_chars
, ' ') != 0
2210 && index (flag_chars
, '+') != 0)
2211 status_warning (status
, "use of both ` ' and `+' flags in format");
2212 /* "If the 0 and - flags both appear,
2213 the 0 flag will be ignored." */
2214 if (index (flag_chars
, '0') != 0
2215 && index (flag_chars
, '-') != 0)
2216 status_warning (status
, "use of both `0' and `-' flags in format");
2217 if (index (flag_chars
, '\'') && pedantic
)
2218 status_warning (status
, "ISO C does not support the `'' format flag");
2219 if (index (flag_chars
, 'I') && pedantic
)
2220 status_warning (status
, "ISO C does not support the `I' format flag");
2221 if (*format_chars
== '*')
2224 /* "...a field width...may be indicated by an asterisk.
2225 In this case, an int argument supplies the field width..." */
2229 status_warning (status
, "too few arguments for format");
2232 if (has_operand_number
!= 0)
2235 opnum
= maybe_read_dollar_number (status
, &format_chars
,
2236 has_operand_number
== 1,
2243 has_operand_number
= 1;
2244 arg_num
= opnum
+ info
->first_arg_num
- 1;
2247 has_operand_number
= 0;
2249 if (info
->first_arg_num
!= 0)
2251 cur_param
= TREE_VALUE (params
);
2252 if (has_operand_number
<= 0)
2254 params
= TREE_CHAIN (params
);
2257 width_wanted_type
.wanted_type
= integer_type_node
;
2258 width_wanted_type
.wanted_type_name
= NULL
;
2259 width_wanted_type
.pointer_count
= 0;
2260 width_wanted_type
.char_lenient_flag
= 0;
2261 width_wanted_type
.writing_in_flag
= 0;
2262 width_wanted_type
.name
= _("field width");
2263 width_wanted_type
.param
= cur_param
;
2264 width_wanted_type
.arg_num
= arg_num
;
2265 width_wanted_type
.next
= NULL
;
2266 if (last_wanted_type
!= 0)
2267 last_wanted_type
->next
= &width_wanted_type
;
2268 if (first_wanted_type
== 0)
2269 first_wanted_type
= &width_wanted_type
;
2270 last_wanted_type
= &width_wanted_type
;
2275 while (ISDIGIT (*format_chars
))
2281 if (*format_chars
== '.')
2285 /* "...a...precision...may be indicated by an asterisk.
2286 In this case, an int argument supplies the...precision." */
2287 if (*format_chars
== '*')
2290 if (has_operand_number
!= 0)
2293 opnum
= maybe_read_dollar_number (status
, &format_chars
,
2294 has_operand_number
== 1,
2301 has_operand_number
= 1;
2302 arg_num
= opnum
+ info
->first_arg_num
- 1;
2305 has_operand_number
= 0;
2307 if (info
->first_arg_num
!= 0)
2311 status_warning (status
, "too few arguments for format");
2314 cur_param
= TREE_VALUE (params
);
2315 if (has_operand_number
<= 0)
2317 params
= TREE_CHAIN (params
);
2320 precision_wanted_type
.wanted_type
= integer_type_node
;
2321 precision_wanted_type
.wanted_type_name
= NULL
;
2322 precision_wanted_type
.pointer_count
= 0;
2323 precision_wanted_type
.char_lenient_flag
= 0;
2324 precision_wanted_type
.writing_in_flag
= 0;
2325 precision_wanted_type
.name
= _("field precision");
2326 precision_wanted_type
.param
= cur_param
;
2327 precision_wanted_type
.arg_num
= arg_num
;
2328 precision_wanted_type
.next
= NULL
;
2329 if (last_wanted_type
!= 0)
2330 last_wanted_type
->next
= &precision_wanted_type
;
2331 if (first_wanted_type
== 0)
2332 first_wanted_type
= &precision_wanted_type
;
2333 last_wanted_type
= &precision_wanted_type
;
2338 while (ISDIGIT (*format_chars
))
2346 fli
= fki
->length_char_specs
;
2349 while (fli
->name
!= 0 && fli
->name
[0] != *format_chars
)
2354 if (fli
->double_name
!= 0 && fli
->name
[0] == *format_chars
)
2357 length_chars
= fli
->double_name
;
2358 length_chars_val
= fli
->double_index
;
2359 length_chars_std
= fli
->double_std
;
2363 length_chars
= fli
->name
;
2364 length_chars_val
= fli
->index
;
2365 length_chars_std
= fli
->std
;
2370 length_chars
= NULL
;
2371 length_chars_val
= FMT_LEN_none
;
2372 length_chars_std
= STD_C89
;
2376 /* Warn if the length modifier is non-standard. */
2377 if (length_chars_std
== STD_EXT
)
2378 status_warning (status
, "ISO C does not support the `%s' %s length modifier",
2379 length_chars
, fki
->name
);
2380 else if ((length_chars_std
== STD_C99
&& !flag_isoc99
)
2381 || (length_chars_std
== STD_C94
&& !flag_isoc94
))
2382 status_warning (status
, "ISO C89 does not support the `%s' %s length modifier",
2383 length_chars
, fki
->name
);
2385 if (*format_chars
== 'a' && info
->format_type
== scanf_format_type
2388 if (format_chars
[1] == 's' || format_chars
[1] == 'S'
2389 || format_chars
[1] == '[')
2391 /* `a' is used as a flag. */
2396 if (suppressed
&& length_chars_val
!= FMT_LEN_none
)
2397 status_warning (status
, "use of `*' and `%s' together in format", length_chars
);
2399 format_char
= *format_chars
;
2400 if (format_char
== 0
2401 || (info
->format_type
!= strftime_format_type
&& format_char
== '%'))
2403 status_warning (status
, "conversion lacks type at end of format");
2407 fci
= fki
->conversion_specs
;
2408 while (fci
->format_chars
!= 0
2409 && index (fci
->format_chars
, format_char
) == 0)
2411 if (fci
->format_chars
== 0)
2413 if (ISGRAPH(format_char
))
2414 status_warning (status
, "unknown conversion type character `%c' in format",
2417 status_warning (status
, "unknown conversion type character 0x%x in format",
2423 if (fci
->std
== STD_EXT
)
2424 status_warning (status
, "ISO C does not support the `%%%c' %s format",
2425 format_char
, fki
->name
);
2426 else if ((fci
->std
== STD_C99
&& !flag_isoc99
)
2427 || (fci
->std
== STD_C94
&& !flag_isoc94
))
2428 status_warning (status
, "ISO C89 does not support the `%%%c' %s format",
2429 format_char
, fki
->name
);
2430 if (index (flag_chars
, 'O') != 0)
2432 if (index (fci
->flags2
, 'o') != 0)
2433 status_warning (status
, "ISO C does not support `%%O%c'", format_char
);
2434 else if (!flag_isoc99
&& index (fci
->flag_chars
, 'O') != 0)
2435 status_warning (status
, "ISO C89 does not support `%%O%c'", format_char
);
2437 if (!flag_isoc99
&& index (flag_chars
, 'E'))
2438 status_warning (status
, "ISO C89 does not support `%%E%c'", format_char
);
2440 if (wide
&& index (fci
->flag_chars
, 'w') == 0)
2441 status_warning (status
, "width used with `%c' format", format_char
);
2442 if (index (fci
->flags2
, '3') != 0
2443 || (format_char
== 'y' && index (flag_chars
, 'E')))
2444 status_warning (status
, "`%%%c' yields only last 2 digits of year in some locales",
2446 else if (index (fci
->flags2
, '2') != 0)
2447 status_warning (status
, "`%%%c' yields only last 2 digits of year", format_char
);
2448 if (precise
&& index (fci
->flag_chars
, 'p') == 0)
2449 status_warning (status
, "precision used with `%c' format", format_char
);
2450 if (aflag
&& index (fci
->flag_chars
, 'a') == 0)
2452 status_warning (status
, "`a' flag used with `%c' format", format_char
);
2453 /* To simplify the following code. */
2456 /* The a flag is a GNU extension. */
2457 else if (pedantic
&& aflag
)
2458 status_warning (status
, "ISO C does not support the `a' flag");
2459 if (index (fci
->flags2
, '[') != 0)
2461 /* Skip over scan set, in case it happens to have '%' in it. */
2462 if (*format_chars
== '^')
2464 /* Find closing bracket; if one is hit immediately, then
2465 it's part of the scan set rather than a terminator. */
2466 if (*format_chars
== ']')
2468 while (*format_chars
&& *format_chars
!= ']')
2470 if (*format_chars
!= ']')
2471 /* The end of the format string was reached. */
2472 status_warning (status
, "no closing `]' for `%%[' format");
2476 if (index (fci
->flag_chars
, '*') == 0)
2477 status_warning (status
, "suppression of `%c' conversion in format", format_char
);
2480 for (i
= 0; flag_chars
[i
] != 0; ++i
)
2482 if (index (fci
->flag_chars
, flag_chars
[i
]) == 0)
2483 status_warning (status
, "flag `%c' used with type `%c'",
2484 flag_chars
[i
], format_char
);
2486 if (info
->format_type
== strftime_format_type
)
2488 if (precise
&& index (flag_chars
, '0') != 0
2489 && (index (fci
->flags2
, 'i') != 0))
2490 status_warning (status
, "`0' flag ignored with precision specifier and `%c' format",
2492 wanted_type
= (fci
->types
[length_chars_val
].type
2493 ? *fci
->types
[length_chars_val
].type
: 0);
2494 wanted_type_name
= fci
->types
[length_chars_val
].name
;
2495 wanted_type_std
= fci
->types
[length_chars_val
].std
;
2496 if (wanted_type
== 0)
2498 status_warning (status
, "use of `%s' length modifier with `%c' type character",
2499 length_chars
, format_char
);
2500 /* Heuristic: skip one argument when an invalid length/type
2501 combination is encountered. */
2505 status_warning (status
, "too few arguments for format");
2508 params
= TREE_CHAIN (params
);
2512 /* Warn if non-standard, provided it is more non-standard
2513 than the length and type characters that may already
2514 have been warned for. */
2515 && wanted_type_std
> length_chars_std
2516 && wanted_type_std
> fci
->std
)
2518 if (wanted_type_std
== STD_EXT
)
2519 status_warning (status
, "ISO C does not support the `%%%s%c' %s format",
2520 length_chars
, format_char
, fki
->name
);
2521 else if ((wanted_type_std
== STD_C99
&& !flag_isoc99
)
2522 || (wanted_type_std
== STD_C94
&& !flag_isoc94
))
2523 status_warning (status
, "ISO C89 does not support the `%%%s%c' %s format",
2524 length_chars
, format_char
, fki
->name
);
2527 /* Finally. . .check type of argument against desired type! */
2528 if (info
->first_arg_num
== 0)
2530 if (fci
->pointer_count
== 0 && wanted_type
== void_type_node
)
2532 if (main_arg_num
!= 0)
2533 status_warning (status
, "operand number specified for format taking no argument");
2537 if (main_arg_num
!= 0)
2539 arg_num
= main_arg_num
;
2540 params
= main_arg_params
;
2545 if (has_operand_number
> 0)
2547 status_warning (status
, "missing $ operand number in format");
2551 has_operand_number
= 0;
2554 status_warning (status
, "too few arguments for format");
2558 cur_param
= TREE_VALUE (params
);
2559 params
= TREE_CHAIN (params
);
2560 main_wanted_type
.wanted_type
= wanted_type
;
2561 main_wanted_type
.wanted_type_name
= wanted_type_name
;
2562 main_wanted_type
.pointer_count
= fci
->pointer_count
+ aflag
;
2563 main_wanted_type
.char_lenient_flag
= 0;
2564 if (index (fci
->flags2
, 'c') != 0)
2565 main_wanted_type
.char_lenient_flag
= 1;
2566 main_wanted_type
.writing_in_flag
= 0;
2567 if (index (fci
->flags2
, 'W') != 0)
2568 main_wanted_type
.writing_in_flag
= 1;
2569 main_wanted_type
.name
= NULL
;
2570 main_wanted_type
.param
= cur_param
;
2571 main_wanted_type
.arg_num
= arg_num
;
2572 main_wanted_type
.next
= NULL
;
2573 if (last_wanted_type
!= 0)
2574 last_wanted_type
->next
= &main_wanted_type
;
2575 if (first_wanted_type
== 0)
2576 first_wanted_type
= &main_wanted_type
;
2577 last_wanted_type
= &main_wanted_type
;
2580 if (first_wanted_type
!= 0)
2581 check_format_types (status
, first_wanted_type
);
2587 /* Check the argument types from a single format conversion (possibly
2588 including width and precision arguments). */
2590 check_format_types (status
, types
)
2592 format_wanted_type
*types
;
2594 for (; types
!= 0; types
= types
->next
)
2603 cur_param
= types
->param
;
2604 cur_type
= TREE_TYPE (cur_param
);
2605 if (TREE_CODE (cur_type
) == ERROR_MARK
)
2608 wanted_type
= types
->wanted_type
;
2609 arg_num
= types
->arg_num
;
2611 /* The following should not occur here. */
2612 if (wanted_type
== 0)
2614 if (wanted_type
== void_type_node
&& types
->pointer_count
== 0)
2617 STRIP_NOPS (cur_param
);
2619 /* Check the types of any additional pointer arguments
2620 that precede the "real" argument. */
2621 for (i
= 0; i
< types
->pointer_count
; ++i
)
2623 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
2625 cur_type
= TREE_TYPE (cur_type
);
2626 if (TREE_CODE (cur_type
) == ERROR_MARK
)
2629 if (cur_param
!= 0 && TREE_CODE (cur_param
) == ADDR_EXPR
)
2630 cur_param
= TREE_OPERAND (cur_param
, 0);
2634 /* See if this is an attempt to write into a const type with
2635 scanf or with printf "%n". Note: the writing in happens
2636 at the first indirection only, if for example
2637 void * const * is passed to scanf %p; passing
2638 const void ** is simply passing an incompatible type. */
2639 if (types
->writing_in_flag
2641 && (TYPE_READONLY (cur_type
)
2643 && (TREE_CODE_CLASS (TREE_CODE (cur_param
)) == 'c'
2644 || (DECL_P (cur_param
)
2645 && TREE_READONLY (cur_param
))))))
2646 status_warning (status
, "writing into constant object (arg %d)", arg_num
);
2648 /* If there are extra type qualifiers beyond the first
2649 indirection, then this makes the types technically
2653 && (TYPE_READONLY (cur_type
)
2654 || TYPE_VOLATILE (cur_type
)
2655 || TYPE_RESTRICT (cur_type
)))
2656 status_warning (status
, "extra type qualifiers in format argument (arg %d)",
2662 if (types
->pointer_count
== 1)
2663 status_warning (status
, "format argument is not a pointer (arg %d)", arg_num
);
2665 status_warning (status
, "format argument is not a pointer to a pointer (arg %d)", arg_num
);
2670 if (i
< types
->pointer_count
)
2673 orig_cur_type
= cur_type
;
2674 cur_type
= TYPE_MAIN_VARIANT (cur_type
);
2676 /* Check whether the argument type is a character type. This leniency
2677 only applies to certain formats, flagged with 'c'.
2679 if (types
->char_lenient_flag
)
2680 char_type_flag
= (cur_type
== char_type_node
2681 || cur_type
== signed_char_type_node
2682 || cur_type
== unsigned_char_type_node
);
2684 /* Check the type of the "real" argument, if there's a type we want. */
2685 if (wanted_type
== cur_type
)
2687 /* If we want `void *', allow any pointer type.
2688 (Anything else would already have got a warning.)
2689 With -pedantic, only allow pointers to void and to character
2691 if (wanted_type
== void_type_node
2692 && (!pedantic
|| (i
== 1 && char_type_flag
)))
2694 /* Don't warn about differences merely in signedness, unless
2695 -pedantic. With -pedantic, warn if the type is a pointer
2696 target and not a character type, and for character types at
2697 a second level of indirection. */
2698 if (TREE_CODE (wanted_type
) == INTEGER_TYPE
2699 && TREE_CODE (cur_type
) == INTEGER_TYPE
2700 && (! pedantic
|| i
== 0 || (i
== 1 && char_type_flag
))
2701 && (TREE_UNSIGNED (wanted_type
)
2702 ? wanted_type
== unsigned_type (cur_type
)
2703 : wanted_type
== signed_type (cur_type
)))
2705 /* Likewise, "signed char", "unsigned char" and "char" are
2706 equivalent but the above test won't consider them equivalent. */
2707 if (wanted_type
== char_type_node
2708 && (! pedantic
|| i
< 2)
2711 /* Now we have a type mismatch. */
2713 register const char *this;
2714 register const char *that
;
2716 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
2718 if (TYPE_NAME (orig_cur_type
) != 0
2719 && TREE_CODE (orig_cur_type
) != INTEGER_TYPE
2720 && !(TREE_CODE (orig_cur_type
) == POINTER_TYPE
2721 && TREE_CODE (TREE_TYPE (orig_cur_type
)) == INTEGER_TYPE
))
2723 if (TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
2724 && DECL_NAME (TYPE_NAME (orig_cur_type
)) != 0)
2725 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2727 that
= IDENTIFIER_POINTER (TYPE_NAME (orig_cur_type
));
2730 /* A nameless type can't possibly match what the format wants.
2731 So there will be a warning for it.
2732 Make up a string to describe vaguely what it is. */
2735 if (TREE_CODE (orig_cur_type
) == POINTER_TYPE
)
2738 that
= "different type";
2741 /* Make the warning better in case of mismatch of int vs long. */
2742 if (TREE_CODE (orig_cur_type
) == INTEGER_TYPE
2743 && TREE_CODE (wanted_type
) == INTEGER_TYPE
2744 && TYPE_PRECISION (orig_cur_type
) == TYPE_PRECISION (wanted_type
)
2745 && TYPE_NAME (orig_cur_type
) != 0
2746 && TREE_CODE (TYPE_NAME (orig_cur_type
)) == TYPE_DECL
)
2747 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (orig_cur_type
)));
2749 if (strcmp (this, that
) != 0)
2751 /* There may be a better name for the format, e.g. size_t,
2752 but we should allow for programs with a perverse typedef
2753 making size_t something other than what the compiler
2755 if (types
->wanted_type_name
!= 0
2756 && strcmp (types
->wanted_type_name
, that
) != 0)
2757 this = types
->wanted_type_name
;
2758 if (types
->name
!= 0)
2759 status_warning (status
, "%s is not type %s (arg %d)", types
->name
, this,
2762 status_warning (status
, "%s format, %s arg (arg %d)", this, that
, arg_num
);
2768 /* Print a warning if a constant expression had overflow in folding.
2769 Invoke this function on every expression that the language
2770 requires to be a constant expression.
2771 Note the ANSI C standard says it is erroneous for a
2772 constant expression to overflow. */
2775 constant_expression_warning (value
)
2778 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
2779 || TREE_CODE (value
) == COMPLEX_CST
)
2780 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
2781 pedwarn ("overflow in constant expression");
2784 /* Print a warning if an expression had overflow in folding.
2785 Invoke this function on every expression that
2786 (1) appears in the source code, and
2787 (2) might be a constant expression that overflowed, and
2788 (3) is not already checked by convert_and_check;
2789 however, do not invoke this function on operands of explicit casts. */
2792 overflow_warning (value
)
2795 if ((TREE_CODE (value
) == INTEGER_CST
2796 || (TREE_CODE (value
) == COMPLEX_CST
2797 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
2798 && TREE_OVERFLOW (value
))
2800 TREE_OVERFLOW (value
) = 0;
2801 if (skip_evaluation
== 0)
2802 warning ("integer overflow in expression");
2804 else if ((TREE_CODE (value
) == REAL_CST
2805 || (TREE_CODE (value
) == COMPLEX_CST
2806 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
2807 && TREE_OVERFLOW (value
))
2809 TREE_OVERFLOW (value
) = 0;
2810 if (skip_evaluation
== 0)
2811 warning ("floating point overflow in expression");
2815 /* Print a warning if a large constant is truncated to unsigned,
2816 or if -Wconversion is used and a constant < 0 is converted to unsigned.
2817 Invoke this function on every expression that might be implicitly
2818 converted to an unsigned type. */
2821 unsigned_conversion_warning (result
, operand
)
2822 tree result
, operand
;
2824 if (TREE_CODE (operand
) == INTEGER_CST
2825 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
2826 && TREE_UNSIGNED (TREE_TYPE (result
))
2827 && skip_evaluation
== 0
2828 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
2830 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
2831 /* This detects cases like converting -129 or 256 to unsigned char. */
2832 warning ("large integer implicitly truncated to unsigned type");
2833 else if (warn_conversion
)
2834 warning ("negative integer implicitly converted to unsigned type");
2838 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2839 Invoke this function on every expression that is converted implicitly,
2840 i.e. because of language rules and not because of an explicit cast. */
2843 convert_and_check (type
, expr
)
2846 tree t
= convert (type
, expr
);
2847 if (TREE_CODE (t
) == INTEGER_CST
)
2849 if (TREE_OVERFLOW (t
))
2851 TREE_OVERFLOW (t
) = 0;
2853 /* Do not diagnose overflow in a constant expression merely
2854 because a conversion overflowed. */
2855 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
2857 /* No warning for converting 0x80000000 to int. */
2858 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
2859 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
2860 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
2861 /* If EXPR fits in the unsigned version of TYPE,
2862 don't warn unless pedantic. */
2864 || TREE_UNSIGNED (type
)
2865 || ! int_fits_type_p (expr
, unsigned_type (type
)))
2866 && skip_evaluation
== 0)
2867 warning ("overflow in implicit constant conversion");
2870 unsigned_conversion_warning (t
, expr
);
2876 c_expand_expr_stmt (expr
)
2879 /* Do default conversion if safe and possibly important,
2880 in case within ({...}). */
2881 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
2882 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
2883 expr
= default_conversion (expr
);
2885 if (TREE_TYPE (expr
) != error_mark_node
2886 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr
))
2887 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
2888 error ("expression statement has incomplete type");
2890 last_expr_type
= TREE_TYPE (expr
);
2891 add_stmt (build_stmt (EXPR_STMT
, expr
));
2894 /* Validate the expression after `case' and apply default promotions. */
2897 check_case_value (value
)
2900 if (value
== NULL_TREE
)
2903 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
2904 STRIP_TYPE_NOPS (value
);
2905 /* In C++, the following is allowed:
2908 switch (...) { case i: ... }
2910 So, we try to reduce the VALUE to a constant that way. */
2911 if (c_language
== clk_cplusplus
)
2913 value
= decl_constant_value (value
);
2914 STRIP_TYPE_NOPS (value
);
2915 value
= fold (value
);
2918 if (TREE_CODE (value
) != INTEGER_CST
2919 && value
!= error_mark_node
)
2921 error ("case label does not reduce to an integer constant");
2922 value
= error_mark_node
;
2925 /* Promote char or short to int. */
2926 value
= default_conversion (value
);
2928 constant_expression_warning (value
);
2933 /* Return an integer type with BITS bits of precision,
2934 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
2937 type_for_size (bits
, unsignedp
)
2941 if (bits
== TYPE_PRECISION (integer_type_node
))
2942 return unsignedp
? unsigned_type_node
: integer_type_node
;
2944 if (bits
== TYPE_PRECISION (signed_char_type_node
))
2945 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2947 if (bits
== TYPE_PRECISION (short_integer_type_node
))
2948 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2950 if (bits
== TYPE_PRECISION (long_integer_type_node
))
2951 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2953 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
2954 return (unsignedp
? long_long_unsigned_type_node
2955 : long_long_integer_type_node
);
2957 if (bits
== TYPE_PRECISION (widest_integer_literal_type_node
))
2958 return (unsignedp
? widest_unsigned_literal_type_node
2959 : widest_integer_literal_type_node
);
2961 if (bits
<= TYPE_PRECISION (intQI_type_node
))
2962 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
2964 if (bits
<= TYPE_PRECISION (intHI_type_node
))
2965 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
2967 if (bits
<= TYPE_PRECISION (intSI_type_node
))
2968 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
2970 if (bits
<= TYPE_PRECISION (intDI_type_node
))
2971 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
2976 /* Return a data type that has machine mode MODE.
2977 If the mode is an integer,
2978 then UNSIGNEDP selects between signed and unsigned types. */
2981 type_for_mode (mode
, unsignedp
)
2982 enum machine_mode mode
;
2985 if (mode
== TYPE_MODE (integer_type_node
))
2986 return unsignedp
? unsigned_type_node
: integer_type_node
;
2988 if (mode
== TYPE_MODE (signed_char_type_node
))
2989 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
2991 if (mode
== TYPE_MODE (short_integer_type_node
))
2992 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
2994 if (mode
== TYPE_MODE (long_integer_type_node
))
2995 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
2997 if (mode
== TYPE_MODE (long_long_integer_type_node
))
2998 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
3000 if (mode
== TYPE_MODE (widest_integer_literal_type_node
))
3001 return unsignedp
? widest_unsigned_literal_type_node
3002 : widest_integer_literal_type_node
;
3004 if (mode
== TYPE_MODE (intQI_type_node
))
3005 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
3007 if (mode
== TYPE_MODE (intHI_type_node
))
3008 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
3010 if (mode
== TYPE_MODE (intSI_type_node
))
3011 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
3013 if (mode
== TYPE_MODE (intDI_type_node
))
3014 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
3016 #if HOST_BITS_PER_WIDE_INT >= 64
3017 if (mode
== TYPE_MODE (intTI_type_node
))
3018 return unsignedp
? unsigned_intTI_type_node
: intTI_type_node
;
3021 if (mode
== TYPE_MODE (float_type_node
))
3022 return float_type_node
;
3024 if (mode
== TYPE_MODE (double_type_node
))
3025 return double_type_node
;
3027 if (mode
== TYPE_MODE (long_double_type_node
))
3028 return long_double_type_node
;
3030 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
3031 return build_pointer_type (char_type_node
);
3033 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
3034 return build_pointer_type (integer_type_node
);
3036 #ifdef VECTOR_MODE_SUPPORTED_P
3037 if (mode
== TYPE_MODE (V4SF_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
3038 return V4SF_type_node
;
3039 if (mode
== TYPE_MODE (V4SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
3040 return V4SI_type_node
;
3041 if (mode
== TYPE_MODE (V2SI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
3042 return V2SI_type_node
;
3043 if (mode
== TYPE_MODE (V4HI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
3044 return V4HI_type_node
;
3045 if (mode
== TYPE_MODE (V8QI_type_node
) && VECTOR_MODE_SUPPORTED_P (mode
))
3046 return V8QI_type_node
;
3052 /* Return an unsigned type the same as TYPE in other respects. */
3054 unsigned_type (type
)
3057 tree type1
= TYPE_MAIN_VARIANT (type
);
3058 if (type1
== signed_char_type_node
|| type1
== char_type_node
)
3059 return unsigned_char_type_node
;
3060 if (type1
== integer_type_node
)
3061 return unsigned_type_node
;
3062 if (type1
== short_integer_type_node
)
3063 return short_unsigned_type_node
;
3064 if (type1
== long_integer_type_node
)
3065 return long_unsigned_type_node
;
3066 if (type1
== long_long_integer_type_node
)
3067 return long_long_unsigned_type_node
;
3068 if (type1
== widest_integer_literal_type_node
)
3069 return widest_unsigned_literal_type_node
;
3070 #if HOST_BITS_PER_WIDE_INT >= 64
3071 if (type1
== intTI_type_node
)
3072 return unsigned_intTI_type_node
;
3074 if (type1
== intDI_type_node
)
3075 return unsigned_intDI_type_node
;
3076 if (type1
== intSI_type_node
)
3077 return unsigned_intSI_type_node
;
3078 if (type1
== intHI_type_node
)
3079 return unsigned_intHI_type_node
;
3080 if (type1
== intQI_type_node
)
3081 return unsigned_intQI_type_node
;
3083 return signed_or_unsigned_type (1, type
);
3086 /* Return a signed type the same as TYPE in other respects. */
3092 tree type1
= TYPE_MAIN_VARIANT (type
);
3093 if (type1
== unsigned_char_type_node
|| type1
== char_type_node
)
3094 return signed_char_type_node
;
3095 if (type1
== unsigned_type_node
)
3096 return integer_type_node
;
3097 if (type1
== short_unsigned_type_node
)
3098 return short_integer_type_node
;
3099 if (type1
== long_unsigned_type_node
)
3100 return long_integer_type_node
;
3101 if (type1
== long_long_unsigned_type_node
)
3102 return long_long_integer_type_node
;
3103 if (type1
== widest_unsigned_literal_type_node
)
3104 return widest_integer_literal_type_node
;
3105 #if HOST_BITS_PER_WIDE_INT >= 64
3106 if (type1
== unsigned_intTI_type_node
)
3107 return intTI_type_node
;
3109 if (type1
== unsigned_intDI_type_node
)
3110 return intDI_type_node
;
3111 if (type1
== unsigned_intSI_type_node
)
3112 return intSI_type_node
;
3113 if (type1
== unsigned_intHI_type_node
)
3114 return intHI_type_node
;
3115 if (type1
== unsigned_intQI_type_node
)
3116 return intQI_type_node
;
3118 return signed_or_unsigned_type (0, type
);
3121 /* Return a type the same as TYPE except unsigned or
3122 signed according to UNSIGNEDP. */
3125 signed_or_unsigned_type (unsignedp
, type
)
3129 if (! INTEGRAL_TYPE_P (type
)
3130 || TREE_UNSIGNED (type
) == unsignedp
)
3133 if (TYPE_PRECISION (type
) == TYPE_PRECISION (signed_char_type_node
))
3134 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
3135 if (TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
3136 return unsignedp
? unsigned_type_node
: integer_type_node
;
3137 if (TYPE_PRECISION (type
) == TYPE_PRECISION (short_integer_type_node
))
3138 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
3139 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_integer_type_node
))
3140 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
3141 if (TYPE_PRECISION (type
) == TYPE_PRECISION (long_long_integer_type_node
))
3142 return (unsignedp
? long_long_unsigned_type_node
3143 : long_long_integer_type_node
);
3144 if (TYPE_PRECISION (type
) == TYPE_PRECISION (widest_integer_literal_type_node
))
3145 return (unsignedp
? widest_unsigned_literal_type_node
3146 : widest_integer_literal_type_node
);
3150 /* Return the minimum number of bits needed to represent VALUE in a
3151 signed or unsigned type, UNSIGNEDP says which. */
3154 min_precision (value
, unsignedp
)
3160 /* If the value is negative, compute its negative minus 1. The latter
3161 adjustment is because the absolute value of the largest negative value
3162 is one larger than the largest positive value. This is equivalent to
3163 a bit-wise negation, so use that operation instead. */
3165 if (tree_int_cst_sgn (value
) < 0)
3166 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
3168 /* Return the number of bits needed, taking into account the fact
3169 that we need one more bit for a signed than unsigned type. */
3171 if (integer_zerop (value
))
3174 log
= tree_floor_log2 (value
);
3176 return log
+ 1 + ! unsignedp
;
3179 /* Print an error message for invalid operands to arith operation CODE.
3180 NOP_EXPR is used as a special case (see truthvalue_conversion). */
3183 binary_op_error (code
)
3184 enum tree_code code
;
3186 register const char *opname
;
3191 error ("invalid truth-value expression");
3195 opname
= "+"; break;
3197 opname
= "-"; break;
3199 opname
= "*"; break;
3201 opname
= "max"; break;
3203 opname
= "min"; break;
3205 opname
= "=="; break;
3207 opname
= "!="; break;
3209 opname
= "<="; break;
3211 opname
= ">="; break;
3213 opname
= "<"; break;
3215 opname
= ">"; break;
3217 opname
= "<<"; break;
3219 opname
= ">>"; break;
3220 case TRUNC_MOD_EXPR
:
3221 case FLOOR_MOD_EXPR
:
3222 opname
= "%"; break;
3223 case TRUNC_DIV_EXPR
:
3224 case FLOOR_DIV_EXPR
:
3225 opname
= "/"; break;
3227 opname
= "&"; break;
3229 opname
= "|"; break;
3230 case TRUTH_ANDIF_EXPR
:
3231 opname
= "&&"; break;
3232 case TRUTH_ORIF_EXPR
:
3233 opname
= "||"; break;
3235 opname
= "^"; break;
3238 opname
= "rotate"; break;
3240 opname
= "unknown"; break;
3242 error ("invalid operands to binary %s", opname
);
3245 /* Subroutine of build_binary_op, used for comparison operations.
3246 See if the operands have both been converted from subword integer types
3247 and, if so, perhaps change them both back to their original type.
3248 This function is also responsible for converting the two operands
3249 to the proper common type for comparison.
3251 The arguments of this function are all pointers to local variables
3252 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3253 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3255 If this function returns nonzero, it means that the comparison has
3256 a constant value. What this function returns is an expression for
3260 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
3261 tree
*op0_ptr
, *op1_ptr
;
3263 enum tree_code
*rescode_ptr
;
3266 tree op0
= *op0_ptr
;
3267 tree op1
= *op1_ptr
;
3268 int unsignedp0
, unsignedp1
;
3270 tree primop0
, primop1
;
3271 enum tree_code code
= *rescode_ptr
;
3273 /* Throw away any conversions to wider types
3274 already present in the operands. */
3276 primop0
= get_narrower (op0
, &unsignedp0
);
3277 primop1
= get_narrower (op1
, &unsignedp1
);
3279 /* Handle the case that OP0 does not *contain* a conversion
3280 but it *requires* conversion to FINAL_TYPE. */
3282 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
3283 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
3284 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
3285 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
3287 /* If one of the operands must be floated, we cannot optimize. */
3288 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
3289 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
3291 /* If first arg is constant, swap the args (changing operation
3292 so value is preserved), for canonicalization. Don't do this if
3293 the second arg is 0. */
3295 if (TREE_CONSTANT (primop0
)
3296 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
3298 register tree tem
= primop0
;
3299 register int temi
= unsignedp0
;
3307 unsignedp0
= unsignedp1
;
3330 *rescode_ptr
= code
;
3333 /* If comparing an integer against a constant more bits wide,
3334 maybe we can deduce a value of 1 or 0 independent of the data.
3335 Or else truncate the constant now
3336 rather than extend the variable at run time.
3338 This is only interesting if the constant is the wider arg.
3339 Also, it is not safe if the constant is unsigned and the
3340 variable arg is signed, since in this case the variable
3341 would be sign-extended and then regarded as unsigned.
3342 Our technique fails in this case because the lowest/highest
3343 possible unsigned results don't follow naturally from the
3344 lowest/highest possible values of the variable operand.
3345 For just EQ_EXPR and NE_EXPR there is another technique that
3346 could be used: see if the constant can be faithfully represented
3347 in the other operand's type, by truncating it and reextending it
3348 and see if that preserves the constant's value. */
3350 if (!real1
&& !real2
3351 && TREE_CODE (primop1
) == INTEGER_CST
3352 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
3354 int min_gt
, max_gt
, min_lt
, max_lt
;
3355 tree maxval
, minval
;
3356 /* 1 if comparison is nominally unsigned. */
3357 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
3360 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
3362 /* If TYPE is an enumeration, then we need to get its min/max
3363 values from it's underlying integral type, not the enumerated
3365 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
3366 type
= type_for_size (TYPE_PRECISION (type
), unsignedp0
);
3368 maxval
= TYPE_MAX_VALUE (type
);
3369 minval
= TYPE_MIN_VALUE (type
);
3371 if (unsignedp
&& !unsignedp0
)
3372 *restype_ptr
= signed_type (*restype_ptr
);
3374 if (TREE_TYPE (primop1
) != *restype_ptr
)
3375 primop1
= convert (*restype_ptr
, primop1
);
3376 if (type
!= *restype_ptr
)
3378 minval
= convert (*restype_ptr
, minval
);
3379 maxval
= convert (*restype_ptr
, maxval
);
3382 if (unsignedp
&& unsignedp0
)
3384 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
3385 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
3386 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
3387 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
3391 min_gt
= INT_CST_LT (primop1
, minval
);
3392 max_gt
= INT_CST_LT (primop1
, maxval
);
3393 min_lt
= INT_CST_LT (minval
, primop1
);
3394 max_lt
= INT_CST_LT (maxval
, primop1
);
3398 /* This used to be a switch, but Genix compiler can't handle that. */
3399 if (code
== NE_EXPR
)
3401 if (max_lt
|| min_gt
)
3402 val
= boolean_true_node
;
3404 else if (code
== EQ_EXPR
)
3406 if (max_lt
|| min_gt
)
3407 val
= boolean_false_node
;
3409 else if (code
== LT_EXPR
)
3412 val
= boolean_true_node
;
3414 val
= boolean_false_node
;
3416 else if (code
== GT_EXPR
)
3419 val
= boolean_true_node
;
3421 val
= boolean_false_node
;
3423 else if (code
== LE_EXPR
)
3426 val
= boolean_true_node
;
3428 val
= boolean_false_node
;
3430 else if (code
== GE_EXPR
)
3433 val
= boolean_true_node
;
3435 val
= boolean_false_node
;
3438 /* If primop0 was sign-extended and unsigned comparison specd,
3439 we did a signed comparison above using the signed type bounds.
3440 But the comparison we output must be unsigned.
3442 Also, for inequalities, VAL is no good; but if the signed
3443 comparison had *any* fixed result, it follows that the
3444 unsigned comparison just tests the sign in reverse
3445 (positive values are LE, negative ones GE).
3446 So we can generate an unsigned comparison
3447 against an extreme value of the signed type. */
3449 if (unsignedp
&& !unsignedp0
)
3456 primop1
= TYPE_MIN_VALUE (type
);
3462 primop1
= TYPE_MAX_VALUE (type
);
3469 type
= unsigned_type (type
);
3472 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
3474 /* This is the case of (char)x >?< 0x80, which people used to use
3475 expecting old C compilers to change the 0x80 into -0x80. */
3476 if (val
== boolean_false_node
)
3477 warning ("comparison is always false due to limited range of data type");
3478 if (val
== boolean_true_node
)
3479 warning ("comparison is always true due to limited range of data type");
3482 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
3484 /* This is the case of (unsigned char)x >?< -1 or < 0. */
3485 if (val
== boolean_false_node
)
3486 warning ("comparison is always false due to limited range of data type");
3487 if (val
== boolean_true_node
)
3488 warning ("comparison is always true due to limited range of data type");
3493 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3494 if (TREE_SIDE_EFFECTS (primop0
))
3495 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
3499 /* Value is not predetermined, but do the comparison
3500 in the type of the operand that is not constant.
3501 TYPE is already properly set. */
3503 else if (real1
&& real2
3504 && (TYPE_PRECISION (TREE_TYPE (primop0
))
3505 == TYPE_PRECISION (TREE_TYPE (primop1
))))
3506 type
= TREE_TYPE (primop0
);
3508 /* If args' natural types are both narrower than nominal type
3509 and both extend in the same manner, compare them
3510 in the type of the wider arg.
3511 Otherwise must actually extend both to the nominal
3512 common type lest different ways of extending
3514 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
3516 else if (unsignedp0
== unsignedp1
&& real1
== real2
3517 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
3518 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
3520 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
3521 type
= signed_or_unsigned_type (unsignedp0
3522 || TREE_UNSIGNED (*restype_ptr
),
3524 /* Make sure shorter operand is extended the right way
3525 to match the longer operand. */
3526 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
3528 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
3533 /* Here we must do the comparison on the nominal type
3534 using the args exactly as we received them. */
3535 type
= *restype_ptr
;
3539 if (!real1
&& !real2
&& integer_zerop (primop1
)
3540 && TREE_UNSIGNED (*restype_ptr
))
3546 /* All unsigned values are >= 0, so we warn if extra warnings
3547 are requested. However, if OP0 is a constant that is
3548 >= 0, the signedness of the comparison isn't an issue,
3549 so suppress the warning. */
3550 if (extra_warnings
&& !in_system_header
3551 && ! (TREE_CODE (primop0
) == INTEGER_CST
3552 && ! TREE_OVERFLOW (convert (signed_type (type
),
3554 warning ("comparison of unsigned expression >= 0 is always true");
3555 value
= boolean_true_node
;
3559 if (extra_warnings
&& !in_system_header
3560 && ! (TREE_CODE (primop0
) == INTEGER_CST
3561 && ! TREE_OVERFLOW (convert (signed_type (type
),
3563 warning ("comparison of unsigned expression < 0 is always false");
3564 value
= boolean_false_node
;
3573 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
3574 if (TREE_SIDE_EFFECTS (primop0
))
3575 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
3582 *op0_ptr
= convert (type
, primop0
);
3583 *op1_ptr
= convert (type
, primop1
);
3585 *restype_ptr
= boolean_type_node
;
3590 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3591 or validate its data type for an `if' or `while' statement or ?..: exp.
3593 This preparation consists of taking the ordinary
3594 representation of an expression expr and producing a valid tree
3595 boolean expression describing whether expr is nonzero. We could
3596 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
3597 but we optimize comparisons, &&, ||, and !.
3599 The resulting type should always be `boolean_type_node'. */
3602 truthvalue_conversion (expr
)
3605 if (TREE_CODE (expr
) == ERROR_MARK
)
3608 #if 0 /* This appears to be wrong for C++. */
3609 /* These really should return error_mark_node after 2.4 is stable.
3610 But not all callers handle ERROR_MARK properly. */
3611 switch (TREE_CODE (TREE_TYPE (expr
)))
3614 error ("struct type value used where scalar is required");
3615 return boolean_false_node
;
3618 error ("union type value used where scalar is required");
3619 return boolean_false_node
;
3622 error ("array type value used where scalar is required");
3623 return boolean_false_node
;
3630 switch (TREE_CODE (expr
))
3633 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
3634 case TRUTH_ANDIF_EXPR
:
3635 case TRUTH_ORIF_EXPR
:
3636 case TRUTH_AND_EXPR
:
3638 case TRUTH_XOR_EXPR
:
3639 case TRUTH_NOT_EXPR
:
3640 TREE_TYPE (expr
) = boolean_type_node
;
3647 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
3650 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
3653 /* If we are taking the address of a external decl, it might be zero
3654 if it is weak, so we cannot optimize. */
3655 if (DECL_P (TREE_OPERAND (expr
, 0))
3656 && DECL_EXTERNAL (TREE_OPERAND (expr
, 0)))
3659 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
3660 return build (COMPOUND_EXPR
, boolean_type_node
,
3661 TREE_OPERAND (expr
, 0), boolean_true_node
);
3663 return boolean_true_node
;
3666 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
3667 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3668 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
3669 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3676 /* These don't change whether an object is non-zero or zero. */
3677 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
3681 /* These don't change whether an object is zero or non-zero, but
3682 we can't ignore them if their second arg has side-effects. */
3683 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
3684 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
3685 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
3687 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
3690 /* Distribute the conversion into the arms of a COND_EXPR. */
3691 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
3692 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
3693 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
3696 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
3697 since that affects how `default_conversion' will behave. */
3698 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
3699 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
3701 /* fall through... */
3703 /* If this is widening the argument, we can ignore it. */
3704 if (TYPE_PRECISION (TREE_TYPE (expr
))
3705 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
3706 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
3710 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
3712 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
3713 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
3715 /* fall through... */
3717 /* This and MINUS_EXPR can be changed into a comparison of the
3719 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
3720 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
3721 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
3722 TREE_OPERAND (expr
, 1), 1);
3723 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
3724 fold (build1 (NOP_EXPR
,
3725 TREE_TYPE (TREE_OPERAND (expr
, 0)),
3726 TREE_OPERAND (expr
, 1))), 1);
3729 if (integer_onep (TREE_OPERAND (expr
, 1))
3730 && TREE_TYPE (expr
) != boolean_type_node
)
3731 /* Using convert here would cause infinite recursion. */
3732 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
3736 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
3737 warning ("suggest parentheses around assignment used as truth value");
3744 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
3746 tree tem
= save_expr (expr
);
3747 return (build_binary_op
3748 ((TREE_SIDE_EFFECTS (expr
)
3749 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
3750 truthvalue_conversion (build_unary_op (REALPART_EXPR
, tem
, 0)),
3751 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, tem
, 0)),
3755 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
3759 /* Read the rest of a #-directive from input stream FINPUT.
3760 In normal use, the directive name and the white space after it
3761 have already been read, so they won't be included in the result.
3762 We allow for the fact that the directive line may contain
3763 a newline embedded within a character or string literal which forms
3764 a part of the directive.
3766 The value is a string in a reusable buffer. It remains valid
3767 only until the next time this function is called.
3769 The terminating character ('\n' or EOF) is left in FINPUT for the
3770 caller to re-read. */
3773 get_directive_line (finput
)
3774 register FILE *finput
;
3776 static char *directive_buffer
= NULL
;
3777 static unsigned buffer_length
= 0;
3779 register char *buffer_limit
;
3780 register int looking_for
= 0;
3781 register int char_escaped
= 0;
3783 if (buffer_length
== 0)
3785 directive_buffer
= (char *)xmalloc (128);
3786 buffer_length
= 128;
3789 buffer_limit
= &directive_buffer
[buffer_length
];
3791 for (p
= directive_buffer
; ; )
3795 /* Make buffer bigger if it is full. */
3796 if (p
>= buffer_limit
)
3798 register unsigned bytes_used
= (p
- directive_buffer
);
3802 = (char *)xrealloc (directive_buffer
, buffer_length
);
3803 p
= &directive_buffer
[bytes_used
];
3804 buffer_limit
= &directive_buffer
[buffer_length
];
3809 /* Discard initial whitespace. */
3810 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
3813 /* Detect the end of the directive. */
3814 if (looking_for
== 0
3815 && (c
== '\n' || c
== EOF
))
3824 return directive_buffer
;
3826 /* Handle string and character constant syntax. */
3829 if (looking_for
== c
&& !char_escaped
)
3830 looking_for
= 0; /* Found terminator... stop looking. */
3833 if (c
== '\'' || c
== '"')
3834 looking_for
= c
; /* Don't stop buffering until we see another
3835 one of these (or an EOF). */
3837 /* Handle backslash. */
3838 char_escaped
= (c
== '\\' && ! char_escaped
);
3841 #endif /* USE_CPPLIB */
3843 /* Make a variant type in the proper way for C/C++, propagating qualifiers
3844 down to the element type of an array. */
3847 c_build_qualified_type (type
, type_quals
)
3851 /* A restrict-qualified pointer type must be a pointer to object or
3852 incomplete type. Note that the use of POINTER_TYPE_P also allows
3853 REFERENCE_TYPEs, which is appropriate for C++. Unfortunately,
3854 the C++ front-end also use POINTER_TYPE for pointer-to-member
3855 values, so even though it should be illegal to use `restrict'
3856 with such an entity we don't flag that here. Thus, special case
3857 code for that case is required in the C++ front-end. */
3858 if ((type_quals
& TYPE_QUAL_RESTRICT
)
3859 && (!POINTER_TYPE_P (type
)
3860 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type
))))
3862 error ("invalid use of `restrict'");
3863 type_quals
&= ~TYPE_QUAL_RESTRICT
;
3866 if (TREE_CODE (type
) == ARRAY_TYPE
)
3867 return build_array_type (c_build_qualified_type (TREE_TYPE (type
),
3869 TYPE_DOMAIN (type
));
3870 return build_qualified_type (type
, type_quals
);
3873 /* Apply the TYPE_QUALS to the new DECL. */
3876 c_apply_type_quals_to_decl (type_quals
, decl
)
3880 if ((type_quals
& TYPE_QUAL_CONST
)
3881 || (TREE_TYPE (decl
)
3882 && TREE_CODE (TREE_TYPE (decl
)) == REFERENCE_TYPE
))
3883 TREE_READONLY (decl
) = 1;
3884 if (type_quals
& TYPE_QUAL_VOLATILE
)
3886 TREE_SIDE_EFFECTS (decl
) = 1;
3887 TREE_THIS_VOLATILE (decl
) = 1;
3889 if (type_quals
& TYPE_QUAL_RESTRICT
)
3891 if (!TREE_TYPE (decl
)
3892 || !POINTER_TYPE_P (TREE_TYPE (decl
))
3893 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (TREE_TYPE (decl
))))
3894 error ("invalid use of `restrict'");
3895 else if (flag_strict_aliasing
)
3897 /* No two restricted pointers can point at the same thing.
3898 However, a restricted pointer can point at the same thing
3899 as an unrestricted pointer, if that unrestricted pointer
3900 is based on the restricted pointer. So, we make the
3901 alias set for the restricted pointer a subset of the
3902 alias set for the type pointed to by the type of the
3905 HOST_WIDE_INT pointed_to_alias_set
3906 = get_alias_set (TREE_TYPE (TREE_TYPE (decl
)));
3908 if (pointed_to_alias_set
== 0)
3909 /* It's not legal to make a subset of alias set zero. */
3913 DECL_POINTER_ALIAS_SET (decl
) = new_alias_set ();
3914 record_alias_subset (pointed_to_alias_set
,
3915 DECL_POINTER_ALIAS_SET (decl
));
3922 /* Return the typed-based alias set for T, which may be an expression
3923 or a type. Return -1 if we don't do anything special. */
3926 lang_get_alias_set (t
)
3931 /* Permit type-punning when accessing a union, provided the access
3932 is directly through the union. For example, this code does not
3933 permit taking the address of a union member and then storing
3934 through it. Even the type-punning allowed here is a GCC
3935 extension, albeit a common and useful one; the C standard says
3936 that such accesses have implementation-defined behavior. */
3938 TREE_CODE (u
) == COMPONENT_REF
|| TREE_CODE (u
) == ARRAY_REF
;
3939 u
= TREE_OPERAND (u
, 0))
3940 if (TREE_CODE (u
) == COMPONENT_REF
3941 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u
, 0))) == UNION_TYPE
)
3944 /* If this is a char *, the ANSI C standard says it can alias
3945 anything. Note that all references need do this. */
3946 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 'r'
3947 && TREE_CODE (TREE_TYPE (t
)) == INTEGER_TYPE
3948 && TYPE_PRECISION (TREE_TYPE (t
)) == TYPE_PRECISION (char_type_node
))
3951 /* That's all the expressions we handle specially. */
3955 /* The C standard specifically allows aliasing between signed and
3956 unsigned variants of the same type. We treat the signed
3957 variant as canonical. */
3958 if (TREE_CODE (t
) == INTEGER_TYPE
&& TREE_UNSIGNED (t
))
3960 tree t1
= signed_type (t
);
3962 /* t1 == t can happen for boolean nodes which are always unsigned. */
3964 return get_alias_set (t1
);
3966 else if (POINTER_TYPE_P (t
))
3970 /* Unfortunately, there is no canonical form of a pointer type.
3971 In particular, if we have `typedef int I', then `int *', and
3972 `I *' are different types. So, we have to pick a canonical
3973 representative. We do this below.
3975 Technically, this approach is actually more conservative that
3976 it needs to be. In particular, `const int *' and `int *'
3977 chould be in different alias sets, according to the C and C++
3978 standard, since their types are not the same, and so,
3979 technically, an `int **' and `const int **' cannot point at
3982 But, the standard is wrong. In particular, this code is
3987 const int* const* cipp = &ip;
3989 And, it doesn't make sense for that to be legal unless you
3990 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
3991 the pointed-to types. This issue has been reported to the
3993 t1
= TYPE_MAIN_VARIANT (TREE_TYPE (t
));
3994 t1
= ((TREE_CODE (t
) == POINTER_TYPE
)
3995 ? build_pointer_type (t1
) : build_reference_type (t1
));
3997 return get_alias_set (t1
);
3999 /* It's not yet safe to use alias sets for classes in C++ because
4000 the TYPE_FIELDs list for a class doesn't mention base classes. */
4001 else if (c_language
== clk_cplusplus
&& AGGREGATE_TYPE_P (t
))
4007 /* Build tree nodes and builtin functions common to both C and C++ language
4009 CPLUS_MODE is nonzero if we are called from the C++ frontend, we generate
4010 some stricter prototypes in that case.
4011 NO_BUILTINS and NO_NONANSI_BUILTINS contain the respective values of
4012 the language frontend flags flag_no_builtin and
4013 flag_no_nonansi_builtin. */
4016 c_common_nodes_and_builtins (cplus_mode
, no_builtins
, no_nonansi_builtins
)
4017 int cplus_mode
, no_builtins
, no_nonansi_builtins
;
4020 tree memcpy_ftype
, memset_ftype
, strlen_ftype
;
4021 tree bzero_ftype
, bcmp_ftype
, puts_ftype
, printf_ftype
;
4022 tree endlink
, int_endlink
, double_endlink
, unsigned_endlink
;
4023 tree sizetype_endlink
;
4024 tree ptr_ftype
, ptr_ftype_unsigned
;
4025 tree void_ftype_any
, void_ftype_int
, int_ftype_any
, sizet_ftype_any
;
4026 tree double_ftype_double
, double_ftype_double_double
;
4027 tree float_ftype_float
, ldouble_ftype_ldouble
;
4028 tree int_ftype_cptr_cptr_sizet
;
4029 tree int_ftype_string_string
, string_ftype_ptr_ptr
;
4030 tree long_ftype_long
;
4031 tree longlong_ftype_longlong
;
4032 /* Either char* or void*. */
4033 tree traditional_ptr_type_node
;
4034 /* Either const char* or const void*. */
4035 tree traditional_cptr_type_node
;
4036 tree traditional_len_type_node
;
4037 tree traditional_len_endlink
;
4038 tree va_list_ref_type_node
;
4039 tree va_list_arg_type_node
;
4041 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_va_list"),
4042 va_list_type_node
));
4044 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_ptrdiff_t"),
4045 ptrdiff_type_node
));
4047 pushdecl (build_decl (TYPE_DECL
, get_identifier ("__builtin_size_t"),
4050 if (TREE_CODE (va_list_type_node
) == ARRAY_TYPE
)
4052 va_list_arg_type_node
= va_list_ref_type_node
=
4053 build_pointer_type (TREE_TYPE (va_list_type_node
));
4057 va_list_arg_type_node
= va_list_type_node
;
4058 va_list_ref_type_node
= build_reference_type (va_list_type_node
);
4061 endlink
= void_list_node
;
4062 int_endlink
= tree_cons (NULL_TREE
, integer_type_node
, endlink
);
4063 double_endlink
= tree_cons (NULL_TREE
, double_type_node
, endlink
);
4064 unsigned_endlink
= tree_cons (NULL_TREE
, unsigned_type_node
, endlink
);
4066 ptr_ftype
= build_function_type (ptr_type_node
, NULL_TREE
);
4067 ptr_ftype_unsigned
= build_function_type (ptr_type_node
, unsigned_endlink
);
4068 sizetype_endlink
= tree_cons (NULL_TREE
, TYPE_DOMAIN (sizetype
), endlink
);
4069 /* We realloc here because sizetype could be int or unsigned. S'ok. */
4070 ptr_ftype_sizetype
= build_function_type (ptr_type_node
, sizetype_endlink
);
4072 sizet_ftype_any
= build_function_type (sizetype
, NULL_TREE
);
4073 int_ftype_any
= build_function_type (integer_type_node
, NULL_TREE
);
4074 void_ftype_any
= build_function_type (void_type_node
, NULL_TREE
);
4075 void_ftype
= build_function_type (void_type_node
, endlink
);
4076 void_ftype_int
= build_function_type (void_type_node
, int_endlink
);
4078 = build_function_type (void_type_node
,
4079 tree_cons (NULL_TREE
, ptr_type_node
, endlink
));
4082 = build_function_type (float_type_node
,
4083 tree_cons (NULL_TREE
, float_type_node
, endlink
));
4086 = build_function_type (double_type_node
, double_endlink
);
4088 ldouble_ftype_ldouble
4089 = build_function_type (long_double_type_node
,
4090 tree_cons (NULL_TREE
, long_double_type_node
,
4093 double_ftype_double_double
4094 = build_function_type (double_type_node
,
4095 tree_cons (NULL_TREE
, double_type_node
,
4099 = build_function_type (integer_type_node
, int_endlink
);
4102 = build_function_type (long_integer_type_node
,
4103 tree_cons (NULL_TREE
, long_integer_type_node
,
4106 longlong_ftype_longlong
4107 = build_function_type (long_long_integer_type_node
,
4108 tree_cons (NULL_TREE
, long_long_integer_type_node
,
4111 int_ftype_cptr_cptr_sizet
4112 = build_function_type (integer_type_node
,
4113 tree_cons (NULL_TREE
, const_ptr_type_node
,
4114 tree_cons (NULL_TREE
, const_ptr_type_node
,
4115 tree_cons (NULL_TREE
,
4119 void_zero_node
= build_int_2 (0, 0);
4120 TREE_TYPE (void_zero_node
) = void_type_node
;
4122 /* Prototype for strcpy. */
4123 string_ftype_ptr_ptr
4124 = build_function_type (string_type_node
,
4125 tree_cons (NULL_TREE
, string_type_node
,
4126 tree_cons (NULL_TREE
,
4127 const_string_type_node
,
4130 traditional_len_type_node
= (flag_traditional
&& ! cplus_mode
4131 ? integer_type_node
: sizetype
);
4132 traditional_len_endlink
= tree_cons (NULL_TREE
, traditional_len_type_node
,
4135 /* Prototype for strcmp. */
4136 int_ftype_string_string
4137 = build_function_type (integer_type_node
,
4138 tree_cons (NULL_TREE
, const_string_type_node
,
4139 tree_cons (NULL_TREE
,
4140 const_string_type_node
,
4143 /* Prototype for strlen. */
4145 = build_function_type (traditional_len_type_node
,
4146 tree_cons (NULL_TREE
, const_string_type_node
,
4149 traditional_ptr_type_node
= (flag_traditional
&& ! cplus_mode
4150 ? string_type_node
: ptr_type_node
);
4151 traditional_cptr_type_node
= (flag_traditional
&& ! cplus_mode
4152 ? const_string_type_node
: const_ptr_type_node
);
4154 /* Prototype for memcpy. */
4156 = build_function_type (traditional_ptr_type_node
,
4157 tree_cons (NULL_TREE
, ptr_type_node
,
4158 tree_cons (NULL_TREE
, const_ptr_type_node
,
4159 sizetype_endlink
)));
4161 /* Prototype for memset. */
4163 = build_function_type (traditional_ptr_type_node
,
4164 tree_cons (NULL_TREE
, ptr_type_node
,
4165 tree_cons (NULL_TREE
, integer_type_node
,
4166 tree_cons (NULL_TREE
,
4170 /* Prototype for bzero. */
4172 = build_function_type (void_type_node
,
4173 tree_cons (NULL_TREE
, traditional_ptr_type_node
,
4174 traditional_len_endlink
));
4176 /* Prototype for bcmp. */
4178 = build_function_type (integer_type_node
,
4179 tree_cons (NULL_TREE
, traditional_cptr_type_node
,
4180 tree_cons (NULL_TREE
,
4181 traditional_cptr_type_node
,
4182 traditional_len_endlink
)));
4184 /* Prototype for puts. */
4186 = build_function_type (integer_type_node
,
4187 tree_cons (NULL_TREE
, const_string_type_node
,
4190 /* Prototype for printf. */
4192 = build_function_type (integer_type_node
,
4193 tree_cons (NULL_TREE
, const_string_type_node
,
4196 builtin_function ("__builtin_constant_p", default_function_type
,
4197 BUILT_IN_CONSTANT_P
, BUILT_IN_NORMAL
, NULL_PTR
);
4199 builtin_function ("__builtin_return_address", ptr_ftype_unsigned
,
4200 BUILT_IN_RETURN_ADDRESS
, BUILT_IN_NORMAL
, NULL_PTR
);
4202 builtin_function ("__builtin_frame_address", ptr_ftype_unsigned
,
4203 BUILT_IN_FRAME_ADDRESS
, BUILT_IN_NORMAL
, NULL_PTR
);
4205 builtin_function ("__builtin_alloca", ptr_ftype_sizetype
,
4206 BUILT_IN_ALLOCA
, BUILT_IN_NORMAL
, "alloca");
4207 builtin_function ("__builtin_ffs", int_ftype_int
, BUILT_IN_FFS
,
4208 BUILT_IN_NORMAL
, NULL_PTR
);
4209 /* Define alloca, ffs as builtins.
4210 Declare _exit just to mark it as volatile. */
4211 if (! no_builtins
&& ! no_nonansi_builtins
)
4214 temp
= builtin_function ("alloca", ptr_ftype_sizetype
,
4215 BUILT_IN_ALLOCA
, BUILT_IN_NORMAL
, NULL_PTR
);
4216 /* Suppress error if redefined as a non-function. */
4217 DECL_BUILT_IN_NONANSI (temp
) = 1;
4219 temp
= builtin_function ("ffs", int_ftype_int
, BUILT_IN_FFS
,
4220 BUILT_IN_NORMAL
, NULL_PTR
);
4221 /* Suppress error if redefined as a non-function. */
4222 DECL_BUILT_IN_NONANSI (temp
) = 1;
4223 temp
= builtin_function ("_exit", void_ftype_int
,
4224 0, NOT_BUILT_IN
, NULL_PTR
);
4225 TREE_THIS_VOLATILE (temp
) = 1;
4226 TREE_SIDE_EFFECTS (temp
) = 1;
4227 /* Suppress error if redefined as a non-function. */
4228 DECL_BUILT_IN_NONANSI (temp
) = 1;
4230 /* The system prototypes for these functions have many
4231 variations, so don't specify parameters to avoid conflicts.
4232 The expand_* functions check the argument types anyway. */
4233 temp
= builtin_function ("bzero", void_ftype_any
,
4234 BUILT_IN_BZERO
, BUILT_IN_NORMAL
, NULL_PTR
);
4235 DECL_BUILT_IN_NONANSI (temp
) = 1;
4236 temp
= builtin_function ("bcmp", int_ftype_any
,
4237 BUILT_IN_BCMP
, BUILT_IN_NORMAL
, NULL_PTR
);
4238 DECL_BUILT_IN_NONANSI (temp
) = 1;
4241 builtin_function ("__builtin_abs", int_ftype_int
, BUILT_IN_ABS
,
4242 BUILT_IN_NORMAL
, NULL_PTR
);
4243 builtin_function ("__builtin_fabsf", float_ftype_float
, BUILT_IN_FABS
,
4244 BUILT_IN_NORMAL
, NULL_PTR
);
4245 builtin_function ("__builtin_fabs", double_ftype_double
, BUILT_IN_FABS
,
4246 BUILT_IN_NORMAL
, NULL_PTR
);
4247 builtin_function ("__builtin_fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
4248 BUILT_IN_NORMAL
, NULL_PTR
);
4249 builtin_function ("__builtin_labs", long_ftype_long
, BUILT_IN_LABS
,
4250 BUILT_IN_NORMAL
, NULL_PTR
);
4251 builtin_function ("__builtin_llabs", longlong_ftype_longlong
, BUILT_IN_LLABS
,
4252 BUILT_IN_NORMAL
, NULL_PTR
);
4253 builtin_function ("__builtin_saveregs", ptr_ftype
, BUILT_IN_SAVEREGS
,
4254 BUILT_IN_NORMAL
, NULL_PTR
);
4255 builtin_function ("__builtin_classify_type", default_function_type
,
4256 BUILT_IN_CLASSIFY_TYPE
, BUILT_IN_NORMAL
, NULL_PTR
);
4257 builtin_function ("__builtin_next_arg", ptr_ftype
, BUILT_IN_NEXT_ARG
,
4258 BUILT_IN_NORMAL
, NULL_PTR
);
4259 builtin_function ("__builtin_args_info", int_ftype_int
, BUILT_IN_ARGS_INFO
,
4260 BUILT_IN_NORMAL
, NULL_PTR
);
4261 builtin_function ("__builtin_setjmp",
4262 build_function_type (integer_type_node
,
4263 tree_cons (NULL_TREE
, ptr_type_node
,
4265 BUILT_IN_SETJMP
, BUILT_IN_NORMAL
, NULL_PTR
);
4266 builtin_function ("__builtin_longjmp",
4267 build_function_type (void_type_node
,
4268 tree_cons (NULL_TREE
, ptr_type_node
,
4269 tree_cons (NULL_TREE
,
4272 BUILT_IN_LONGJMP
, BUILT_IN_NORMAL
, NULL_PTR
);
4273 builtin_function ("__builtin_trap", void_ftype
, BUILT_IN_TRAP
,
4274 BUILT_IN_NORMAL
, NULL_PTR
);
4276 /* ISO C99 IEEE Unordered compares. */
4277 builtin_function ("__builtin_isgreater", default_function_type
,
4278 BUILT_IN_ISGREATER
, BUILT_IN_NORMAL
, NULL_PTR
);
4279 builtin_function ("__builtin_isgreaterequal", default_function_type
,
4280 BUILT_IN_ISGREATEREQUAL
, BUILT_IN_NORMAL
, NULL_PTR
);
4281 builtin_function ("__builtin_isless", default_function_type
,
4282 BUILT_IN_ISLESS
, BUILT_IN_NORMAL
, NULL_PTR
);
4283 builtin_function ("__builtin_islessequal", default_function_type
,
4284 BUILT_IN_ISLESSEQUAL
, BUILT_IN_NORMAL
, NULL_PTR
);
4285 builtin_function ("__builtin_islessgreater", default_function_type
,
4286 BUILT_IN_ISLESSGREATER
, BUILT_IN_NORMAL
, NULL_PTR
);
4287 builtin_function ("__builtin_isunordered", default_function_type
,
4288 BUILT_IN_ISUNORDERED
, BUILT_IN_NORMAL
, NULL_PTR
);
4290 /* Untyped call and return. */
4291 builtin_function ("__builtin_apply_args", ptr_ftype
,
4292 BUILT_IN_APPLY_ARGS
, BUILT_IN_NORMAL
, NULL_PTR
);
4294 temp
= tree_cons (NULL_TREE
,
4295 build_pointer_type (build_function_type (void_type_node
,
4297 tree_cons (NULL_TREE
,
4299 tree_cons (NULL_TREE
,
4302 builtin_function ("__builtin_apply",
4303 build_function_type (ptr_type_node
, temp
),
4304 BUILT_IN_APPLY
, BUILT_IN_NORMAL
, NULL_PTR
);
4305 builtin_function ("__builtin_return", void_ftype_ptr
,
4306 BUILT_IN_RETURN
, BUILT_IN_NORMAL
, NULL_PTR
);
4308 /* Support for varargs.h and stdarg.h. */
4309 builtin_function ("__builtin_varargs_start",
4310 build_function_type (void_type_node
,
4311 tree_cons (NULL_TREE
,
4312 va_list_ref_type_node
,
4314 BUILT_IN_VARARGS_START
, BUILT_IN_NORMAL
, NULL_PTR
);
4316 builtin_function ("__builtin_stdarg_start",
4317 build_function_type (void_type_node
,
4318 tree_cons (NULL_TREE
,
4319 va_list_ref_type_node
,
4321 BUILT_IN_STDARG_START
, BUILT_IN_NORMAL
, NULL_PTR
);
4323 builtin_function ("__builtin_va_end",
4324 build_function_type (void_type_node
,
4325 tree_cons (NULL_TREE
,
4326 va_list_ref_type_node
,
4328 BUILT_IN_VA_END
, BUILT_IN_NORMAL
, NULL_PTR
);
4330 builtin_function ("__builtin_va_copy",
4331 build_function_type (void_type_node
,
4332 tree_cons (NULL_TREE
,
4333 va_list_ref_type_node
,
4334 tree_cons (NULL_TREE
,
4335 va_list_arg_type_node
,
4337 BUILT_IN_VA_COPY
, BUILT_IN_NORMAL
, NULL_PTR
);
4339 /* ??? Ought to be `T __builtin_expect(T, T)' for any type T. */
4340 builtin_function ("__builtin_expect",
4341 build_function_type (long_integer_type_node
,
4342 tree_cons (NULL_TREE
,
4343 long_integer_type_node
,
4344 tree_cons (NULL_TREE
,
4345 long_integer_type_node
,
4347 BUILT_IN_EXPECT
, BUILT_IN_NORMAL
, NULL_PTR
);
4349 /* Currently under experimentation. */
4350 builtin_function ("__builtin_memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
,
4351 BUILT_IN_NORMAL
, "memcpy");
4352 builtin_function ("__builtin_memcmp", int_ftype_cptr_cptr_sizet
,
4353 BUILT_IN_MEMCMP
, BUILT_IN_NORMAL
, "memcmp");
4354 builtin_function ("__builtin_memset", memset_ftype
,
4355 BUILT_IN_MEMSET
, BUILT_IN_NORMAL
, "memset");
4356 builtin_function ("__builtin_bzero", bzero_ftype
,
4357 BUILT_IN_BZERO
, BUILT_IN_NORMAL
, "bzero");
4358 builtin_function ("__builtin_bcmp", bcmp_ftype
,
4359 BUILT_IN_BCMP
, BUILT_IN_NORMAL
, "bcmp");
4360 builtin_function ("__builtin_strcmp", int_ftype_string_string
,
4361 BUILT_IN_STRCMP
, BUILT_IN_NORMAL
, "strcmp");
4362 builtin_function ("__builtin_strcpy", string_ftype_ptr_ptr
,
4363 BUILT_IN_STRCPY
, BUILT_IN_NORMAL
, "strcpy");
4364 builtin_function ("__builtin_strlen", strlen_ftype
,
4365 BUILT_IN_STRLEN
, BUILT_IN_NORMAL
, "strlen");
4366 builtin_function ("__builtin_sqrtf", float_ftype_float
,
4367 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, "sqrtf");
4368 builtin_function ("__builtin_fsqrt", double_ftype_double
,
4369 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, "sqrt");
4370 builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble
,
4371 BUILT_IN_FSQRT
, BUILT_IN_NORMAL
, "sqrtl");
4372 builtin_function ("__builtin_sinf", float_ftype_float
,
4373 BUILT_IN_SIN
, BUILT_IN_NORMAL
, "sinf");
4374 builtin_function ("__builtin_sin", double_ftype_double
,
4375 BUILT_IN_SIN
, BUILT_IN_NORMAL
, "sin");
4376 builtin_function ("__builtin_sinl", ldouble_ftype_ldouble
,
4377 BUILT_IN_SIN
, BUILT_IN_NORMAL
, "sinl");
4378 builtin_function ("__builtin_cosf", float_ftype_float
,
4379 BUILT_IN_COS
, BUILT_IN_NORMAL
, "cosf");
4380 builtin_function ("__builtin_cos", double_ftype_double
,
4381 BUILT_IN_COS
, BUILT_IN_NORMAL
, "cos");
4382 builtin_function ("__builtin_cosl", ldouble_ftype_ldouble
,
4383 BUILT_IN_COS
, BUILT_IN_NORMAL
, "cosl");
4384 built_in_decls
[BUILT_IN_PUTCHAR
] =
4385 builtin_function ("__builtin_putchar", int_ftype_int
,
4386 BUILT_IN_PUTCHAR
, BUILT_IN_NORMAL
, "putchar");
4387 built_in_decls
[BUILT_IN_PUTS
] =
4388 builtin_function ("__builtin_puts", puts_ftype
,
4389 BUILT_IN_PUTS
, BUILT_IN_NORMAL
, "puts");
4390 builtin_function ("__builtin_printf", printf_ftype
,
4391 BUILT_IN_PRINTF
, BUILT_IN_NORMAL
, "printf");
4392 /* We declare these without argument so that the initial declaration
4393 for these identifiers is a builtin. That allows us to redeclare
4394 them later with argument without worrying about the explicit
4395 declarations in stdio.h being taken as the initial declaration.
4396 Also, save the _DECL for these so we can use them later. */
4397 built_in_decls
[BUILT_IN_FWRITE
] =
4398 builtin_function ("__builtin_fwrite", sizet_ftype_any
,
4399 BUILT_IN_FWRITE
, BUILT_IN_NORMAL
, "fwrite");
4400 built_in_decls
[BUILT_IN_FPUTC
] =
4401 builtin_function ("__builtin_fputc", int_ftype_any
,
4402 BUILT_IN_FPUTC
, BUILT_IN_NORMAL
, "fputc");
4403 built_in_decls
[BUILT_IN_FPUTS
] =
4404 builtin_function ("__builtin_fputs", int_ftype_any
,
4405 BUILT_IN_FPUTS
, BUILT_IN_NORMAL
, "fputs");
4409 builtin_function ("abs", int_ftype_int
, BUILT_IN_ABS
,
4410 BUILT_IN_NORMAL
, NULL_PTR
);
4411 builtin_function ("fabsf", float_ftype_float
, BUILT_IN_FABS
,
4412 BUILT_IN_NORMAL
, NULL_PTR
);
4413 builtin_function ("fabs", double_ftype_double
, BUILT_IN_FABS
,
4414 BUILT_IN_NORMAL
, NULL_PTR
);
4415 builtin_function ("fabsl", ldouble_ftype_ldouble
, BUILT_IN_FABS
,
4416 BUILT_IN_NORMAL
, NULL_PTR
);
4417 builtin_function ("labs", long_ftype_long
, BUILT_IN_LABS
,
4418 BUILT_IN_NORMAL
, NULL_PTR
);
4419 if (flag_isoc99
|| ! no_nonansi_builtins
)
4420 builtin_function ("llabs", longlong_ftype_longlong
, BUILT_IN_LLABS
,
4421 BUILT_IN_NORMAL
, NULL_PTR
);
4422 builtin_function ("memcpy", memcpy_ftype
, BUILT_IN_MEMCPY
,
4423 BUILT_IN_NORMAL
, NULL_PTR
);
4424 builtin_function ("memcmp", int_ftype_cptr_cptr_sizet
, BUILT_IN_MEMCMP
,
4425 BUILT_IN_NORMAL
, NULL_PTR
);
4426 builtin_function ("memset", memset_ftype
, BUILT_IN_MEMSET
,
4427 BUILT_IN_NORMAL
, NULL_PTR
);
4428 builtin_function ("strcmp", int_ftype_string_string
, BUILT_IN_STRCMP
,
4429 BUILT_IN_NORMAL
, NULL_PTR
);
4430 builtin_function ("strcpy", string_ftype_ptr_ptr
, BUILT_IN_STRCPY
,
4431 BUILT_IN_NORMAL
, NULL_PTR
);
4432 builtin_function ("strlen", strlen_ftype
, BUILT_IN_STRLEN
,
4433 BUILT_IN_NORMAL
, NULL_PTR
);
4434 builtin_function ("sqrtf", float_ftype_float
, BUILT_IN_FSQRT
,
4435 BUILT_IN_NORMAL
, NULL_PTR
);
4436 builtin_function ("sqrt", double_ftype_double
, BUILT_IN_FSQRT
,
4437 BUILT_IN_NORMAL
, NULL_PTR
);
4438 builtin_function ("sqrtl", ldouble_ftype_ldouble
, BUILT_IN_FSQRT
,
4439 BUILT_IN_NORMAL
, NULL_PTR
);
4440 builtin_function ("sinf", float_ftype_float
, BUILT_IN_SIN
,
4441 BUILT_IN_NORMAL
, NULL_PTR
);
4442 builtin_function ("sin", double_ftype_double
, BUILT_IN_SIN
,
4443 BUILT_IN_NORMAL
, NULL_PTR
);
4444 builtin_function ("sinl", ldouble_ftype_ldouble
, BUILT_IN_SIN
,
4445 BUILT_IN_NORMAL
, NULL_PTR
);
4446 builtin_function ("cosf", float_ftype_float
, BUILT_IN_COS
,
4447 BUILT_IN_NORMAL
, NULL_PTR
);
4448 builtin_function ("cos", double_ftype_double
, BUILT_IN_COS
,
4449 BUILT_IN_NORMAL
, NULL_PTR
);
4450 builtin_function ("cosl", ldouble_ftype_ldouble
, BUILT_IN_COS
,
4451 BUILT_IN_NORMAL
, NULL_PTR
);
4452 builtin_function ("printf", printf_ftype
, BUILT_IN_PRINTF
,
4453 BUILT_IN_NORMAL
, NULL_PTR
);
4454 /* We declare these without argument so that the initial
4455 declaration for these identifiers is a builtin. That allows
4456 us to redeclare them later with argument without worrying
4457 about the explicit declarations in stdio.h being taken as the
4458 initial declaration. */
4459 builtin_function ("fputc", int_ftype_any
, BUILT_IN_FPUTC
,
4460 BUILT_IN_NORMAL
, NULL_PTR
);
4461 builtin_function ("fputs", int_ftype_any
, BUILT_IN_FPUTS
,
4462 BUILT_IN_NORMAL
, NULL_PTR
);
4464 /* Declare these functions volatile
4465 to avoid spurious "control drops through" warnings. */
4466 temp
= builtin_function ("abort", cplus_mode
? void_ftype
: void_ftype_any
,
4467 0, NOT_BUILT_IN
, NULL_PTR
);
4468 TREE_THIS_VOLATILE (temp
) = 1;
4469 TREE_SIDE_EFFECTS (temp
) = 1;
4471 #if 0 /* ??? The C++ frontend used to do this. */
4472 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
4474 DECL_BUILT_IN_NONANSI (temp
) = 1;
4476 temp
= builtin_function ("exit",
4477 cplus_mode
? void_ftype_int
: void_ftype_any
,
4478 0, NOT_BUILT_IN
, NULL_PTR
);
4479 TREE_THIS_VOLATILE (temp
) = 1;
4480 TREE_SIDE_EFFECTS (temp
) = 1;
4482 #if 0 /* ??? The C++ frontend used to do this. */
4483 /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on
4485 DECL_BUILT_IN_NONANSI (temp
) = 1;
4490 /* Support for these has not been written in either expand_builtin
4491 or build_function_call. */
4492 builtin_function ("__builtin_div", default_ftype
, BUILT_IN_DIV
,
4493 BUILT_IN_NORMAL
, NULL_PTR
);
4494 builtin_function ("__builtin_ldiv", default_ftype
, BUILT_IN_LDIV
,
4495 BUILT_IN_NORMAL
, NULL_PTR
);
4496 builtin_function ("__builtin_ffloor", double_ftype_double
, BUILT_IN_FFLOOR
,
4497 BUILT_IN_NORMAL
, NULL_PTR
);
4498 builtin_function ("__builtin_fceil", double_ftype_double
, BUILT_IN_FCEIL
,
4499 BUILT_IN_NORMAL
, NULL_PTR
);
4500 builtin_function ("__builtin_fmod", double_ftype_double_double
,
4501 BUILT_IN_FMOD
, BUILT_IN_NORMAL
, NULL_PTR
);
4502 builtin_function ("__builtin_frem", double_ftype_double_double
,
4503 BUILT_IN_FREM
, BUILT_IN_NORMAL
, NULL_PTR
);
4504 builtin_function ("__builtin_getexp", double_ftype_double
, BUILT_IN_GETEXP
,
4505 BUILT_IN_NORMAL
, NULL_PTR
);
4506 builtin_function ("__builtin_getman", double_ftype_double
, BUILT_IN_GETMAN
,
4507 BUILT_IN_NORMAL
, NULL_PTR
);
4510 main_identifier_node
= get_identifier ("main");
4512 /* ??? Perhaps there's a better place to do this. But it is related
4513 to __builtin_va_arg, so it isn't that off-the-wall. */
4514 lang_type_promotes_to
= simple_type_promotes_to
;
4518 build_va_arg (expr
, type
)
4521 return build1 (VA_ARG_EXPR
, type
, expr
);
4524 /* Given a type, apply default promotions wrt unnamed function arguments
4525 and return the new type. Return NULL_TREE if no change. */
4526 /* ??? There is a function of the same name in the C++ front end that
4527 does something similar, but is more thorough and does not return NULL
4528 if no change. We could perhaps share code, but it would make the
4529 self_promoting_type property harder to identify. */
4532 simple_type_promotes_to (type
)
4535 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4536 return double_type_node
;
4538 if (C_PROMOTING_INTEGER_TYPE_P (type
))
4540 /* Traditionally, unsignedness is preserved in default promotions.
4541 Also preserve unsignedness if not really getting any wider. */
4542 if (TREE_UNSIGNED (type
)
4543 && (flag_traditional
4544 || TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
)))
4545 return unsigned_type_node
;
4546 return integer_type_node
;
4552 /* Return 1 if PARMS specifies a fixed number of parameters
4553 and none of their types is affected by default promotions. */
4556 self_promoting_args_p (parms
)
4560 for (t
= parms
; t
; t
= TREE_CHAIN (t
))
4562 register tree type
= TREE_VALUE (t
);
4564 if (TREE_CHAIN (t
) == 0 && type
!= void_type_node
)
4570 if (TYPE_MAIN_VARIANT (type
) == float_type_node
)
4573 if (C_PROMOTING_INTEGER_TYPE_P (type
))
4579 /* Recognize certain built-in functions so we can make tree-codes
4580 other than CALL_EXPR. We do this when it enables fold-const.c
4581 to do something useful. */
4582 /* ??? By rights this should go in builtins.c, but only C and C++
4583 implement build_{binary,unary}_op. Not exactly sure what bits
4584 of functionality are actually needed from those functions, or
4585 where the similar functionality exists in the other front ends. */
4588 expand_tree_builtin (function
, params
, coerced_params
)
4589 tree function
, params
, coerced_params
;
4591 enum tree_code code
;
4593 if (DECL_BUILT_IN_CLASS (function
) != BUILT_IN_NORMAL
)
4596 switch (DECL_FUNCTION_CODE (function
))
4600 case BUILT_IN_LLABS
:
4602 if (coerced_params
== 0)
4603 return integer_zero_node
;
4604 return build_unary_op (ABS_EXPR
, TREE_VALUE (coerced_params
), 0);
4606 case BUILT_IN_ISGREATER
:
4607 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
4613 case BUILT_IN_ISGREATEREQUAL
:
4614 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
4620 case BUILT_IN_ISLESS
:
4621 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
4627 case BUILT_IN_ISLESSEQUAL
:
4628 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
4634 case BUILT_IN_ISLESSGREATER
:
4635 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
)
4641 case BUILT_IN_ISUNORDERED
:
4642 if (TARGET_FLOAT_FORMAT
!= IEEE_FLOAT_FORMAT
)
4643 return integer_zero_node
;
4644 code
= UNORDERED_EXPR
;
4652 || TREE_CHAIN (params
) == 0)
4654 error ("too few arguments to function `%s'",
4655 IDENTIFIER_POINTER (DECL_NAME (function
)));
4656 return error_mark_node
;
4658 else if (TREE_CHAIN (TREE_CHAIN (params
)) != 0)
4660 error ("too many arguments to function `%s'",
4661 IDENTIFIER_POINTER (DECL_NAME (function
)));
4662 return error_mark_node
;
4665 arg0
= TREE_VALUE (params
);
4666 arg1
= TREE_VALUE (TREE_CHAIN (params
));
4667 arg0
= build_binary_op (code
, arg0
, arg1
, 0);
4668 if (code
!= UNORDERED_EXPR
)
4669 arg0
= build_unary_op (TRUTH_NOT_EXPR
, arg0
, 0);
4681 /* Returns non-zero if CODE is the code for a statement. */
4684 statement_code_p (code
)
4685 enum tree_code code
;
4708 if (lang_statement_code_p
)
4709 return (*lang_statement_code_p
) (code
);
4714 /* Walk the statemen tree, rooted at *tp. Apply FUNC to all the
4715 sub-trees of *TP in a pre-order traversal. FUNC is called with the
4716 DATA and the address of each sub-tree. If FUNC returns a non-NULL
4717 value, the traversal is aborted, and the value returned by FUNC is
4718 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
4719 the node being visited are not walked.
4721 We don't need a without_duplicates variant of this one because the
4722 statement tree is a tree, not a graph. */
4725 walk_stmt_tree (tp
, func
, data
)
4730 enum tree_code code
;
4735 #define WALK_SUBTREE(NODE) \
4738 result = walk_stmt_tree (&(NODE), func, data); \
4744 /* Skip empty subtrees. */
4748 /* Skip subtrees below non-statement nodes. */
4749 if (!statement_code_p (TREE_CODE (*tp
)))
4752 /* Call the function. */
4754 result
= (*func
) (tp
, &walk_subtrees
, data
);
4756 /* If we found something, return it. */
4760 /* Even if we didn't, FUNC may have decided that there was nothing
4761 interesting below this point in the tree. */
4765 /* FUNC may have modified the tree, recheck that we're looking at a
4767 code
= TREE_CODE (*tp
);
4768 if (!statement_code_p (code
))
4771 /* Walk over all the sub-trees of this operand. Statement nodes never
4772 contain RTL, and we needn't worry about TARGET_EXPRs. */
4773 len
= TREE_CODE_LENGTH (code
);
4775 /* Go through the subtrees. We need to do this in forward order so
4776 that the scope of a FOR_EXPR is handled properly. */
4777 for (i
= 0; i
< len
; ++i
)
4778 WALK_SUBTREE (TREE_OPERAND (*tp
, i
));
4780 /* Finally visit the chain. This can be tail-recursion optimized if
4781 we write it this way. */
4782 return walk_stmt_tree (&TREE_CHAIN (*tp
), func
, data
);
4787 /* Used to compare case labels. K1 and K2 are actually tree nodes
4788 representing case labels, or NULL_TREE for a `default' label.
4789 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
4790 K2, and 0 if K1 and K2 are equal. */
4793 case_compare (k1
, k2
)
4797 /* Consider a NULL key (such as arises with a `default' label) to be
4798 smaller than anything else. */
4804 return tree_int_cst_compare ((tree
) k1
, (tree
) k2
);
4807 /* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
4808 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
4809 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
4810 case label was declared using the usual C/C++ syntax, rather than
4811 the GNU case range extension. CASES is a tree containing all the
4812 case ranges processed so far; COND is the condition for the
4813 switch-statement itself. Returns the CASE_LABEL created, or
4814 ERROR_MARK_NODE if no CASE_LABEL is created. */
4817 c_add_case_label (cases
, cond
, low_value
, high_value
)
4826 splay_tree_node node
;
4828 /* Create the LABEL_DECL itself. */
4829 label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4830 DECL_CONTEXT (label
) = current_function_decl
;
4832 /* If there was an error processing the switch condition, bail now
4833 before we get more confused. */
4834 if (!cond
|| cond
== error_mark_node
)
4836 /* Add a label anyhow so that the back-end doesn't think that
4837 the beginning of the switch is unreachable. */
4839 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4840 return error_mark_node
;
4843 if ((low_value
&& TREE_TYPE (low_value
)
4844 && POINTER_TYPE_P (TREE_TYPE (low_value
)))
4845 || (high_value
&& TREE_TYPE (high_value
)
4846 && POINTER_TYPE_P (TREE_TYPE (high_value
))))
4847 error ("pointers are not permitted as case values");
4849 /* Case ranges are a GNU extension. */
4850 if (high_value
&& pedantic
)
4852 if (c_language
== clk_cplusplus
)
4853 pedwarn ("ISO C++ forbids range expressions in switch statements");
4855 pedwarn ("ISO C forbids range expressions in switch statements");
4858 type
= TREE_TYPE (cond
);
4861 low_value
= check_case_value (low_value
);
4862 low_value
= convert_and_check (type
, low_value
);
4866 high_value
= check_case_value (high_value
);
4867 high_value
= convert_and_check (type
, high_value
);
4870 /* If an error has occurred, bail out now. */
4871 if (low_value
== error_mark_node
|| high_value
== error_mark_node
)
4874 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4875 return error_mark_node
;
4878 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
4879 really a case range, even though it was written that way. Remove
4880 the HIGH_VALUE to simplify later processing. */
4881 if (tree_int_cst_equal (low_value
, high_value
))
4882 high_value
= NULL_TREE
;
4883 if (low_value
&& high_value
4884 && !tree_int_cst_lt (low_value
, high_value
))
4885 warning ("empty range specified");
4887 /* Look up the LOW_VALUE in the table of case labels we already
4889 node
= splay_tree_lookup (cases
, (splay_tree_key
) low_value
);
4890 /* If there was not an exact match, check for overlapping ranges.
4891 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
4892 that's a `default' label and the only overlap is an exact match. */
4893 if (!node
&& (low_value
|| high_value
))
4895 splay_tree_node low_bound
;
4896 splay_tree_node high_bound
;
4898 /* Even though there wasn't an exact match, there might be an
4899 overlap between this case range and another case range.
4900 Since we've (inductively) not allowed any overlapping case
4901 ranges, we simply need to find the greatest low case label
4902 that is smaller that LOW_VALUE, and the smallest low case
4903 label that is greater than LOW_VALUE. If there is an overlap
4904 it will occur in one of these two ranges. */
4905 low_bound
= splay_tree_predecessor (cases
,
4906 (splay_tree_key
) low_value
);
4907 high_bound
= splay_tree_successor (cases
,
4908 (splay_tree_key
) low_value
);
4910 /* Check to see if the LOW_BOUND overlaps. It is smaller than
4911 the LOW_VALUE, so there is no need to check unless the
4912 LOW_BOUND is in fact itself a case range. */
4914 && CASE_HIGH ((tree
) low_bound
->value
)
4915 && tree_int_cst_compare (CASE_HIGH ((tree
) low_bound
->value
),
4918 /* Check to see if the HIGH_BOUND overlaps. The low end of that
4919 range is bigger than the low end of the current range, so we
4920 are only interested if the current range is a real range, and
4921 not an ordinary case label. */
4924 && (tree_int_cst_compare ((tree
) high_bound
->key
,
4929 /* If there was an overlap, issue an error. */
4932 tree duplicate
= CASE_LABEL_DECL ((tree
) node
->value
);
4936 error ("duplicate (or overlapping) case value");
4937 error_with_decl (duplicate
,
4938 "this is the first entry overlapping that value");
4942 error ("duplicate case value") ;
4943 error_with_decl (duplicate
, "previously used here");
4947 error ("multiple default labels in one switch");
4948 error_with_decl (duplicate
, "this is the first default label");
4951 add_stmt (build_case_label (NULL_TREE
, NULL_TREE
, label
));
4954 /* Add a CASE_LABEL to the statement-tree. */
4955 case_label
= add_stmt (build_case_label (low_value
, high_value
, label
));
4956 /* Register this case label in the splay tree. */
4957 splay_tree_insert (cases
,
4958 (splay_tree_key
) low_value
,
4959 (splay_tree_value
) case_label
);
4964 /* Mark P (a stmt_tree) for GC. The use of a `void *' for the
4965 parameter allows this function to be used as a GC-marking
4972 stmt_tree st
= (stmt_tree
) p
;
4974 ggc_mark_tree (st
->x_last_stmt
);
4975 ggc_mark_tree (st
->x_last_expr_type
);
4978 /* Mark LD for GC. */
4981 c_mark_lang_decl (c
)
4982 struct c_lang_decl
*c
;
4984 ggc_mark_tree (c
->saved_tree
);
4987 /* Mark F for GC. */
4990 mark_c_language_function (f
)
4991 struct language_function
*f
;
4996 mark_stmt_tree (&f
->x_stmt_tree
);
4997 ggc_mark_tree (f
->x_scope_stmt_stack
);
5000 /* Hook used by expand_expr to expand language-specific tree codes. */
5003 c_expand_expr (exp
, target
, tmode
, modifier
)
5006 enum machine_mode tmode
;
5007 enum expand_modifier modifier
;
5009 switch (TREE_CODE (exp
))
5016 /* Since expand_expr_stmt calls free_temp_slots after every
5017 expression statement, we must call push_temp_slots here.
5018 Otherwise, any temporaries in use now would be considered
5019 out-of-scope after the first EXPR_STMT from within the
5022 rtl_expr
= expand_start_stmt_expr ();
5023 expand_stmt (STMT_EXPR_STMT (exp
));
5024 expand_end_stmt_expr (rtl_expr
);
5025 result
= expand_expr (rtl_expr
, target
, tmode
, modifier
);
5039 /* Hook used by safe_from_p to handle language-specific tree codes. */
5042 c_safe_from_p (target
, exp
)
5046 /* We can see statements here when processing the body of a
5047 statement-expression. For a declaration statement declaring a
5048 variable, look at the variable's initializer. */
5049 if (TREE_CODE (exp
) == DECL_STMT
)
5051 tree decl
= DECL_STMT_DECL (exp
);
5053 if (TREE_CODE (decl
) == VAR_DECL
5054 && DECL_INITIAL (decl
)
5055 && !safe_from_p (target
, DECL_INITIAL (decl
), /*top_p=*/0))
5059 /* For any statement, we must follow the statement-chain. */
5060 if (statement_code_p (TREE_CODE (exp
)) && TREE_CHAIN (exp
))
5061 return safe_from_p (target
, TREE_CHAIN (exp
), /*top_p=*/0);
5063 /* Assume everything else is safe. */
5067 /* Tree code classes. */
5069 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
5071 static char c_tree_code_type
[] = {
5073 #include "c-common.def"
5077 /* Table indexed by tree code giving number of expression
5078 operands beyond the fixed part of the node structure.
5079 Not used for types or decls. */
5081 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
5083 static int c_tree_code_length
[] = {
5085 #include "c-common.def"
5089 /* Names of tree components.
5090 Used for printing out the tree and error messages. */
5091 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
5093 static const char *c_tree_code_name
[] = {
5095 #include "c-common.def"
5099 /* Adds the tree codes specific to the C front end to the list of all
5105 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
5107 (int)LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
5108 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
5110 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
5111 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
5113 (LAST_C_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));