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
4 Free Software Foundation, Inc.
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
41 #include "splay-tree.h"
45 /* We may keep statistics about how long which files took to compile. */
46 static int header_time, body_time;
47 static splay_tree file_info_tree;
49 int pending_lang_change; /* If we need to switch languages - C++ only */
50 int c_header_level; /* depth in C headers - C++ only */
52 static tree interpret_integer (const cpp_token *, unsigned int);
53 static tree interpret_float (const cpp_token *, unsigned int);
54 static tree interpret_fixed (const cpp_token *, unsigned int);
55 static enum integer_type_kind narrowest_unsigned_type
56 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
57 static enum integer_type_kind narrowest_signed_type
58 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
59 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
60 static tree lex_charconst (const cpp_token *);
61 static void update_header_times (const char *);
62 static int dump_one_header (splay_tree_node, void *);
63 static void cb_line_change (cpp_reader *, const cpp_token *, int);
64 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
65 static void cb_def_pragma (cpp_reader *, unsigned int);
66 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
67 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
72 struct cpp_callbacks *cb;
73 struct c_fileinfo *toplevel;
75 /* The get_fileinfo data structure must be initialized before
76 cpp_read_main_file is called. */
77 toplevel = get_fileinfo ("<top level>");
78 if (flag_detailed_statistics)
81 body_time = get_run_time ();
82 toplevel->time = body_time;
85 cb = cpp_get_callbacks (parse_in);
87 cb->line_change = cb_line_change;
89 cb->def_pragma = cb_def_pragma;
90 cb->valid_pch = c_common_valid_pch;
91 cb->read_pch = c_common_read_pch;
93 /* Set the debug callbacks if we can use them. */
94 if (debug_info_level == DINFO_LEVEL_VERBOSE
95 && (write_symbols == DWARF2_DEBUG
96 || write_symbols == VMS_AND_DWARF2_DEBUG))
98 cb->define = cb_define;
104 get_fileinfo (const char *name)
107 struct c_fileinfo *fi;
110 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
112 (splay_tree_delete_value_fn) free);
114 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
116 return (struct c_fileinfo *) n->value;
118 fi = XNEW (struct c_fileinfo);
120 fi->interface_only = 0;
121 fi->interface_unknown = 1;
122 splay_tree_insert (file_info_tree, (splay_tree_key) name,
123 (splay_tree_value) fi);
128 update_header_times (const char *name)
130 /* Changing files again. This means currently collected time
131 is charged against header time, and body time starts back at 0. */
132 if (flag_detailed_statistics)
134 int this_time = get_run_time ();
135 struct c_fileinfo *file = get_fileinfo (name);
136 header_time += this_time - body_time;
137 file->time += this_time - body_time;
138 body_time = this_time;
143 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
145 print_time ((const char *) n->key,
146 ((struct c_fileinfo *) n->value)->time);
151 dump_time_statistics (void)
153 struct c_fileinfo *file = get_fileinfo (input_filename);
154 int this_time = get_run_time ();
155 file->time += this_time - body_time;
157 fprintf (stderr, "\n******\n");
158 print_time ("header files (total)", header_time);
159 print_time ("main file (total)", this_time - body_time);
160 fprintf (stderr, "ratio = %g : 1\n",
161 (double) header_time / (double) (this_time - body_time));
162 fprintf (stderr, "\n******\n");
164 splay_tree_foreach (file_info_tree, dump_one_header, 0);
168 cb_ident (cpp_reader * ARG_UNUSED (pfile),
169 unsigned int ARG_UNUSED (line),
170 const cpp_string * ARG_UNUSED (str))
172 #ifdef ASM_OUTPUT_IDENT
175 /* Convert escapes in the string. */
176 cpp_string cstr = { 0, 0 };
177 if (cpp_interpret_string (pfile, str, 1, &cstr, false))
179 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
180 free (CONST_CAST (unsigned char *, cstr.text));
186 /* Called at the start of every non-empty line. TOKEN is the first
187 lexed token on the line. Used for diagnostic line numbers. */
189 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
192 if (token->type != CPP_EOF && !parsing_args)
193 input_location = token->src_loc;
197 fe_file_change (const struct line_map *new_map)
202 if (new_map->reason == LC_ENTER)
204 /* Don't stack the main buffer on the input stack;
205 we already did in compile_file. */
206 if (!MAIN_FILE_P (new_map))
208 int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
210 input_location = included_at;
211 push_srcloc (new_map->start_location);
212 (*debug_hooks->start_source_file) (included_at, new_map->to_file);
213 #ifndef NO_IMPLICIT_EXTERN_C
216 else if (new_map->sysp == 2)
219 ++pending_lang_change;
224 else if (new_map->reason == LC_LEAVE)
226 #ifndef NO_IMPLICIT_EXTERN_C
227 if (c_header_level && --c_header_level == 0)
229 if (new_map->sysp == 2)
230 warning (0, "badly nested C headers from preprocessor");
231 --pending_lang_change;
236 (*debug_hooks->end_source_file) (new_map->to_line);
239 update_header_times (new_map->to_file);
240 in_system_header = new_map->sysp != 0;
241 input_location = new_map->start_location;
245 cb_def_pragma (cpp_reader *pfile, source_location loc)
247 /* Issue a warning message if we have been asked to do so. Ignore
248 unknown pragmas in system headers unless an explicit
249 -Wunknown-pragmas has been given. */
250 if (warn_unknown_pragmas > in_system_header)
252 const unsigned char *space, *name;
254 location_t fe_loc = loc;
256 space = name = (const unsigned char *) "";
257 s = cpp_get_token (pfile);
258 if (s->type != CPP_EOF)
260 space = cpp_token_as_text (pfile, s);
261 s = cpp_get_token (pfile);
262 if (s->type == CPP_NAME)
263 name = cpp_token_as_text (pfile, s);
266 warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
267 &fe_loc, space, name);
271 /* #define callback for DWARF and DWARF2 debug info. */
273 cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
275 const struct line_map *map = linemap_lookup (line_table, loc);
276 (*debug_hooks->define) (SOURCE_LINE (map, loc),
277 (const char *) cpp_macro_definition (pfile, node));
280 /* #undef callback for DWARF and DWARF2 debug info. */
282 cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
285 const struct line_map *map = linemap_lookup (line_table, loc);
286 (*debug_hooks->undef) (SOURCE_LINE (map, loc),
287 (const char *) NODE_NAME (node));
290 /* Read a token and return its type. Fill *VALUE with its value, if
291 applicable. Fill *CPP_FLAGS with the token's flags, if it is
295 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
298 static bool no_more_pch;
299 const cpp_token *tok;
301 unsigned char add_flags = 0;
303 timevar_push (TV_CPP);
305 tok = cpp_get_token_with_location (parse_in, loc);
315 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
320 unsigned int flags = cpp_classify_number (parse_in, tok);
322 switch (flags & CPP_N_CATEGORY)
325 /* cpplib has issued an error. */
326 *value = error_mark_node;
331 /* C++ uses '0' to mark virtual functions as pure.
332 Set PURE_ZERO to pass this information to the C++ parser. */
333 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
334 add_flags = PURE_ZERO;
335 *value = interpret_integer (tok, flags);
339 *value = interpret_float (tok, flags);
349 /* An @ may give the next token special significance in Objective-C. */
350 if (c_dialect_objc ())
352 location_t atloc = *loc;
356 tok = cpp_get_token_with_location (parse_in, &newloc);
365 type = lex_string (tok, value, true, true);
369 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
370 if (objc_is_reserved_word (*value))
379 error ("%Hstray %<@%> in program", &atloc);
390 unsigned char name[4];
392 *cpp_spell_token (parse_in, tok, name, true) = 0;
394 error ("stray %qs in program", name);
401 cppchar_t c = tok->val.str.text[0];
403 if (c == '"' || c == '\'')
404 error ("missing terminating %c character", (int) c);
405 else if (ISGRAPH (c))
406 error ("stray %qc in program", (int) c);
408 error ("stray %<\\%o%> in program", (int) c);
414 *value = lex_charconst (tok);
419 if ((lex_flags & C_LEX_RAW_STRINGS) == 0)
421 type = lex_string (tok, value, false,
422 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
425 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
429 *value = build_int_cst (NULL, tok->val.pragma);
432 /* These tokens should not be visible outside cpplib. */
433 case CPP_HEADER_NAME:
444 *cpp_flags = tok->flags | add_flags;
449 c_common_no_more_pch ();
452 timevar_pop (TV_CPP);
457 /* Returns the narrowest C-visible unsigned type, starting with the
458 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
461 static enum integer_type_kind
462 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
463 unsigned HOST_WIDE_INT high,
466 enum integer_type_kind itk;
468 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
469 itk = itk_unsigned_int;
470 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
471 itk = itk_unsigned_long;
473 itk = itk_unsigned_long_long;
475 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
477 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
479 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
480 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
481 && TREE_INT_CST_LOW (upper) >= low))
488 /* Ditto, but narrowest signed type. */
489 static enum integer_type_kind
490 narrowest_signed_type (unsigned HOST_WIDE_INT low,
491 unsigned HOST_WIDE_INT high, unsigned int flags)
493 enum integer_type_kind itk;
495 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
497 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
503 for (; itk < itk_none; itk += 2 /* skip signed types */)
505 tree upper = TYPE_MAX_VALUE (integer_types[itk]);
507 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
508 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
509 && TREE_INT_CST_LOW (upper) >= low))
516 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
518 interpret_integer (const cpp_token *token, unsigned int flags)
521 enum integer_type_kind itk;
523 cpp_options *options = cpp_get_options (parse_in);
525 integer = cpp_interpret_integer (parse_in, token, flags);
526 integer = cpp_num_sign_extend (integer, options->precision);
528 /* The type of a constant with a U suffix is straightforward. */
529 if (flags & CPP_N_UNSIGNED)
530 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
533 /* The type of a potentially-signed integer constant varies
534 depending on the base it's in, the standard in use, and the
536 enum integer_type_kind itk_u
537 = narrowest_unsigned_type (integer.low, integer.high, flags);
538 enum integer_type_kind itk_s
539 = narrowest_signed_type (integer.low, integer.high, flags);
541 /* In both C89 and C99, octal and hex constants may be signed or
542 unsigned, whichever fits tighter. We do not warn about this
543 choice differing from the traditional choice, as the constant
544 is probably a bit pattern and either way will work. */
545 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
546 itk = MIN (itk_u, itk_s);
549 /* In C99, decimal constants are always signed.
550 In C89, decimal constants that don't fit in long have
551 undefined behavior; we try to make them unsigned long.
552 In GCC's extended C89, that last is true of decimal
553 constants that don't fit in long long, too. */
556 if (itk_s > itk_u && itk_s > itk_long)
560 if (itk_u < itk_unsigned_long)
561 itk_u = itk_unsigned_long;
563 warning (0, "this decimal constant is unsigned only in ISO C90");
566 warning (OPT_Wtraditional,
567 "this decimal constant would be unsigned in ISO C90");
573 /* cpplib has already issued a warning for overflow. */
574 type = ((flags & CPP_N_UNSIGNED)
575 ? widest_unsigned_literal_type_node
576 : widest_integer_literal_type_node);
578 type = integer_types[itk];
580 if (itk > itk_unsigned_long
581 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
582 && !in_system_header && !flag_isoc99)
583 pedwarn ("integer constant is too large for %qs type",
584 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
586 value = build_int_cst_wide (type, integer.low, integer.high);
588 /* Convert imaginary to a complex type. */
589 if (flags & CPP_N_IMAGINARY)
590 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
595 /* Interpret TOKEN, a floating point number with FLAGS as classified
598 interpret_float (const cpp_token *token, unsigned int flags)
602 REAL_VALUE_TYPE real;
606 /* Decode _Fract and _Accum. */
607 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
608 return interpret_fixed (token, flags);
610 /* Decode type based on width and properties. */
611 if (flags & CPP_N_DFLOAT)
612 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
613 type = dfloat128_type_node;
614 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
615 type = dfloat32_type_node;
617 type = dfloat64_type_node;
619 if (flags & CPP_N_WIDTH_MD)
622 enum machine_mode mode;
624 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
629 mode = targetm.c.mode_for_suffix (suffix);
630 if (mode == VOIDmode)
632 error ("unsupported non-standard suffix on floating constant");
635 return error_mark_node;
638 pedwarn ("non-standard suffix on floating constant");
640 type = c_common_type_for_mode (mode, 0);
643 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
644 type = long_double_type_node;
645 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
646 || flag_single_precision_constant)
647 type = float_type_node;
649 type = double_type_node;
651 /* Copy the constant to a nul-terminated buffer. If the constant
652 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
653 can't handle them. */
654 copylen = token->val.str.len;
655 if (flags & CPP_N_DFLOAT)
659 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
660 /* Must be an F or L or machine defined suffix. */
662 if (flags & CPP_N_IMAGINARY)
667 copy = (char *) alloca (copylen + 1);
668 memcpy (copy, token->val.str.text, copylen);
669 copy[copylen] = '\0';
671 real_from_string3 (&real, copy, TYPE_MODE (type));
673 /* Both C and C++ require a diagnostic for a floating constant
674 outside the range of representable values of its type. Since we
675 have __builtin_inf* to produce an infinity, this is now a
676 mandatory pedwarn if the target does not support infinities. */
677 if (REAL_VALUE_ISINF (real))
679 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
680 pedwarn ("floating constant exceeds range of %qT", type);
682 warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
684 /* We also give a warning if the value underflows. */
685 else if (REAL_VALUES_EQUAL (real, dconst0))
687 REAL_VALUE_TYPE realvoidmode;
688 int overflow = real_from_string (&realvoidmode, copy);
689 if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
690 warning (OPT_Woverflow, "floating constant truncated to zero");
693 /* Create a node with determined type and value. */
694 value = build_real (type, real);
695 if (flags & CPP_N_IMAGINARY)
696 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
701 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
705 interpret_fixed (const cpp_token *token, unsigned int flags)
709 FIXED_VALUE_TYPE fixed;
713 copylen = token->val.str.len;
715 if (flags & CPP_N_FRACT) /* _Fract. */
717 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
719 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
721 type = unsigned_long_long_fract_type_node;
724 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
726 type = unsigned_long_fract_type_node;
729 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
731 type = unsigned_short_fract_type_node;
736 type = unsigned_fract_type_node;
740 else /* Signed _Fract. */
742 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
744 type = long_long_fract_type_node;
747 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
749 type = long_fract_type_node;
752 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
754 type = short_fract_type_node;
759 type = fract_type_node;
766 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
768 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
770 type = unsigned_long_long_accum_type_node;
773 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
775 type = unsigned_long_accum_type_node;
778 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
780 type = unsigned_short_accum_type_node;
785 type = unsigned_accum_type_node;
789 else /* Signed _Accum. */
791 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
793 type = long_long_accum_type_node;
796 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
798 type = long_accum_type_node;
801 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
803 type = short_accum_type_node;
808 type = accum_type_node;
814 copy = (char *) alloca (copylen + 1);
815 memcpy (copy, token->val.str.text, copylen);
816 copy[copylen] = '\0';
818 fixed_from_string (&fixed, copy, TYPE_MODE (type));
820 /* Create a node with determined type and value. */
821 value = build_fixed (type, fixed);
826 /* Convert a series of STRING and/or WSTRING tokens into a tree,
827 performing string constant concatenation. TOK is the first of
828 these. VALP is the location to write the string into. OBJC_STRING
829 indicates whether an '@' token preceded the incoming token.
830 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
833 This is unfortunately more work than it should be. If any of the
834 strings in the series has an L prefix, the result is a wide string
835 (6.4.5p4). Whether or not the result is a wide string affects the
836 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
837 sequences do not continue across the boundary between two strings in
838 a series (6.4.5p7), so we must not lose the boundaries. Therefore
839 cpp_interpret_string takes a vector of cpp_string structures, which
840 we must arrange to provide. */
842 static enum cpp_ttype
843 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
848 struct obstack str_ob;
851 /* Try to avoid the overhead of creating and destroying an obstack
852 for the common case of just one string. */
853 cpp_string str = tok->val.str;
854 cpp_string *strs = &str;
856 if (tok->type == CPP_WSTRING)
860 tok = cpp_get_token (parse_in);
866 if (c_dialect_objc ())
883 gcc_obstack_init (&str_ob);
884 obstack_grow (&str_ob, &str, sizeof (cpp_string));
888 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
892 /* We have read one more token than we want. */
893 _cpp_backup_tokens (parse_in, 1);
895 strs = XOBFINISH (&str_ob, cpp_string *);
897 if (concats && !objc_string && !in_system_header)
898 warning (OPT_Wtraditional,
899 "traditional C rejects string constant concatenation");
902 ? cpp_interpret_string : cpp_interpret_string_notranslate)
903 (parse_in, strs, concats + 1, &istr, wide))
905 value = build_string (istr.len, (const char *) istr.text);
906 free (CONST_CAST (unsigned char *, istr.text));
910 /* Callers cannot generally handle error_mark_node in this context,
911 so return the empty string instead. cpp_interpret_string has
914 value = build_string (TYPE_PRECISION (wchar_type_node)
915 / TYPE_PRECISION (char_type_node),
916 "\0\0\0"); /* widest supported wchar_t
919 value = build_string (1, "");
922 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
923 *valp = fix_string_type (value);
926 obstack_free (&str_ob, 0);
928 return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
931 /* Converts a (possibly wide) character constant token into a tree. */
933 lex_charconst (const cpp_token *token)
937 unsigned int chars_seen;
940 result = cpp_interpret_charconst (parse_in, token,
941 &chars_seen, &unsignedp);
943 if (token->type == CPP_WCHAR)
944 type = wchar_type_node;
945 /* In C, a character constant has type 'int'.
946 In C++ 'char', but multi-char charconsts have type 'int'. */
947 else if (!c_dialect_cxx () || chars_seen > 1)
948 type = integer_type_node;
950 type = char_type_node;
952 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
953 before possibly widening to HOST_WIDE_INT for build_int_cst. */
954 if (unsignedp || (cppchar_signed_t) result >= 0)
955 value = build_int_cst_wide (type, result, 0);
957 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);