1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2022 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"
31 #include "file-prefix-map.h" /* remap_macro_filename() */
32 #include "langhooks.h"
35 /* We may keep statistics about how long which files took to compile. */
36 static int header_time
, body_time
;
37 static splay_tree file_info_tree
;
39 int pending_lang_change
; /* If we need to switch languages - C++ only */
40 int c_header_level
; /* depth in C headers - C++ only */
42 static tree
interpret_integer (const cpp_token
*, unsigned int,
43 enum overflow_type
*);
44 static tree
interpret_float (const cpp_token
*, unsigned int, const char *,
45 enum overflow_type
*);
46 static tree
interpret_fixed (const cpp_token
*, unsigned int);
47 static enum integer_type_kind narrowest_unsigned_type
48 (const widest_int
&, unsigned int);
49 static enum integer_type_kind narrowest_signed_type
50 (const widest_int
&, unsigned int);
51 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
52 static tree
lex_charconst (const cpp_token
*);
53 static void update_header_times (const char *);
54 static int dump_one_header (splay_tree_node
, void *);
55 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
56 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
57 static void cb_def_pragma (cpp_reader
*, unsigned int);
58 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
59 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
64 struct c_fileinfo
*toplevel
;
66 /* The get_fileinfo data structure must be initialized before
67 cpp_read_main_file is called. */
68 toplevel
= get_fileinfo ("<top level>");
69 if (flag_detailed_statistics
)
72 body_time
= get_run_time ();
73 toplevel
->time
= body_time
;
76 struct cpp_callbacks
*cb
= cpp_get_callbacks (parse_in
);
78 cb
->line_change
= cb_line_change
;
80 cb
->def_pragma
= cb_def_pragma
;
81 cb
->valid_pch
= c_common_valid_pch
;
82 cb
->read_pch
= c_common_read_pch
;
83 cb
->has_attribute
= c_common_has_attribute
;
84 cb
->has_builtin
= c_common_has_builtin
;
85 cb
->get_source_date_epoch
= cb_get_source_date_epoch
;
86 cb
->get_suggestion
= cb_get_suggestion
;
87 cb
->remap_filename
= remap_macro_filename
;
89 /* Set the debug callbacks if we can use them. */
90 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
91 && dwarf_debuginfo_p ())
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_id
= canonicalize_attr_name (attr_id
);
342 if (c_dialect_cxx ())
344 /* OpenMP attributes need special handling. */
345 if ((flag_openmp
|| flag_openmp_simd
)
346 && is_attribute_p ("omp", attr_ns
)
347 && (is_attribute_p ("directive", attr_id
)
348 || is_attribute_p ("sequence", attr_id
)))
352 attr_name
= NULL_TREE
;
354 attr_name
= build_tree_list (attr_ns
, attr_id
);
358 cpp_error (pfile
, CPP_DL_ERROR
,
359 "attribute identifier required after scope");
360 attr_name
= NULL_TREE
;
365 /* Some standard attributes need special handling. */
366 if (c_dialect_cxx ())
368 if (is_attribute_p ("noreturn", attr_name
))
370 else if (is_attribute_p ("deprecated", attr_name
))
372 else if (is_attribute_p ("maybe_unused", attr_name
)
373 || is_attribute_p ("fallthrough", attr_name
))
375 else if (is_attribute_p ("no_unique_address", attr_name
)
376 || is_attribute_p ("likely", attr_name
)
377 || is_attribute_p ("unlikely", attr_name
))
379 else if (is_attribute_p ("nodiscard", attr_name
))
384 if (is_attribute_p ("deprecated", attr_name
))
386 else if (is_attribute_p ("fallthrough", attr_name
))
388 else if (is_attribute_p ("nodiscard", attr_name
))
390 else if (is_attribute_p ("maybe_unused", attr_name
))
392 else if (is_attribute_p ("noreturn", attr_name
)
393 || is_attribute_p ("_Noreturn", attr_name
))
397 attr_name
= NULL_TREE
;
399 if (attr_name
&& (have_scope
|| !std_syntax
))
402 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
409 cpp_error (pfile
, CPP_DL_ERROR
,
410 "macro \"__has_attribute\" requires an identifier");
414 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
415 cpp_error (pfile
, CPP_DL_ERROR
,
416 "missing ')' after \"__has_attribute\"");
421 /* Callback for has_builtin. */
424 c_common_has_builtin (cpp_reader
*pfile
)
426 const cpp_token
*token
= get_token_no_padding (pfile
);
427 if (token
->type
!= CPP_OPEN_PAREN
)
429 cpp_error (pfile
, CPP_DL_ERROR
,
430 "missing '(' after \"__has_builtin\"");
434 const char *name
= "";
435 token
= get_token_no_padding (pfile
);
436 if (token
->type
== CPP_NAME
)
438 name
= (const char *) cpp_token_as_text (pfile
, token
);
439 token
= get_token_no_padding (pfile
);
440 if (token
->type
!= CPP_CLOSE_PAREN
)
442 cpp_error (pfile
, CPP_DL_ERROR
,
443 "expected ')' after \"%s\"", name
);
449 cpp_error (pfile
, CPP_DL_ERROR
,
450 "macro \"__has_builtin\" requires an identifier");
451 if (token
->type
== CPP_CLOSE_PAREN
)
455 /* Consume tokens up to the closing parenthesis, including any nested
456 pairs of parentheses, to avoid confusing redundant errors. */
457 for (unsigned nparen
= 1; ; token
= get_token_no_padding (pfile
))
459 if (token
->type
== CPP_OPEN_PAREN
)
461 else if (token
->type
== CPP_CLOSE_PAREN
)
463 else if (token
->type
== CPP_EOF
)
469 return names_builtin_p (name
);
473 /* Read a token and return its type. Fill *VALUE with its value, if
474 applicable. Fill *CPP_FLAGS with the token's flags, if it is
478 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
481 const cpp_token
*tok
;
483 unsigned char add_flags
= 0;
484 enum overflow_type overflow
= OT_NONE
;
486 timevar_push (TV_CPP
);
488 tok
= cpp_get_token_with_location (parse_in
, loc
);
498 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
503 const char *suffix
= NULL
;
504 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
506 switch (flags
& CPP_N_CATEGORY
)
509 /* cpplib has issued an error. */
510 *value
= error_mark_node
;
514 /* C++ uses '0' to mark virtual functions as pure.
515 Set PURE_ZERO to pass this information to the C++ parser. */
516 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
517 add_flags
= PURE_ZERO
| DECIMAL_INT
;
518 else if ((flags
& CPP_N_INTEGER
) && (flags
& CPP_N_DECIMAL
))
519 /* -Wxor-used-as-pow is only active for LHS of ^ expressed
520 as a decimal integer. */
521 add_flags
= DECIMAL_INT
;
522 *value
= interpret_integer (tok
, flags
, &overflow
);
526 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
533 if (flags
& CPP_N_USERDEF
)
537 tree suffix_id
= get_identifier (suffix
);
538 int len
= tok
->val
.str
.len
- strlen (suffix
);
539 /* If this is going to be used as a C string to pass to a
540 raw literal operator, we need to add a trailing NUL. */
541 tree num_string
= build_string (len
+ 1,
542 (const char *) tok
->val
.str
.text
);
543 TREE_TYPE (num_string
) = char_array_type_node
;
544 num_string
= fix_string_type (num_string
);
545 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
547 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
555 /* An @ may give the next token special significance in Objective-C. */
556 if (c_dialect_objc ())
558 location_t atloc
= *loc
;
562 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
574 type
= lex_string (tok
, value
, true, true);
578 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
579 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
580 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
583 /* Note the complication: if we found an OBJC_CXX
584 keyword, for example, 'class', we will be
585 returning a token of type CPP_AT_NAME and rid
586 code RID_CLASS (not RID_AT_CLASS). The language
587 parser needs to convert that to RID_AT_CLASS.
588 However, we've now spliced the '@' together with the
589 keyword that follows; Adjust the location so that we
590 get a source range covering the composite.
592 *loc
= make_location (atloc
, atloc
, newloc
);
599 error_at (atloc
, "stray %<@%> in program");
610 unsigned char name
[8];
612 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
614 error_at (*loc
, "stray %qs in program", name
);
621 cppchar_t c
= tok
->val
.str
.text
[0];
623 if (c
== '"' || c
== '\'')
624 error_at (*loc
, "missing terminating %c character", (int) c
);
625 else if (ISGRAPH (c
))
626 error_at (*loc
, "stray %qc in program", (int) c
);
629 rich_location
rich_loc (line_table
, *loc
);
630 rich_loc
.set_escape_on_output (true);
631 error_at (&rich_loc
, "stray %<\\%o%> in program", (int) c
);
636 case CPP_CHAR_USERDEF
:
637 case CPP_WCHAR_USERDEF
:
638 case CPP_CHAR16_USERDEF
:
639 case CPP_CHAR32_USERDEF
:
640 case CPP_UTF8CHAR_USERDEF
:
643 cpp_token temp_tok
= *tok
;
644 const char *suffix
= cpp_get_userdef_suffix (tok
);
645 temp_tok
.val
.str
.len
-= strlen (suffix
);
646 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
647 literal
= build_userdef_literal (get_identifier (suffix
),
648 lex_charconst (&temp_tok
),
659 *value
= lex_charconst (tok
);
662 case CPP_STRING_USERDEF
:
663 case CPP_WSTRING_USERDEF
:
664 case CPP_STRING16_USERDEF
:
665 case CPP_STRING32_USERDEF
:
666 case CPP_UTF8STRING_USERDEF
:
668 tree literal
, string
;
669 const char *suffix
= cpp_get_userdef_suffix (tok
);
670 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
671 (const char *) tok
->val
.str
.text
);
672 literal
= build_userdef_literal (get_identifier (suffix
),
673 string
, OT_NONE
, NULL_TREE
);
683 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
685 type
= lex_string (tok
, value
, false,
686 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
689 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
693 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
696 case CPP_HEADER_NAME
:
697 *value
= build_string (tok
->val
.str
.len
, (const char *)tok
->val
.str
.text
);
700 /* This token should not be visible outside cpplib. */
704 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
705 when it is a FALLTHROUGH comment, in that case set
706 PREV_FALLTHROUGH flag on the next non-comment token. */
708 if (tok
->flags
& PREV_FALLTHROUGH
)
712 tok
= cpp_get_token_with_location (parse_in
, loc
);
715 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
716 add_flags
|= PREV_FALLTHROUGH
;
727 *cpp_flags
= tok
->flags
| add_flags
;
729 timevar_pop (TV_CPP
);
734 /* Returns the narrowest C-visible unsigned type, starting with the
735 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
738 static enum integer_type_kind
739 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
743 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
744 itk
= itk_unsigned_int
;
745 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
746 itk
= itk_unsigned_long
;
748 itk
= itk_unsigned_long_long
;
750 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
754 if (integer_types
[itk
] == NULL_TREE
)
756 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
758 if (wi::geu_p (wi::to_widest (upper
), val
))
759 return (enum integer_type_kind
) itk
;
765 /* Ditto, but narrowest signed type. */
766 static enum integer_type_kind
767 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
771 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
773 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
778 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
782 if (integer_types
[itk
] == NULL_TREE
)
784 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
786 if (wi::geu_p (wi::to_widest (upper
), val
))
787 return (enum integer_type_kind
) itk
;
793 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
795 interpret_integer (const cpp_token
*token
, unsigned int flags
,
796 enum overflow_type
*overflow
)
799 enum integer_type_kind itk
;
801 HOST_WIDE_INT ival
[3];
805 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
806 if (integer
.overflow
)
807 *overflow
= OT_OVERFLOW
;
809 ival
[0] = integer
.low
;
810 ival
[1] = integer
.high
;
812 widest_int wval
= widest_int::from_array (ival
, 3);
814 /* The type of a constant with a U suffix is straightforward. */
815 if (flags
& CPP_N_UNSIGNED
)
816 itk
= narrowest_unsigned_type (wval
, flags
);
819 /* The type of a potentially-signed integer constant varies
820 depending on the base it's in, the standard in use, and the
822 enum integer_type_kind itk_u
823 = narrowest_unsigned_type (wval
, flags
);
824 enum integer_type_kind itk_s
825 = narrowest_signed_type (wval
, flags
);
827 /* In both C89 and C99, octal and hex constants may be signed or
828 unsigned, whichever fits tighter. We do not warn about this
829 choice differing from the traditional choice, as the constant
830 is probably a bit pattern and either way will work. */
831 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
832 itk
= MIN (itk_u
, itk_s
);
835 /* In C99, decimal constants are always signed.
836 In C89, decimal constants that don't fit in long have
837 undefined behavior; we try to make them unsigned long.
838 In GCC's extended C89, that last is true of decimal
839 constants that don't fit in long long, too. */
842 if (itk_s
> itk_u
&& itk_s
> itk_long
)
846 if (itk_u
< itk_unsigned_long
)
847 itk_u
= itk_unsigned_long
;
849 warning (0, "this decimal constant is unsigned only in ISO C90");
852 warning (OPT_Wtraditional
,
853 "this decimal constant would be unsigned in ISO C90");
859 /* cpplib has already issued a warning for overflow. */
860 type
= ((flags
& CPP_N_UNSIGNED
)
861 ? widest_unsigned_literal_type_node
862 : widest_integer_literal_type_node
);
863 else if (flags
& CPP_N_SIZE_T
)
865 /* itk refers to fundamental types not aliased size types. */
866 if (flags
& CPP_N_UNSIGNED
)
867 type
= size_type_node
;
869 type
= signed_size_type_node
;
873 type
= integer_types
[itk
];
874 if (itk
> itk_unsigned_long
875 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
877 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
878 ? DK_PEDWARN
: DK_WARNING
,
879 input_location
, OPT_Wlong_long
,
880 (flags
& CPP_N_UNSIGNED
)
881 ? "integer constant is too large for %<unsigned long%> type"
882 : "integer constant is too large for %<long%> type");
885 value
= wide_int_to_tree (type
, wval
);
887 /* Convert imaginary to a complex type. */
888 if (flags
& CPP_N_IMAGINARY
)
889 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
894 /* Interpret TOKEN, a floating point number with FLAGS as classified
895 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
897 interpret_float (const cpp_token
*token
, unsigned int flags
,
898 const char *suffix
, enum overflow_type
*overflow
)
903 REAL_VALUE_TYPE real
;
904 REAL_VALUE_TYPE real_trunc
;
910 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
911 pragma has been used and is either double or _Decimal64. Types
912 that are not allowed with decimal float default to double. */
913 if (flags
& CPP_N_DEFAULT
)
915 flags
^= CPP_N_DEFAULT
;
916 flags
|= CPP_N_MEDIUM
;
918 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
920 warning (OPT_Wunsuffixed_float_constants
,
921 "unsuffixed floating constant");
922 if (float_const_decimal64_p ())
923 flags
|= CPP_N_DFLOAT
;
927 /* Decode _Fract and _Accum. */
928 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
929 return interpret_fixed (token
, flags
);
931 /* Decode type based on width and properties. */
932 if (flags
& CPP_N_DFLOAT
)
933 if (!targetm
.decimal_float_supported_p ())
935 error ("decimal floating-point not supported for this target");
936 return error_mark_node
;
938 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
939 type
= dfloat128_type_node
;
940 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
941 type
= dfloat32_type_node
;
943 type
= dfloat64_type_node
;
945 if (flags
& CPP_N_WIDTH_MD
)
950 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
955 mode
= targetm
.c
.mode_for_suffix (suffix
);
956 if (mode
== VOIDmode
)
958 error ("unsupported non-standard suffix on floating constant");
960 return error_mark_node
;
963 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
965 type
= c_common_type_for_mode (mode
, 0);
966 /* For Q suffix, prefer float128t_type_node (__float128) type
967 over float128_type_node (_Float128) type if they are distinct. */
968 if (type
== float128_type_node
&& float128t_type_node
)
969 type
= float128t_type_node
;
972 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
974 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
975 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
977 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
978 if (floatn_nx_types
[i
].n
== (int) n
979 && floatn_nx_types
[i
].extended
== extended
)
981 type
= FLOATN_NX_TYPE_NODE (i
);
984 if (type
== NULL_TREE
)
986 error ("unsupported non-standard suffix on floating constant");
987 return error_mark_node
;
989 else if (c_dialect_cxx () && !extended
)
991 if (cxx_dialect
< cxx23
)
992 pedwarn (input_location
, OPT_Wpedantic
,
993 "%<f%d%> or %<F%d%> suffix on floating constant only "
994 "available with %<-std=c++2b%> or %<-std=gnu++2b%>",
998 pedwarn (input_location
, OPT_Wpedantic
,
999 "non-standard suffix on floating constant");
1001 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1002 type
= long_double_type_node
;
1003 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
1004 || flag_single_precision_constant
)
1005 type
= float_type_node
;
1007 type
= double_type_node
;
1009 if (c_dialect_cxx ())
1010 const_type
= NULL_TREE
;
1012 const_type
= excess_precision_type (type
);
1016 /* Copy the constant to a nul-terminated buffer. If the constant
1017 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
1018 can't handle them. */
1019 copylen
= token
->val
.str
.len
;
1020 if (flags
& CPP_N_USERDEF
)
1021 copylen
-= strlen (suffix
);
1022 else if (flags
& CPP_N_DFLOAT
)
1026 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
1027 /* Must be an F or L or machine defined suffix. */
1029 if (flags
& CPP_N_IMAGINARY
)
1030 /* I or J suffix. */
1032 if (flags
& CPP_N_FLOATNX
)
1034 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
1036 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
1045 copy
= (char *) alloca (copylen
+ 1);
1046 if (c_dialect_cxx () ? cxx_dialect
> cxx11
: flag_isoc2x
)
1049 for (size_t i
= 0; i
< copylen
; ++i
)
1050 if (token
->val
.str
.text
[i
] != '\'')
1051 copy
[maxlen
++] = token
->val
.str
.text
[i
];
1052 copy
[maxlen
] = '\0';
1056 memcpy (copy
, token
->val
.str
.text
, copylen
);
1057 copy
[copylen
] = '\0';
1060 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
1061 if (const_type
!= type
)
1062 /* Diagnosing if the result of converting the value with excess
1063 precision to the semantic type would overflow (with associated
1064 double rounding) is more appropriate than diagnosing if the
1065 result of converting the string directly to the semantic type
1067 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
1069 /* Both C and C++ require a diagnostic for a floating constant
1070 outside the range of representable values of its type. Since we
1071 have __builtin_inf* to produce an infinity, this is now a
1072 mandatory pedwarn if the target does not support infinities. */
1073 if (REAL_VALUE_ISINF (real
)
1074 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
1076 *overflow
= OT_OVERFLOW
;
1077 if (!(flags
& CPP_N_USERDEF
))
1079 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1080 pedwarn (input_location
, 0,
1081 "floating constant exceeds range of %qT", type
);
1083 warning (OPT_Woverflow
,
1084 "floating constant exceeds range of %qT", type
);
1087 /* We also give a warning if the value underflows. */
1088 else if (real_equal (&real
, &dconst0
)
1089 || (const_type
!= type
1090 && real_equal (&real_trunc
, &dconst0
)))
1092 REAL_VALUE_TYPE realvoidmode
;
1093 int oflow
= real_from_string (&realvoidmode
, copy
);
1094 *overflow
= (oflow
== 0 ? OT_NONE
1095 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
1096 if (!(flags
& CPP_N_USERDEF
))
1098 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
1099 warning (OPT_Woverflow
, "floating constant truncated to zero");
1103 /* Create a node with determined type and value. */
1104 value
= build_real (const_type
, real
);
1105 if (flags
& CPP_N_IMAGINARY
)
1107 value
= build_complex (NULL_TREE
,
1108 fold_convert (const_type
,
1109 integer_zero_node
), value
);
1110 if (type
!= const_type
)
1112 const_type
= TREE_TYPE (value
);
1113 type
= build_complex_type (type
);
1117 if (type
!= const_type
)
1118 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
1123 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1127 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1131 FIXED_VALUE_TYPE fixed
;
1135 copylen
= token
->val
.str
.len
;
1137 if (flags
& CPP_N_FRACT
) /* _Fract. */
1139 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1141 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1143 type
= unsigned_long_long_fract_type_node
;
1146 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1148 type
= unsigned_long_fract_type_node
;
1151 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1153 type
= unsigned_short_fract_type_node
;
1158 type
= unsigned_fract_type_node
;
1162 else /* Signed _Fract. */
1164 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1166 type
= long_long_fract_type_node
;
1169 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1171 type
= long_fract_type_node
;
1174 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1176 type
= short_fract_type_node
;
1181 type
= fract_type_node
;
1188 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1190 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1192 type
= unsigned_long_long_accum_type_node
;
1195 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1197 type
= unsigned_long_accum_type_node
;
1200 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1202 type
= unsigned_short_accum_type_node
;
1207 type
= unsigned_accum_type_node
;
1211 else /* Signed _Accum. */
1213 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1215 type
= long_long_accum_type_node
;
1218 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1220 type
= long_accum_type_node
;
1223 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1225 type
= short_accum_type_node
;
1230 type
= accum_type_node
;
1236 copy
= (char *) alloca (copylen
+ 1);
1237 memcpy (copy
, token
->val
.str
.text
, copylen
);
1238 copy
[copylen
] = '\0';
1240 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1242 /* Create a node with determined type and value. */
1243 value
= build_fixed (type
, fixed
);
1248 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1249 UTF8STRING tokens into a tree, performing string constant
1250 concatenation. TOK is the first of these. VALP is the location to
1251 write the string into. OBJC_STRING indicates whether an '@' token
1252 preceded the incoming token (in that case, the strings can either
1253 be ObjC strings, preceded by a single '@', or normal strings, not
1254 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1255 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1256 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1258 This is unfortunately more work than it should be. If any of the
1259 strings in the series has an L prefix, the result is a wide string
1260 (6.4.5p4). Whether or not the result is a wide string affects the
1261 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1262 sequences do not continue across the boundary between two strings in
1263 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1264 cpp_interpret_string takes a vector of cpp_string structures, which
1265 we must arrange to provide. */
1267 static enum cpp_ttype
1268 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1272 struct obstack str_ob
;
1273 struct obstack loc_ob
;
1275 enum cpp_ttype type
= tok
->type
;
1277 /* Try to avoid the overhead of creating and destroying an obstack
1278 for the common case of just one string. */
1279 cpp_string str
= tok
->val
.str
;
1280 location_t init_loc
= tok
->src_loc
;
1281 cpp_string
*strs
= &str
;
1282 location_t
*locs
= NULL
;
1284 /* objc_at_sign_was_seen is only used when doing Objective-C string
1285 concatenation. It is 'true' if we have seen an '@' before the
1286 current string, and 'false' if not. We must see exactly one or
1287 zero '@' before each string. */
1288 bool objc_at_sign_was_seen
= false;
1291 tok
= cpp_get_token (parse_in
);
1299 if (objc_at_sign_was_seen
)
1300 error ("repeated %<@%> before Objective-C string");
1302 objc_at_sign_was_seen
= true;
1313 case CPP_UTF8STRING
:
1314 if (type
!= tok
->type
)
1316 if (type
== CPP_STRING
)
1319 error ("unsupported non-standard concatenation of string literals");
1326 gcc_obstack_init (&str_ob
);
1327 gcc_obstack_init (&loc_ob
);
1328 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1329 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1333 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1334 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1337 objc_at_sign_was_seen
= false;
1341 /* It is an error if we saw a '@' with no following string. */
1342 if (objc_at_sign_was_seen
)
1343 error ("stray %<@%> in program");
1345 /* We have read one more token than we want. */
1346 _cpp_backup_tokens (parse_in
, 1);
1349 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1350 locs
= XOBFINISH (&loc_ob
, location_t
*);
1353 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1354 warning (OPT_Wtraditional
,
1355 "traditional C rejects string constant concatenation");
1358 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1359 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1361 value
= build_string (istr
.len
, (const char *) istr
.text
);
1362 free (CONST_CAST (unsigned char *, istr
.text
));
1366 gcc_assert (g_string_concat_db
);
1367 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1372 /* Callers cannot generally handle error_mark_node in this context,
1373 so return the empty string instead. cpp_interpret_string has
1379 case CPP_UTF8STRING
:
1380 if (type
== CPP_UTF8STRING
&& flag_char8_t
)
1382 value
= build_string (TYPE_PRECISION (char8_type_node
)
1383 / TYPE_PRECISION (char_type_node
),
1384 ""); /* char8_t is 8 bits */
1387 value
= build_string (1, "");
1390 value
= build_string (TYPE_PRECISION (char16_type_node
)
1391 / TYPE_PRECISION (char_type_node
),
1392 "\0"); /* char16_t is 16 bits */
1395 value
= build_string (TYPE_PRECISION (char32_type_node
)
1396 / TYPE_PRECISION (char_type_node
),
1397 "\0\0\0"); /* char32_t is 32 bits */
1400 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1401 / TYPE_PRECISION (char_type_node
),
1402 "\0\0\0"); /* widest supported wchar_t
1412 TREE_TYPE (value
) = char_array_type_node
;
1414 case CPP_UTF8STRING
:
1416 TREE_TYPE (value
) = char8_array_type_node
;
1418 TREE_TYPE (value
) = char_array_type_node
;
1421 TREE_TYPE (value
) = char16_array_type_node
;
1424 TREE_TYPE (value
) = char32_array_type_node
;
1427 TREE_TYPE (value
) = wchar_array_type_node
;
1429 *valp
= fix_string_type (value
);
1433 obstack_free (&str_ob
, 0);
1434 obstack_free (&loc_ob
, 0);
1437 return objc_string
? CPP_OBJC_STRING
: type
;
1440 /* Converts a (possibly wide) character constant token into a tree. */
1442 lex_charconst (const cpp_token
*token
)
1446 unsigned int chars_seen
;
1449 result
= cpp_interpret_charconst (parse_in
, token
,
1450 &chars_seen
, &unsignedp
);
1452 if (token
->type
== CPP_WCHAR
)
1453 type
= wchar_type_node
;
1454 else if (token
->type
== CPP_CHAR32
)
1455 type
= char32_type_node
;
1456 else if (token
->type
== CPP_CHAR16
)
1457 type
= char16_type_node
;
1458 else if (token
->type
== CPP_UTF8CHAR
)
1461 type
= char8_type_node
;
1463 type
= char_type_node
;
1465 /* In C, a character constant has type 'int'.
1466 In C++ 'char', but multi-char charconsts have type 'int'. */
1467 else if (!c_dialect_cxx () || chars_seen
> 1)
1468 type
= integer_type_node
;
1470 type
= char_type_node
;
1472 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1473 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1474 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1475 value
= build_int_cst (type
, result
);
1477 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1482 /* Helper function for c_parser_peek_conflict_marker
1483 and cp_lexer_peek_conflict_marker.
1484 Given a possible conflict marker token of kind TOK1_KIND
1485 consisting of a pair of characters, get the token kind for the
1486 standalone final character. */
1489 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1493 default: gcc_unreachable ();