1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26
27 #include "tree.h"
28 #include "input.h"
29 #include "output.h"
30 #include "c-common.h"
31 #include "flags.h"
32 #include "timevar.h"
33 #include "cpplib.h"
34 #include "c-pragma.h"
35 #include "intl.h"
36 #include "splay-tree.h"
37 #include "debug.h"
38 #include "target.h"
39
40 /* We may keep statistics about how long which files took to compile. */
41 static int header_time, body_time;
42 static splay_tree file_info_tree;
43
44 int pending_lang_change; /* If we need to switch languages - C++ only */
45 int c_header_level; /* depth in C headers - C++ only */
46
47 static tree interpret_integer (const cpp_token *, unsigned int);
48 static tree interpret_float (const cpp_token *, unsigned int, const char *);
49 static tree interpret_fixed (const cpp_token *, unsigned int);
50 static enum integer_type_kind narrowest_unsigned_type
51 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
52 static enum integer_type_kind narrowest_signed_type
53 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
54 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
55 static tree lex_charconst (const cpp_token *);
56 static void update_header_times (const char *);
57 static int dump_one_header (splay_tree_node, void *);
58 static void cb_line_change (cpp_reader *, const cpp_token *, int);
59 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
60 static void cb_def_pragma (cpp_reader *, unsigned int);
61 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
62 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
63
64 void
init_c_lex(void)65 init_c_lex (void)
66 {
67 struct cpp_callbacks *cb;
68 struct c_fileinfo *toplevel;
69
70 /* The get_fileinfo data structure must be initialized before
71 cpp_read_main_file is called. */
72 toplevel = get_fileinfo ("<top level>");
73 if (flag_detailed_statistics)
74 {
75 header_time = 0;
76 body_time = get_run_time ();
77 toplevel->time = body_time;
78 }
79
80 cb = cpp_get_callbacks (parse_in);
81
82 cb->line_change = cb_line_change;
83 cb->ident = cb_ident;
84 cb->def_pragma = cb_def_pragma;
85 cb->valid_pch = c_common_valid_pch;
86 cb->read_pch = c_common_read_pch;
87
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)
93 {
94 cb->define = cb_define;
95 cb->undef = cb_undef;
96 }
97 }
98
99 struct c_fileinfo *
get_fileinfo(const char * name)100 get_fileinfo (const char *name)
101 {
102 splay_tree_node n;
103 struct c_fileinfo *fi;
104
105 if (!file_info_tree)
106 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
107 0,
108 (splay_tree_delete_value_fn) free);
109
110 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
111 if (n)
112 return (struct c_fileinfo *) n->value;
113
114 fi = XNEW (struct c_fileinfo);
115 fi->time = 0;
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);
120 return fi;
121 }
122
123 static void
update_header_times(const char * name)124 update_header_times (const char *name)
125 {
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)
129 {
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;
135 }
136 }
137
138 static int
dump_one_header(splay_tree_node n,void * ARG_UNUSED (dummy))139 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
140 {
141 print_time ((const char *) n->key,
142 ((struct c_fileinfo *) n->value)->time);
143 return 0;
144 }
145
146 void
dump_time_statistics(void)147 dump_time_statistics (void)
148 {
149 struct c_fileinfo *file = get_fileinfo (input_filename);
150 int this_time = get_run_time ();
151 file->time += this_time - body_time;
152
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");
159
160 splay_tree_foreach (file_info_tree, dump_one_header, 0);
161 }
162
163 static void
cb_ident(cpp_reader * ARG_UNUSED (pfile),unsigned int ARG_UNUSED (line),const cpp_string * ARG_UNUSED (str))164 cb_ident (cpp_reader * ARG_UNUSED (pfile),
165 unsigned int ARG_UNUSED (line),
166 const cpp_string * ARG_UNUSED (str))
167 {
168 #ifdef ASM_OUTPUT_IDENT
169 if (!flag_no_ident)
170 {
171 /* Convert escapes in the string. */
172 cpp_string cstr = { 0, 0 };
173 if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
174 {
175 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
176 free (CONST_CAST (unsigned char *, cstr.text));
177 }
178 }
179 #endif
180 }
181
182 /* Called at the start of every non-empty line. TOKEN is the first
183 lexed token on the line. Used for diagnostic line numbers. */
184 static void
cb_line_change(cpp_reader * ARG_UNUSED (pfile),const cpp_token * token,int parsing_args)185 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
186 int parsing_args)
187 {
188 if (token->type != CPP_EOF && !parsing_args)
189 input_location = token->src_loc;
190 }
191
192 void
fe_file_change(const struct line_map * new_map)193 fe_file_change (const struct line_map *new_map)
194 {
195 if (new_map == NULL)
196 return;
197
198 if (new_map->reason == LC_ENTER)
199 {
200 /* Don't stack the main buffer on the input stack;
201 we already did in compile_file. */
202 if (!MAIN_FILE_P (new_map))
203 {
204 unsigned int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
205 int line = 0;
206 if (included_at > BUILTINS_LOCATION)
207 line = SOURCE_LINE (new_map - 1, included_at);
208
209 input_location = new_map->start_location;
210 (*debug_hooks->start_source_file) (line, LINEMAP_FILE (new_map));
211 #ifndef NO_IMPLICIT_EXTERN_C
212 if (c_header_level)
213 ++c_header_level;
214 else if (LINEMAP_SYSP (new_map) == 2)
215 {
216 c_header_level = 1;
217 ++pending_lang_change;
218 }
219 #endif
220 }
221 }
222 else if (new_map->reason == LC_LEAVE)
223 {
224 #ifndef NO_IMPLICIT_EXTERN_C
225 if (c_header_level && --c_header_level == 0)
226 {
227 if (LINEMAP_SYSP (new_map) == 2)
228 warning (0, "badly nested C headers from preprocessor");
229 --pending_lang_change;
230 }
231 #endif
232 input_location = new_map->start_location;
233
234 (*debug_hooks->end_source_file) (LINEMAP_LINE (new_map));
235 }
236
237 update_header_times (LINEMAP_FILE (new_map));
238 input_location = new_map->start_location;
239 }
240
241 static void
cb_def_pragma(cpp_reader * pfile,source_location loc)242 cb_def_pragma (cpp_reader *pfile, source_location loc)
243 {
244 /* Issue a warning message if we have been asked to do so. Ignore
245 unknown pragmas in system headers unless an explicit
246 -Wunknown-pragmas has been given. */
247 if (warn_unknown_pragmas > in_system_header)
248 {
249 const unsigned char *space, *name;
250 const cpp_token *s;
251 location_t fe_loc = loc;
252
253 space = name = (const unsigned char *) "";
254 s = cpp_get_token (pfile);
255 if (s->type != CPP_EOF)
256 {
257 space = cpp_token_as_text (pfile, s);
258 s = cpp_get_token (pfile);
259 if (s->type == CPP_NAME)
260 name = cpp_token_as_text (pfile, s);
261 }
262
263 warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring #pragma %s %s",
264 space, name);
265 }
266 }
267
268 /* #define callback for DWARF and DWARF2 debug info. */
269 static void
cb_define(cpp_reader * pfile,source_location loc,cpp_hashnode * node)270 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
271 {
272 const struct line_map *map = linemap_lookup (line_table, loc);
273 (*debug_hooks->define) (SOURCE_LINE (map, loc),
274 (const char *) cpp_macro_definition (pfile, node));
275 }
276
277 /* #undef callback for DWARF and DWARF2 debug info. */
278 static void
cb_undef(cpp_reader * ARG_UNUSED (pfile),source_location loc,cpp_hashnode * node)279 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
280 cpp_hashnode *node)
281 {
282 const struct line_map *map = linemap_lookup (line_table, loc);
283 (*debug_hooks->undef) (SOURCE_LINE (map, loc),
284 (const char *) NODE_NAME (node));
285 }
286
287 /* Read a token and return its type. Fill *VALUE with its value, if
288 applicable. Fill *CPP_FLAGS with the token's flags, if it is
289 non-NULL. */
290
291 enum cpp_ttype
c_lex_with_flags(tree * value,location_t * loc,unsigned char * cpp_flags,int lex_flags)292 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
293 int lex_flags)
294 {
295 static bool no_more_pch;
296 const cpp_token *tok;
297 enum cpp_ttype type;
298 unsigned char add_flags = 0;
299
300 timevar_push (TV_CPP);
301 retry:
302 tok = cpp_get_token_with_location (parse_in, loc);
303 type = tok->type;
304
305 retry_after_at:
306 switch (type)
307 {
308 case CPP_PADDING:
309 goto retry;
310
311 case CPP_NAME:
312 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
313 break;
314
315 case CPP_NUMBER:
316 {
317 const char *suffix = NULL;
318 unsigned int flags = cpp_classify_number (parse_in, tok, &suffix);
319
320 switch (flags & CPP_N_CATEGORY)
321 {
322 case CPP_N_INVALID:
323 /* cpplib has issued an error. */
324 *value = error_mark_node;
325 break;
326
327 case CPP_N_INTEGER:
328 /* C++ uses '0' to mark virtual functions as pure.
329 Set PURE_ZERO to pass this information to the C++ parser. */
330 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
331 add_flags = PURE_ZERO;
332 *value = interpret_integer (tok, flags);
333 break;
334
335 case CPP_N_FLOATING:
336 *value = interpret_float (tok, flags, suffix);
337 break;
338
339 default:
340 gcc_unreachable ();
341 }
342
343 if (flags & CPP_N_USERDEF)
344 {
345 char *str;
346 tree literal;
347 tree suffix_id = get_identifier (suffix);
348 int len = tok->val.str.len - strlen (suffix);
349 /* If this is going to be used as a C string to pass to a
350 raw literal operator, we need to add a trailing NUL. */
351 tree num_string = build_string (len + 1,
352 (const char *) tok->val.str.text);
353 TREE_TYPE (num_string) = char_array_type_node;
354 num_string = fix_string_type (num_string);
355 str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
356 str[len] = '\0';
357 literal = build_userdef_literal (suffix_id, *value,
358 num_string);
359 *value = literal;
360 }
361 }
362 break;
363
364 case CPP_ATSIGN:
365 /* An @ may give the next token special significance in Objective-C. */
366 if (c_dialect_objc ())
367 {
368 location_t atloc = *loc;
369 location_t newloc;
370
371 retry_at:
372 tok = cpp_get_token_with_location (parse_in, &newloc);
373 type = tok->type;
374 switch (type)
375 {
376 case CPP_PADDING:
377 goto retry_at;
378
379 case CPP_STRING:
380 case CPP_WSTRING:
381 case CPP_STRING16:
382 case CPP_STRING32:
383 case CPP_UTF8STRING:
384 type = lex_string (tok, value, true, true);
385 break;
386
387 case CPP_NAME:
388 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
389 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
390 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
391 {
392 type = CPP_AT_NAME;
393 /* Note the complication: if we found an OBJC_CXX
394 keyword, for example, 'class', we will be
395 returning a token of type CPP_AT_NAME and rid
396 code RID_CLASS (not RID_AT_CLASS). The language
397 parser needs to convert that to RID_AT_CLASS.
398 */
399 break;
400 }
401 /* FALLTHROUGH */
402
403 default:
404 /* ... or not. */
405 error_at (atloc, "stray %<@%> in program");
406 *loc = newloc;
407 goto retry_after_at;
408 }
409 break;
410 }
411
412 /* FALLTHROUGH */
413 case CPP_HASH:
414 case CPP_PASTE:
415 {
416 unsigned char name[8];
417
418 *cpp_spell_token (parse_in, tok, name, true) = 0;
419
420 error ("stray %qs in program", name);
421 }
422
423 goto retry;
424
425 case CPP_OTHER:
426 {
427 cppchar_t c = tok->val.str.text[0];
428
429 if (c == '"' || c == '\'')
430 error ("missing terminating %c character", (int) c);
431 else if (ISGRAPH (c))
432 error ("stray %qc in program", (int) c);
433 else
434 error ("stray %<\\%o%> in program", (int) c);
435 }
436 goto retry;
437
438 case CPP_CHAR_USERDEF:
439 case CPP_WCHAR_USERDEF:
440 case CPP_CHAR16_USERDEF:
441 case CPP_CHAR32_USERDEF:
442 {
443 tree literal;
444 cpp_token temp_tok = *tok;
445 const char *suffix = cpp_get_userdef_suffix (tok);
446 temp_tok.val.str.len -= strlen (suffix);
447 temp_tok.type = cpp_userdef_char_remove_type (type);
448 literal = build_userdef_literal (get_identifier (suffix),
449 lex_charconst (&temp_tok), NULL_TREE);
450 *value = literal;
451 }
452 break;
453
454 case CPP_CHAR:
455 case CPP_WCHAR:
456 case CPP_CHAR16:
457 case CPP_CHAR32:
458 *value = lex_charconst (tok);
459 break;
460
461 case CPP_STRING_USERDEF:
462 case CPP_WSTRING_USERDEF:
463 case CPP_STRING16_USERDEF:
464 case CPP_STRING32_USERDEF:
465 case CPP_UTF8STRING_USERDEF:
466 {
467 tree literal, string;
468 const char *suffix = cpp_get_userdef_suffix (tok);
469 string = build_string (tok->val.str.len - strlen (suffix),
470 (const char *) tok->val.str.text);
471 literal = build_userdef_literal (get_identifier (suffix),
472 string, NULL_TREE);
473 *value = literal;
474 }
475 break;
476
477 case CPP_STRING:
478 case CPP_WSTRING:
479 case CPP_STRING16:
480 case CPP_STRING32:
481 case CPP_UTF8STRING:
482 if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
483 {
484 type = lex_string (tok, value, false,
485 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
486 break;
487 }
488 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
489 break;
490
491 case CPP_PRAGMA:
492 *value = build_int_cst (integer_type_node, tok->val.pragma);
493 break;
494
495 /* These tokens should not be visible outside cpplib. */
496 case CPP_HEADER_NAME:
497 case CPP_MACRO_ARG:
498 gcc_unreachable ();
499
500 /* CPP_COMMENT will appear when compiling with -C and should be
501 ignored. */
502 case CPP_COMMENT:
503 goto retry;
504
505 default:
506 *value = NULL_TREE;
507 break;
508 }
509
510 if (cpp_flags)
511 *cpp_flags = tok->flags | add_flags;
512
513 if (!no_more_pch)
514 {
515 no_more_pch = true;
516 c_common_no_more_pch ();
517 }
518
519 timevar_pop (TV_CPP);
520
521 return type;
522 }
523
524 /* Returns the narrowest C-visible unsigned type, starting with the
525 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
526 there isn't one. */
527
528 static enum integer_type_kind
narrowest_unsigned_type(unsigned HOST_WIDE_INT low,unsigned HOST_WIDE_INT high,unsigned int flags)529 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
530 unsigned HOST_WIDE_INT high,
531 unsigned int flags)
532 {
533 int itk;
534
535 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
536 itk = itk_unsigned_int;
537 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
538 itk = itk_unsigned_long;
539 else
540 itk = itk_unsigned_long_long;
541
542 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
543 {
544 tree upper;
545
546 if (integer_types[itk] == NULL_TREE)
547 continue;
548 upper = TYPE_MAX_VALUE (integer_types[itk]);
549
550 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
551 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
552 && TREE_INT_CST_LOW (upper) >= low))
553 return (enum integer_type_kind) itk;
554 }
555
556 return itk_none;
557 }
558
559 /* Ditto, but narrowest signed type. */
560 static enum integer_type_kind
narrowest_signed_type(unsigned HOST_WIDE_INT low,unsigned HOST_WIDE_INT high,unsigned int flags)561 narrowest_signed_type (unsigned HOST_WIDE_INT low,
562 unsigned HOST_WIDE_INT high, unsigned int flags)
563 {
564 int itk;
565
566 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
567 itk = itk_int;
568 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
569 itk = itk_long;
570 else
571 itk = itk_long_long;
572
573
574 for (; itk < itk_none; itk += 2 /* skip signed types */)
575 {
576 tree upper;
577
578 if (integer_types[itk] == NULL_TREE)
579 continue;
580 upper = TYPE_MAX_VALUE (integer_types[itk]);
581
582 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
583 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
584 && TREE_INT_CST_LOW (upper) >= low))
585 return (enum integer_type_kind) itk;
586 }
587
588 return itk_none;
589 }
590
591 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
592 static tree
interpret_integer(const cpp_token * token,unsigned int flags)593 interpret_integer (const cpp_token *token, unsigned int flags)
594 {
595 tree value, type;
596 enum integer_type_kind itk;
597 cpp_num integer;
598 cpp_options *options = cpp_get_options (parse_in);
599
600 integer = cpp_interpret_integer (parse_in, token, flags);
601 integer = cpp_num_sign_extend (integer, options->precision);
602
603 /* The type of a constant with a U suffix is straightforward. */
604 if (flags & CPP_N_UNSIGNED)
605 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
606 else
607 {
608 /* The type of a potentially-signed integer constant varies
609 depending on the base it's in, the standard in use, and the
610 length suffixes. */
611 enum integer_type_kind itk_u
612 = narrowest_unsigned_type (integer.low, integer.high, flags);
613 enum integer_type_kind itk_s
614 = narrowest_signed_type (integer.low, integer.high, flags);
615
616 /* In both C89 and C99, octal and hex constants may be signed or
617 unsigned, whichever fits tighter. We do not warn about this
618 choice differing from the traditional choice, as the constant
619 is probably a bit pattern and either way will work. */
620 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
621 itk = MIN (itk_u, itk_s);
622 else
623 {
624 /* In C99, decimal constants are always signed.
625 In C89, decimal constants that don't fit in long have
626 undefined behavior; we try to make them unsigned long.
627 In GCC's extended C89, that last is true of decimal
628 constants that don't fit in long long, too. */
629
630 itk = itk_s;
631 if (itk_s > itk_u && itk_s > itk_long)
632 {
633 if (!flag_isoc99)
634 {
635 if (itk_u < itk_unsigned_long)
636 itk_u = itk_unsigned_long;
637 itk = itk_u;
638 warning (0, "this decimal constant is unsigned only in ISO C90");
639 }
640 else
641 warning (OPT_Wtraditional,
642 "this decimal constant would be unsigned in ISO C90");
643 }
644 }
645 }
646
647 if (itk == itk_none)
648 /* cpplib has already issued a warning for overflow. */
649 type = ((flags & CPP_N_UNSIGNED)
650 ? widest_unsigned_literal_type_node
651 : widest_integer_literal_type_node);
652 else
653 {
654 type = integer_types[itk];
655 if (itk > itk_unsigned_long
656 && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
657 emit_diagnostic
658 ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
659 ? DK_PEDWARN : DK_WARNING,
660 input_location, OPT_Wlong_long,
661 (flags & CPP_N_UNSIGNED)
662 ? "integer constant is too large for %<unsigned long%> type"
663 : "integer constant is too large for %<long%> type");
664 }
665
666 value = build_int_cst_wide (type, integer.low, integer.high);
667
668 /* Convert imaginary to a complex type. */
669 if (flags & CPP_N_IMAGINARY)
670 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
671
672 return value;
673 }
674
675 /* Interpret TOKEN, a floating point number with FLAGS as classified
676 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
677 static tree
interpret_float(const cpp_token * token,unsigned int flags,const char * suffix)678 interpret_float (const cpp_token *token, unsigned int flags,
679 const char *suffix)
680 {
681 tree type;
682 tree const_type;
683 tree value;
684 REAL_VALUE_TYPE real;
685 REAL_VALUE_TYPE real_trunc;
686 char *copy;
687 size_t copylen;
688
689 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
690 pragma has been used and is either double or _Decimal64. Types
691 that are not allowed with decimal float default to double. */
692 if (flags & CPP_N_DEFAULT)
693 {
694 flags ^= CPP_N_DEFAULT;
695 flags |= CPP_N_MEDIUM;
696
697 if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
698 {
699 warning (OPT_Wunsuffixed_float_constants,
700 "unsuffixed float constant");
701 if (float_const_decimal64_p ())
702 flags |= CPP_N_DFLOAT;
703 }
704 }
705
706 /* Decode _Fract and _Accum. */
707 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
708 return interpret_fixed (token, flags);
709
710 /* Decode type based on width and properties. */
711 if (flags & CPP_N_DFLOAT)
712 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
713 type = dfloat128_type_node;
714 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
715 type = dfloat32_type_node;
716 else
717 type = dfloat64_type_node;
718 else
719 if (flags & CPP_N_WIDTH_MD)
720 {
721 char suffix;
722 enum machine_mode mode;
723
724 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
725 suffix = 'w';
726 else
727 suffix = 'q';
728
729 mode = targetm.c.mode_for_suffix (suffix);
730 if (mode == VOIDmode)
731 {
732 error ("unsupported non-standard suffix on floating constant");
733
734 return error_mark_node;
735 }
736 else
737 pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
738
739 type = c_common_type_for_mode (mode, 0);
740 gcc_assert (type);
741 }
742 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
743 type = long_double_type_node;
744 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
745 || flag_single_precision_constant)
746 type = float_type_node;
747 else
748 type = double_type_node;
749
750 const_type = excess_precision_type (type);
751 if (!const_type)
752 const_type = type;
753
754 /* Copy the constant to a nul-terminated buffer. If the constant
755 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
756 can't handle them. */
757 copylen = token->val.str.len;
758 if (flags & CPP_N_USERDEF)
759 copylen -= strlen (suffix);
760 else if (flags & CPP_N_DFLOAT)
761 copylen -= 2;
762 else
763 {
764 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
765 /* Must be an F or L or machine defined suffix. */
766 copylen--;
767 if (flags & CPP_N_IMAGINARY)
768 /* I or J suffix. */
769 copylen--;
770 }
771
772 copy = (char *) alloca (copylen + 1);
773 memcpy (copy, token->val.str.text, copylen);
774 copy[copylen] = '\0';
775
776 real_from_string3 (&real, copy, TYPE_MODE (const_type));
777 if (const_type != type)
778 /* Diagnosing if the result of converting the value with excess
779 precision to the semantic type would overflow (with associated
780 double rounding) is more appropriate than diagnosing if the
781 result of converting the string directly to the semantic type
782 would overflow. */
783 real_convert (&real_trunc, TYPE_MODE (type), &real);
784
785 /* Both C and C++ require a diagnostic for a floating constant
786 outside the range of representable values of its type. Since we
787 have __builtin_inf* to produce an infinity, this is now a
788 mandatory pedwarn if the target does not support infinities. */
789 if (REAL_VALUE_ISINF (real)
790 || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
791 {
792 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
793 pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
794 else
795 warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
796 }
797 /* We also give a warning if the value underflows. */
798 else if (REAL_VALUES_EQUAL (real, dconst0)
799 || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
800 {
801 REAL_VALUE_TYPE realvoidmode;
802 int overflow = real_from_string (&realvoidmode, copy);
803 if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
804 warning (OPT_Woverflow, "floating constant truncated to zero");
805 }
806
807 /* Create a node with determined type and value. */
808 value = build_real (const_type, real);
809 if (flags & CPP_N_IMAGINARY)
810 {
811 value = build_complex (NULL_TREE, convert (const_type,
812 integer_zero_node), value);
813 if (type != const_type)
814 {
815 const_type = TREE_TYPE (value);
816 type = build_complex_type (type);
817 }
818 }
819
820 if (type != const_type)
821 value = build1 (EXCESS_PRECISION_EXPR, type, value);
822
823 return value;
824 }
825
826 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
827 by cpplib. */
828
829 static tree
interpret_fixed(const cpp_token * token,unsigned int flags)830 interpret_fixed (const cpp_token *token, unsigned int flags)
831 {
832 tree type;
833 tree value;
834 FIXED_VALUE_TYPE fixed;
835 char *copy;
836 size_t copylen;
837
838 copylen = token->val.str.len;
839
840 if (flags & CPP_N_FRACT) /* _Fract. */
841 {
842 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
843 {
844 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
845 {
846 type = unsigned_long_long_fract_type_node;
847 copylen -= 4;
848 }
849 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
850 {
851 type = unsigned_long_fract_type_node;
852 copylen -= 3;
853 }
854 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
855 {
856 type = unsigned_short_fract_type_node;
857 copylen -= 3;
858 }
859 else
860 {
861 type = unsigned_fract_type_node;
862 copylen -= 2;
863 }
864 }
865 else /* Signed _Fract. */
866 {
867 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
868 {
869 type = long_long_fract_type_node;
870 copylen -= 3;
871 }
872 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
873 {
874 type = long_fract_type_node;
875 copylen -= 2;
876 }
877 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
878 {
879 type = short_fract_type_node;
880 copylen -= 2;
881 }
882 else
883 {
884 type = fract_type_node;
885 copylen --;
886 }
887 }
888 }
889 else /* _Accum. */
890 {
891 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
892 {
893 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
894 {
895 type = unsigned_long_long_accum_type_node;
896 copylen -= 4;
897 }
898 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
899 {
900 type = unsigned_long_accum_type_node;
901 copylen -= 3;
902 }
903 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
904 {
905 type = unsigned_short_accum_type_node;
906 copylen -= 3;
907 }
908 else
909 {
910 type = unsigned_accum_type_node;
911 copylen -= 2;
912 }
913 }
914 else /* Signed _Accum. */
915 {
916 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
917 {
918 type = long_long_accum_type_node;
919 copylen -= 3;
920 }
921 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
922 {
923 type = long_accum_type_node;
924 copylen -= 2;
925 }
926 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
927 {
928 type = short_accum_type_node;
929 copylen -= 2;
930 }
931 else
932 {
933 type = accum_type_node;
934 copylen --;
935 }
936 }
937 }
938
939 copy = (char *) alloca (copylen + 1);
940 memcpy (copy, token->val.str.text, copylen);
941 copy[copylen] = '\0';
942
943 fixed_from_string (&fixed, copy, TYPE_MODE (type));
944
945 /* Create a node with determined type and value. */
946 value = build_fixed (type, fixed);
947
948 return value;
949 }
950
951 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
952 UTF8STRING tokens into a tree, performing string constant
953 concatenation. TOK is the first of these. VALP is the location to
954 write the string into. OBJC_STRING indicates whether an '@' token
955 preceded the incoming token (in that case, the strings can either
956 be ObjC strings, preceded by a single '@', or normal strings, not
957 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
958 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
959 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
960
961 This is unfortunately more work than it should be. If any of the
962 strings in the series has an L prefix, the result is a wide string
963 (6.4.5p4). Whether or not the result is a wide string affects the
964 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
965 sequences do not continue across the boundary between two strings in
966 a series (6.4.5p7), so we must not lose the boundaries. Therefore
967 cpp_interpret_string takes a vector of cpp_string structures, which
968 we must arrange to provide. */
969
970 static enum cpp_ttype
lex_string(const cpp_token * tok,tree * valp,bool objc_string,bool translate)971 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
972 {
973 tree value;
974 size_t concats = 0;
975 struct obstack str_ob;
976 cpp_string istr;
977 enum cpp_ttype type = tok->type;
978
979 /* Try to avoid the overhead of creating and destroying an obstack
980 for the common case of just one string. */
981 cpp_string str = tok->val.str;
982 cpp_string *strs = &str;
983
984 /* objc_at_sign_was_seen is only used when doing Objective-C string
985 concatenation. It is 'true' if we have seen an '@' before the
986 current string, and 'false' if not. We must see exactly one or
987 zero '@' before each string. */
988 bool objc_at_sign_was_seen = false;
989
990 retry:
991 tok = cpp_get_token (parse_in);
992 switch (tok->type)
993 {
994 case CPP_PADDING:
995 goto retry;
996 case CPP_ATSIGN:
997 if (objc_string)
998 {
999 if (objc_at_sign_was_seen)
1000 error ("repeated %<@%> before Objective-C string");
1001
1002 objc_at_sign_was_seen = true;
1003 goto retry;
1004 }
1005 /* FALLTHROUGH */
1006
1007 default:
1008 break;
1009
1010 case CPP_WSTRING:
1011 case CPP_STRING16:
1012 case CPP_STRING32:
1013 case CPP_UTF8STRING:
1014 if (type != tok->type)
1015 {
1016 if (type == CPP_STRING)
1017 type = tok->type;
1018 else
1019 error ("unsupported non-standard concatenation of string literals");
1020 }
1021
1022 case CPP_STRING:
1023 if (!concats)
1024 {
1025 gcc_obstack_init (&str_ob);
1026 obstack_grow (&str_ob, &str, sizeof (cpp_string));
1027 }
1028
1029 concats++;
1030 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
1031 if (objc_string)
1032 objc_at_sign_was_seen = false;
1033 goto retry;
1034 }
1035
1036 /* It is an error if we saw a '@' with no following string. */
1037 if (objc_at_sign_was_seen)
1038 error ("stray %<@%> in program");
1039
1040 /* We have read one more token than we want. */
1041 _cpp_backup_tokens (parse_in, 1);
1042 if (concats)
1043 strs = XOBFINISH (&str_ob, cpp_string *);
1044
1045 if (concats && !objc_string && !in_system_header)
1046 warning (OPT_Wtraditional,
1047 "traditional C rejects string constant concatenation");
1048
1049 if ((translate
1050 ? cpp_interpret_string : cpp_interpret_string_notranslate)
1051 (parse_in, strs, concats + 1, &istr, type))
1052 {
1053 value = build_string (istr.len, (const char *) istr.text);
1054 free (CONST_CAST (unsigned char *, istr.text));
1055 }
1056 else
1057 {
1058 /* Callers cannot generally handle error_mark_node in this context,
1059 so return the empty string instead. cpp_interpret_string has
1060 issued an error. */
1061 switch (type)
1062 {
1063 default:
1064 case CPP_STRING:
1065 case CPP_UTF8STRING:
1066 value = build_string (1, "");
1067 break;
1068 case CPP_STRING16:
1069 value = build_string (TYPE_PRECISION (char16_type_node)
1070 / TYPE_PRECISION (char_type_node),
1071 "\0"); /* char16_t is 16 bits */
1072 break;
1073 case CPP_STRING32:
1074 value = build_string (TYPE_PRECISION (char32_type_node)
1075 / TYPE_PRECISION (char_type_node),
1076 "\0\0\0"); /* char32_t is 32 bits */
1077 break;
1078 case CPP_WSTRING:
1079 value = build_string (TYPE_PRECISION (wchar_type_node)
1080 / TYPE_PRECISION (char_type_node),
1081 "\0\0\0"); /* widest supported wchar_t
1082 is 32 bits */
1083 break;
1084 }
1085 }
1086
1087 switch (type)
1088 {
1089 default:
1090 case CPP_STRING:
1091 case CPP_UTF8STRING:
1092 TREE_TYPE (value) = char_array_type_node;
1093 break;
1094 case CPP_STRING16:
1095 TREE_TYPE (value) = char16_array_type_node;
1096 break;
1097 case CPP_STRING32:
1098 TREE_TYPE (value) = char32_array_type_node;
1099 break;
1100 case CPP_WSTRING:
1101 TREE_TYPE (value) = wchar_array_type_node;
1102 }
1103 *valp = fix_string_type (value);
1104
1105 if (concats)
1106 obstack_free (&str_ob, 0);
1107
1108 return objc_string ? CPP_OBJC_STRING : type;
1109 }
1110
1111 /* Converts a (possibly wide) character constant token into a tree. */
1112 static tree
lex_charconst(const cpp_token * token)1113 lex_charconst (const cpp_token *token)
1114 {
1115 cppchar_t result;
1116 tree type, value;
1117 unsigned int chars_seen;
1118 int unsignedp = 0;
1119
1120 result = cpp_interpret_charconst (parse_in, token,
1121 &chars_seen, &unsignedp);
1122
1123 if (token->type == CPP_WCHAR)
1124 type = wchar_type_node;
1125 else if (token->type == CPP_CHAR32)
1126 type = char32_type_node;
1127 else if (token->type == CPP_CHAR16)
1128 type = char16_type_node;
1129 /* In C, a character constant has type 'int'.
1130 In C++ 'char', but multi-char charconsts have type 'int'. */
1131 else if (!c_dialect_cxx () || chars_seen > 1)
1132 type = integer_type_node;
1133 else
1134 type = char_type_node;
1135
1136 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1137 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1138 if (unsignedp || (cppchar_signed_t) result >= 0)
1139 value = build_int_cst_wide (type, result, 0);
1140 else
1141 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1142
1143 return value;
1144 }
1145