1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
26 #include "stringpool.h"
27 #include "stor-layout.h"
30 #include "file-prefix-map.h" /* remap_macro_filename() */
31 #include "langhooks.h"
34 /* We may keep statistics about how long which files took to compile. */
35 static int header_time
, body_time
;
36 static splay_tree file_info_tree
;
38 int pending_lang_change
; /* If we need to switch languages - C++ only */
39 int c_header_level
; /* depth in C headers - C++ only */
41 static tree
interpret_integer (const cpp_token
*, unsigned int,
42 enum overflow_type
*);
43 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
44 enum overflow_type
*);
45 static tree
interpret_fixed (const cpp_token
*, unsigned int);
46 static enum integer_type_kind narrowest_unsigned_type
47 (const widest_int
&, unsigned int);
48 static enum integer_type_kind narrowest_signed_type
49 (const widest_int
&, unsigned int);
50 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
51 static tree
lex_charconst (const cpp_token
*);
52 static void update_header_times (const char *);
53 static int dump_one_header (splay_tree_node
, void *);
54 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
55 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
56 static void cb_def_pragma (cpp_reader
*, unsigned int);
57 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
58 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
63 struct c_fileinfo
*toplevel
;
65 /* The get_fileinfo data structure must be initialized before
66 cpp_read_main_file is called. */
67 toplevel
= get_fileinfo ("<top level>");
68 if (flag_detailed_statistics
)
71 body_time
= get_run_time ();
72 toplevel
->time
= body_time
;
75 struct cpp_callbacks
*cb
= cpp_get_callbacks (parse_in
);
77 cb
->line_change
= cb_line_change
;
79 cb
->def_pragma
= cb_def_pragma
;
80 cb
->valid_pch
= c_common_valid_pch
;
81 cb
->read_pch
= c_common_read_pch
;
82 cb
->has_attribute
= c_common_has_attribute
;
83 cb
->has_builtin
= c_common_has_builtin
;
84 cb
->get_source_date_epoch
= cb_get_source_date_epoch
;
85 cb
->get_suggestion
= cb_get_suggestion
;
86 cb
->remap_filename
= remap_macro_filename
;
88 /* Set the debug callbacks if we can use them. */
89 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
90 && (write_symbols
== DWARF2_DEBUG
91 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
92 || flag_dump_go_spec
!= NULL
)
94 cb
->define
= cb_define
;
100 get_fileinfo (const char *name
)
103 struct c_fileinfo
*fi
;
106 file_info_tree
= splay_tree_new (splay_tree_compare_strings
,
108 splay_tree_delete_pointers
);
110 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
112 return (struct c_fileinfo
*) n
->value
;
114 fi
= XNEW (struct c_fileinfo
);
116 fi
->interface_only
= 0;
117 fi
->interface_unknown
= 1;
118 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
119 (splay_tree_value
) fi
);
124 update_header_times (const char *name
)
126 /* Changing files again. This means currently collected time
127 is charged against header time, and body time starts back at 0. */
128 if (flag_detailed_statistics
)
130 int this_time
= get_run_time ();
131 struct c_fileinfo
*file
= get_fileinfo (name
);
132 header_time
+= this_time
- body_time
;
133 file
->time
+= this_time
- body_time
;
134 body_time
= this_time
;
139 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
141 print_time ((const char *) n
->key
,
142 ((struct c_fileinfo
*) n
->value
)->time
);
147 dump_time_statistics (void)
149 struct c_fileinfo
*file
= get_fileinfo (LOCATION_FILE (input_location
));
150 int this_time
= get_run_time ();
151 file
->time
+= this_time
- body_time
;
153 fprintf (stderr
, "\n******\n");
154 print_time ("header files (total)", header_time
);
155 print_time ("main file (total)", this_time
- body_time
);
156 fprintf (stderr
, "ratio = %g : 1\n",
157 (double) header_time
/ (double) (this_time
- body_time
));
158 fprintf (stderr
, "\n******\n");
160 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
164 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
165 unsigned int ARG_UNUSED (line
),
166 const cpp_string
* ARG_UNUSED (str
))
170 /* Convert escapes in the string. */
171 cpp_string cstr
= { 0, 0 };
172 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
174 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
175 free (CONST_CAST (unsigned char *, cstr
.text
));
180 /* Called at the start of every non-empty line. TOKEN is the first
181 lexed token on the line. Used for diagnostic line numbers. */
183 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
186 if (token
->type
!= CPP_EOF
&& !parsing_args
)
187 input_location
= token
->src_loc
;
191 fe_file_change (const line_map_ordinary
*new_map
)
196 if (new_map
->reason
== LC_ENTER
)
198 /* Don't stack the main buffer on the input stack;
199 we already did in compile_file. */
200 if (!MAIN_FILE_P (new_map
))
202 location_t included_at
= linemap_included_from (new_map
);
204 if (included_at
> BUILTINS_LOCATION
)
205 line
= SOURCE_LINE (new_map
- 1, included_at
);
207 input_location
= new_map
->start_location
;
208 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
209 #ifdef SYSTEM_IMPLICIT_EXTERN_C
212 else if (LINEMAP_SYSP (new_map
) == 2)
215 ++pending_lang_change
;
220 else if (new_map
->reason
== LC_LEAVE
)
222 #ifdef SYSTEM_IMPLICIT_EXTERN_C
223 if (c_header_level
&& --c_header_level
== 0)
225 if (LINEMAP_SYSP (new_map
) == 2)
226 warning (0, "badly nested C headers from preprocessor");
227 --pending_lang_change
;
230 input_location
= new_map
->start_location
;
232 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
235 update_header_times (LINEMAP_FILE (new_map
));
236 input_location
= new_map
->start_location
;
240 cb_def_pragma (cpp_reader
*pfile
, location_t loc
)
242 /* Issue a warning message if we have been asked to do so. Ignore
243 unknown pragmas in system headers unless an explicit
244 -Wunknown-pragmas has been given. */
245 if (warn_unknown_pragmas
> in_system_header_at (input_location
))
247 const unsigned char *space
, *name
;
249 location_t fe_loc
= loc
;
251 space
= name
= (const unsigned char *) "";
252 s
= cpp_get_token (pfile
);
253 if (s
->type
!= CPP_EOF
)
255 space
= cpp_token_as_text (pfile
, s
);
256 s
= cpp_get_token (pfile
);
257 if (s
->type
== CPP_NAME
)
258 name
= cpp_token_as_text (pfile
, s
);
261 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring %<#pragma %s %s%>",
266 /* #define callback for DWARF and DWARF2 debug info. */
268 cb_define (cpp_reader
*pfile
, location_t loc
, cpp_hashnode
*node
)
270 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
271 (*debug_hooks
->define
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
272 (const char *) cpp_macro_definition (pfile
, node
));
275 /* #undef callback for DWARF and DWARF2 debug info. */
277 cb_undef (cpp_reader
*pfile
, location_t loc
, cpp_hashnode
*node
)
279 if (lang_hooks
.preprocess_undef
)
280 lang_hooks
.preprocess_undef (pfile
, loc
, node
);
282 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
283 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
284 (const char *) NODE_NAME (node
));
287 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
288 and not consume CPP_EOF. */
289 static const cpp_token
*
290 get_token_no_padding (cpp_reader
*pfile
)
294 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
295 if (ret
->type
== CPP_EOF
)
297 ret
= cpp_get_token (pfile
);
298 if (ret
->type
!= CPP_PADDING
)
303 /* Callback for has_attribute. */
305 c_common_has_attribute (cpp_reader
*pfile
, bool std_syntax
)
308 tree attr_name
= NULL_TREE
;
309 const cpp_token
*token
;
311 token
= get_token_no_padding (pfile
);
312 if (token
->type
!= CPP_OPEN_PAREN
)
314 cpp_error (pfile
, CPP_DL_ERROR
,
315 "missing '(' after \"__has_attribute\"");
318 token
= get_token_no_padding (pfile
);
319 if (token
->type
== CPP_NAME
)
321 attr_name
= get_identifier ((const char *)
322 cpp_token_as_text (pfile
, token
));
323 attr_name
= canonicalize_attr_name (attr_name
);
324 bool have_scope
= false;
326 const cpp_token
*nxt_token
;
328 nxt_token
= cpp_peek_token (pfile
, idx
++);
329 while (nxt_token
->type
== CPP_PADDING
);
330 if (nxt_token
->type
== CPP_SCOPE
)
333 get_token_no_padding (pfile
); // Eat scope.
334 nxt_token
= get_token_no_padding (pfile
);
335 if (nxt_token
->type
== CPP_NAME
)
337 tree attr_ns
= attr_name
;
339 = get_identifier ((const char *)
340 cpp_token_as_text (pfile
, nxt_token
));
341 attr_name
= build_tree_list (attr_ns
, attr_id
);
345 cpp_error (pfile
, CPP_DL_ERROR
,
346 "attribute identifier required after scope");
347 attr_name
= NULL_TREE
;
352 /* Some standard attributes need special handling. */
353 if (c_dialect_cxx ())
355 if (is_attribute_p ("noreturn", attr_name
))
357 else if (is_attribute_p ("deprecated", attr_name
))
359 else if (is_attribute_p ("maybe_unused", attr_name
)
360 || is_attribute_p ("fallthrough", attr_name
))
362 else if (is_attribute_p ("no_unique_address", attr_name
)
363 || is_attribute_p ("likely", attr_name
)
364 || is_attribute_p ("unlikely", attr_name
))
366 else if (is_attribute_p ("nodiscard", attr_name
))
371 if (is_attribute_p ("deprecated", attr_name
)
372 || is_attribute_p ("maybe_unused", attr_name
)
373 || is_attribute_p ("fallthrough", attr_name
))
375 else if (is_attribute_p ("nodiscard", attr_name
))
379 attr_name
= NULL_TREE
;
381 if (attr_name
&& (have_scope
|| !std_syntax
))
384 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
391 cpp_error (pfile
, CPP_DL_ERROR
,
392 "macro \"__has_attribute\" requires an identifier");
396 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
397 cpp_error (pfile
, CPP_DL_ERROR
,
398 "missing ')' after \"__has_attribute\"");
403 /* Callback for has_builtin. */
406 c_common_has_builtin (cpp_reader
*pfile
)
408 const cpp_token
*token
= get_token_no_padding (pfile
);
409 if (token
->type
!= CPP_OPEN_PAREN
)
411 cpp_error (pfile
, CPP_DL_ERROR
,
412 "missing '(' after \"__has_builtin\"");
416 const char *name
= "";
417 token
= get_token_no_padding (pfile
);
418 if (token
->type
== CPP_NAME
)
420 name
= (const char *) cpp_token_as_text (pfile
, token
);
421 token
= get_token_no_padding (pfile
);
422 if (token
->type
!= CPP_CLOSE_PAREN
)
424 cpp_error (pfile
, CPP_DL_ERROR
,
425 "expected ')' after \"%s\"", name
);
431 cpp_error (pfile
, CPP_DL_ERROR
,
432 "macro \"__has_builtin\" requires an identifier");
433 if (token
->type
== CPP_CLOSE_PAREN
)
437 /* Consume tokens up to the closing parenthesis, including any nested
438 pairs of parentheses, to avoid confusing redundant errors. */
439 for (unsigned nparen
= 1; ; token
= get_token_no_padding (pfile
))
441 if (token
->type
== CPP_OPEN_PAREN
)
443 else if (token
->type
== CPP_CLOSE_PAREN
)
445 else if (token
->type
== CPP_EOF
)
451 return names_builtin_p (name
);
455 /* Read a token and return its type. Fill *VALUE with its value, if
456 applicable. Fill *CPP_FLAGS with the token's flags, if it is
460 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
463 const cpp_token
*tok
;
465 unsigned char add_flags
= 0;
466 enum overflow_type overflow
= OT_NONE
;
468 timevar_push (TV_CPP
);
470 tok
= cpp_get_token_with_location (parse_in
, loc
);
480 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
485 const char *suffix
= NULL
;
486 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
488 switch (flags
& CPP_N_CATEGORY
)
491 /* cpplib has issued an error. */
492 *value
= error_mark_node
;
496 /* C++ uses '0' to mark virtual functions as pure.
497 Set PURE_ZERO to pass this information to the C++ parser. */
498 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
499 add_flags
= PURE_ZERO
;
500 *value
= interpret_integer (tok
, flags
, &overflow
);
504 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
511 if (flags
& CPP_N_USERDEF
)
515 tree suffix_id
= get_identifier (suffix
);
516 int len
= tok
->val
.str
.len
- strlen (suffix
);
517 /* If this is going to be used as a C string to pass to a
518 raw literal operator, we need to add a trailing NUL. */
519 tree num_string
= build_string (len
+ 1,
520 (const char *) tok
->val
.str
.text
);
521 TREE_TYPE (num_string
) = char_array_type_node
;
522 num_string
= fix_string_type (num_string
);
523 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
525 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
533 /* An @ may give the next token special significance in Objective-C. */
534 if (c_dialect_objc ())
536 location_t atloc
= *loc
;
540 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
552 type
= lex_string (tok
, value
, true, true);
556 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
557 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
558 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
561 /* Note the complication: if we found an OBJC_CXX
562 keyword, for example, 'class', we will be
563 returning a token of type CPP_AT_NAME and rid
564 code RID_CLASS (not RID_AT_CLASS). The language
565 parser needs to convert that to RID_AT_CLASS.
566 However, we've now spliced the '@' together with the
567 keyword that follows; Adjust the location so that we
568 get a source range covering the composite.
570 *loc
= make_location (atloc
, atloc
, newloc
);
577 error_at (atloc
, "stray %<@%> in program");
588 unsigned char name
[8];
590 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
592 error_at (*loc
, "stray %qs in program", name
);
599 cppchar_t c
= tok
->val
.str
.text
[0];
601 if (c
== '"' || c
== '\'')
602 error_at (*loc
, "missing terminating %c character", (int) c
);
603 else if (ISGRAPH (c
))
604 error_at (*loc
, "stray %qc in program", (int) c
);
606 error_at (*loc
, "stray %<\\%o%> in program", (int) c
);
610 case CPP_CHAR_USERDEF
:
611 case CPP_WCHAR_USERDEF
:
612 case CPP_CHAR16_USERDEF
:
613 case CPP_CHAR32_USERDEF
:
614 case CPP_UTF8CHAR_USERDEF
:
617 cpp_token temp_tok
= *tok
;
618 const char *suffix
= cpp_get_userdef_suffix (tok
);
619 temp_tok
.val
.str
.len
-= strlen (suffix
);
620 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
621 literal
= build_userdef_literal (get_identifier (suffix
),
622 lex_charconst (&temp_tok
),
633 *value
= lex_charconst (tok
);
636 case CPP_STRING_USERDEF
:
637 case CPP_WSTRING_USERDEF
:
638 case CPP_STRING16_USERDEF
:
639 case CPP_STRING32_USERDEF
:
640 case CPP_UTF8STRING_USERDEF
:
642 tree literal
, string
;
643 const char *suffix
= cpp_get_userdef_suffix (tok
);
644 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
645 (const char *) tok
->val
.str
.text
);
646 literal
= build_userdef_literal (get_identifier (suffix
),
647 string
, OT_NONE
, NULL_TREE
);
657 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
659 type
= lex_string (tok
, value
, false,
660 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
663 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
667 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
670 /* These tokens should not be visible outside cpplib. */
671 case CPP_HEADER_NAME
:
675 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
676 when it is a FALLTHROUGH comment, in that case set
677 PREV_FALLTHROUGH flag on the next non-comment token. */
679 if (tok
->flags
& PREV_FALLTHROUGH
)
683 tok
= cpp_get_token_with_location (parse_in
, loc
);
686 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
687 add_flags
|= PREV_FALLTHROUGH
;
698 *cpp_flags
= tok
->flags
| add_flags
;
700 timevar_pop (TV_CPP
);
705 /* Returns the narrowest C-visible unsigned type, starting with the
706 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
709 static enum integer_type_kind
710 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
714 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
715 itk
= itk_unsigned_int
;
716 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
717 itk
= itk_unsigned_long
;
719 itk
= itk_unsigned_long_long
;
721 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
725 if (integer_types
[itk
] == NULL_TREE
)
727 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
729 if (wi::geu_p (wi::to_widest (upper
), val
))
730 return (enum integer_type_kind
) itk
;
736 /* Ditto, but narrowest signed type. */
737 static enum integer_type_kind
738 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
742 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
744 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
749 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
753 if (integer_types
[itk
] == NULL_TREE
)
755 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
757 if (wi::geu_p (wi::to_widest (upper
), val
))
758 return (enum integer_type_kind
) itk
;
764 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
766 interpret_integer (const cpp_token
*token
, unsigned int flags
,
767 enum overflow_type
*overflow
)
770 enum integer_type_kind itk
;
772 HOST_WIDE_INT ival
[3];
776 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
777 if (integer
.overflow
)
778 *overflow
= OT_OVERFLOW
;
780 ival
[0] = integer
.low
;
781 ival
[1] = integer
.high
;
783 widest_int wval
= widest_int::from_array (ival
, 3);
785 /* The type of a constant with a U suffix is straightforward. */
786 if (flags
& CPP_N_UNSIGNED
)
787 itk
= narrowest_unsigned_type (wval
, flags
);
790 /* The type of a potentially-signed integer constant varies
791 depending on the base it's in, the standard in use, and the
793 enum integer_type_kind itk_u
794 = narrowest_unsigned_type (wval
, flags
);
795 enum integer_type_kind itk_s
796 = narrowest_signed_type (wval
, flags
);
798 /* In both C89 and C99, octal and hex constants may be signed or
799 unsigned, whichever fits tighter. We do not warn about this
800 choice differing from the traditional choice, as the constant
801 is probably a bit pattern and either way will work. */
802 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
803 itk
= MIN (itk_u
, itk_s
);
806 /* In C99, decimal constants are always signed.
807 In C89, decimal constants that don't fit in long have
808 undefined behavior; we try to make them unsigned long.
809 In GCC's extended C89, that last is true of decimal
810 constants that don't fit in long long, too. */
813 if (itk_s
> itk_u
&& itk_s
> itk_long
)
817 if (itk_u
< itk_unsigned_long
)
818 itk_u
= itk_unsigned_long
;
820 warning (0, "this decimal constant is unsigned only in ISO C90");
823 warning (OPT_Wtraditional
,
824 "this decimal constant would be unsigned in ISO C90");
830 /* cpplib has already issued a warning for overflow. */
831 type
= ((flags
& CPP_N_UNSIGNED
)
832 ? widest_unsigned_literal_type_node
833 : widest_integer_literal_type_node
);
836 type
= integer_types
[itk
];
837 if (itk
> itk_unsigned_long
838 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
840 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
841 ? DK_PEDWARN
: DK_WARNING
,
842 input_location
, OPT_Wlong_long
,
843 (flags
& CPP_N_UNSIGNED
)
844 ? "integer constant is too large for %<unsigned long%> type"
845 : "integer constant is too large for %<long%> type");
848 value
= wide_int_to_tree (type
, wval
);
850 /* Convert imaginary to a complex type. */
851 if (flags
& CPP_N_IMAGINARY
)
852 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
857 /* Interpret TOKEN, a floating point number with FLAGS as classified
858 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
860 interpret_float (const cpp_token
*token
, unsigned int flags
,
861 const char *suffix
, enum overflow_type
*overflow
)
866 REAL_VALUE_TYPE real
;
867 REAL_VALUE_TYPE real_trunc
;
873 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
874 pragma has been used and is either double or _Decimal64. Types
875 that are not allowed with decimal float default to double. */
876 if (flags
& CPP_N_DEFAULT
)
878 flags
^= CPP_N_DEFAULT
;
879 flags
|= CPP_N_MEDIUM
;
881 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
883 warning (OPT_Wunsuffixed_float_constants
,
884 "unsuffixed floating constant");
885 if (float_const_decimal64_p ())
886 flags
|= CPP_N_DFLOAT
;
890 /* Decode _Fract and _Accum. */
891 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
892 return interpret_fixed (token
, flags
);
894 /* Decode type based on width and properties. */
895 if (flags
& CPP_N_DFLOAT
)
896 if (!targetm
.decimal_float_supported_p ())
898 error ("decimal floating-point not supported for this target");
899 return error_mark_node
;
901 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
902 type
= dfloat128_type_node
;
903 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
904 type
= dfloat32_type_node
;
906 type
= dfloat64_type_node
;
908 if (flags
& CPP_N_WIDTH_MD
)
913 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
918 mode
= targetm
.c
.mode_for_suffix (suffix
);
919 if (mode
== VOIDmode
)
921 error ("unsupported non-standard suffix on floating constant");
923 return error_mark_node
;
926 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
928 type
= c_common_type_for_mode (mode
, 0);
931 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
933 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
934 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
936 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
937 if (floatn_nx_types
[i
].n
== (int) n
938 && floatn_nx_types
[i
].extended
== extended
)
940 type
= FLOATN_NX_TYPE_NODE (i
);
943 if (type
== NULL_TREE
)
945 error ("unsupported non-standard suffix on floating constant");
946 return error_mark_node
;
949 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
951 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
952 type
= long_double_type_node
;
953 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
954 || flag_single_precision_constant
)
955 type
= float_type_node
;
957 type
= double_type_node
;
959 const_type
= excess_precision_type (type
);
963 /* Copy the constant to a nul-terminated buffer. If the constant
964 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
965 can't handle them. */
966 copylen
= token
->val
.str
.len
;
967 if (flags
& CPP_N_USERDEF
)
968 copylen
-= strlen (suffix
);
969 else if (flags
& CPP_N_DFLOAT
)
973 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
974 /* Must be an F or L or machine defined suffix. */
976 if (flags
& CPP_N_IMAGINARY
)
979 if (flags
& CPP_N_FLOATNX
)
981 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
983 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
992 copy
= (char *) alloca (copylen
+ 1);
993 if (cxx_dialect
> cxx11
)
996 for (size_t i
= 0; i
< copylen
; ++i
)
997 if (token
->val
.str
.text
[i
] != '\'')
998 copy
[maxlen
++] = token
->val
.str
.text
[i
];
1003 memcpy (copy
, token
->val
.str
.text
, copylen
);
1004 copy
[copylen
] = '\0';
1007 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
1008 if (const_type
!= type
)
1009 /* Diagnosing if the result of converting the value with excess
1010 precision to the semantic type would overflow (with associated
1011 double rounding) is more appropriate than diagnosing if the
1012 result of converting the string directly to the semantic type
1014 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
1016 /* Both C and C++ require a diagnostic for a floating constant
1017 outside the range of representable values of its type. Since we
1018 have __builtin_inf* to produce an infinity, this is now a
1019 mandatory pedwarn if the target does not support infinities. */
1020 if (REAL_VALUE_ISINF (real
)
1021 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
1023 *overflow
= OT_OVERFLOW
;
1024 if (!(flags
& CPP_N_USERDEF
))
1026 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1027 pedwarn (input_location
, 0,
1028 "floating constant exceeds range of %qT", type
);
1030 warning (OPT_Woverflow
,
1031 "floating constant exceeds range of %qT", type
);
1034 /* We also give a warning if the value underflows. */
1035 else if (real_equal (&real
, &dconst0
)
1036 || (const_type
!= type
1037 && real_equal (&real_trunc
, &dconst0
)))
1039 REAL_VALUE_TYPE realvoidmode
;
1040 int oflow
= real_from_string (&realvoidmode
, copy
);
1041 *overflow
= (oflow
== 0 ? OT_NONE
1042 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
1043 if (!(flags
& CPP_N_USERDEF
))
1045 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
1046 warning (OPT_Woverflow
, "floating constant truncated to zero");
1050 /* Create a node with determined type and value. */
1051 value
= build_real (const_type
, real
);
1052 if (flags
& CPP_N_IMAGINARY
)
1054 value
= build_complex (NULL_TREE
,
1055 fold_convert (const_type
,
1056 integer_zero_node
), value
);
1057 if (type
!= const_type
)
1059 const_type
= TREE_TYPE (value
);
1060 type
= build_complex_type (type
);
1064 if (type
!= const_type
)
1065 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
1070 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1074 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1078 FIXED_VALUE_TYPE fixed
;
1082 copylen
= token
->val
.str
.len
;
1084 if (flags
& CPP_N_FRACT
) /* _Fract. */
1086 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1088 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1090 type
= unsigned_long_long_fract_type_node
;
1093 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1095 type
= unsigned_long_fract_type_node
;
1098 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1100 type
= unsigned_short_fract_type_node
;
1105 type
= unsigned_fract_type_node
;
1109 else /* Signed _Fract. */
1111 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1113 type
= long_long_fract_type_node
;
1116 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1118 type
= long_fract_type_node
;
1121 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1123 type
= short_fract_type_node
;
1128 type
= fract_type_node
;
1135 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1137 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1139 type
= unsigned_long_long_accum_type_node
;
1142 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1144 type
= unsigned_long_accum_type_node
;
1147 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1149 type
= unsigned_short_accum_type_node
;
1154 type
= unsigned_accum_type_node
;
1158 else /* Signed _Accum. */
1160 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1162 type
= long_long_accum_type_node
;
1165 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1167 type
= long_accum_type_node
;
1170 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1172 type
= short_accum_type_node
;
1177 type
= accum_type_node
;
1183 copy
= (char *) alloca (copylen
+ 1);
1184 memcpy (copy
, token
->val
.str
.text
, copylen
);
1185 copy
[copylen
] = '\0';
1187 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1189 /* Create a node with determined type and value. */
1190 value
= build_fixed (type
, fixed
);
1195 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1196 UTF8STRING tokens into a tree, performing string constant
1197 concatenation. TOK is the first of these. VALP is the location to
1198 write the string into. OBJC_STRING indicates whether an '@' token
1199 preceded the incoming token (in that case, the strings can either
1200 be ObjC strings, preceded by a single '@', or normal strings, not
1201 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1202 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1203 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1205 This is unfortunately more work than it should be. If any of the
1206 strings in the series has an L prefix, the result is a wide string
1207 (6.4.5p4). Whether or not the result is a wide string affects the
1208 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1209 sequences do not continue across the boundary between two strings in
1210 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1211 cpp_interpret_string takes a vector of cpp_string structures, which
1212 we must arrange to provide. */
1214 static enum cpp_ttype
1215 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1219 struct obstack str_ob
;
1220 struct obstack loc_ob
;
1222 enum cpp_ttype type
= tok
->type
;
1224 /* Try to avoid the overhead of creating and destroying an obstack
1225 for the common case of just one string. */
1226 cpp_string str
= tok
->val
.str
;
1227 location_t init_loc
= tok
->src_loc
;
1228 cpp_string
*strs
= &str
;
1229 location_t
*locs
= NULL
;
1231 /* objc_at_sign_was_seen is only used when doing Objective-C string
1232 concatenation. It is 'true' if we have seen an '@' before the
1233 current string, and 'false' if not. We must see exactly one or
1234 zero '@' before each string. */
1235 bool objc_at_sign_was_seen
= false;
1238 tok
= cpp_get_token (parse_in
);
1246 if (objc_at_sign_was_seen
)
1247 error ("repeated %<@%> before Objective-C string");
1249 objc_at_sign_was_seen
= true;
1260 case CPP_UTF8STRING
:
1261 if (type
!= tok
->type
)
1263 if (type
== CPP_STRING
)
1266 error ("unsupported non-standard concatenation of string literals");
1273 gcc_obstack_init (&str_ob
);
1274 gcc_obstack_init (&loc_ob
);
1275 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1276 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1280 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1281 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1284 objc_at_sign_was_seen
= false;
1288 /* It is an error if we saw a '@' with no following string. */
1289 if (objc_at_sign_was_seen
)
1290 error ("stray %<@%> in program");
1292 /* We have read one more token than we want. */
1293 _cpp_backup_tokens (parse_in
, 1);
1296 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1297 locs
= XOBFINISH (&loc_ob
, location_t
*);
1300 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1301 warning (OPT_Wtraditional
,
1302 "traditional C rejects string constant concatenation");
1305 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1306 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1308 value
= build_string (istr
.len
, (const char *) istr
.text
);
1309 free (CONST_CAST (unsigned char *, istr
.text
));
1313 gcc_assert (g_string_concat_db
);
1314 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1319 /* Callers cannot generally handle error_mark_node in this context,
1320 so return the empty string instead. cpp_interpret_string has
1326 case CPP_UTF8STRING
:
1327 value
= build_string (1, "");
1330 value
= build_string (TYPE_PRECISION (char16_type_node
)
1331 / TYPE_PRECISION (char_type_node
),
1332 "\0"); /* char16_t is 16 bits */
1335 value
= build_string (TYPE_PRECISION (char32_type_node
)
1336 / TYPE_PRECISION (char_type_node
),
1337 "\0\0\0"); /* char32_t is 32 bits */
1340 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1341 / TYPE_PRECISION (char_type_node
),
1342 "\0\0\0"); /* widest supported wchar_t
1352 TREE_TYPE (value
) = char_array_type_node
;
1354 case CPP_UTF8STRING
:
1356 TREE_TYPE (value
) = char8_array_type_node
;
1358 TREE_TYPE (value
) = char_array_type_node
;
1361 TREE_TYPE (value
) = char16_array_type_node
;
1364 TREE_TYPE (value
) = char32_array_type_node
;
1367 TREE_TYPE (value
) = wchar_array_type_node
;
1369 *valp
= fix_string_type (value
);
1373 obstack_free (&str_ob
, 0);
1374 obstack_free (&loc_ob
, 0);
1377 return objc_string
? CPP_OBJC_STRING
: type
;
1380 /* Converts a (possibly wide) character constant token into a tree. */
1382 lex_charconst (const cpp_token
*token
)
1386 unsigned int chars_seen
;
1389 result
= cpp_interpret_charconst (parse_in
, token
,
1390 &chars_seen
, &unsignedp
);
1392 if (token
->type
== CPP_WCHAR
)
1393 type
= wchar_type_node
;
1394 else if (token
->type
== CPP_CHAR32
)
1395 type
= char32_type_node
;
1396 else if (token
->type
== CPP_CHAR16
)
1397 type
= char16_type_node
;
1398 else if (token
->type
== CPP_UTF8CHAR
)
1400 if (!c_dialect_cxx ())
1401 type
= unsigned_char_type_node
;
1402 else if (flag_char8_t
)
1403 type
= char8_type_node
;
1405 type
= char_type_node
;
1407 /* In C, a character constant has type 'int'.
1408 In C++ 'char', but multi-char charconsts have type 'int'. */
1409 else if (!c_dialect_cxx () || chars_seen
> 1)
1410 type
= integer_type_node
;
1412 type
= char_type_node
;
1414 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1415 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1416 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1417 value
= build_int_cst (type
, result
);
1419 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1424 /* Helper function for c_parser_peek_conflict_marker
1425 and cp_lexer_peek_conflict_marker.
1426 Given a possible conflict marker token of kind TOK1_KIND
1427 consisting of a pair of characters, get the token kind for the
1428 standalone final character. */
1431 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1435 default: gcc_unreachable ();