1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2023 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
))
381 else if (is_attribute_p ("assume", attr_name
))
383 else if (is_attribute_p ("init_priority", attr_name
))
385 /* The (non-standard) init_priority attribute is always
386 included in the attribute table, but we don't want to
387 advertise the attribute unless the target actually
388 supports init priorities. */
389 result
= SUPPORTS_INIT_PRIORITY
? 1 : 0;
390 attr_name
= NULL_TREE
;
395 if (is_attribute_p ("deprecated", attr_name
))
397 else if (is_attribute_p ("fallthrough", attr_name
))
399 else if (is_attribute_p ("nodiscard", attr_name
))
401 else if (is_attribute_p ("maybe_unused", attr_name
))
403 else if (is_attribute_p ("noreturn", attr_name
)
404 || is_attribute_p ("_Noreturn", attr_name
))
408 attr_name
= NULL_TREE
;
410 if (attr_name
&& (have_scope
|| !std_syntax
))
413 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
420 cpp_error (pfile
, CPP_DL_ERROR
,
421 "macro \"__has_attribute\" requires an identifier");
425 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
426 cpp_error (pfile
, CPP_DL_ERROR
,
427 "missing ')' after \"__has_attribute\"");
432 /* Callback for has_builtin. */
435 c_common_has_builtin (cpp_reader
*pfile
)
437 const cpp_token
*token
= get_token_no_padding (pfile
);
438 if (token
->type
!= CPP_OPEN_PAREN
)
440 cpp_error (pfile
, CPP_DL_ERROR
,
441 "missing '(' after \"__has_builtin\"");
445 const char *name
= "";
446 token
= get_token_no_padding (pfile
);
447 if (token
->type
== CPP_NAME
)
449 name
= (const char *) cpp_token_as_text (pfile
, token
);
450 token
= get_token_no_padding (pfile
);
451 if (token
->type
!= CPP_CLOSE_PAREN
)
453 cpp_error (pfile
, CPP_DL_ERROR
,
454 "expected ')' after \"%s\"", name
);
460 cpp_error (pfile
, CPP_DL_ERROR
,
461 "macro \"__has_builtin\" requires an identifier");
462 if (token
->type
== CPP_CLOSE_PAREN
)
466 /* Consume tokens up to the closing parenthesis, including any nested
467 pairs of parentheses, to avoid confusing redundant errors. */
468 for (unsigned nparen
= 1; ; token
= get_token_no_padding (pfile
))
470 if (token
->type
== CPP_OPEN_PAREN
)
472 else if (token
->type
== CPP_CLOSE_PAREN
)
474 else if (token
->type
== CPP_EOF
)
480 return names_builtin_p (name
);
484 /* Read a token and return its type. Fill *VALUE with its value, if
485 applicable. Fill *CPP_FLAGS with the token's flags, if it is
489 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
492 const cpp_token
*tok
;
494 unsigned char add_flags
= 0;
495 enum overflow_type overflow
= OT_NONE
;
497 timevar_push (TV_CPP
);
499 tok
= cpp_get_token_with_location (parse_in
, loc
);
509 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
514 const char *suffix
= NULL
;
515 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
517 switch (flags
& CPP_N_CATEGORY
)
520 /* cpplib has issued an error. */
521 *value
= error_mark_node
;
525 /* C++ uses '0' to mark virtual functions as pure.
526 Set PURE_ZERO to pass this information to the C++ parser. */
527 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
528 add_flags
= PURE_ZERO
| DECIMAL_INT
;
529 else if ((flags
& CPP_N_INTEGER
) && (flags
& CPP_N_DECIMAL
))
530 /* -Wxor-used-as-pow is only active for LHS of ^ expressed
531 as a decimal integer. */
532 add_flags
= DECIMAL_INT
;
533 *value
= interpret_integer (tok
, flags
, &overflow
);
537 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
544 if (flags
& CPP_N_USERDEF
)
548 tree suffix_id
= get_identifier (suffix
);
549 int len
= tok
->val
.str
.len
- strlen (suffix
);
550 /* If this is going to be used as a C string to pass to a
551 raw literal operator, we need to add a trailing NUL. */
552 tree num_string
= build_string (len
+ 1,
553 (const char *) tok
->val
.str
.text
);
554 TREE_TYPE (num_string
) = char_array_type_node
;
555 num_string
= fix_string_type (num_string
);
556 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
558 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
566 /* An @ may give the next token special significance in Objective-C. */
567 if (c_dialect_objc ())
569 location_t atloc
= *loc
;
573 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
585 type
= lex_string (tok
, value
, true, true);
589 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
590 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
591 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
594 /* Note the complication: if we found an OBJC_CXX
595 keyword, for example, 'class', we will be
596 returning a token of type CPP_AT_NAME and rid
597 code RID_CLASS (not RID_AT_CLASS). The language
598 parser needs to convert that to RID_AT_CLASS.
599 However, we've now spliced the '@' together with the
600 keyword that follows; Adjust the location so that we
601 get a source range covering the composite.
603 *loc
= make_location (atloc
, atloc
, newloc
);
610 error_at (atloc
, "stray %<@%> in program");
621 unsigned char name
[8];
623 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
625 error_at (*loc
, "stray %qs in program", name
);
632 cppchar_t c
= tok
->val
.str
.text
[0];
634 if (c
== '"' || c
== '\'')
635 error_at (*loc
, "missing terminating %c character", (int) c
);
636 else if (ISGRAPH (c
))
637 error_at (*loc
, "stray %qc in program", (int) c
);
640 rich_location
rich_loc (line_table
, *loc
);
641 rich_loc
.set_escape_on_output (true);
642 error_at (&rich_loc
, "stray %<\\%o%> in program", (int) c
);
647 case CPP_CHAR_USERDEF
:
648 case CPP_WCHAR_USERDEF
:
649 case CPP_CHAR16_USERDEF
:
650 case CPP_CHAR32_USERDEF
:
651 case CPP_UTF8CHAR_USERDEF
:
654 cpp_token temp_tok
= *tok
;
655 const char *suffix
= cpp_get_userdef_suffix (tok
);
656 temp_tok
.val
.str
.len
-= strlen (suffix
);
657 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
658 literal
= build_userdef_literal (get_identifier (suffix
),
659 lex_charconst (&temp_tok
),
670 *value
= lex_charconst (tok
);
673 case CPP_STRING_USERDEF
:
674 case CPP_WSTRING_USERDEF
:
675 case CPP_STRING16_USERDEF
:
676 case CPP_STRING32_USERDEF
:
677 case CPP_UTF8STRING_USERDEF
:
679 tree literal
, string
;
680 const char *suffix
= cpp_get_userdef_suffix (tok
);
681 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
682 (const char *) tok
->val
.str
.text
);
683 literal
= build_userdef_literal (get_identifier (suffix
),
684 string
, OT_NONE
, NULL_TREE
);
694 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
696 type
= lex_string (tok
, value
, false,
697 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
700 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
704 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
707 case CPP_HEADER_NAME
:
708 *value
= build_string (tok
->val
.str
.len
, (const char *)tok
->val
.str
.text
);
711 /* This token should not be visible outside cpplib. */
715 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
716 when it is a FALLTHROUGH comment, in that case set
717 PREV_FALLTHROUGH flag on the next non-comment token. */
719 if (tok
->flags
& PREV_FALLTHROUGH
)
723 tok
= cpp_get_token_with_location (parse_in
, loc
);
726 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
727 add_flags
|= PREV_FALLTHROUGH
;
738 *cpp_flags
= tok
->flags
| add_flags
;
740 timevar_pop (TV_CPP
);
745 /* Returns the narrowest C-visible unsigned type, starting with the
746 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
749 static enum integer_type_kind
750 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
754 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
755 itk
= itk_unsigned_int
;
756 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
757 itk
= itk_unsigned_long
;
759 itk
= itk_unsigned_long_long
;
761 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
765 if (integer_types
[itk
] == NULL_TREE
)
767 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
769 if (wi::geu_p (wi::to_widest (upper
), val
))
770 return (enum integer_type_kind
) itk
;
776 /* Ditto, but narrowest signed type. */
777 static enum integer_type_kind
778 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
782 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
784 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
789 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
793 if (integer_types
[itk
] == NULL_TREE
)
795 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
797 if (wi::geu_p (wi::to_widest (upper
), val
))
798 return (enum integer_type_kind
) itk
;
804 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
806 interpret_integer (const cpp_token
*token
, unsigned int flags
,
807 enum overflow_type
*overflow
)
810 enum integer_type_kind itk
;
812 HOST_WIDE_INT ival
[3];
816 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
817 if (integer
.overflow
)
818 *overflow
= OT_OVERFLOW
;
820 ival
[0] = integer
.low
;
821 ival
[1] = integer
.high
;
823 widest_int wval
= widest_int::from_array (ival
, 3);
825 /* The type of a constant with a U suffix is straightforward. */
826 if (flags
& CPP_N_UNSIGNED
)
827 itk
= narrowest_unsigned_type (wval
, flags
);
830 /* The type of a potentially-signed integer constant varies
831 depending on the base it's in, the standard in use, and the
833 enum integer_type_kind itk_u
834 = narrowest_unsigned_type (wval
, flags
);
835 enum integer_type_kind itk_s
836 = narrowest_signed_type (wval
, flags
);
838 /* In both C89 and C99, octal and hex constants may be signed or
839 unsigned, whichever fits tighter. We do not warn about this
840 choice differing from the traditional choice, as the constant
841 is probably a bit pattern and either way will work. */
842 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
843 itk
= MIN (itk_u
, itk_s
);
846 /* In C99, decimal constants are always signed.
847 In C89, decimal constants that don't fit in long have
848 undefined behavior; we try to make them unsigned long.
849 In GCC's extended C89, that last is true of decimal
850 constants that don't fit in long long, too. */
853 if (itk_s
> itk_u
&& itk_s
> itk_long
)
857 if (itk_u
< itk_unsigned_long
)
858 itk_u
= itk_unsigned_long
;
860 warning (0, "this decimal constant is unsigned only in ISO C90");
863 warning (OPT_Wtraditional
,
864 "this decimal constant would be unsigned in ISO C90");
870 /* cpplib has already issued a warning for overflow. */
871 type
= ((flags
& CPP_N_UNSIGNED
)
872 ? widest_unsigned_literal_type_node
873 : widest_integer_literal_type_node
);
874 else if (flags
& CPP_N_SIZE_T
)
876 /* itk refers to fundamental types not aliased size types. */
877 if (flags
& CPP_N_UNSIGNED
)
878 type
= size_type_node
;
880 type
= signed_size_type_node
;
884 type
= integer_types
[itk
];
885 if (itk
> itk_unsigned_long
886 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
888 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
889 ? DK_PEDWARN
: DK_WARNING
,
890 input_location
, OPT_Wlong_long
,
891 (flags
& CPP_N_UNSIGNED
)
892 ? "integer constant is too large for %<unsigned long%> type"
893 : "integer constant is too large for %<long%> type");
896 value
= wide_int_to_tree (type
, wval
);
898 /* Convert imaginary to a complex type. */
899 if (flags
& CPP_N_IMAGINARY
)
900 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
905 /* Interpret TOKEN, a floating point number with FLAGS as classified
906 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
908 interpret_float (const cpp_token
*token
, unsigned int flags
,
909 const char *suffix
, enum overflow_type
*overflow
)
914 REAL_VALUE_TYPE real
;
915 REAL_VALUE_TYPE real_trunc
;
921 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
922 pragma has been used and is either double or _Decimal64. Types
923 that are not allowed with decimal float default to double. */
924 if (flags
& CPP_N_DEFAULT
)
926 flags
^= CPP_N_DEFAULT
;
927 flags
|= CPP_N_MEDIUM
;
929 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
931 warning (OPT_Wunsuffixed_float_constants
,
932 "unsuffixed floating constant");
933 if (float_const_decimal64_p ())
934 flags
|= CPP_N_DFLOAT
;
938 /* Decode _Fract and _Accum. */
939 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
940 return interpret_fixed (token
, flags
);
942 /* Decode type based on width and properties. */
943 if (flags
& CPP_N_DFLOAT
)
944 if (!targetm
.decimal_float_supported_p ())
946 error ("decimal floating-point not supported for this target");
947 return error_mark_node
;
949 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
950 type
= dfloat128_type_node
;
951 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
952 type
= dfloat32_type_node
;
954 type
= dfloat64_type_node
;
956 if (flags
& CPP_N_WIDTH_MD
)
961 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
966 mode
= targetm
.c
.mode_for_suffix (suffix
);
967 if (mode
== VOIDmode
)
969 error ("unsupported non-standard suffix on floating constant");
971 return error_mark_node
;
974 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
976 type
= c_common_type_for_mode (mode
, 0);
977 /* For Q suffix, prefer float128t_type_node (__float128) type
978 over float128_type_node (_Float128) type if they are distinct. */
979 if (type
== float128_type_node
&& float128t_type_node
)
980 type
= float128t_type_node
;
983 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
985 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
986 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
988 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
989 if (floatn_nx_types
[i
].n
== (int) n
990 && floatn_nx_types
[i
].extended
== extended
)
992 type
= FLOATN_NX_TYPE_NODE (i
);
995 if (type
== NULL_TREE
)
997 error ("unsupported non-standard suffix on floating constant");
998 return error_mark_node
;
1000 else if (c_dialect_cxx () && !extended
)
1002 if (cxx_dialect
< cxx23
)
1003 pedwarn (input_location
, OPT_Wpedantic
,
1004 "%<f%d%> or %<F%d%> suffix on floating constant only "
1005 "available with %<-std=c++2b%> or %<-std=gnu++2b%>",
1009 pedwarn (input_location
, OPT_Wpedantic
,
1010 "non-standard suffix on floating constant");
1012 else if ((flags
& CPP_N_BFLOAT16
) != 0)
1014 type
= bfloat16_type_node
;
1015 if (type
== NULL_TREE
)
1017 error ("unsupported non-standard suffix on floating constant");
1018 return error_mark_node
;
1020 if (!c_dialect_cxx ())
1021 pedwarn (input_location
, OPT_Wpedantic
,
1022 "non-standard suffix on floating constant");
1023 else if (cxx_dialect
< cxx23
)
1024 pedwarn (input_location
, OPT_Wpedantic
,
1025 "%<bf16%> or %<BF16%> suffix on floating constant only "
1026 "available with %<-std=c++2b%> or %<-std=gnu++2b%>");
1028 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1029 type
= long_double_type_node
;
1030 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
1031 || flag_single_precision_constant
)
1032 type
= float_type_node
;
1034 type
= double_type_node
;
1036 const_type
= excess_precision_type (type
);
1040 /* Copy the constant to a nul-terminated buffer. If the constant
1041 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
1042 can't handle them. */
1043 copylen
= token
->val
.str
.len
;
1044 if (flags
& CPP_N_USERDEF
)
1045 copylen
-= strlen (suffix
);
1046 else if (flags
& CPP_N_DFLOAT
)
1050 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
1051 /* Must be an F or L or machine defined suffix. */
1053 if (flags
& CPP_N_IMAGINARY
)
1054 /* I or J suffix. */
1056 if (flags
& CPP_N_FLOATNX
)
1058 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
1060 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
1069 copy
= (char *) alloca (copylen
+ 1);
1070 if (c_dialect_cxx () ? cxx_dialect
> cxx11
: flag_isoc2x
)
1073 for (size_t i
= 0; i
< copylen
; ++i
)
1074 if (token
->val
.str
.text
[i
] != '\'')
1075 copy
[maxlen
++] = token
->val
.str
.text
[i
];
1076 copy
[maxlen
] = '\0';
1080 memcpy (copy
, token
->val
.str
.text
, copylen
);
1081 copy
[copylen
] = '\0';
1084 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
1085 if (const_type
!= type
)
1086 /* Diagnosing if the result of converting the value with excess
1087 precision to the semantic type would overflow (with associated
1088 double rounding) is more appropriate than diagnosing if the
1089 result of converting the string directly to the semantic type
1091 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
1093 /* Both C and C++ require a diagnostic for a floating constant
1094 outside the range of representable values of its type. Since we
1095 have __builtin_inf* to produce an infinity, this is now a
1096 mandatory pedwarn if the target does not support infinities. */
1097 if (REAL_VALUE_ISINF (real
)
1098 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
1100 *overflow
= OT_OVERFLOW
;
1101 if (!(flags
& CPP_N_USERDEF
))
1103 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1104 pedwarn (input_location
, 0,
1105 "floating constant exceeds range of %qT", type
);
1107 warning (OPT_Woverflow
,
1108 "floating constant exceeds range of %qT", type
);
1111 /* We also give a warning if the value underflows. */
1112 else if (real_equal (&real
, &dconst0
)
1113 || (const_type
!= type
1114 && real_equal (&real_trunc
, &dconst0
)))
1116 REAL_VALUE_TYPE realvoidmode
;
1117 int oflow
= real_from_string (&realvoidmode
, copy
);
1118 *overflow
= (oflow
== 0 ? OT_NONE
1119 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
1120 if (!(flags
& CPP_N_USERDEF
))
1122 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
1123 warning (OPT_Woverflow
, "floating constant truncated to zero");
1127 /* Create a node with determined type and value. */
1128 value
= build_real (const_type
, real
);
1129 if (flags
& CPP_N_IMAGINARY
)
1131 value
= build_complex (NULL_TREE
,
1132 fold_convert (const_type
,
1133 integer_zero_node
), value
);
1134 if (type
!= const_type
)
1136 const_type
= TREE_TYPE (value
);
1137 type
= build_complex_type (type
);
1141 if (type
!= const_type
)
1142 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
1147 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1151 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1155 FIXED_VALUE_TYPE fixed
;
1159 copylen
= token
->val
.str
.len
;
1161 if (flags
& CPP_N_FRACT
) /* _Fract. */
1163 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1165 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1167 type
= unsigned_long_long_fract_type_node
;
1170 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1172 type
= unsigned_long_fract_type_node
;
1175 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1177 type
= unsigned_short_fract_type_node
;
1182 type
= unsigned_fract_type_node
;
1186 else /* Signed _Fract. */
1188 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1190 type
= long_long_fract_type_node
;
1193 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1195 type
= long_fract_type_node
;
1198 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1200 type
= short_fract_type_node
;
1205 type
= fract_type_node
;
1212 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1214 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1216 type
= unsigned_long_long_accum_type_node
;
1219 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1221 type
= unsigned_long_accum_type_node
;
1224 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1226 type
= unsigned_short_accum_type_node
;
1231 type
= unsigned_accum_type_node
;
1235 else /* Signed _Accum. */
1237 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1239 type
= long_long_accum_type_node
;
1242 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1244 type
= long_accum_type_node
;
1247 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1249 type
= short_accum_type_node
;
1254 type
= accum_type_node
;
1260 copy
= (char *) alloca (copylen
+ 1);
1261 memcpy (copy
, token
->val
.str
.text
, copylen
);
1262 copy
[copylen
] = '\0';
1264 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1266 /* Create a node with determined type and value. */
1267 value
= build_fixed (type
, fixed
);
1272 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1273 UTF8STRING tokens into a tree, performing string constant
1274 concatenation. TOK is the first of these. VALP is the location to
1275 write the string into. OBJC_STRING indicates whether an '@' token
1276 preceded the incoming token (in that case, the strings can either
1277 be ObjC strings, preceded by a single '@', or normal strings, not
1278 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1279 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1280 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1282 This is unfortunately more work than it should be. If any of the
1283 strings in the series has an L prefix, the result is a wide string
1284 (6.4.5p4). Whether or not the result is a wide string affects the
1285 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1286 sequences do not continue across the boundary between two strings in
1287 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1288 cpp_interpret_string takes a vector of cpp_string structures, which
1289 we must arrange to provide. */
1291 static enum cpp_ttype
1292 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1296 struct obstack str_ob
;
1297 struct obstack loc_ob
;
1299 enum cpp_ttype type
= tok
->type
;
1301 /* Try to avoid the overhead of creating and destroying an obstack
1302 for the common case of just one string. */
1303 cpp_string str
= tok
->val
.str
;
1304 location_t init_loc
= tok
->src_loc
;
1305 cpp_string
*strs
= &str
;
1306 location_t
*locs
= NULL
;
1308 /* objc_at_sign_was_seen is only used when doing Objective-C string
1309 concatenation. It is 'true' if we have seen an '@' before the
1310 current string, and 'false' if not. We must see exactly one or
1311 zero '@' before each string. */
1312 bool objc_at_sign_was_seen
= false;
1315 tok
= cpp_get_token (parse_in
);
1323 if (objc_at_sign_was_seen
)
1324 error ("repeated %<@%> before Objective-C string");
1326 objc_at_sign_was_seen
= true;
1337 case CPP_UTF8STRING
:
1338 if (type
!= tok
->type
)
1340 if (type
== CPP_STRING
)
1343 error ("unsupported non-standard concatenation of string literals");
1350 gcc_obstack_init (&str_ob
);
1351 gcc_obstack_init (&loc_ob
);
1352 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1353 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1357 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1358 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1361 objc_at_sign_was_seen
= false;
1365 /* It is an error if we saw a '@' with no following string. */
1366 if (objc_at_sign_was_seen
)
1367 error ("stray %<@%> in program");
1369 /* We have read one more token than we want. */
1370 _cpp_backup_tokens (parse_in
, 1);
1373 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1374 locs
= XOBFINISH (&loc_ob
, location_t
*);
1377 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1378 warning (OPT_Wtraditional
,
1379 "traditional C rejects string constant concatenation");
1382 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1383 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1385 value
= build_string (istr
.len
, (const char *) istr
.text
);
1386 free (CONST_CAST (unsigned char *, istr
.text
));
1390 gcc_assert (g_string_concat_db
);
1391 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1396 /* Callers cannot generally handle error_mark_node in this context,
1397 so return the empty string instead. cpp_interpret_string has
1403 case CPP_UTF8STRING
:
1404 if (type
== CPP_UTF8STRING
&& flag_char8_t
)
1406 value
= build_string (TYPE_PRECISION (char8_type_node
)
1407 / TYPE_PRECISION (char_type_node
),
1408 ""); /* char8_t is 8 bits */
1411 value
= build_string (1, "");
1414 value
= build_string (TYPE_PRECISION (char16_type_node
)
1415 / TYPE_PRECISION (char_type_node
),
1416 "\0"); /* char16_t is 16 bits */
1419 value
= build_string (TYPE_PRECISION (char32_type_node
)
1420 / TYPE_PRECISION (char_type_node
),
1421 "\0\0\0"); /* char32_t is 32 bits */
1424 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1425 / TYPE_PRECISION (char_type_node
),
1426 "\0\0\0"); /* widest supported wchar_t
1436 TREE_TYPE (value
) = char_array_type_node
;
1438 case CPP_UTF8STRING
:
1440 TREE_TYPE (value
) = char8_array_type_node
;
1442 TREE_TYPE (value
) = char_array_type_node
;
1445 TREE_TYPE (value
) = char16_array_type_node
;
1448 TREE_TYPE (value
) = char32_array_type_node
;
1451 TREE_TYPE (value
) = wchar_array_type_node
;
1453 *valp
= fix_string_type (value
);
1457 obstack_free (&str_ob
, 0);
1458 obstack_free (&loc_ob
, 0);
1461 return objc_string
? CPP_OBJC_STRING
: type
;
1464 /* Converts a (possibly wide) character constant token into a tree. */
1466 lex_charconst (const cpp_token
*token
)
1470 unsigned int chars_seen
;
1473 result
= cpp_interpret_charconst (parse_in
, token
,
1474 &chars_seen
, &unsignedp
);
1476 if (token
->type
== CPP_WCHAR
)
1477 type
= wchar_type_node
;
1478 else if (token
->type
== CPP_CHAR32
)
1479 type
= char32_type_node
;
1480 else if (token
->type
== CPP_CHAR16
)
1481 type
= char16_type_node
;
1482 else if (token
->type
== CPP_UTF8CHAR
)
1485 type
= char8_type_node
;
1487 type
= char_type_node
;
1489 /* In C, a character constant has type 'int'.
1490 In C++ 'char', but multi-char charconsts have type 'int'. */
1491 else if (!c_dialect_cxx () || chars_seen
> 1)
1492 type
= integer_type_node
;
1494 type
= char_type_node
;
1496 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1497 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1498 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1499 value
= build_int_cst (type
, result
);
1501 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1506 /* Helper function for c_parser_peek_conflict_marker
1507 and cp_lexer_peek_conflict_marker.
1508 Given a possible conflict marker token of kind TOK1_KIND
1509 consisting of a pair of characters, get the token kind for the
1510 standalone final character. */
1513 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1517 default: gcc_unreachable ();