1 /* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
30 #ifndef WCHAR_TYPE_SIZE
32 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
34 #define WCHAR_TYPE_SIZE BITS_PER_WORD
38 extern struct obstack permanent_obstack
;
40 enum attrs
{A_PACKED
, A_NOCOMMON
, A_NORETURN
, A_CONST
, A_T_UNION
,
41 A_CONSTRUCTOR
, A_DESTRUCTOR
, A_MODE
, A_SECTION
, A_ALIGNED
,
42 A_UNUSED
, A_FORMAT
, A_WEAK
, A_ALIAS
};
44 static void declare_hidden_char_array
PROTO((char *, char *));
45 static void add_attribute
PROTO((enum attrs
, char *,
47 static void init_attributes
PROTO((void));
49 /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */
52 declare_function_name ()
54 char *name
, *printable_name
;
56 if (current_function_decl
== NULL
)
59 printable_name
= "top level";
63 char *kind
= "function";
64 if (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
)
66 /* Allow functions to be nameless (such as artificial ones). */
67 if (DECL_NAME (current_function_decl
))
68 name
= IDENTIFIER_POINTER (DECL_NAME (current_function_decl
));
71 printable_name
= (*decl_printable_name
) (current_function_decl
, &kind
);
74 declare_hidden_char_array ("__FUNCTION__", name
);
75 declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name
);
79 declare_hidden_char_array (name
, value
)
82 tree decl
, type
, init
;
85 /* If the default size of char arrays isn't big enough for the name,
86 or if we want to give warnings for large objects, make a bigger one. */
87 vlen
= strlen (value
) + 1;
88 type
= char_array_type_node
;
89 if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type
))) < vlen
91 type
= build_array_type (char_type_node
,
92 build_index_type (build_int_2 (vlen
, 0)));
93 push_obstacks_nochange ();
94 decl
= build_decl (VAR_DECL
, get_identifier (name
), type
);
95 TREE_STATIC (decl
) = 1;
96 TREE_READONLY (decl
) = 1;
97 TREE_ASM_WRITTEN (decl
) = 1;
98 DECL_SOURCE_LINE (decl
) = 0;
99 DECL_ARTIFICIAL (decl
) = 1;
100 DECL_IN_SYSTEM_HEADER (decl
) = 1;
101 DECL_IGNORED_P (decl
) = 1;
102 init
= build_string (vlen
, value
);
103 TREE_TYPE (init
) = type
;
104 DECL_INITIAL (decl
) = init
;
105 finish_decl (pushdecl (decl
), init
, NULL_TREE
);
108 /* Given a chain of STRING_CST nodes,
109 concatenate them into one STRING_CST
110 and give it a suitable array-of-chars data type. */
113 combine_strings (strings
)
116 register tree value
, t
;
117 register int length
= 1;
120 int wchar_bytes
= TYPE_PRECISION (wchar_type_node
) / BITS_PER_UNIT
;
123 if (TREE_CHAIN (strings
))
125 /* More than one in the chain, so concatenate. */
126 register char *p
, *q
;
128 /* Don't include the \0 at the end of each substring,
129 except for the last one.
130 Count wide strings and ordinary strings separately. */
131 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
133 if (TREE_TYPE (t
) == wchar_array_type_node
)
135 wide_length
+= (TREE_STRING_LENGTH (t
) - wchar_bytes
);
139 length
+= (TREE_STRING_LENGTH (t
) - 1);
142 /* If anything is wide, the non-wides will be converted,
143 which makes them take more space. */
145 length
= length
* wchar_bytes
+ wide_length
;
147 p
= savealloc (length
);
149 /* Copy the individual strings into the new combined string.
150 If the combined string is wide, convert the chars to ints
151 for any individual strings that are not wide. */
154 for (t
= strings
; t
; t
= TREE_CHAIN (t
))
156 int len
= (TREE_STRING_LENGTH (t
)
157 - ((TREE_TYPE (t
) == wchar_array_type_node
)
159 if ((TREE_TYPE (t
) == wchar_array_type_node
) == wide_flag
)
161 bcopy (TREE_STRING_POINTER (t
), q
, len
);
167 for (i
= 0; i
< len
; i
++)
169 if (WCHAR_TYPE_SIZE
== HOST_BITS_PER_SHORT
)
170 ((short *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
172 ((int *) q
)[i
] = TREE_STRING_POINTER (t
)[i
];
174 q
+= len
* wchar_bytes
;
180 for (i
= 0; i
< wchar_bytes
; i
++)
186 value
= make_node (STRING_CST
);
187 TREE_STRING_POINTER (value
) = p
;
188 TREE_STRING_LENGTH (value
) = length
;
189 TREE_CONSTANT (value
) = 1;
194 length
= TREE_STRING_LENGTH (value
);
195 if (TREE_TYPE (value
) == wchar_array_type_node
)
199 /* Compute the number of elements, for the array type. */
200 nchars
= wide_flag
? length
/ wchar_bytes
: length
;
202 /* Create the array type for the string constant.
203 -Wwrite-strings says make the string constant an array of const char
204 so that copying it to a non-const pointer will get a warning. */
205 if (warn_write_strings
206 && (! flag_traditional
&& ! flag_writable_strings
))
209 = build_type_variant (wide_flag
? wchar_type_node
: char_type_node
,
212 = build_array_type (elements
,
213 build_index_type (build_int_2 (nchars
- 1, 0)));
217 = build_array_type (wide_flag
? wchar_type_node
: char_type_node
,
218 build_index_type (build_int_2 (nchars
- 1, 0)));
219 TREE_CONSTANT (value
) = 1;
220 TREE_STATIC (value
) = 1;
224 /* To speed up processing of attributes, we maintain an array of
225 IDENTIFIER_NODES and the corresponding attribute types. */
227 /* Array to hold attribute information. */
229 static struct {enum attrs id
; tree name
; int min
, max
, decl_req
;} attrtab
[50];
231 static int attrtab_idx
= 0;
233 /* Add an entry to the attribute table above. */
236 add_attribute (id
, string
, min_len
, max_len
, decl_req
)
239 int min_len
, max_len
;
244 attrtab
[attrtab_idx
].id
= id
;
245 attrtab
[attrtab_idx
].name
= get_identifier (string
);
246 attrtab
[attrtab_idx
].min
= min_len
;
247 attrtab
[attrtab_idx
].max
= max_len
;
248 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
250 sprintf (buf
, "__%s__", string
);
252 attrtab
[attrtab_idx
].id
= id
;
253 attrtab
[attrtab_idx
].name
= get_identifier (buf
);
254 attrtab
[attrtab_idx
].min
= min_len
;
255 attrtab
[attrtab_idx
].max
= max_len
;
256 attrtab
[attrtab_idx
++].decl_req
= decl_req
;
259 /* Initialize attribute table. */
264 add_attribute (A_PACKED
, "packed", 0, 0, 0);
265 add_attribute (A_NOCOMMON
, "nocommon", 0, 0, 1);
266 add_attribute (A_NORETURN
, "noreturn", 0, 0, 1);
267 add_attribute (A_NORETURN
, "volatile", 0, 0, 1);
268 add_attribute (A_UNUSED
, "unused", 0, 0, 1);
269 add_attribute (A_CONST
, "const", 0, 0, 1);
270 add_attribute (A_T_UNION
, "transparent_union", 0, 0, 0);
271 add_attribute (A_CONSTRUCTOR
, "constructor", 0, 0, 1);
272 add_attribute (A_DESTRUCTOR
, "destructor", 0, 0, 1);
273 add_attribute (A_MODE
, "mode", 1, 1, 1);
274 add_attribute (A_SECTION
, "section", 1, 1, 1);
275 add_attribute (A_ALIGNED
, "aligned", 0, 1, 0);
276 add_attribute (A_FORMAT
, "format", 3, 3, 1);
277 add_attribute (A_WEAK
, "weak", 0, 0, 1);
278 add_attribute (A_ALIAS
, "alias", 1, 1, 1);
281 /* Process the attributes listed in ATTRIBUTES and PREFIX_ATTRIBUTES
282 and install them in NODE, which is either a DECL (including a TYPE_DECL)
283 or a TYPE. PREFIX_ATTRIBUTES can appear after the declaration specifiers
284 and declaration modifiers but before the declaration proper. */
287 decl_attributes (node
, attributes
, prefix_attributes
)
288 tree node
, attributes
, prefix_attributes
;
294 if (attrtab_idx
== 0)
297 if (TREE_CODE_CLASS (TREE_CODE (node
)) == 'd')
300 type
= TREE_TYPE (decl
);
301 is_type
= TREE_CODE (node
) == TYPE_DECL
;
303 else if (TREE_CODE_CLASS (TREE_CODE (node
)) == 't')
304 type
= node
, is_type
= 1;
306 attributes
= chainon (prefix_attributes
, attributes
);
308 for (a
= attributes
; a
; a
= TREE_CHAIN (a
))
310 tree name
= TREE_PURPOSE (a
);
311 tree args
= TREE_VALUE (a
);
315 for (i
= 0; i
< attrtab_idx
; i
++)
316 if (attrtab
[i
].name
== name
)
319 if (i
== attrtab_idx
)
321 if (! valid_machine_attribute (name
, args
, decl
, type
))
322 warning ("`%s' attribute directive ignored",
323 IDENTIFIER_POINTER (name
));
326 else if (attrtab
[i
].decl_req
&& decl
== 0)
328 warning ("`%s' attribute does not apply to types",
329 IDENTIFIER_POINTER (name
));
332 else if (list_length (args
) < attrtab
[i
].min
333 || list_length (args
) > attrtab
[i
].max
)
335 error ("wrong number of arguments specified for `%s' attribute",
336 IDENTIFIER_POINTER (name
));
345 TYPE_PACKED (type
) = 1;
346 else if (TREE_CODE (decl
) == FIELD_DECL
)
347 DECL_PACKED (decl
) = 1;
348 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
349 used for DECL_REGISTER. It wouldn't mean anything anyway. */
351 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
355 if (TREE_CODE (decl
) == VAR_DECL
)
356 DECL_COMMON (decl
) = 0;
358 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
362 if (TREE_CODE (decl
) == FUNCTION_DECL
)
363 TREE_THIS_VOLATILE (decl
) = 1;
364 else if (TREE_CODE (type
) == POINTER_TYPE
365 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
366 TREE_TYPE (decl
) = type
368 (build_type_variant (TREE_TYPE (type
),
369 TREE_READONLY (TREE_TYPE (type
)), 1));
371 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
375 if (TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == VAR_DECL
376 || TREE_CODE (decl
) == FUNCTION_DECL
)
377 TREE_USED (decl
) = 1;
379 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
383 if (TREE_CODE (decl
) == FUNCTION_DECL
)
384 TREE_READONLY (decl
) = 1;
385 else if (TREE_CODE (type
) == POINTER_TYPE
386 && TREE_CODE (TREE_TYPE (type
)) == FUNCTION_TYPE
)
387 TREE_TYPE (decl
) = type
389 (build_type_variant (TREE_TYPE (type
), 1,
390 TREE_THIS_VOLATILE (TREE_TYPE (type
))));
392 warning ( "`%s' attribute ignored", IDENTIFIER_POINTER (name
));
397 && TREE_CODE (type
) == UNION_TYPE
399 || TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
))))
400 TYPE_TRANSPARENT_UNION (type
) = 1;
401 else if (decl
!= 0 && TREE_CODE (decl
) == PARM_DECL
402 && TREE_CODE (type
) == UNION_TYPE
403 && TYPE_MODE (type
) == DECL_MODE (TYPE_FIELDS (type
)))
404 DECL_TRANSPARENT_UNION (decl
) = 1;
406 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
410 if (TREE_CODE (decl
) == FUNCTION_DECL
411 && TREE_CODE (type
) == FUNCTION_TYPE
412 && decl_function_context (decl
) == 0)
414 DECL_STATIC_CONSTRUCTOR (decl
) = 1;
415 TREE_USED (decl
) = 1;
418 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
422 if (TREE_CODE (decl
) == FUNCTION_DECL
423 && TREE_CODE (type
) == FUNCTION_TYPE
424 && decl_function_context (decl
) == 0)
426 DECL_STATIC_DESTRUCTOR (decl
) = 1;
427 TREE_USED (decl
) = 1;
430 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
434 if (TREE_CODE (TREE_VALUE (args
)) != IDENTIFIER_NODE
)
435 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
439 char *p
= IDENTIFIER_POINTER (TREE_VALUE (args
));
440 int len
= strlen (p
);
441 enum machine_mode mode
= VOIDmode
;
444 if (len
> 4 && p
[0] == '_' && p
[1] == '_'
445 && p
[len
- 1] == '_' && p
[len
- 2] == '_')
447 char *newp
= (char *) alloca (len
- 1);
449 strcpy (newp
, &p
[2]);
450 newp
[len
- 4] = '\0';
454 /* Give this decl a type with the specified mode.
455 First check for the special modes. */
456 if (! strcmp (p
, "byte"))
458 else if (!strcmp (p
, "word"))
460 else if (! strcmp (p
, "pointer"))
463 for (j
= 0; j
< NUM_MACHINE_MODES
; j
++)
464 if (!strcmp (p
, GET_MODE_NAME (j
)))
465 mode
= (enum machine_mode
) j
;
467 if (mode
== VOIDmode
)
468 error ("unknown machine mode `%s'", p
);
469 else if (0 == (typefm
= type_for_mode (mode
,
470 TREE_UNSIGNED (type
))))
471 error ("no data type for mode `%s'", p
);
474 TREE_TYPE (decl
) = type
= typefm
;
475 DECL_SIZE (decl
) = 0;
476 layout_decl (decl
, 0);
482 #ifdef ASM_OUTPUT_SECTION_NAME
483 if ((TREE_CODE (decl
) == FUNCTION_DECL
484 || TREE_CODE (decl
) == VAR_DECL
)
485 && TREE_CODE (TREE_VALUE (args
)) == STRING_CST
)
487 if (TREE_CODE (decl
) == VAR_DECL
488 && current_function_decl
!= NULL_TREE
)
489 error_with_decl (decl
,
490 "section attribute cannot be specified for local variables");
491 /* The decl may have already been given a section attribute from
492 a previous declaration. Ensure they match. */
493 else if (DECL_SECTION_NAME (decl
) != NULL_TREE
494 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)),
495 TREE_STRING_POINTER (TREE_VALUE (args
))) != 0)
496 error_with_decl (node
,
497 "section of `%s' conflicts with previous declaration");
499 DECL_SECTION_NAME (decl
) = TREE_VALUE (args
);
502 error_with_decl (node
,
503 "section attribute not allowed for `%s'");
505 error_with_decl (node
,
506 "section attributes are not supported for this target");
513 = (args
? TREE_VALUE (args
)
514 : size_int (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
517 /* Strip any NOPs of any kind. */
518 while (TREE_CODE (align_expr
) == NOP_EXPR
519 || TREE_CODE (align_expr
) == CONVERT_EXPR
520 || TREE_CODE (align_expr
) == NON_LVALUE_EXPR
)
521 align_expr
= TREE_OPERAND (align_expr
, 0);
523 if (TREE_CODE (align_expr
) != INTEGER_CST
)
525 error ("requested alignment is not a constant");
529 align
= TREE_INT_CST_LOW (align_expr
) * BITS_PER_UNIT
;
531 if (exact_log2 (align
) == -1)
532 error ("requested alignment is not a power of 2");
534 TYPE_ALIGN (type
) = align
;
535 else if (TREE_CODE (decl
) != VAR_DECL
536 && TREE_CODE (decl
) != FIELD_DECL
)
537 error_with_decl (decl
,
538 "alignment may not be specified for `%s'");
540 DECL_ALIGN (decl
) = align
;
546 tree format_type
= TREE_VALUE (args
);
547 tree format_num_expr
= TREE_VALUE (TREE_CHAIN (args
));
548 tree first_arg_num_expr
549 = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args
)));
556 if (TREE_CODE (decl
) != FUNCTION_DECL
)
558 error_with_decl (decl
,
559 "argument format specified for non-function `%s'");
563 if (TREE_CODE (format_type
) == IDENTIFIER_NODE
564 && (!strcmp (IDENTIFIER_POINTER (format_type
), "printf")
565 || !strcmp (IDENTIFIER_POINTER (format_type
),
568 else if (TREE_CODE (format_type
) == IDENTIFIER_NODE
569 && (!strcmp (IDENTIFIER_POINTER (format_type
), "scanf")
570 || !strcmp (IDENTIFIER_POINTER (format_type
),
575 error ("unrecognized format specifier for `%s'");
579 /* Strip any conversions from the string index and first arg number
580 and verify they are constants. */
581 while (TREE_CODE (format_num_expr
) == NOP_EXPR
582 || TREE_CODE (format_num_expr
) == CONVERT_EXPR
583 || TREE_CODE (format_num_expr
) == NON_LVALUE_EXPR
)
584 format_num_expr
= TREE_OPERAND (format_num_expr
, 0);
586 while (TREE_CODE (first_arg_num_expr
) == NOP_EXPR
587 || TREE_CODE (first_arg_num_expr
) == CONVERT_EXPR
588 || TREE_CODE (first_arg_num_expr
) == NON_LVALUE_EXPR
)
589 first_arg_num_expr
= TREE_OPERAND (first_arg_num_expr
, 0);
591 if (TREE_CODE (format_num_expr
) != INTEGER_CST
592 || TREE_CODE (first_arg_num_expr
) != INTEGER_CST
)
594 error ("format string has non-constant operand number");
598 format_num
= TREE_INT_CST_LOW (format_num_expr
);
599 first_arg_num
= TREE_INT_CST_LOW (first_arg_num_expr
);
600 if (first_arg_num
!= 0 && first_arg_num
<= format_num
)
602 error ("format string arg follows the args to be formatted");
606 /* If a parameter list is specified, verify that the format_num
607 argument is actually a string, in case the format attribute
609 argument
= TYPE_ARG_TYPES (type
);
612 for (arg_num
= 1; ; ++arg_num
)
614 if (argument
== 0 || arg_num
== format_num
)
616 argument
= TREE_CHAIN (argument
);
619 || TREE_CODE (TREE_VALUE (argument
)) != POINTER_TYPE
620 || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument
)))
623 error ("format string arg not a string type");
626 if (first_arg_num
!= 0)
628 /* Verify that first_arg_num points to the last arg,
631 arg_num
++, argument
= TREE_CHAIN (argument
);
632 if (arg_num
!= first_arg_num
)
634 error ("args to be formatted is not ...");
640 record_function_format (DECL_NAME (decl
),
641 DECL_ASSEMBLER_NAME (decl
),
642 is_scan
, format_num
, first_arg_num
);
651 if ((TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_INITIAL (decl
))
652 || TREE_CODE (decl
) != FUNCTION_DECL
&& ! DECL_EXTERNAL (decl
))
653 error_with_decl (decl
,
654 "`%s' defined both normally and as an alias");
655 else if (decl_function_context (decl
) == 0)
657 tree id
= get_identifier (TREE_STRING_POINTER
658 (TREE_VALUE (args
)));
659 if (TREE_CODE (decl
) == FUNCTION_DECL
)
660 DECL_INITIAL (decl
) = error_mark_node
;
662 DECL_EXTERNAL (decl
) = 0;
663 assemble_alias (decl
, id
);
666 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name
));
672 /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against
675 #define T_I &integer_type_node
676 #define T_L &long_integer_type_node
677 #define T_LL &long_long_integer_type_node
678 #define T_S &short_integer_type_node
679 #define T_UI &unsigned_type_node
680 #define T_UL &long_unsigned_type_node
681 #define T_ULL &long_long_unsigned_type_node
682 #define T_US &short_unsigned_type_node
683 #define T_F &float_type_node
684 #define T_D &double_type_node
685 #define T_LD &long_double_type_node
686 #define T_C &char_type_node
687 #define T_V &void_type_node
688 #define T_W &wchar_type_node
689 #define T_ST &sizetype
694 /* Type of argument if no length modifier is used. */
696 /* Type of argument if length modifier for shortening is used.
697 If NULL, then this modifier is not allowed. */
699 /* Type of argument if length modifier `l' is used.
700 If NULL, then this modifier is not allowed. */
702 /* Type of argument if length modifier `q' or `ll' is used.
703 If NULL, then this modifier is not allowed. */
705 /* Type of argument if length modifier `L' is used.
706 If NULL, then this modifier is not allowed. */
708 /* List of other modifier characters allowed with these options. */
712 static format_char_info print_char_table
[] = {
713 { "di", 0, T_I
, T_I
, T_L
, T_LL
, T_LL
, "-wp0 +" },
714 { "oxX", 0, T_UI
, T_UI
, T_UL
, T_ULL
, T_ULL
, "-wp0#" },
715 { "u", 0, T_UI
, T_UI
, T_UL
, T_ULL
, T_ULL
, "-wp0" },
716 /* Two GNU extensions. */
717 { "Z", 0, T_ST
, NULL
, NULL
, NULL
, NULL
, "-wp0" },
718 { "m", 0, T_V
, NULL
, NULL
, NULL
, NULL
, "-wp" },
719 { "feEgG", 0, T_D
, NULL
, NULL
, NULL
, T_LD
, "-wp0 +#" },
720 { "c", 0, T_I
, NULL
, T_W
, NULL
, NULL
, "-w" },
721 { "C", 0, T_W
, NULL
, NULL
, NULL
, NULL
, "-w" },
722 { "s", 1, T_C
, NULL
, T_W
, NULL
, NULL
, "-wp" },
723 { "S", 1, T_W
, NULL
, NULL
, NULL
, NULL
, "-wp" },
724 { "p", 1, T_V
, NULL
, NULL
, NULL
, NULL
, "-w" },
725 { "n", 1, T_I
, T_S
, T_L
, T_LL
, NULL
, "" },
729 static format_char_info scan_char_table
[] = {
730 { "di", 1, T_I
, T_S
, T_L
, T_LL
, T_LL
, "*" },
731 { "ouxX", 1, T_UI
, T_US
, T_UL
, T_ULL
, T_ULL
, "*" },
732 { "efgEG", 1, T_F
, NULL
, T_D
, NULL
, T_LD
, "*" },
733 { "sc", 1, T_C
, NULL
, T_W
, NULL
, NULL
, "*a" },
734 { "[", 1, T_C
, NULL
, NULL
, NULL
, NULL
, "*a" },
735 { "C", 1, T_W
, NULL
, NULL
, NULL
, NULL
, "*" },
736 { "S", 1, T_W
, NULL
, NULL
, NULL
, NULL
, "*" },
737 { "p", 2, T_V
, NULL
, NULL
, NULL
, NULL
, "*" },
738 { "n", 1, T_I
, T_S
, T_L
, T_LL
, NULL
, "" },
742 typedef struct function_format_info
{
743 struct function_format_info
*next
; /* next structure on the list */
744 tree name
; /* identifier such as "printf" */
745 tree assembler_name
; /* optional mangled identifier (for C++) */
746 int is_scan
; /* TRUE if *scanf */
747 int format_num
; /* number of format argument */
748 int first_arg_num
; /* number of first arg (zero for varargs) */
749 } function_format_info
;
751 static function_format_info
*function_format_list
= NULL
;
753 static void check_format_info
PROTO((function_format_info
*, tree
));
755 /* Initialize the table of functions to perform format checking on.
756 The ANSI functions are always checked (whether <stdio.h> is
757 included or not), since it is common to call printf without
758 including <stdio.h>. There shouldn't be a problem with this,
759 since ANSI reserves these function names whether you include the
760 header file or not. In any case, the checking is harmless. */
763 init_function_format_info ()
765 record_function_format (get_identifier ("printf"), NULL_TREE
, 0, 1, 2);
766 record_function_format (get_identifier ("fprintf"), NULL_TREE
, 0, 2, 3);
767 record_function_format (get_identifier ("sprintf"), NULL_TREE
, 0, 2, 3);
768 record_function_format (get_identifier ("scanf"), NULL_TREE
, 1, 1, 2);
769 record_function_format (get_identifier ("fscanf"), NULL_TREE
, 1, 2, 3);
770 record_function_format (get_identifier ("sscanf"), NULL_TREE
, 1, 2, 3);
771 record_function_format (get_identifier ("vprintf"), NULL_TREE
, 0, 1, 0);
772 record_function_format (get_identifier ("vfprintf"), NULL_TREE
, 0, 2, 0);
773 record_function_format (get_identifier ("vsprintf"), NULL_TREE
, 0, 2, 0);
776 /* Record information for argument format checking. FUNCTION_IDENT is
777 the identifier node for the name of the function to check (its decl
778 need not exist yet). IS_SCAN is true for scanf-type format checking;
779 false indicates printf-style format checking. FORMAT_NUM is the number
780 of the argument which is the format control string (starting from 1).
781 FIRST_ARG_NUM is the number of the first actual argument to check
782 against teh format string, or zero if no checking is not be done
783 (e.g. for varargs such as vfprintf). */
786 record_function_format (name
, assembler_name
, is_scan
,
787 format_num
, first_arg_num
)
794 function_format_info
*info
;
796 /* Re-use existing structure if it's there. */
798 for (info
= function_format_list
; info
; info
= info
->next
)
800 if (info
->name
== name
&& info
->assembler_name
== assembler_name
)
805 info
= (function_format_info
*) xmalloc (sizeof (function_format_info
));
806 info
->next
= function_format_list
;
807 function_format_list
= info
;
810 info
->assembler_name
= assembler_name
;
813 info
->is_scan
= is_scan
;
814 info
->format_num
= format_num
;
815 info
->first_arg_num
= first_arg_num
;
818 static char tfaff
[] = "too few arguments for format";
820 /* Check the argument list of a call to printf, scanf, etc.
821 NAME is the function identifier.
822 ASSEMBLER_NAME is the function's assembler identifier.
823 (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.)
824 PARAMS is the list of argument values. */
827 check_function_format (name
, assembler_name
, params
)
832 function_format_info
*info
;
834 /* See if this function is a format function. */
835 for (info
= function_format_list
; info
; info
= info
->next
)
837 if (info
->assembler_name
838 ? (info
->assembler_name
== assembler_name
)
839 : (info
->name
== name
))
842 check_format_info (info
, params
);
848 /* Check the argument list of a call to printf, scanf, etc.
849 INFO points to the function_format_info structure.
850 PARAMS is the list of argument values. */
853 check_format_info (info
, params
)
854 function_format_info
*info
;
859 int suppressed
, wide
, precise
;
867 tree first_fillin_param
;
869 format_char_info
*fci
;
870 static char message
[132];
872 int has_operand_number
= 0;
874 /* Skip to format argument. If the argument isn't available, there's
875 no work for us to do; prototype checking will catch the problem. */
876 for (arg_num
= 1; ; ++arg_num
)
880 if (arg_num
== info
->format_num
)
882 params
= TREE_CHAIN (params
);
884 format_tree
= TREE_VALUE (params
);
885 params
= TREE_CHAIN (params
);
886 if (format_tree
== 0)
888 /* We can only check the format if it's a string constant. */
889 while (TREE_CODE (format_tree
) == NOP_EXPR
)
890 format_tree
= TREE_OPERAND (format_tree
, 0); /* strip coercion */
891 if (integer_zerop (format_tree
))
893 warning ("null format string");
896 if (TREE_CODE (format_tree
) != ADDR_EXPR
)
898 format_tree
= TREE_OPERAND (format_tree
, 0);
899 if (TREE_CODE (format_tree
) != STRING_CST
)
901 format_chars
= TREE_STRING_POINTER (format_tree
);
902 format_length
= TREE_STRING_LENGTH (format_tree
);
903 if (format_length
<= 1)
904 warning ("zero-length format string");
905 if (format_chars
[--format_length
] != 0)
907 warning ("unterminated format string");
910 /* Skip to first argument to check. */
911 while (arg_num
+ 1 < info
->first_arg_num
)
915 params
= TREE_CHAIN (params
);
919 first_fillin_param
= params
;
923 if (*format_chars
== 0)
925 if (format_chars
- TREE_STRING_POINTER (format_tree
) != format_length
)
926 warning ("embedded `\\0' in format");
927 if (info
->first_arg_num
!= 0 && params
!= 0 && ! has_operand_number
)
928 warning ("too many arguments for format");
931 if (*format_chars
++ != '%')
933 if (*format_chars
== 0)
935 warning ("spurious trailing `%%' in format");
938 if (*format_chars
== '%')
944 suppressed
= wide
= precise
= FALSE
;
947 suppressed
= *format_chars
== '*';
950 while (isdigit (*format_chars
))
955 /* See if we have a number followed by a dollar sign. If we do,
956 it is an operand number, so set PARAMS to that operand. */
957 if (*format_chars
>= '0' && *format_chars
<= '9')
959 char *p
= format_chars
;
961 while (*p
>= '0' && *p
++ <= '9')
966 int opnum
= atoi (format_chars
);
968 params
= first_fillin_param
;
969 format_chars
= p
+ 1;
970 has_operand_number
= 1;
972 for (i
= 1; i
< opnum
&& params
!= 0; i
++)
973 params
= TREE_CHAIN (params
);
975 if (opnum
== 0 || params
== 0)
977 warning ("operand number out of range in format");
983 while (*format_chars
!= 0 && index (" +#0-", *format_chars
) != 0)
985 if (index (flag_chars
, *format_chars
) != 0)
987 sprintf (message
, "repeated `%c' flag in format",
991 i
= strlen (flag_chars
);
992 flag_chars
[i
++] = *format_chars
++;
995 /* "If the space and + flags both appear,
996 the space flag will be ignored." */
997 if (index (flag_chars
, ' ') != 0
998 && index (flag_chars
, '+') != 0)
999 warning ("use of both ` ' and `+' flags in format");
1000 /* "If the 0 and - flags both appear,
1001 the 0 flag will be ignored." */
1002 if (index (flag_chars
, '0') != 0
1003 && index (flag_chars
, '-') != 0)
1004 warning ("use of both `0' and `-' flags in format");
1005 if (*format_chars
== '*')
1008 /* "...a field width...may be indicated by an asterisk.
1009 In this case, an int argument supplies the field width..." */
1016 if (info
->first_arg_num
!= 0)
1018 cur_param
= TREE_VALUE (params
);
1019 params
= TREE_CHAIN (params
);
1021 /* size_t is generally not valid here.
1022 It will work on most machines, because size_t and int
1023 have the same mode. But might as well warn anyway,
1024 since it will fail on other machines. */
1025 if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
1026 != integer_type_node
)
1028 (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
1029 != unsigned_type_node
))
1032 "field width is not type int (arg %d)",
1040 while (isdigit (*format_chars
))
1046 if (*format_chars
== '.')
1050 if (*format_chars
!= '*' && !isdigit (*format_chars
))
1051 warning ("`.' not followed by `*' or digit in format");
1052 /* "...a...precision...may be indicated by an asterisk.
1053 In this case, an int argument supplies the...precision." */
1054 if (*format_chars
== '*')
1056 if (info
->first_arg_num
!= 0)
1064 cur_param
= TREE_VALUE (params
);
1065 params
= TREE_CHAIN (params
);
1067 if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param
))
1068 != integer_type_node
)
1071 "field width is not type int (arg %d)",
1079 while (isdigit (*format_chars
))
1084 if (*format_chars
== 'h' || *format_chars
== 'l' || *format_chars
== 'q' ||
1085 *format_chars
== 'L')
1086 length_char
= *format_chars
++;
1089 if (length_char
== 'l' && *format_chars
== 'l')
1090 length_char
= 'q', format_chars
++;
1092 if (*format_chars
== 'a')
1097 if (suppressed
&& length_char
!= 0)
1100 "use of `*' and `%c' together in format",
1104 format_char
= *format_chars
;
1105 if (format_char
== 0 || format_char
== '%')
1107 warning ("conversion lacks type at end of format");
1111 fci
= info
->is_scan
? scan_char_table
: print_char_table
;
1112 while (fci
->format_chars
!= 0
1113 && index (fci
->format_chars
, format_char
) == 0)
1115 if (fci
->format_chars
== 0)
1117 if (format_char
>= 040 && format_char
< 0177)
1119 "unknown conversion type character `%c' in format",
1123 "unknown conversion type character 0x%x in format",
1128 if (wide
&& index (fci
->flag_chars
, 'w') == 0)
1130 sprintf (message
, "width used with `%c' format",
1134 if (precise
&& index (fci
->flag_chars
, 'p') == 0)
1136 sprintf (message
, "precision used with `%c' format",
1140 if (aflag
&& index (fci
->flag_chars
, 'a') == 0)
1142 sprintf (message
, "`a' flag used with `%c' format",
1146 if (info
->is_scan
&& format_char
== '[')
1148 /* Skip over scan set, in case it happens to have '%' in it. */
1149 if (*format_chars
== '^')
1151 /* Find closing bracket; if one is hit immediately, then
1152 it's part of the scan set rather than a terminator. */
1153 if (*format_chars
== ']')
1155 while (*format_chars
&& *format_chars
!= ']')
1157 if (*format_chars
!= ']')
1158 /* The end of the format string was reached. */
1159 warning ("no closing `]' for `%%[' format");
1163 if (index (fci
->flag_chars
, '*') == 0)
1166 "suppression of `%c' conversion in format",
1172 for (i
= 0; flag_chars
[i
] != 0; ++i
)
1174 if (index (fci
->flag_chars
, flag_chars
[i
]) == 0)
1176 sprintf (message
, "flag `%c' used with type `%c'",
1177 flag_chars
[i
], format_char
);
1181 if (precise
&& index (flag_chars
, '0') != 0
1182 && (format_char
== 'd' || format_char
== 'i'
1183 || format_char
== 'o' || format_char
== 'u'
1184 || format_char
== 'x' || format_char
== 'x'))
1187 "precision and `0' flag not both allowed with `%c' format",
1191 switch (length_char
)
1193 default: wanted_type
= fci
->nolen
? *(fci
->nolen
) : 0; break;
1194 case 'h': wanted_type
= fci
->hlen
? *(fci
->hlen
) : 0; break;
1195 case 'l': wanted_type
= fci
->llen
? *(fci
->llen
) : 0; break;
1196 case 'q': wanted_type
= fci
->qlen
? *(fci
->qlen
) : 0; break;
1197 case 'L': wanted_type
= fci
->bigllen
? *(fci
->bigllen
) : 0; break;
1199 if (wanted_type
== 0)
1202 "use of `%c' length character with `%c' type character",
1203 length_char
, format_char
);
1208 ** XXX -- should kvetch about stuff such as
1212 ** scanf ("%d", &i);
1216 /* Finally. . .check type of argument against desired type! */
1217 if (info
->first_arg_num
== 0)
1219 if (fci
->pointer_count
== 0 && wanted_type
== void_type_node
)
1220 /* This specifier takes no argument. */
1227 cur_param
= TREE_VALUE (params
);
1228 params
= TREE_CHAIN (params
);
1230 cur_type
= TREE_TYPE (cur_param
);
1232 /* Check the types of any additional pointer arguments
1233 that precede the "real" argument. */
1234 for (i
= 0; i
< fci
->pointer_count
; ++i
)
1236 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
1238 cur_type
= TREE_TYPE (cur_type
);
1241 if (TREE_CODE (cur_type
) != ERROR_MARK
)
1244 "format argument is not a %s (arg %d)",
1245 ((fci
->pointer_count
== 1) ? "pointer" : "pointer to a pointer"),
1252 /* Check the type of the "real" argument, if there's a type we want. */
1253 if (i
== fci
->pointer_count
&& wanted_type
!= 0
1254 && TREE_CODE (cur_type
) != ERROR_MARK
1255 && wanted_type
!= TYPE_MAIN_VARIANT (cur_type
)
1256 /* If we want `void *', allow any pointer type.
1257 (Anything else would already have got a warning.) */
1258 && ! (wanted_type
== void_type_node
1259 && fci
->pointer_count
> 0)
1260 /* Don't warn about differences merely in signedness. */
1261 && !(TREE_CODE (wanted_type
) == INTEGER_TYPE
1262 && TREE_CODE (TYPE_MAIN_VARIANT (cur_type
)) == INTEGER_TYPE
1263 && (TREE_UNSIGNED (wanted_type
)
1264 ? wanted_type
== (cur_type
= unsigned_type (cur_type
))
1265 : wanted_type
== (cur_type
= signed_type (cur_type
))))
1266 /* Likewise, "signed char", "unsigned char" and "char" are
1267 equivalent but the above test won't consider them equivalent. */
1268 && ! (wanted_type
== char_type_node
1269 && (TYPE_MAIN_VARIANT (cur_type
) == signed_char_type_node
1270 || TYPE_MAIN_VARIANT (cur_type
) == unsigned_char_type_node
)))
1272 register char *this;
1273 register char *that
;
1275 this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type
)));
1277 if (TREE_CODE (cur_type
) != ERROR_MARK
1278 && TYPE_NAME (cur_type
) != 0
1279 && TREE_CODE (cur_type
) != INTEGER_TYPE
1280 && !(TREE_CODE (cur_type
) == POINTER_TYPE
1281 && TREE_CODE (TREE_TYPE (cur_type
)) == INTEGER_TYPE
))
1283 if (TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
1284 && DECL_NAME (TYPE_NAME (cur_type
)) != 0)
1285 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1287 that
= IDENTIFIER_POINTER (TYPE_NAME (cur_type
));
1290 /* A nameless type can't possibly match what the format wants.
1291 So there will be a warning for it.
1292 Make up a string to describe vaguely what it is. */
1295 if (TREE_CODE (cur_type
) == POINTER_TYPE
)
1298 that
= "different type";
1301 /* Make the warning better in case of mismatch of int vs long. */
1302 if (TREE_CODE (cur_type
) == INTEGER_TYPE
1303 && TREE_CODE (wanted_type
) == INTEGER_TYPE
1304 && TYPE_PRECISION (cur_type
) == TYPE_PRECISION (wanted_type
)
1305 && TYPE_NAME (cur_type
) != 0
1306 && TREE_CODE (TYPE_NAME (cur_type
)) == TYPE_DECL
)
1307 that
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type
)));
1309 if (strcmp (this, that
) != 0)
1311 sprintf (message
, "%s format, %s arg (arg %d)",
1312 this, that
, arg_num
);
1319 /* Print a warning if a constant expression had overflow in folding.
1320 Invoke this function on every expression that the language
1321 requires to be a constant expression.
1322 Note the ANSI C standard says it is erroneous for a
1323 constant expression to overflow. */
1326 constant_expression_warning (value
)
1329 if ((TREE_CODE (value
) == INTEGER_CST
|| TREE_CODE (value
) == REAL_CST
1330 || TREE_CODE (value
) == COMPLEX_CST
)
1331 && TREE_CONSTANT_OVERFLOW (value
) && pedantic
)
1332 pedwarn ("overflow in constant expression");
1335 /* Print a warning if an expression had overflow in folding.
1336 Invoke this function on every expression that
1337 (1) appears in the source code, and
1338 (2) might be a constant expression that overflowed, and
1339 (3) is not already checked by convert_and_check;
1340 however, do not invoke this function on operands of explicit casts. */
1343 overflow_warning (value
)
1346 if ((TREE_CODE (value
) == INTEGER_CST
1347 || (TREE_CODE (value
) == COMPLEX_CST
1348 && TREE_CODE (TREE_REALPART (value
)) == INTEGER_CST
))
1349 && TREE_OVERFLOW (value
))
1351 TREE_OVERFLOW (value
) = 0;
1352 warning ("integer overflow in expression");
1354 else if ((TREE_CODE (value
) == REAL_CST
1355 || (TREE_CODE (value
) == COMPLEX_CST
1356 && TREE_CODE (TREE_REALPART (value
)) == REAL_CST
))
1357 && TREE_OVERFLOW (value
))
1359 TREE_OVERFLOW (value
) = 0;
1360 warning ("floating-pointer overflow in expression");
1364 /* Print a warning if a large constant is truncated to unsigned,
1365 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1366 Invoke this function on every expression that might be implicitly
1367 converted to an unsigned type. */
1370 unsigned_conversion_warning (result
, operand
)
1371 tree result
, operand
;
1373 if (TREE_CODE (operand
) == INTEGER_CST
1374 && TREE_CODE (TREE_TYPE (result
)) == INTEGER_TYPE
1375 && TREE_UNSIGNED (TREE_TYPE (result
))
1376 && !int_fits_type_p (operand
, TREE_TYPE (result
)))
1378 if (!int_fits_type_p (operand
, signed_type (TREE_TYPE (result
))))
1379 /* This detects cases like converting -129 or 256 to unsigned char. */
1380 warning ("large integer implicitly truncated to unsigned type");
1381 else if (warn_conversion
)
1382 warning ("negative integer implicitly converted to unsigned type");
1386 /* Convert EXPR to TYPE, warning about conversion problems with constants.
1387 Invoke this function on every expression that is converted implicitly,
1388 i.e. because of language rules and not because of an explicit cast. */
1391 convert_and_check (type
, expr
)
1394 tree t
= convert (type
, expr
);
1395 if (TREE_CODE (t
) == INTEGER_CST
)
1397 if (TREE_OVERFLOW (t
))
1399 TREE_OVERFLOW (t
) = 0;
1401 /* Do not diagnose overflow in a constant expression merely
1402 because a conversion overflowed. */
1403 TREE_CONSTANT_OVERFLOW (t
) = TREE_CONSTANT_OVERFLOW (expr
);
1405 /* No warning for converting 0x80000000 to int. */
1406 if (!(TREE_UNSIGNED (type
) < TREE_UNSIGNED (TREE_TYPE (expr
))
1407 && TREE_CODE (TREE_TYPE (expr
)) == INTEGER_TYPE
1408 && TYPE_PRECISION (type
) == TYPE_PRECISION (TREE_TYPE (expr
))))
1409 /* If EXPR fits in the unsigned version of TYPE,
1410 don't warn unless pedantic. */
1412 || TREE_UNSIGNED (type
)
1413 || ! int_fits_type_p (expr
, unsigned_type (type
)))
1414 warning ("overflow in implicit constant conversion");
1417 unsigned_conversion_warning (t
, expr
);
1423 c_expand_expr_stmt (expr
)
1426 /* Do default conversion if safe and possibly important,
1427 in case within ({...}). */
1428 if ((TREE_CODE (TREE_TYPE (expr
)) == ARRAY_TYPE
&& lvalue_p (expr
))
1429 || TREE_CODE (TREE_TYPE (expr
)) == FUNCTION_TYPE
)
1430 expr
= default_conversion (expr
);
1432 if (TREE_TYPE (expr
) != error_mark_node
1433 && TYPE_SIZE (TREE_TYPE (expr
)) == 0
1434 && TREE_CODE (TREE_TYPE (expr
)) != ARRAY_TYPE
)
1435 error ("expression statement has incomplete type");
1437 expand_expr_stmt (expr
);
1440 /* Validate the expression after `case' and apply default promotions. */
1443 check_case_value (value
)
1446 if (value
== NULL_TREE
)
1449 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1450 STRIP_TYPE_NOPS (value
);
1452 if (TREE_CODE (value
) != INTEGER_CST
1453 && value
!= error_mark_node
)
1455 error ("case label does not reduce to an integer constant");
1456 value
= error_mark_node
;
1459 /* Promote char or short to int. */
1460 value
= default_conversion (value
);
1462 constant_expression_warning (value
);
1467 /* Return an integer type with BITS bits of precision,
1468 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1471 type_for_size (bits
, unsignedp
)
1475 if (bits
== TYPE_PRECISION (integer_type_node
))
1476 return unsignedp
? unsigned_type_node
: integer_type_node
;
1478 if (bits
== TYPE_PRECISION (signed_char_type_node
))
1479 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1481 if (bits
== TYPE_PRECISION (short_integer_type_node
))
1482 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1484 if (bits
== TYPE_PRECISION (long_integer_type_node
))
1485 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1487 if (bits
== TYPE_PRECISION (long_long_integer_type_node
))
1488 return (unsignedp
? long_long_unsigned_type_node
1489 : long_long_integer_type_node
);
1491 if (bits
<= TYPE_PRECISION (intQI_type_node
))
1492 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1494 if (bits
<= TYPE_PRECISION (intHI_type_node
))
1495 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1497 if (bits
<= TYPE_PRECISION (intSI_type_node
))
1498 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1500 if (bits
<= TYPE_PRECISION (intDI_type_node
))
1501 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1506 /* Return a data type that has machine mode MODE.
1507 If the mode is an integer,
1508 then UNSIGNEDP selects between signed and unsigned types. */
1511 type_for_mode (mode
, unsignedp
)
1512 enum machine_mode mode
;
1515 if (mode
== TYPE_MODE (integer_type_node
))
1516 return unsignedp
? unsigned_type_node
: integer_type_node
;
1518 if (mode
== TYPE_MODE (signed_char_type_node
))
1519 return unsignedp
? unsigned_char_type_node
: signed_char_type_node
;
1521 if (mode
== TYPE_MODE (short_integer_type_node
))
1522 return unsignedp
? short_unsigned_type_node
: short_integer_type_node
;
1524 if (mode
== TYPE_MODE (long_integer_type_node
))
1525 return unsignedp
? long_unsigned_type_node
: long_integer_type_node
;
1527 if (mode
== TYPE_MODE (long_long_integer_type_node
))
1528 return unsignedp
? long_long_unsigned_type_node
: long_long_integer_type_node
;
1530 if (mode
== TYPE_MODE (intQI_type_node
))
1531 return unsignedp
? unsigned_intQI_type_node
: intQI_type_node
;
1533 if (mode
== TYPE_MODE (intHI_type_node
))
1534 return unsignedp
? unsigned_intHI_type_node
: intHI_type_node
;
1536 if (mode
== TYPE_MODE (intSI_type_node
))
1537 return unsignedp
? unsigned_intSI_type_node
: intSI_type_node
;
1539 if (mode
== TYPE_MODE (intDI_type_node
))
1540 return unsignedp
? unsigned_intDI_type_node
: intDI_type_node
;
1542 if (mode
== TYPE_MODE (float_type_node
))
1543 return float_type_node
;
1545 if (mode
== TYPE_MODE (double_type_node
))
1546 return double_type_node
;
1548 if (mode
== TYPE_MODE (long_double_type_node
))
1549 return long_double_type_node
;
1551 if (mode
== TYPE_MODE (build_pointer_type (char_type_node
)))
1552 return build_pointer_type (char_type_node
);
1554 if (mode
== TYPE_MODE (build_pointer_type (integer_type_node
)))
1555 return build_pointer_type (integer_type_node
);
1560 /* Return the minimum number of bits needed to represent VALUE in a
1561 signed or unsigned type, UNSIGNEDP says which. */
1564 min_precision (value
, unsignedp
)
1570 /* If the value is negative, compute its negative minus 1. The latter
1571 adjustment is because the absolute value of the largest negative value
1572 is one larger than the largest positive value. This is equivalent to
1573 a bit-wise negation, so use that operation instead. */
1575 if (tree_int_cst_sgn (value
) < 0)
1576 value
= fold (build1 (BIT_NOT_EXPR
, TREE_TYPE (value
), value
));
1578 /* Return the number of bits needed, taking into account the fact
1579 that we need one more bit for a signed than unsigned type. */
1581 if (integer_zerop (value
))
1583 else if (TREE_INT_CST_HIGH (value
) != 0)
1584 log
= HOST_BITS_PER_WIDE_INT
+ floor_log2 (TREE_INT_CST_HIGH (value
));
1586 log
= floor_log2 (TREE_INT_CST_LOW (value
));
1588 return log
+ 1 + ! unsignedp
;
1591 /* Print an error message for invalid operands to arith operation CODE.
1592 NOP_EXPR is used as a special case (see truthvalue_conversion). */
1595 binary_op_error (code
)
1596 enum tree_code code
;
1598 register char *opname
= "unknown";
1603 error ("invalid truth-value expression");
1607 opname
= "+"; break;
1609 opname
= "-"; break;
1611 opname
= "*"; break;
1613 opname
= "max"; break;
1615 opname
= "min"; break;
1617 opname
= "=="; break;
1619 opname
= "!="; break;
1621 opname
= "<="; break;
1623 opname
= ">="; break;
1625 opname
= "<"; break;
1627 opname
= ">"; break;
1629 opname
= "<<"; break;
1631 opname
= ">>"; break;
1632 case TRUNC_MOD_EXPR
:
1633 case FLOOR_MOD_EXPR
:
1634 opname
= "%"; break;
1635 case TRUNC_DIV_EXPR
:
1636 case FLOOR_DIV_EXPR
:
1637 opname
= "/"; break;
1639 opname
= "&"; break;
1641 opname
= "|"; break;
1642 case TRUTH_ANDIF_EXPR
:
1643 opname
= "&&"; break;
1644 case TRUTH_ORIF_EXPR
:
1645 opname
= "||"; break;
1647 opname
= "^"; break;
1650 opname
= "rotate"; break;
1652 error ("invalid operands to binary %s", opname
);
1655 /* Subroutine of build_binary_op, used for comparison operations.
1656 See if the operands have both been converted from subword integer types
1657 and, if so, perhaps change them both back to their original type.
1658 This function is also responsible for converting the two operands
1659 to the proper common type for comparison.
1661 The arguments of this function are all pointers to local variables
1662 of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
1663 RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
1665 If this function returns nonzero, it means that the comparison has
1666 a constant value. What this function returns is an expression for
1670 shorten_compare (op0_ptr
, op1_ptr
, restype_ptr
, rescode_ptr
)
1671 tree
*op0_ptr
, *op1_ptr
;
1673 enum tree_code
*rescode_ptr
;
1676 tree op0
= *op0_ptr
;
1677 tree op1
= *op1_ptr
;
1678 int unsignedp0
, unsignedp1
;
1680 tree primop0
, primop1
;
1681 enum tree_code code
= *rescode_ptr
;
1683 /* Throw away any conversions to wider types
1684 already present in the operands. */
1686 primop0
= get_narrower (op0
, &unsignedp0
);
1687 primop1
= get_narrower (op1
, &unsignedp1
);
1689 /* Handle the case that OP0 does not *contain* a conversion
1690 but it *requires* conversion to FINAL_TYPE. */
1692 if (op0
== primop0
&& TREE_TYPE (op0
) != *restype_ptr
)
1693 unsignedp0
= TREE_UNSIGNED (TREE_TYPE (op0
));
1694 if (op1
== primop1
&& TREE_TYPE (op1
) != *restype_ptr
)
1695 unsignedp1
= TREE_UNSIGNED (TREE_TYPE (op1
));
1697 /* If one of the operands must be floated, we cannot optimize. */
1698 real1
= TREE_CODE (TREE_TYPE (primop0
)) == REAL_TYPE
;
1699 real2
= TREE_CODE (TREE_TYPE (primop1
)) == REAL_TYPE
;
1701 /* If first arg is constant, swap the args (changing operation
1702 so value is preserved), for canonicalization. Don't do this if
1703 the second arg is 0. */
1705 if (TREE_CONSTANT (primop0
)
1706 && ! integer_zerop (primop1
) && ! real_zerop (primop1
))
1708 register tree tem
= primop0
;
1709 register int temi
= unsignedp0
;
1717 unsignedp0
= unsignedp1
;
1738 *rescode_ptr
= code
;
1741 /* If comparing an integer against a constant more bits wide,
1742 maybe we can deduce a value of 1 or 0 independent of the data.
1743 Or else truncate the constant now
1744 rather than extend the variable at run time.
1746 This is only interesting if the constant is the wider arg.
1747 Also, it is not safe if the constant is unsigned and the
1748 variable arg is signed, since in this case the variable
1749 would be sign-extended and then regarded as unsigned.
1750 Our technique fails in this case because the lowest/highest
1751 possible unsigned results don't follow naturally from the
1752 lowest/highest possible values of the variable operand.
1753 For just EQ_EXPR and NE_EXPR there is another technique that
1754 could be used: see if the constant can be faithfully represented
1755 in the other operand's type, by truncating it and reextending it
1756 and see if that preserves the constant's value. */
1758 if (!real1
&& !real2
1759 && TREE_CODE (primop1
) == INTEGER_CST
1760 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
))
1762 int min_gt
, max_gt
, min_lt
, max_lt
;
1763 tree maxval
, minval
;
1764 /* 1 if comparison is nominally unsigned. */
1765 int unsignedp
= TREE_UNSIGNED (*restype_ptr
);
1768 type
= signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
));
1770 maxval
= TYPE_MAX_VALUE (type
);
1771 minval
= TYPE_MIN_VALUE (type
);
1773 if (unsignedp
&& !unsignedp0
)
1774 *restype_ptr
= signed_type (*restype_ptr
);
1776 if (TREE_TYPE (primop1
) != *restype_ptr
)
1777 primop1
= convert (*restype_ptr
, primop1
);
1778 if (type
!= *restype_ptr
)
1780 minval
= convert (*restype_ptr
, minval
);
1781 maxval
= convert (*restype_ptr
, maxval
);
1784 if (unsignedp
&& unsignedp0
)
1786 min_gt
= INT_CST_LT_UNSIGNED (primop1
, minval
);
1787 max_gt
= INT_CST_LT_UNSIGNED (primop1
, maxval
);
1788 min_lt
= INT_CST_LT_UNSIGNED (minval
, primop1
);
1789 max_lt
= INT_CST_LT_UNSIGNED (maxval
, primop1
);
1793 min_gt
= INT_CST_LT (primop1
, minval
);
1794 max_gt
= INT_CST_LT (primop1
, maxval
);
1795 min_lt
= INT_CST_LT (minval
, primop1
);
1796 max_lt
= INT_CST_LT (maxval
, primop1
);
1800 /* This used to be a switch, but Genix compiler can't handle that. */
1801 if (code
== NE_EXPR
)
1803 if (max_lt
|| min_gt
)
1804 val
= boolean_true_node
;
1806 else if (code
== EQ_EXPR
)
1808 if (max_lt
|| min_gt
)
1809 val
= boolean_false_node
;
1811 else if (code
== LT_EXPR
)
1814 val
= boolean_true_node
;
1816 val
= boolean_false_node
;
1818 else if (code
== GT_EXPR
)
1821 val
= boolean_true_node
;
1823 val
= boolean_false_node
;
1825 else if (code
== LE_EXPR
)
1828 val
= boolean_true_node
;
1830 val
= boolean_false_node
;
1832 else if (code
== GE_EXPR
)
1835 val
= boolean_true_node
;
1837 val
= boolean_false_node
;
1840 /* If primop0 was sign-extended and unsigned comparison specd,
1841 we did a signed comparison above using the signed type bounds.
1842 But the comparison we output must be unsigned.
1844 Also, for inequalities, VAL is no good; but if the signed
1845 comparison had *any* fixed result, it follows that the
1846 unsigned comparison just tests the sign in reverse
1847 (positive values are LE, negative ones GE).
1848 So we can generate an unsigned comparison
1849 against an extreme value of the signed type. */
1851 if (unsignedp
&& !unsignedp0
)
1858 primop1
= TYPE_MIN_VALUE (type
);
1864 primop1
= TYPE_MAX_VALUE (type
);
1868 type
= unsigned_type (type
);
1871 if (!max_gt
&& !unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1873 /* This is the case of (char)x >?< 0x80, which people used to use
1874 expecting old C compilers to change the 0x80 into -0x80. */
1875 if (val
== boolean_false_node
)
1876 warning ("comparison is always 0 due to limited range of data type");
1877 if (val
== boolean_true_node
)
1878 warning ("comparison is always 1 due to limited range of data type");
1881 if (!min_lt
&& unsignedp0
&& TREE_CODE (primop0
) != INTEGER_CST
)
1883 /* This is the case of (unsigned char)x >?< -1 or < 0. */
1884 if (val
== boolean_false_node
)
1885 warning ("comparison is always 0 due to limited range of data type");
1886 if (val
== boolean_true_node
)
1887 warning ("comparison is always 1 due to limited range of data type");
1892 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1893 if (TREE_SIDE_EFFECTS (primop0
))
1894 return build (COMPOUND_EXPR
, TREE_TYPE (val
), primop0
, val
);
1898 /* Value is not predetermined, but do the comparison
1899 in the type of the operand that is not constant.
1900 TYPE is already properly set. */
1902 else if (real1
&& real2
1903 && (TYPE_PRECISION (TREE_TYPE (primop0
))
1904 == TYPE_PRECISION (TREE_TYPE (primop1
))))
1905 type
= TREE_TYPE (primop0
);
1907 /* If args' natural types are both narrower than nominal type
1908 and both extend in the same manner, compare them
1909 in the type of the wider arg.
1910 Otherwise must actually extend both to the nominal
1911 common type lest different ways of extending
1913 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
1915 else if (unsignedp0
== unsignedp1
&& real1
== real2
1916 && TYPE_PRECISION (TREE_TYPE (primop0
)) < TYPE_PRECISION (*restype_ptr
)
1917 && TYPE_PRECISION (TREE_TYPE (primop1
)) < TYPE_PRECISION (*restype_ptr
))
1919 type
= common_type (TREE_TYPE (primop0
), TREE_TYPE (primop1
));
1920 type
= signed_or_unsigned_type (unsignedp0
1921 || TREE_UNSIGNED (*restype_ptr
),
1923 /* Make sure shorter operand is extended the right way
1924 to match the longer operand. */
1925 primop0
= convert (signed_or_unsigned_type (unsignedp0
, TREE_TYPE (primop0
)),
1927 primop1
= convert (signed_or_unsigned_type (unsignedp1
, TREE_TYPE (primop1
)),
1932 /* Here we must do the comparison on the nominal type
1933 using the args exactly as we received them. */
1934 type
= *restype_ptr
;
1938 if (!real1
&& !real2
&& integer_zerop (primop1
)
1939 && TREE_UNSIGNED (*restype_ptr
))
1945 /* All unsigned values are >= 0, so we warn if extra warnings
1946 are requested. However, if OP0 is a constant that is
1947 >= 0, the signedness of the comparison isn't an issue,
1948 so suppress the warning. */
1950 && ! (TREE_CODE (primop0
) == INTEGER_CST
1951 && ! TREE_OVERFLOW (convert (signed_type (type
),
1953 warning ("unsigned value >= 0 is always 1");
1954 value
= boolean_true_node
;
1959 && ! (TREE_CODE (primop0
) == INTEGER_CST
1960 && ! TREE_OVERFLOW (convert (signed_type (type
),
1962 warning ("unsigned value < 0 is always 0");
1963 value
= boolean_false_node
;
1968 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
1969 if (TREE_SIDE_EFFECTS (primop0
))
1970 return build (COMPOUND_EXPR
, TREE_TYPE (value
),
1977 *op0_ptr
= convert (type
, primop0
);
1978 *op1_ptr
= convert (type
, primop1
);
1980 *restype_ptr
= boolean_type_node
;
1985 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
1986 or validate its data type for an `if' or `while' statement or ?..: exp.
1988 This preparation consists of taking the ordinary
1989 representation of an expression expr and producing a valid tree
1990 boolean expression describing whether expr is nonzero. We could
1991 simply always do build_binary_op (NE_EXPR, expr, boolean_false_node, 1),
1992 but we optimize comparisons, &&, ||, and !.
1994 The resulting type should always be `boolean_type_node'. */
1997 truthvalue_conversion (expr
)
2000 if (TREE_CODE (expr
) == ERROR_MARK
)
2003 #if 0 /* This appears to be wrong for C++. */
2004 /* These really should return error_mark_node after 2.4 is stable.
2005 But not all callers handle ERROR_MARK properly. */
2006 switch (TREE_CODE (TREE_TYPE (expr
)))
2009 error ("struct type value used where scalar is required");
2010 return boolean_false_node
;
2013 error ("union type value used where scalar is required");
2014 return boolean_false_node
;
2017 error ("array type value used where scalar is required");
2018 return boolean_false_node
;
2025 switch (TREE_CODE (expr
))
2027 /* It is simpler and generates better code to have only TRUTH_*_EXPR
2028 or comparison expressions as truth values at this level. */
2031 /* A one-bit unsigned bit-field is already acceptable. */
2032 if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr
, 1)))
2033 && TREE_UNSIGNED (TREE_OPERAND (expr
, 1)))
2039 /* It is simpler and generates better code to have only TRUTH_*_EXPR
2040 or comparison expressions as truth values at this level. */
2042 if (integer_zerop (TREE_OPERAND (expr
, 1)))
2043 return build_unary_op (TRUTH_NOT_EXPR
, TREE_OPERAND (expr
, 0), 0);
2045 case NE_EXPR
: case LE_EXPR
: case GE_EXPR
: case LT_EXPR
: case GT_EXPR
:
2046 case TRUTH_ANDIF_EXPR
:
2047 case TRUTH_ORIF_EXPR
:
2048 case TRUTH_AND_EXPR
:
2050 case TRUTH_XOR_EXPR
:
2051 case TRUTH_NOT_EXPR
:
2052 TREE_TYPE (expr
) = boolean_type_node
;
2059 return integer_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2062 return real_zerop (expr
) ? boolean_false_node
: boolean_true_node
;
2065 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 0)))
2066 return build (COMPOUND_EXPR
, boolean_type_node
,
2067 TREE_OPERAND (expr
, 0), boolean_true_node
);
2069 return boolean_true_node
;
2072 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1))
2073 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2074 truthvalue_conversion (TREE_OPERAND (expr
, 0)),
2075 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2082 /* These don't change whether an object is non-zero or zero. */
2083 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2087 /* These don't change whether an object is zero or non-zero, but
2088 we can't ignore them if their second arg has side-effects. */
2089 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr
, 1)))
2090 return build (COMPOUND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 1),
2091 truthvalue_conversion (TREE_OPERAND (expr
, 0)));
2093 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2096 /* Distribute the conversion into the arms of a COND_EXPR. */
2097 return fold (build (COND_EXPR
, boolean_type_node
, TREE_OPERAND (expr
, 0),
2098 truthvalue_conversion (TREE_OPERAND (expr
, 1)),
2099 truthvalue_conversion (TREE_OPERAND (expr
, 2))));
2102 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2103 since that affects how `default_conversion' will behave. */
2104 if (TREE_CODE (TREE_TYPE (expr
)) == REFERENCE_TYPE
2105 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr
, 0))) == REFERENCE_TYPE
)
2107 /* fall through... */
2109 /* If this is widening the argument, we can ignore it. */
2110 if (TYPE_PRECISION (TREE_TYPE (expr
))
2111 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr
, 0))))
2112 return truthvalue_conversion (TREE_OPERAND (expr
, 0));
2116 /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize
2118 if (TARGET_FLOAT_FORMAT
== IEEE_FLOAT_FORMAT
2119 && TREE_CODE (TREE_TYPE (expr
)) == REAL_TYPE
)
2121 /* fall through... */
2123 /* This and MINUS_EXPR can be changed into a comparison of the
2125 if (TREE_TYPE (TREE_OPERAND (expr
, 0))
2126 == TREE_TYPE (TREE_OPERAND (expr
, 1)))
2127 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2128 TREE_OPERAND (expr
, 1), 1);
2129 return build_binary_op (NE_EXPR
, TREE_OPERAND (expr
, 0),
2130 fold (build1 (NOP_EXPR
,
2131 TREE_TYPE (TREE_OPERAND (expr
, 0)),
2132 TREE_OPERAND (expr
, 1))), 1);
2135 if (integer_onep (TREE_OPERAND (expr
, 1))
2136 && TREE_TYPE (expr
) != boolean_type_node
)
2137 /* Using convert here would cause infinite recursion. */
2138 return build1 (NOP_EXPR
, boolean_type_node
, expr
);
2142 if (warn_parentheses
&& C_EXP_ORIGINAL_CODE (expr
) == MODIFY_EXPR
)
2143 warning ("suggest parentheses around assignment used as truth value");
2147 if (TREE_CODE (TREE_TYPE (expr
)) == COMPLEX_TYPE
)
2148 return (build_binary_op
2149 ((TREE_SIDE_EFFECTS (expr
)
2150 ? TRUTH_OR_EXPR
: TRUTH_ORIF_EXPR
),
2151 truthvalue_conversion (build_unary_op (REALPART_EXPR
, expr
, 0)),
2152 truthvalue_conversion (build_unary_op (IMAGPART_EXPR
, expr
, 0)),
2155 return build_binary_op (NE_EXPR
, expr
, integer_zero_node
, 1);
2158 /* Read the rest of a #-directive from input stream FINPUT.
2159 In normal use, the directive name and the white space after it
2160 have already been read, so they won't be included in the result.
2161 We allow for the fact that the directive line may contain
2162 a newline embedded within a character or string literal which forms
2163 a part of the directive.
2165 The value is a string in a reusable buffer. It remains valid
2166 only until the next time this function is called.
2168 The terminating character ('\n' or EOF) is left in FINPUT for the
2169 caller to re-read. */
2172 get_directive_line (finput
)
2173 register FILE *finput
;
2175 static char *directive_buffer
= NULL
;
2176 static unsigned buffer_length
= 0;
2178 register char *buffer_limit
;
2179 register int looking_for
= 0;
2180 register int char_escaped
= 0;
2182 if (buffer_length
== 0)
2184 directive_buffer
= (char *)xmalloc (128);
2185 buffer_length
= 128;
2188 buffer_limit
= &directive_buffer
[buffer_length
];
2190 for (p
= directive_buffer
; ; )
2194 /* Make buffer bigger if it is full. */
2195 if (p
>= buffer_limit
)
2197 register unsigned bytes_used
= (p
- directive_buffer
);
2201 = (char *)xrealloc (directive_buffer
, buffer_length
);
2202 p
= &directive_buffer
[bytes_used
];
2203 buffer_limit
= &directive_buffer
[buffer_length
];
2208 /* Discard initial whitespace. */
2209 if ((c
== ' ' || c
== '\t') && p
== directive_buffer
)
2212 /* Detect the end of the directive. */
2213 if (looking_for
== 0
2214 && (c
== '\n' || c
== EOF
))
2223 return directive_buffer
;
2225 /* Handle string and character constant syntax. */
2228 if (looking_for
== c
&& !char_escaped
)
2229 looking_for
= 0; /* Found terminator... stop looking. */
2232 if (c
== '\'' || c
== '"')
2233 looking_for
= c
; /* Don't stop buffering until we see another
2234 another one of these (or an EOF). */
2236 /* Handle backslash. */
2237 char_escaped
= (c
== '\\' && ! char_escaped
);
2241 /* Make a variant type in the proper way for C/C++, propagating qualifiers
2242 down to the element type of an array. */
2245 c_build_type_variant (type
, constp
, volatilep
)
2247 int constp
, volatilep
;
2249 if (TREE_CODE (type
) == ARRAY_TYPE
)
2251 tree real_main_variant
= TYPE_MAIN_VARIANT (type
);
2253 push_obstacks (TYPE_OBSTACK (real_main_variant
),
2254 TYPE_OBSTACK (real_main_variant
));
2255 type
= build_array_type (c_build_type_variant (TREE_TYPE (type
),
2257 TYPE_DOMAIN (type
));
2259 /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not,
2260 make a copy. (TYPE might have come from the hash table and
2261 REAL_MAIN_VARIANT might be in some function's obstack.) */
2263 if (TYPE_OBSTACK (type
) != TYPE_OBSTACK (real_main_variant
))
2265 type
= copy_node (type
);
2266 TYPE_POINTER_TO (type
) = TYPE_REFERENCE_TO (type
) = 0;
2269 TYPE_MAIN_VARIANT (type
) = real_main_variant
;
2272 return build_type_variant (type
, constp
, volatilep
);