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() */
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
* ARG_UNUSED (pfile
), location_t loc
,
280 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
281 (*debug_hooks
->undef
) (SOURCE_LINE (linemap_check_ordinary (map
), loc
),
282 (const char *) NODE_NAME (node
));
285 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
286 and not consume CPP_EOF. */
287 static const cpp_token
*
288 get_token_no_padding (cpp_reader
*pfile
)
292 const cpp_token
*ret
= cpp_peek_token (pfile
, 0);
293 if (ret
->type
== CPP_EOF
)
295 ret
= cpp_get_token (pfile
);
296 if (ret
->type
!= CPP_PADDING
)
301 /* Callback for has_attribute. */
303 c_common_has_attribute (cpp_reader
*pfile
)
306 tree attr_name
= NULL_TREE
;
307 const cpp_token
*token
;
309 token
= get_token_no_padding (pfile
);
310 if (token
->type
!= CPP_OPEN_PAREN
)
312 cpp_error (pfile
, CPP_DL_ERROR
,
313 "missing '(' after \"__has_attribute\"");
316 token
= get_token_no_padding (pfile
);
317 if (token
->type
== CPP_NAME
)
319 attr_name
= get_identifier ((const char *)
320 cpp_token_as_text (pfile
, token
));
321 attr_name
= canonicalize_attr_name (attr_name
);
322 if (c_dialect_cxx ())
325 const cpp_token
*nxt_token
;
327 nxt_token
= cpp_peek_token (pfile
, idx
++);
328 while (nxt_token
->type
== CPP_PADDING
);
329 if (nxt_token
->type
== CPP_SCOPE
)
331 get_token_no_padding (pfile
); // Eat scope.
332 nxt_token
= get_token_no_padding (pfile
);
333 if (nxt_token
->type
== CPP_NAME
)
335 tree attr_ns
= attr_name
;
337 = get_identifier ((const char *)
338 cpp_token_as_text (pfile
, nxt_token
));
339 attr_name
= build_tree_list (attr_ns
, attr_id
);
343 cpp_error (pfile
, CPP_DL_ERROR
,
344 "attribute identifier required after scope");
345 attr_name
= NULL_TREE
;
350 /* Some standard attributes need special handling. */
351 if (is_attribute_p ("noreturn", attr_name
))
353 else if (is_attribute_p ("deprecated", attr_name
))
355 else if (is_attribute_p ("maybe_unused", attr_name
)
356 || is_attribute_p ("fallthrough", attr_name
))
358 else if (is_attribute_p ("no_unique_address", attr_name
)
359 || is_attribute_p ("likely", attr_name
)
360 || is_attribute_p ("unlikely", attr_name
))
362 else if (is_attribute_p ("nodiscard", attr_name
))
365 attr_name
= NULL_TREE
;
371 const struct attribute_spec
*attr
= lookup_attribute_spec (attr_name
);
378 cpp_error (pfile
, CPP_DL_ERROR
,
379 "macro \"__has_attribute\" requires an identifier");
383 if (get_token_no_padding (pfile
)->type
!= CPP_CLOSE_PAREN
)
384 cpp_error (pfile
, CPP_DL_ERROR
,
385 "missing ')' after \"__has_attribute\"");
390 /* Callback for has_builtin. */
393 c_common_has_builtin (cpp_reader
*pfile
)
395 const cpp_token
*token
= get_token_no_padding (pfile
);
396 if (token
->type
!= CPP_OPEN_PAREN
)
398 cpp_error (pfile
, CPP_DL_ERROR
,
399 "missing '(' after \"__has_builtin\"");
403 const char *name
= "";
404 token
= get_token_no_padding (pfile
);
405 if (token
->type
== CPP_NAME
)
407 name
= (const char *) cpp_token_as_text (pfile
, token
);
408 token
= get_token_no_padding (pfile
);
409 if (token
->type
!= CPP_CLOSE_PAREN
)
411 cpp_error (pfile
, CPP_DL_ERROR
,
412 "expected ')' after \"%s\"", name
);
418 cpp_error (pfile
, CPP_DL_ERROR
,
419 "macro \"__has_builtin\" requires an identifier");
420 if (token
->type
== CPP_CLOSE_PAREN
)
424 /* Consume tokens up to the closing parenthesis, including any nested
425 pairs of parentheses, to avoid confusing redundant errors. */
426 for (unsigned nparen
= 1; ; token
= get_token_no_padding (pfile
))
428 if (token
->type
== CPP_OPEN_PAREN
)
430 else if (token
->type
== CPP_CLOSE_PAREN
)
432 else if (token
->type
== CPP_EOF
)
438 return names_builtin_p (name
);
442 /* Read a token and return its type. Fill *VALUE with its value, if
443 applicable. Fill *CPP_FLAGS with the token's flags, if it is
447 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
450 const cpp_token
*tok
;
452 unsigned char add_flags
= 0;
453 enum overflow_type overflow
= OT_NONE
;
455 timevar_push (TV_CPP
);
457 tok
= cpp_get_token_with_location (parse_in
, loc
);
467 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
472 const char *suffix
= NULL
;
473 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
475 switch (flags
& CPP_N_CATEGORY
)
478 /* cpplib has issued an error. */
479 *value
= error_mark_node
;
483 /* C++ uses '0' to mark virtual functions as pure.
484 Set PURE_ZERO to pass this information to the C++ parser. */
485 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
486 add_flags
= PURE_ZERO
;
487 *value
= interpret_integer (tok
, flags
, &overflow
);
491 *value
= interpret_float (tok
, flags
, suffix
, &overflow
);
498 if (flags
& CPP_N_USERDEF
)
502 tree suffix_id
= get_identifier (suffix
);
503 int len
= tok
->val
.str
.len
- strlen (suffix
);
504 /* If this is going to be used as a C string to pass to a
505 raw literal operator, we need to add a trailing NUL. */
506 tree num_string
= build_string (len
+ 1,
507 (const char *) tok
->val
.str
.text
);
508 TREE_TYPE (num_string
) = char_array_type_node
;
509 num_string
= fix_string_type (num_string
);
510 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
512 literal
= build_userdef_literal (suffix_id
, *value
, overflow
,
520 /* An @ may give the next token special significance in Objective-C. */
521 if (c_dialect_objc ())
523 location_t atloc
= *loc
;
527 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
539 type
= lex_string (tok
, value
, true, true);
543 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
544 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
545 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
548 /* Note the complication: if we found an OBJC_CXX
549 keyword, for example, 'class', we will be
550 returning a token of type CPP_AT_NAME and rid
551 code RID_CLASS (not RID_AT_CLASS). The language
552 parser needs to convert that to RID_AT_CLASS.
560 error_at (atloc
, "stray %<@%> in program");
571 unsigned char name
[8];
573 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
575 error_at (*loc
, "stray %qs in program", name
);
582 cppchar_t c
= tok
->val
.str
.text
[0];
584 if (c
== '"' || c
== '\'')
585 error_at (*loc
, "missing terminating %c character", (int) c
);
586 else if (ISGRAPH (c
))
587 error_at (*loc
, "stray %qc in program", (int) c
);
589 error_at (*loc
, "stray %<\\%o%> in program", (int) c
);
593 case CPP_CHAR_USERDEF
:
594 case CPP_WCHAR_USERDEF
:
595 case CPP_CHAR16_USERDEF
:
596 case CPP_CHAR32_USERDEF
:
597 case CPP_UTF8CHAR_USERDEF
:
600 cpp_token temp_tok
= *tok
;
601 const char *suffix
= cpp_get_userdef_suffix (tok
);
602 temp_tok
.val
.str
.len
-= strlen (suffix
);
603 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
604 literal
= build_userdef_literal (get_identifier (suffix
),
605 lex_charconst (&temp_tok
),
616 *value
= lex_charconst (tok
);
619 case CPP_STRING_USERDEF
:
620 case CPP_WSTRING_USERDEF
:
621 case CPP_STRING16_USERDEF
:
622 case CPP_STRING32_USERDEF
:
623 case CPP_UTF8STRING_USERDEF
:
625 tree literal
, string
;
626 const char *suffix
= cpp_get_userdef_suffix (tok
);
627 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
628 (const char *) tok
->val
.str
.text
);
629 literal
= build_userdef_literal (get_identifier (suffix
),
630 string
, OT_NONE
, NULL_TREE
);
640 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
642 type
= lex_string (tok
, value
, false,
643 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
646 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
650 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
653 /* These tokens should not be visible outside cpplib. */
654 case CPP_HEADER_NAME
:
658 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
659 when it is a FALLTHROUGH comment, in that case set
660 PREV_FALLTHROUGH flag on the next non-comment token. */
662 if (tok
->flags
& PREV_FALLTHROUGH
)
666 tok
= cpp_get_token_with_location (parse_in
, loc
);
669 while (type
== CPP_PADDING
|| type
== CPP_COMMENT
);
670 add_flags
|= PREV_FALLTHROUGH
;
681 *cpp_flags
= tok
->flags
| add_flags
;
683 timevar_pop (TV_CPP
);
688 /* Returns the narrowest C-visible unsigned type, starting with the
689 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
692 static enum integer_type_kind
693 narrowest_unsigned_type (const widest_int
&val
, unsigned int flags
)
697 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
698 itk
= itk_unsigned_int
;
699 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
700 itk
= itk_unsigned_long
;
702 itk
= itk_unsigned_long_long
;
704 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
708 if (integer_types
[itk
] == NULL_TREE
)
710 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
712 if (wi::geu_p (wi::to_widest (upper
), val
))
713 return (enum integer_type_kind
) itk
;
719 /* Ditto, but narrowest signed type. */
720 static enum integer_type_kind
721 narrowest_signed_type (const widest_int
&val
, unsigned int flags
)
725 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
727 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
732 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
736 if (integer_types
[itk
] == NULL_TREE
)
738 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
740 if (wi::geu_p (wi::to_widest (upper
), val
))
741 return (enum integer_type_kind
) itk
;
747 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
749 interpret_integer (const cpp_token
*token
, unsigned int flags
,
750 enum overflow_type
*overflow
)
753 enum integer_type_kind itk
;
755 HOST_WIDE_INT ival
[3];
759 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
760 if (integer
.overflow
)
761 *overflow
= OT_OVERFLOW
;
763 ival
[0] = integer
.low
;
764 ival
[1] = integer
.high
;
766 widest_int wval
= widest_int::from_array (ival
, 3);
768 /* The type of a constant with a U suffix is straightforward. */
769 if (flags
& CPP_N_UNSIGNED
)
770 itk
= narrowest_unsigned_type (wval
, flags
);
773 /* The type of a potentially-signed integer constant varies
774 depending on the base it's in, the standard in use, and the
776 enum integer_type_kind itk_u
777 = narrowest_unsigned_type (wval
, flags
);
778 enum integer_type_kind itk_s
779 = narrowest_signed_type (wval
, flags
);
781 /* In both C89 and C99, octal and hex constants may be signed or
782 unsigned, whichever fits tighter. We do not warn about this
783 choice differing from the traditional choice, as the constant
784 is probably a bit pattern and either way will work. */
785 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
786 itk
= MIN (itk_u
, itk_s
);
789 /* In C99, decimal constants are always signed.
790 In C89, decimal constants that don't fit in long have
791 undefined behavior; we try to make them unsigned long.
792 In GCC's extended C89, that last is true of decimal
793 constants that don't fit in long long, too. */
796 if (itk_s
> itk_u
&& itk_s
> itk_long
)
800 if (itk_u
< itk_unsigned_long
)
801 itk_u
= itk_unsigned_long
;
803 warning (0, "this decimal constant is unsigned only in ISO C90");
806 warning (OPT_Wtraditional
,
807 "this decimal constant would be unsigned in ISO C90");
813 /* cpplib has already issued a warning for overflow. */
814 type
= ((flags
& CPP_N_UNSIGNED
)
815 ? widest_unsigned_literal_type_node
816 : widest_integer_literal_type_node
);
819 type
= integer_types
[itk
];
820 if (itk
> itk_unsigned_long
821 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
823 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
824 ? DK_PEDWARN
: DK_WARNING
,
825 input_location
, OPT_Wlong_long
,
826 (flags
& CPP_N_UNSIGNED
)
827 ? "integer constant is too large for %<unsigned long%> type"
828 : "integer constant is too large for %<long%> type");
831 value
= wide_int_to_tree (type
, wval
);
833 /* Convert imaginary to a complex type. */
834 if (flags
& CPP_N_IMAGINARY
)
835 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
840 /* Interpret TOKEN, a floating point number with FLAGS as classified
841 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
843 interpret_float (const cpp_token
*token
, unsigned int flags
,
844 const char *suffix
, enum overflow_type
*overflow
)
849 REAL_VALUE_TYPE real
;
850 REAL_VALUE_TYPE real_trunc
;
856 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
857 pragma has been used and is either double or _Decimal64. Types
858 that are not allowed with decimal float default to double. */
859 if (flags
& CPP_N_DEFAULT
)
861 flags
^= CPP_N_DEFAULT
;
862 flags
|= CPP_N_MEDIUM
;
864 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
866 warning (OPT_Wunsuffixed_float_constants
,
867 "unsuffixed floating constant");
868 if (float_const_decimal64_p ())
869 flags
|= CPP_N_DFLOAT
;
873 /* Decode _Fract and _Accum. */
874 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
875 return interpret_fixed (token
, flags
);
877 /* Decode type based on width and properties. */
878 if (flags
& CPP_N_DFLOAT
)
879 if (!targetm
.decimal_float_supported_p ())
881 error ("decimal floating-point not supported for this target");
882 return error_mark_node
;
884 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
885 type
= dfloat128_type_node
;
886 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
887 type
= dfloat32_type_node
;
889 type
= dfloat64_type_node
;
891 if (flags
& CPP_N_WIDTH_MD
)
896 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
901 mode
= targetm
.c
.mode_for_suffix (suffix
);
902 if (mode
== VOIDmode
)
904 error ("unsupported non-standard suffix on floating constant");
906 return error_mark_node
;
909 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
911 type
= c_common_type_for_mode (mode
, 0);
914 else if ((flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
)) != 0)
916 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
917 bool extended
= (flags
& CPP_N_FLOATNX
) != 0;
919 for (int i
= 0; i
< NUM_FLOATN_NX_TYPES
; i
++)
920 if (floatn_nx_types
[i
].n
== (int) n
921 && floatn_nx_types
[i
].extended
== extended
)
923 type
= FLOATN_NX_TYPE_NODE (i
);
926 if (type
== NULL_TREE
)
928 error ("unsupported non-standard suffix on floating constant");
929 return error_mark_node
;
932 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
934 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
935 type
= long_double_type_node
;
936 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
937 || flag_single_precision_constant
)
938 type
= float_type_node
;
940 type
= double_type_node
;
942 const_type
= excess_precision_type (type
);
946 /* Copy the constant to a nul-terminated buffer. If the constant
947 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
948 can't handle them. */
949 copylen
= token
->val
.str
.len
;
950 if (flags
& CPP_N_USERDEF
)
951 copylen
-= strlen (suffix
);
952 else if (flags
& CPP_N_DFLOAT
)
956 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
957 /* Must be an F or L or machine defined suffix. */
959 if (flags
& CPP_N_IMAGINARY
)
962 if (flags
& CPP_N_FLOATNX
)
964 if (flags
& (CPP_N_FLOATN
| CPP_N_FLOATNX
))
966 unsigned int n
= (flags
& CPP_N_WIDTH_FLOATN_NX
) >> CPP_FLOATN_SHIFT
;
975 copy
= (char *) alloca (copylen
+ 1);
976 if (cxx_dialect
> cxx11
)
979 for (size_t i
= 0; i
< copylen
; ++i
)
980 if (token
->val
.str
.text
[i
] != '\'')
981 copy
[maxlen
++] = token
->val
.str
.text
[i
];
986 memcpy (copy
, token
->val
.str
.text
, copylen
);
987 copy
[copylen
] = '\0';
990 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
991 if (const_type
!= type
)
992 /* Diagnosing if the result of converting the value with excess
993 precision to the semantic type would overflow (with associated
994 double rounding) is more appropriate than diagnosing if the
995 result of converting the string directly to the semantic type
997 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
999 /* Both C and C++ require a diagnostic for a floating constant
1000 outside the range of representable values of its type. Since we
1001 have __builtin_inf* to produce an infinity, this is now a
1002 mandatory pedwarn if the target does not support infinities. */
1003 if (REAL_VALUE_ISINF (real
)
1004 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
1006 *overflow
= OT_OVERFLOW
;
1007 if (!(flags
& CPP_N_USERDEF
))
1009 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
1010 pedwarn (input_location
, 0,
1011 "floating constant exceeds range of %qT", type
);
1013 warning (OPT_Woverflow
,
1014 "floating constant exceeds range of %qT", type
);
1017 /* We also give a warning if the value underflows. */
1018 else if (real_equal (&real
, &dconst0
)
1019 || (const_type
!= type
1020 && real_equal (&real_trunc
, &dconst0
)))
1022 REAL_VALUE_TYPE realvoidmode
;
1023 int oflow
= real_from_string (&realvoidmode
, copy
);
1024 *overflow
= (oflow
== 0 ? OT_NONE
1025 : (oflow
< 0 ? OT_UNDERFLOW
: OT_OVERFLOW
));
1026 if (!(flags
& CPP_N_USERDEF
))
1028 if (oflow
< 0 || !real_equal (&realvoidmode
, &dconst0
))
1029 warning (OPT_Woverflow
, "floating constant truncated to zero");
1033 /* Create a node with determined type and value. */
1034 value
= build_real (const_type
, real
);
1035 if (flags
& CPP_N_IMAGINARY
)
1037 value
= build_complex (NULL_TREE
,
1038 fold_convert (const_type
,
1039 integer_zero_node
), value
);
1040 if (type
!= const_type
)
1042 const_type
= TREE_TYPE (value
);
1043 type
= build_complex_type (type
);
1047 if (type
!= const_type
)
1048 value
= build1_loc (token
->src_loc
, EXCESS_PRECISION_EXPR
, type
, value
);
1053 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1057 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
1061 FIXED_VALUE_TYPE fixed
;
1065 copylen
= token
->val
.str
.len
;
1067 if (flags
& CPP_N_FRACT
) /* _Fract. */
1069 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
1071 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1073 type
= unsigned_long_long_fract_type_node
;
1076 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1078 type
= unsigned_long_fract_type_node
;
1081 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1083 type
= unsigned_short_fract_type_node
;
1088 type
= unsigned_fract_type_node
;
1092 else /* Signed _Fract. */
1094 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1096 type
= long_long_fract_type_node
;
1099 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1101 type
= long_fract_type_node
;
1104 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1106 type
= short_fract_type_node
;
1111 type
= fract_type_node
;
1118 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
1120 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1122 type
= unsigned_long_long_accum_type_node
;
1125 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1127 type
= unsigned_long_accum_type_node
;
1130 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1132 type
= unsigned_short_accum_type_node
;
1137 type
= unsigned_accum_type_node
;
1141 else /* Signed _Accum. */
1143 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
1145 type
= long_long_accum_type_node
;
1148 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
1150 type
= long_accum_type_node
;
1153 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
1155 type
= short_accum_type_node
;
1160 type
= accum_type_node
;
1166 copy
= (char *) alloca (copylen
+ 1);
1167 memcpy (copy
, token
->val
.str
.text
, copylen
);
1168 copy
[copylen
] = '\0';
1170 fixed_from_string (&fixed
, copy
, SCALAR_TYPE_MODE (type
));
1172 /* Create a node with determined type and value. */
1173 value
= build_fixed (type
, fixed
);
1178 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1179 UTF8STRING tokens into a tree, performing string constant
1180 concatenation. TOK is the first of these. VALP is the location to
1181 write the string into. OBJC_STRING indicates whether an '@' token
1182 preceded the incoming token (in that case, the strings can either
1183 be ObjC strings, preceded by a single '@', or normal strings, not
1184 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1185 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1186 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1188 This is unfortunately more work than it should be. If any of the
1189 strings in the series has an L prefix, the result is a wide string
1190 (6.4.5p4). Whether or not the result is a wide string affects the
1191 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1192 sequences do not continue across the boundary between two strings in
1193 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1194 cpp_interpret_string takes a vector of cpp_string structures, which
1195 we must arrange to provide. */
1197 static enum cpp_ttype
1198 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
1202 struct obstack str_ob
;
1203 struct obstack loc_ob
;
1205 enum cpp_ttype type
= tok
->type
;
1207 /* Try to avoid the overhead of creating and destroying an obstack
1208 for the common case of just one string. */
1209 cpp_string str
= tok
->val
.str
;
1210 location_t init_loc
= tok
->src_loc
;
1211 cpp_string
*strs
= &str
;
1212 location_t
*locs
= NULL
;
1214 /* objc_at_sign_was_seen is only used when doing Objective-C string
1215 concatenation. It is 'true' if we have seen an '@' before the
1216 current string, and 'false' if not. We must see exactly one or
1217 zero '@' before each string. */
1218 bool objc_at_sign_was_seen
= false;
1221 tok
= cpp_get_token (parse_in
);
1229 if (objc_at_sign_was_seen
)
1230 error ("repeated %<@%> before Objective-C string");
1232 objc_at_sign_was_seen
= true;
1243 case CPP_UTF8STRING
:
1244 if (type
!= tok
->type
)
1246 if (type
== CPP_STRING
)
1249 error ("unsupported non-standard concatenation of string literals");
1256 gcc_obstack_init (&str_ob
);
1257 gcc_obstack_init (&loc_ob
);
1258 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1259 obstack_grow (&loc_ob
, &init_loc
, sizeof (location_t
));
1263 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1264 obstack_grow (&loc_ob
, &tok
->src_loc
, sizeof (location_t
));
1267 objc_at_sign_was_seen
= false;
1271 /* It is an error if we saw a '@' with no following string. */
1272 if (objc_at_sign_was_seen
)
1273 error ("stray %<@%> in program");
1275 /* We have read one more token than we want. */
1276 _cpp_backup_tokens (parse_in
, 1);
1279 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1280 locs
= XOBFINISH (&loc_ob
, location_t
*);
1283 if (concats
&& !objc_string
&& !in_system_header_at (input_location
))
1284 warning (OPT_Wtraditional
,
1285 "traditional C rejects string constant concatenation");
1288 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1289 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1291 value
= build_string (istr
.len
, (const char *) istr
.text
);
1292 free (CONST_CAST (unsigned char *, istr
.text
));
1296 gcc_assert (g_string_concat_db
);
1297 g_string_concat_db
->record_string_concatenation (concats
+ 1, locs
);
1302 /* Callers cannot generally handle error_mark_node in this context,
1303 so return the empty string instead. cpp_interpret_string has
1309 case CPP_UTF8STRING
:
1310 value
= build_string (1, "");
1313 value
= build_string (TYPE_PRECISION (char16_type_node
)
1314 / TYPE_PRECISION (char_type_node
),
1315 "\0"); /* char16_t is 16 bits */
1318 value
= build_string (TYPE_PRECISION (char32_type_node
)
1319 / TYPE_PRECISION (char_type_node
),
1320 "\0\0\0"); /* char32_t is 32 bits */
1323 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1324 / TYPE_PRECISION (char_type_node
),
1325 "\0\0\0"); /* widest supported wchar_t
1335 TREE_TYPE (value
) = char_array_type_node
;
1337 case CPP_UTF8STRING
:
1339 TREE_TYPE (value
) = char8_array_type_node
;
1341 TREE_TYPE (value
) = char_array_type_node
;
1344 TREE_TYPE (value
) = char16_array_type_node
;
1347 TREE_TYPE (value
) = char32_array_type_node
;
1350 TREE_TYPE (value
) = wchar_array_type_node
;
1352 *valp
= fix_string_type (value
);
1356 obstack_free (&str_ob
, 0);
1357 obstack_free (&loc_ob
, 0);
1360 return objc_string
? CPP_OBJC_STRING
: type
;
1363 /* Converts a (possibly wide) character constant token into a tree. */
1365 lex_charconst (const cpp_token
*token
)
1369 unsigned int chars_seen
;
1372 result
= cpp_interpret_charconst (parse_in
, token
,
1373 &chars_seen
, &unsignedp
);
1375 if (token
->type
== CPP_WCHAR
)
1376 type
= wchar_type_node
;
1377 else if (token
->type
== CPP_CHAR32
)
1378 type
= char32_type_node
;
1379 else if (token
->type
== CPP_CHAR16
)
1380 type
= char16_type_node
;
1381 else if (token
->type
== CPP_UTF8CHAR
)
1383 if (!c_dialect_cxx ())
1384 type
= unsigned_char_type_node
;
1385 else if (flag_char8_t
)
1386 type
= char8_type_node
;
1388 type
= char_type_node
;
1390 /* In C, a character constant has type 'int'.
1391 In C++ 'char', but multi-char charconsts have type 'int'. */
1392 else if (!c_dialect_cxx () || chars_seen
> 1)
1393 type
= integer_type_node
;
1395 type
= char_type_node
;
1397 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1398 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1399 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1400 value
= build_int_cst (type
, result
);
1402 value
= build_int_cst (type
, (cppchar_signed_t
) result
);
1407 /* Helper function for c_parser_peek_conflict_marker
1408 and cp_lexer_peek_conflict_marker.
1409 Given a possible conflict marker token of kind TOK1_KIND
1410 consisting of a pair of characters, get the token kind for the
1411 standalone final character. */
1414 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind
)
1418 default: gcc_unreachable ();