This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[pph] Refactor pth/pph code out of cp/parser.c
- From: Diego Novillo <dnovillo at google dot com>
- To: gcc-patches at gcc dot gnu dot org, Jason Merrill <jason at redhat dot com>, Lawrence Crowl <crowl at google dot com>
- Date: Thu, 2 Dec 2010 16:55:52 -0500
- Subject: [pph] Refactor pth/pph code out of cp/parser.c
This patch is large but mechanical. It splits all the pth/pph
functionality out of cp/parser.c into three new files:
cp/parser.h: Common API exported by cp/parser.c.
cp/pph.h: Data structures for pth/pph.
cp/pph.c: Implementation for pth/pph.
Jason, would it be OK if I ported cp/parser.h to mainline now?
It does not change anything in terms of functionality but it
would simplify future merges from trunk into the branch.
Bootstrapped and tested on x86_64.
Diego.
2010-12-02 Diego Novillo <dnovillo@google.com>
* pph.c: New file.
* pph.h: New file.
* parser.h: New file.
* decl.c: Include pph.h.
* cp/Make-lang.in (CXX_AND_OBJCXX_OBJS): Add cp/pph.o.
(CXX_PARSER_H): Define.
(CXX_PPH_H): Define.
(cp/cp-lang.o): Add dependency on CXX_PARSER_H and
CXX_PPH_H.
(cp/parser.o): Likewise.
(cp/decl.o): Add dependency on CXX_PPH_H.
(cp/call.o): Likewise.
(cp/pt.o): Likewise.
(cp/name-lookup.o): Likewise.
(cp/pph.o): New.
* cp/cp-lang.c: Include parser.h and pph.h.
* cp/pt.c: Include pph.h.
* cp/parser.c: Remove inclusion of timevar.h,
pointer-set.h, fixed-value.h, cpplib.h, line-map.h,
md5.h, hashtab.h, tree-pass.h and tree-inline.h.
Include parser.h and pph.h
(struct tree_check): Move to parser.h.
(struct cp_token): Likewise.
(struct cp_lexer): Likewise.
(struct cp_token_cache): Likewise.
(struct cp_token_ident_d): Likewise.
(CPP_KEYWORD): Likewise.
(CPP_TEMPLATE_ID): Likewise.
(CPP_NESTED_NAME_SPECIFIER): Likewise.
(N_CP_TTYPES): Likewise.
(enum cp_parser_status_kind): Likewise.
(struct cp_parser_context): Likewise.
(struct cp_default_arg_entry_d): Likewise.
(struct cp_unparsed_functions_entry_d): Likewise.
(struct cp_parser): Likewise.
(struct cp_token_hunk): Move to pph.h.
(DIGEST_LEN): Likewise.
(struct pth_image): Likewise.
(pth_image_ptr): Likewise.
(struct pth_include): Likewise.
(pth_include_ptr): Likewise.
(struct pth_state): Likewise.
(struct pth_stats_d): Likewise.
(PTH_STATS_INCR): Likewise.
(struct pph_stats_d): Likewise.
(PPH_STATS_INCR): Likewise.
(pth_stats): Make extern.
(pph_stats): Likewise.
(cp_lexer_dump_tokens): Likewise.
(cp_lexer_debug_tokens): Likewise.
(cp_lexer_token_position): Likewise.
(cp_lexer_get_tokens): Likewise.
(the_parser): Likewise.
(pph_decl_head_token_cache): Move to pph.c
(pph_decl_body_token_cache): Likewise.
(struct pph_decl_deps_d): Likewise.
(pph_decl_deps): Likewise.
(pph_tree_catcher): Likewise.
(pph_name_lookups): Likewise.
(pph_name_lookups_set): Likewise.
(pph_nl_token_map): Likewise.
(pph_logfile): Likewise.
(pph_print_tokens): Likewise.
(pathnames_equal_p): Likewise.
(pph_debug_location): Likewise.
(pph_debug_loc_of_tree): Likewise.
(pth_image_dir_hash): Likewise.
(pth_image_dir_eq): Likewise.
(pth_global_state): Likewise.
(pth_get_state): Likewise.
(pth_id_str): Likewise.
(pth_header_len): Likewise.
(PTH_EXTENSION): Likewise.
(pth_name_for): Likewise.
(pth_file_for): Likewise.
(pth_get_md5_digest): Likewise.
(pth_get_index_from_type): Likewise.
(pth_write_uint): Likewise.
(pth_write_sizet): Likewise.
(pth_write_bytes): Likewise.
(pth_write_string): Likewise.
(pth_write_number): Likewise.
(pth_save_token_value): Likewise.
(pth_save_token): Likewise.
(pth_write_header): Likewise.
(pth_dump_identifiers): Likewise.
(pth_debug_identifiers): Likewise.
(pth_dump_hunk): Likewise.
(pth_debug_hunk): Likewise.
(pth_dump_include): Likewise.
(pth_debug_include): Likewise.
(pth_dump_token_hunks_1): Likewise.
(pth_dump_token_hunks): Likewise.
(pth_debug_token_hunks): Likewise.
(pth_dump_image): Likewise.
(pth_debug_image): Likewise.
(pth_show_image_stats): Likewise.
(pth_dump_state): Likewise.
(pth_debug_state): Likewise.
(pth_save_identifiers): Likewise.
(pth_save_hunk): Likewise.
(pth_save_include): Likewise.
(pth_save_image): Likewise.
(pth_get_type_from_index): Likewise.
(pth_read_uint): Likewise.
(pth_read_sizet): Likewise.
(pth_read_bytes): Likewise.
(pth_read_string): Likewise.
(pth_read_string_alloc): Likewise.
(pth_load_number): Likewise.
(pth_load_token_value): Likewise.
(pth_load_identifiers): Likewise.
(pth_load_hunk): Likewise.
(pth_create_include): Likewise.
(pth_load_include): Likewise.
(pth_load_image): Likewise.
(pth_have_valid_image_for): Likewise.
(pth_new_image): Likewise.
(pth_image_lookup): Likewise.
(pth_append_hunk): Likewise.
(pth_hunk_is_valid_p): Likewise.
(pth_image_can_be_used): Likewise.
(pth_get_dir_and_name): Likewise.
(pth_process_text_file): Likewise.
(pth_image_to_lexer): Likewise.
(pth_lexer_to_image): Likewise.
(pth_get_file_transition): Likewise.
(pth_leave_file): Likewise.
(pth_enter_file): Likewise.
(pth_file_change): Likewise.
(pth_include_handler): Likewise.
(pth_init): Likewise.
(pth_print_stats): Likewise.
(pth_finish): Likewise.
(pph_log_exposed): Likewise.
(pph_allocate_catcher_memory): Likewise.
(pph_free_catcher_memory): Likewise.
(pph_start_exposed): Likewise.
(pph_lookup_head_token_cache_for): Likewise.
(pph_lookup_body_token_cache_for): Likewise.
(pph_set_head_token_cache_for): Likewise.
(pph_set_body_token_cache_for): Likewise.
(pph_copy_decls_into_cache): Likewise.
(pph_copy_decls_outof_cache): Likewise.
(pph_stop_exposed): Likewise.
(pph_debug_tree): Likewise.
(pph_debug_type): Likewise.
(pph_tree_caught_p): Likewise.
(pph_catch_head_tokens_for): Likewise.
(pph_catch_body_tokens_for): Likewise.
(pph_lookup_dependencies_for): Likewise.
(pph_set_dependencies_for): Likewise.
(is_namespace): Likewise.
(PPH_ARTIFICIAL): Likewise.
(pph_null_exposed): Likewise.
(pph_live_exposed): Likewise.
(pph_find_exposed_for): Likewise.
(pph_catch_dependencies_for): Likewise.
(pph_catch_tree): Likewise.
(pph_uncatch_tree): Likewise.
(pph_locate_name_lookups_in): Likewise.
(pph_print_copy_tokens): Likewise.
(pph_print_token_range): Likewise.
(pph_print_dependence): Likewise.
(pph_print_depend_template): Likewise.
(pph_print_depend_decl): Likewise.
(pph_print_depend_type): Likewise.
(pph_print_depend_type_type): Likewise.
(pph_print_depend_func_type): Likewise.
(pph_print_depend_var_type): Likewise.
(pph_get_decl_exposure): Likewise.
(pph_print_dependences): Likewise.
(pph_print_declaration_head): Likewise.
(pph_print_declaration_body): Likewise.
(pph_find_special_methods): Likewise.
(pph_implicit_class_cost): Likewise.
(pph_print_declaration): Likewise.
(pph_print_declarations): Likewise.
(pph_print_trees_tokens): Likewise.
(pph_catch_name_lookup): Likewise.
(pph_print_stats): Likewise.
(pph_init): Likewise.
(pph_finish): Likewise.
* config-lang.in (gtfiles): Add cp/parser.h, cp/pph.h
and cp/pph.c.
* call.c: Include pph.h
* cp-tree.h (PPH_POP_TIMEVAR_AND_RETURN): Move to
pph.h
(pph_catch_tree): Likewise.
(pph_uncatch_tree): Likewise.
(pph_catch_name_lookup): Likewise.
* name-lookup.c: Include pph.h.
Index: cp/decl.c
===================================================================
--- cp/decl.c (revision 166209)
+++ cp/decl.c (working copy)
@@ -54,6 +54,7 @@ along with GCC; see the file COPYING3.
#include "splay-tree.h"
#include "plugin.h"
#include "langhooks.h"
+#include "pph.h"
/* Possible cases of bad specifiers type used by bad_specifiers. */
enum bad_spec_place {
Index: cp/Make-lang.in
===================================================================
--- cp/Make-lang.in (revision 166209)
+++ cp/Make-lang.in (working copy)
@@ -81,7 +81,7 @@ CXX_AND_OBJCXX_OBJS = cp/call.o cp/decl.
cp/typeck.o cp/cvt.o cp/except.o cp/friend.o cp/init.o cp/method.o \
cp/search.o cp/semantics.o cp/tree.o cp/repo.o cp/dump.o cp/optimize.o \
cp/mangle.o cp/cp-objcp-common.o cp/name-lookup.o cp/cxx-pretty-print.o \
- cp/cp-gimplify.o tree-mudflap.o $(CXX_C_OBJS)
+ cp/cp-gimplify.o cp/pph.o tree-mudflap.o $(CXX_C_OBJS)
# Language-specific object files for C++.
CXX_OBJS = cp/cp-lang.o c-family/stub-objc.o $(CXX_AND_OBJCXX_OBJS)
@@ -243,19 +243,23 @@ CXX_TREE_H = $(TREE_H) cp/name-lookup.h
$(FUNCTION_H) \
$(SYSTEM_H) coretypes.h $(CONFIG_H) $(TARGET_H) $(GGC_H) \
$(srcdir)/../include/hashtab.h
-
+CXX_PARSER_H = tree.h c-family/c-pragma.h cp/parser.h
CXX_PRETTY_PRINT_H = cp/cxx-pretty-print.h $(C_PRETTY_PRINT_H)
+CXX_PPH_H = $(srcdir)/../libcpp/include/line-map.h $(HASHTAB_H) \
+ $(CXX_PARSER_H) $(TIMEVAR_H) cp/pph.h
cp/lex.o: cp/lex.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) \
$(C_PRAGMA_H) toplev.h output.h input.h cp/operators.def $(TM_P_H)
cp/cp-lang.o: cp/cp-lang.c $(CXX_TREE_H) $(TM_H) toplev.h debug.h langhooks.h \
$(LANGHOOKS_DEF_H) $(C_COMMON_H) gtype-cp.h gt-cp-cp-lang.h \
- cp/cp-objcp-common.h $(EXPR_H) $(TARGET_H)
+ cp/cp-objcp-common.h $(EXPR_H) $(TARGET_H) $(CXX_PARSER_H) \
+ $(CXX_PPH_H)
cp/decl.o: cp/decl.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h \
output.h toplev.h $(HASHTAB_H) $(RTL_H) \
cp/operators.def $(TM_P_H) $(TREE_INLINE_H) $(DIAGNOSTIC_H) $(C_PRAGMA_H) \
debug.h gt-cp-decl.h $(TIMEVAR_H) $(TARGET_H) $(PLUGIN_H) \
- intl.h tree-iterator.h $(SPLAY_TREE_H) langhooks.h
+ intl.h tree-iterator.h $(SPLAY_TREE_H) langhooks.h \
+ $(CXX_PPH_H)
cp/decl2.o: cp/decl2.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) cp/decl.h \
output.h toplev.h $(C_COMMON_H) gt-cp-decl2.h $(CGRAPH_H) \
$(C_PRAGMA_H) $(TREE_DUMP_H) intl.h $(TARGET_H) $(GIMPLE_H) $(POINTER_SET_H) \
@@ -273,7 +277,8 @@ cp/class.o: cp/class.c $(CXX_TREE_H) $(T
$(TARGET_H) convert.h $(CGRAPH_H) $(TREE_DUMP_H) gt-cp-class.h \
$(SPLAY_TREE_H)
cp/call.o: cp/call.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h \
- $(DIAGNOSTIC_CORE_H) intl.h gt-cp-call.h convert.h $(TARGET_H) langhooks.h
+ $(DIAGNOSTIC_CORE_H) intl.h gt-cp-call.h convert.h $(TARGET_H) langhooks.h \
+ $(CXX_PPH_H)
cp/friend.o: cp/friend.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h
cp/init.o: cp/init.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) \
toplev.h $(EXCEPT_H) $(TARGET_H)
@@ -293,7 +298,8 @@ cp/except.o: cp/except.c $(CXX_TREE_H) $
toplev.h cp/cfns.h $(TREE_INLINE_H) $(TARGET_H)
cp/expr.o: cp/expr.c $(CXX_TREE_H) $(TM_H) $(FLAGS_H) toplev.h $(TM_P_H)
cp/pt.o: cp/pt.c $(CXX_TREE_H) $(TM_H) cp/decl.h cp/cp-objcp-common.h \
- toplev.h $(TREE_INLINE_H) pointer-set.h gt-cp-pt.h vecprim.h intl.h
+ toplev.h $(TREE_INLINE_H) pointer-set.h gt-cp-pt.h vecprim.h intl.h \
+ $(CXX_PPH_H)
cp/error.o: cp/error.c $(CXX_TREE_H) $(TM_H) toplev.h $(DIAGNOSTIC_H) \
$(FLAGS_H) $(REAL_H) $(LANGHOOKS_DEF_H) $(CXX_PRETTY_PRINT_H) \
tree-diagnostic.h tree-pretty-print.h
@@ -312,13 +318,19 @@ cp/mangle.o: cp/mangle.c $(CXX_TREE_H) $
cp/parser.o: cp/parser.c $(CXX_TREE_H) $(TM_H) $(DIAGNOSTIC_CORE_H) \
gt-cp-parser.h output.h $(TARGET_H) $(PLUGIN_H) intl.h \
pointer-set.h fixed-value.h $(MD5_H) $(HASHTAB_H) tree-pass.h \
- $(TREE_INLINE_H) tree-pretty-print.h
+ $(TREE_INLINE_H) tree-pretty-print.h $(CXX_PARSER_H) \
+ $(CXX_PPH_H)
cp/cp-gimplify.o: cp/cp-gimplify.c $(CXX_TREE_H) toplev.h $(C_COMMON_H) \
$(TM_H) coretypes.h pointer-set.h tree-iterator.h
cp/name-lookup.o: cp/name-lookup.c $(CONFIG_H) $(SYSTEM_H) coretypes.h \
$(TM_H) $(CXX_TREE_H) $(TIMEVAR_H) gt-cp-name-lookup.h toplev.h \
- $(DIAGNOSTIC_CORE_H) $(FLAGS_H) debug.h tree-pretty-print.h
+ $(DIAGNOSTIC_CORE_H) $(FLAGS_H) debug.h tree-pretty-print.h \
+ $(CXX_PPH_H)
cp/cxx-pretty-print.o: cp/cxx-pretty-print.c $(CXX_PRETTY_PRINT_H) \
$(CONFIG_H) $(SYSTEM_H) $(TM_H) coretypes.h $(CXX_TREE_H) tree-pretty-print.h
+cp/pph.c: cp/pph.c $(CONFIG_H) $(SYSTEM_H) coretypes.h $(CPPLIB_H) \
+ toplev.h $(TREE_H) $(CXX_TREE_H) $(TIMEVAR_H) pointer-set.h \
+ fixed-value.h $(TREE_PASS_H) $(TREE_INLINE_H) tree-pretty-print.h \
+ $(CXX_PARSER_H) $(CXX_PPH_H)
Index: cp/pph.c
===================================================================
--- cp/pph.c (revision 0)
+++ cp/pph.c (revision 0)
@@ -0,0 +1,4137 @@
+/* Factored pre-tokenized header (PTH) support for C++
+ Copyright (C) 2010 Free Software Foundation, Inc.
+ Contributed by Lawrence Crowl <crowl@google.com> and
+ Diego Novillo <dnovillo@google.com>.
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "cpplib.h"
+#include "toplev.h"
+#include "tree.h"
+#include "cp-tree.h"
+#include "timevar.h"
+#include "pointer-set.h"
+#include "fixed-value.h"
+#include "md5.h"
+#include "tree-pass.h"
+#include "tree-inline.h"
+#include "tree-pretty-print.h"
+#include "parser.h"
+#include "pph.h"
+
+/* Statistics collected for PTH/PPH. */
+struct pth_stats_d pth_stats;
+struct pph_stats_d pph_stats;
+
+/* Forward declarations to solve cyclical references. */
+static void pph_print_trees_tokens (VEC(tree,heap) *, cp_token *, cp_token *);
+
+/* Map of decl dependencies. */
+static struct pph_decl_deps_d *pph_decl_deps = NULL;
+
+/* Tree catcher for the incremental compiler. Whenever this array is
+ allocated, make_node_stat() will push certain trees into this array. */
+static VEC(tree,heap) *pph_tree_catcher = NULL;
+
+/* Catcher for name lookups. This stores every name lookup performed
+ on identifiers while we are catching ASTs in the parser. */
+static VEC(tree,heap) *pph_name_lookups = NULL;
+
+/* Since identifiers may be looked up more than once during parsing,
+ this set prevents duplicate symbols from being placed in
+ pph_name_lookups. */
+static struct pointer_set_t *pph_name_lookups_set = NULL;
+
+/* This map stores the token locations where a given symbol was looked
+ up. When an identifier is looked up and resolved to symbol S, we
+ check where the current token pointer is and save it in a vector
+ associated with S. */
+static struct pointer_map_t *pph_nl_token_map = NULL;
+
+/* Log file where PPH analysis is written to. Controlled by
+ -fpph_logfile. If this flag is not given, stdout is used. */
+FILE *pph_logfile = NULL;
+
+/* Cache of token ranges for head of symbol declarations. For each
+ *_DECL tree intercepted during parsing, we store the vector of
+ tokens that make up the head of the declaration for the node. */
+static struct pointer_map_t *pph_decl_head_token_cache = NULL;
+
+/* Cache of token ranges for body of symbol declarations. For each
+ *_DECL tree intercepted during parsing, we store the vector of
+ tokens that make up the body of the declaration for the node. */
+static struct pointer_map_t *pph_decl_body_token_cache = NULL;
+
+
+/* Return true if path P1 and path P2 point to the same file. */
+
+static inline bool
+pathnames_equal_p (const char *p1, const char *p2)
+{
+ return strcmp (lrealpath (p1), lrealpath (p2)) == 0;
+}
+
+/* Expand and print location LOC to FILE. If FILE is NULL, pph_logfile
+ is used. */
+
+static void
+pph_debug_location (FILE *file, location_t loc)
+{
+ expanded_location xloc;
+ file = (file) ? file : pph_logfile;
+ xloc = expand_location (loc);
+ fprintf (file, "%s:%d:%d", lrealpath (xloc.file), xloc.line, xloc.column);
+}
+
+
+/* Expand and print the location of tree T to FILE. If FILE is NULL,
+ pph_logfile is used. */
+
+static void
+pph_debug_loc_of_tree (FILE *file, tree t)
+{
+ pph_debug_location (file, DECL_SOURCE_LOCATION (t));
+}
+
+
+/* Hash and comparison functions for the directory of cached images. */
+
+static hashval_t
+pth_image_dir_hash (const void *p)
+{
+ const char *s = lrealpath (((const pth_image *)p)->fname);
+ return htab_hash_string (s);
+}
+
+
+static int
+pth_image_dir_eq (const void *p1, const void *p2)
+{
+ const char *s1 = ((const pth_image *)p1)->fname;
+ const char *s2 = ((const pth_image *)p2)->fname;
+ return pathnames_equal_p (s1, s2);
+}
+
+
+static GTY(()) pth_state *pth_global_state = NULL;
+
+/* Return the global PTH state where the cache and its directory
+ are stored. */
+
+pth_state *
+pth_get_state (void)
+{
+ if (pth_global_state == NULL)
+ {
+ pth_global_state = ggc_alloc_cleared_pth_state ();
+ pth_global_state->cache_dir = htab_create_ggc (10, pth_image_dir_hash,
+ pth_image_dir_eq, NULL);
+ }
+
+ return pth_global_state;
+}
+
+
+/* Return an identification string for a PTH image. */
+
+static const char *
+pth_id_str (void)
+{
+ /* FIXME pph - Build a better identification string. */
+ return "PTH0x42";
+}
+
+
+/* Return the number of bytes taken by the header of a PTH image. */
+
+static size_t
+pth_header_len (void)
+{
+ /* The header of a PTH image contains:
+ - An identification string (pth_id_str ())
+ - The MD5 digest for the source file associated with the image.
+ */
+ return strlen (pth_id_str ()) + DIGEST_LEN;
+}
+
+
+#define PTH_EXTENSION ".pth"
+
+/* Return a new string with the extension PTH_EXTENSION appended to NAME. The
+ caller is responsible for freeing the returned string. */
+
+static char *
+pth_name_for (const char *name)
+{
+ size_t i, len;
+ char *s;
+
+ len = strlen (name) + sizeof (PTH_EXTENSION) + 1;
+ s = XCNEWVEC (char, len);
+ sprintf (s, "%s" PTH_EXTENSION, name);
+
+ /* Make the file name unique and store it in the current directory. */
+ for (i = 0; i < len - sizeof (PTH_EXTENSION) - 1; i++)
+ if (!ISALNUM (s[i]))
+ s[i] = '_';
+
+ return s;
+}
+
+
+/* Open an image file for path NAME with MODE. */
+
+static FILE *
+pth_file_for (const char *name, const char *mode)
+{
+ char *s;
+ FILE *f;
+
+ s = pth_name_for (name);
+ f = fopen (s, mode);
+ if (f == NULL)
+ fatal_error ("can%'t open token stream file %s: %m", s);
+ free (s);
+
+ return f;
+}
+
+
+/* Compute the MD5 digest for FNAME. Store it in DIGEST. */
+
+static void
+pth_get_md5_digest (const char *fname, unsigned char digest[DIGEST_LEN])
+{
+ if (flag_pth_md5)
+ {
+ FILE *f;
+
+ timevar_push (TV_PTH_MD5);
+
+ f = fopen (fname, "rb");
+ if (f == NULL)
+ fatal_error ("Cannot open %s for computing its digest: %m", fname);
+
+ md5_stream (f, digest);
+
+ fclose (f);
+
+ timevar_pop (TV_PTH_MD5);
+ }
+ else
+ {
+ struct stat buf;
+
+ if (stat (fname,&buf) != 0)
+ fatal_error ("Cannot stat %s: %m", fname);
+
+ memset (digest, 0, DIGEST_LEN);
+ memcpy (digest, &buf.st_mtime, sizeof (buf.st_mtime));
+ }
+}
+
+
+/* Compute an index value for TYPE suitable for restoring it later
+ from global_trees[] or integer_types. The index is saved
+ in TYPE_IX_P and the number category (one of CPP_N_INTEGER,
+ CPP_N_FLOATING, etc) is saved in CATEGORY_P. */
+
+static void
+pth_get_index_from_type (tree type, unsigned *type_ix_p, unsigned *category_p)
+{
+ void **val_p;
+ static struct pointer_map_t *type_cache = NULL;
+
+ /* For complex types we will just use the type of the components. */
+ if (TREE_CODE (type) == COMPLEX_TYPE)
+ {
+ *type_ix_p = 0;
+ *category_p = CPP_N_IMAGINARY;
+ return;
+ }
+
+ if (type_cache == NULL)
+ type_cache = pointer_map_create ();
+
+ val_p = pointer_map_contains (type_cache, type);
+ if (val_p)
+ *type_ix_p = *((unsigned *) val_p);
+ else
+ {
+ if (CP_INTEGRAL_TYPE_P (type))
+ {
+ unsigned i;
+ for (i = itk_char; i < itk_none; i++)
+ if (type == integer_types[i])
+ {
+ *type_ix_p = (unsigned) i;
+ break;
+ }
+
+ gcc_assert (i != itk_none);
+ }
+ else if (FLOAT_TYPE_P (type) || FIXED_POINT_TYPE_P (type))
+ {
+ unsigned i;
+
+ for (i = TI_ERROR_MARK; i < TI_MAX; i++)
+ if (global_trees[i] == type)
+ {
+ *type_ix_p = (unsigned) i;
+ break;
+ }
+
+ gcc_assert (i != TI_MAX);
+ }
+ else
+ gcc_unreachable ();
+ }
+
+ if (CP_INTEGRAL_TYPE_P (type))
+ *category_p = CPP_N_INTEGER;
+ else if (FLOAT_TYPE_P (type))
+ *category_p = CPP_N_FLOATING;
+ else if (FIXED_POINT_TYPE_P (type))
+ *category_p = CPP_N_FRACT;
+ else
+ gcc_unreachable ();
+}
+
+
+/* Write a uint VALUE to the STREAM. Return the number of bytes written. */
+
+static inline size_t
+pth_write_uint (unsigned int value, FILE *stream)
+{
+ size_t sent = fwrite (&value, 1, sizeof (value), stream);
+ gcc_assert (sent == sizeof (value));
+ return sent;
+}
+
+
+/* Write a size_t VALUE to the STREAM. Return the number of bytes written. */
+
+static inline size_t
+pth_write_sizet (size_t value, FILE *stream)
+{
+ size_t sent = fwrite (&value, 1, sizeof (value), stream);
+ gcc_assert (sent == sizeof (value));
+ return sent;
+}
+
+
+/* Write N bytes from P to STREAM. */
+
+static inline size_t
+pth_write_bytes (const void *p, size_t n, FILE *stream)
+{
+ size_t sent = fwrite (p, 1, n, stream);
+ gcc_assert (sent == n);
+ return sent;
+}
+
+
+/* Write string STR and its LENGTH to STREAM. */
+
+static inline size_t
+pth_write_string (const char *str, unsigned int length, FILE *stream)
+{
+ size_t sent;
+
+ if (str == NULL)
+ sent = pth_write_uint (-1, stream);
+ else
+ {
+ sent = pth_write_uint (length, stream);
+ if (length > 0)
+ sent += pth_write_bytes (str, length, stream);
+ }
+
+ return sent;
+}
+
+
+/* Save the number VAL to file F. Return the number of bytes written. */
+
+static size_t
+pth_write_number (tree val, FILE *f)
+{
+ unsigned type_idx, type_kind;
+ size_t nbytes;
+
+ pth_get_index_from_type (TREE_TYPE (val), &type_idx, &type_kind);
+
+ nbytes = 0;
+ nbytes += pth_write_uint (type_idx, f);
+ nbytes += pth_write_uint (type_kind, f);
+
+ if (type_kind == CPP_N_INTEGER)
+ {
+ HOST_WIDE_INT v[2];
+
+ v[0] = TREE_INT_CST_LOW (val);
+ v[1] = TREE_INT_CST_HIGH (val);
+ nbytes += pth_write_bytes (v, 2 * sizeof (HOST_WIDE_INT), f);
+ }
+ else if (type_kind == CPP_N_FLOATING)
+ {
+ REAL_VALUE_TYPE r = TREE_REAL_CST (val);
+ nbytes += pth_write_bytes (&r, sizeof (REAL_VALUE_TYPE), f);
+ }
+ else if (type_kind == CPP_N_FRACT)
+ {
+ FIXED_VALUE_TYPE fv = TREE_FIXED_CST (val);
+ nbytes += pth_write_bytes (&fv, sizeof (FIXED_VALUE_TYPE), f);
+ }
+ else if (type_kind == CPP_N_IMAGINARY)
+ {
+ pth_write_number (TREE_REALPART (val), f);
+ pth_write_number (TREE_IMAGPART (val), f);
+ }
+ else
+ gcc_unreachable ();
+
+ return nbytes;
+}
+
+
+/* Save the tree associated with TOKEN to file F. Return the number
+ of bytes written. */
+
+static size_t
+pth_save_token_value (cp_token *token, FILE *f)
+{
+ const char *str;
+ size_t nbytes;
+ unsigned len;
+ tree val;
+
+ val = token->u.value;
+ nbytes = 0;
+ switch (token->type)
+ {
+ case CPP_TEMPLATE_ID:
+ case CPP_NESTED_NAME_SPECIFIER:
+ break;
+
+ case CPP_NAME:
+ /* FIXME pph. Hash the strings and emit a string table. */
+ str = IDENTIFIER_POINTER (val);
+ len = IDENTIFIER_LENGTH (val);
+ nbytes += pth_write_string (str, len, f);
+ break;
+
+ case CPP_KEYWORD:
+ /* Nothing to do. We will reconstruct the keyword from
+ ridpointers[token->keyword] at load time. */
+ break;
+
+ case CPP_CHAR:
+ case CPP_WCHAR:
+ case CPP_CHAR16:
+ case CPP_CHAR32:
+ case CPP_NUMBER:
+ nbytes += pth_write_number (val, f);
+ break;
+
+ case CPP_STRING:
+ case CPP_WSTRING:
+ case CPP_STRING16:
+ case CPP_STRING32:
+ /* FIXME pph. Need to represent the type. */
+ str = TREE_STRING_POINTER (val);
+ len = TREE_STRING_LENGTH (val);
+ nbytes += pth_write_string (str, len, f);
+ break;
+
+ case CPP_PRAGMA:
+ /* Nothing to do. Field pragma_kind has already been written. */
+ break;
+
+ default:
+ gcc_assert (token->u.value == NULL);
+ nbytes += pth_write_bytes (&token->u.value, sizeof (token->u.value), f);
+ }
+
+ return nbytes;
+}
+
+
+/* Save TOKEN on file F. Return the number of bytes written on F. */
+
+static size_t
+pth_save_token (cp_token *token, FILE *f)
+{
+ size_t nbytes;
+
+ /* Do not write out the final field in TOKEN. It contains
+ pointers that need to be pickled separately.
+
+ FIXME pph - Need to also emit the location_t table so we can
+ reconstruct it when reading the PTH state. */
+ nbytes = pth_write_bytes (token, sizeof (cp_token) - sizeof (void *), f);
+ nbytes += pth_save_token_value (token, f);
+
+ return nbytes;
+}
+
+
+/* Write header information for IMAGE to STREAM. */
+
+static void
+pth_write_header (pth_image *image, FILE *stream)
+{
+ size_t nbytes;
+ const char *id = pth_id_str ();
+
+ if (!image->digest_computed_p)
+ {
+ pth_get_md5_digest (image->fname, image->digest);
+ image->digest_computed_p = true;
+ }
+
+ nbytes = pth_write_bytes (id, strlen (id), stream);
+ nbytes += pth_write_bytes (image->digest, DIGEST_LEN, stream);
+
+ gcc_assert (nbytes == pth_header_len ());
+}
+
+/* Dump a table of IDENTIFIERS to the STREAM. */
+
+static void
+pth_dump_identifiers (FILE *stream, cpp_idents_used *identifiers)
+{
+ unsigned int idx, col = 1;
+
+ fprintf (stream, "%u identifiers up to %u chars\n",
+ identifiers->num_entries, identifiers->max_length);
+ for (idx = 0; idx < identifiers->num_entries; ++idx)
+ {
+ cpp_ident_use *ident = identifiers->entries + idx;
+
+ if (col + ident->ident_len >= 80)
+ {
+ fprintf (stream, "\n");
+ col = 1;
+ }
+ if (ident->before_str || ident->after_str)
+ {
+ if (col > 1)
+ fprintf (stream, "\n");
+ fprintf (stream, " %s = %s -> %s\n", ident->ident_str,
+ ident->before_str, ident->after_str);
+ col = 1;
+ }
+ else
+ {
+ fprintf (stream, " %s", ident->ident_str);
+ col += ident->ident_len;
+ }
+ }
+ fprintf (stream, "\n");
+}
+
+/* Dump a debug log of the IDENTIFIERS. */
+
+void
+pth_debug_identifiers (cpp_idents_used *identifiers);
+
+void
+pth_debug_identifiers (cpp_idents_used *identifiers)
+{
+ pth_dump_identifiers (stderr, identifiers);
+}
+
+/* Dump a HUNK to the STREAM. */
+
+static void
+pth_dump_hunk (FILE *stream, cp_token_hunk *hunk)
+{
+ fprintf (stream, "Hunk location: { %lu, %lu, %lu }\n", hunk->text_offset.cur,
+ hunk->text_offset.line_base, hunk->text_offset.next_line);
+ fprintf (stream, "Hunk length: %lu characters\n", hunk->text_length);
+ pth_dump_identifiers (stream, &hunk->identifiers);
+ cp_lexer_dump_tokens (stream, hunk->buffer, 0);
+}
+
+/* Dump a debug log of the HUNK. */
+
+static void
+pth_debug_hunk (cp_token_hunk *hunk)
+{
+ pth_dump_hunk (stderr, hunk);
+}
+
+
+/* Dump #include command INCLUDE to FILE. */
+
+static void
+pth_dump_include (FILE *f, pth_include *include)
+{
+ if (include == NULL)
+ return;
+
+ if (include->itype == IT_INCLUDE)
+ fprintf (f, "#include ");
+ else if (include->itype == IT_INCLUDE_NEXT)
+ fprintf (f, "#include_next ");
+ else if (include->itype == IT_IMPORT)
+ fprintf (f, "#import ");
+ else
+ fprintf (f, "#??? ");
+
+ fprintf (f, "%c%s%c",
+ (include->angle_brackets) ? '<' : '"',
+ include->iname,
+ (include->angle_brackets) ? '>' : '"');
+
+ fprintf (f, " (found in %s)\n", include->dname);
+}
+
+
+/* Dump #include command INCLUDE to stderr. */
+
+static void
+pth_debug_include (pth_include *include)
+{
+ pth_dump_include (stderr, include);
+}
+
+
+/* Recursive helper for pth_dump_token_hunks_1. VISITED keeps track of
+ images that have already been dumped to avoid infinite recursion. */
+
+static void
+pth_dump_token_hunks_1 (FILE *f, pth_image *image,
+ struct pointer_set_t *visited)
+{
+ unsigned i, h_ix, i_ix;
+ char s;
+
+ if (pointer_set_insert (visited, image))
+ return;
+
+ fprintf (f, "LC_ENTER: %s {\n", image->fname);
+
+ for (i = 0, h_ix = 0, i_ix = 0;
+ VEC_iterate (char, image->ih_sequence, i, s);
+ i++)
+ {
+ if (s == 'H')
+ {
+ cp_token_hunk *hunk;
+ hunk = VEC_index (cp_token_hunk_ptr, image->token_hunks, h_ix++);
+ pth_dump_hunk (f, hunk);
+ }
+ else if (s == 'I')
+ {
+ pth_include *include;
+ include = VEC_index (pth_include_ptr, image->includes, i_ix++);
+ pth_dump_include (f, include);
+ pth_dump_token_hunks_1 (f, include->image, visited);
+ }
+ }
+
+ fprintf (f, "LC_LEAVE: %s }\n", image->fname);
+}
+
+
+/* Dump all the tokens in IMAGE and the files included by it to F. */
+
+static void
+pth_dump_token_hunks (FILE *f, pth_image *image)
+{
+ struct pointer_set_t *visited = pointer_set_create ();
+ pth_dump_token_hunks_1 (f, image, visited);
+ pointer_set_destroy (visited);
+}
+
+
+/* Dump all the tokens in IMAGE and the files included by it to stderr. */
+
+void
+pth_debug_token_hunks (pth_image *image)
+{
+ pth_dump_token_hunks (stderr, image);
+}
+
+
+/* Dump a debugging representation of IMAGE to F. */
+
+static void
+pth_dump_image (FILE *f, pth_image *image)
+{
+ unsigned i;
+ cp_token_hunk *hunk;
+ pth_include *include;
+ char s;
+
+ if (image == NULL)
+ return;
+
+ fprintf (f, "Image for: %s\n", image->fname);
+
+ fprintf (f, " MD5 digest: ");
+ if (image->digest_computed_p)
+ {
+ for (i = 0; i < DIGEST_LEN; i++)
+ fprintf (f, "%02x", image->digest[i]);
+ fprintf (f, "\n");
+ }
+ else
+ fprintf (f, "NOT COMPUTED\n");
+
+ fprintf (f, " %u token hunks: { ",
+ VEC_length (cp_token_hunk_ptr, image->token_hunks));
+ for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
+ fprintf (f, "%u ", VEC_length (cp_token, hunk->buffer));
+ fprintf (f, "}\n");
+
+ fprintf (f, " %u includes:\n",
+ VEC_length (pth_include_ptr, image->includes));
+ for (i = 0; VEC_iterate (pth_include_ptr, image->includes, i, include); i++)
+ {
+ fprintf (f, "\t");
+ pth_dump_include (f, include);
+ }
+
+ fprintf (f, " Include-Hunk (IH) sequence: ");
+ for (i = 0; VEC_iterate (char, image->ih_sequence, i, s); i++)
+ fputc (s, f);
+ fputc ('\n', f);
+
+ if (image->loaded_p)
+ fprintf (f, " Instantiated from image: %s\n", pth_name_for (image->fname));
+ else
+ {
+ fprintf (f, " Instantiated from character stream: %s\n", image->fname);
+
+ if (image->save_p)
+ fprintf (f, " Will be saved to image: %s\n",
+ pth_name_for (image->fname));
+ else
+ fprintf (f, " Will NOT be saved to an image (not include-guarded)\n");
+ }
+
+ if (image->used_p)
+ fprintf (f, " Image already applied to current compilation context\n");
+
+ if (flag_pth_debug >= 4)
+ pth_dump_token_hunks (f, image);
+}
+
+
+/* Dump a debugging representation of IMAGE to stderr. */
+
+static void
+pth_debug_image (pth_image *image)
+{
+ pth_dump_image (stderr, image);
+}
+
+
+/* Show statistics for PTH image IMAGE on FILE. if FILE is NULL, use
+ pph_logfile. */
+
+static void
+pth_show_image_stats (FILE *file, pth_image *image)
+{
+ unsigned i, num_tokens;
+ cp_token_hunk *hunk;
+
+ if (image == NULL)
+ return;
+
+ if (file == NULL)
+ file = pph_logfile;
+
+ num_tokens = 0;
+ for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
+ num_tokens += VEC_length (cp_token, hunk->buffer);
+
+ fprintf (file, "%s: %u tokens, %u token hunks\n", image->fname, num_tokens,
+ VEC_length (cp_token_hunk_ptr, image->token_hunks));
+}
+
+
+/* Dump the current PTH state to F. */
+
+static void
+pth_dump_state (FILE *f)
+{
+ unsigned i;
+ pth_state *state;
+ pth_image *image;
+
+ state = pth_get_state ();
+ fprintf (f, "Incremental compilation state\n\n");
+ fprintf (f, "%u file images\n", VEC_length (pth_image_ptr, state->cache));
+ for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
+ pth_dump_image (f, image);
+
+ fprintf (f, "\nCurrent image being processed: %s\n",
+ (state->cur_image) ? state->cur_image->fname : "NONE");
+
+ if (state->lexer)
+ {
+ fprintf (f, "Tokens in main lexer:\n");
+ cp_lexer_dump_tokens (f, state->lexer->buffer, 0);
+ }
+}
+
+
+/* Dump the current PTH state to stderr. */
+
+void
+pth_debug_state (void)
+{
+ pth_dump_state (stderr);
+}
+
+
+/* Save the IDENTIFIERS to the STREAM. */
+
+static void
+pth_save_identifiers (cpp_idents_used *identifiers, FILE *stream)
+{
+ unsigned int num_entries, id;
+
+ num_entries = identifiers->num_entries;
+ pth_write_uint (identifiers->max_length, stream);
+ pth_write_uint (num_entries, stream);
+
+ for ( id = 0; id < num_entries; ++id )
+ {
+ cpp_ident_use *entry = identifiers->entries + id;
+
+ gcc_assert (entry->ident_len <= identifiers->max_length);
+ pth_write_string (entry->ident_str, entry->ident_len, stream);
+
+ gcc_assert (entry->before_len <= identifiers->max_length);
+ pth_write_string (entry->before_str, entry->before_len, stream);
+
+ gcc_assert (entry->after_len <= identifiers->max_length);
+ pth_write_string (entry->after_str, entry->after_len, stream);
+ }
+}
+
+/* Save the HUNK to the STREAM. */
+
+static void
+pth_save_hunk (cp_token_hunk *hunk, FILE *stream)
+{
+ unsigned j;
+ cp_token *token;
+
+ if (flag_pth_debug >= 5)
+ pth_debug_hunk (hunk);
+
+ /* Write out the identifiers used by HUNK. */
+ pth_save_identifiers (&hunk->identifiers, stream);
+
+ /* Write the offset into the text file where this token starts. */
+ pth_write_sizet (hunk->text_offset.cur, stream);
+ pth_write_sizet (hunk->text_offset.line_base, stream);
+ pth_write_sizet (hunk->text_offset.next_line, stream);
+
+ /* Write the length of the hunk. */
+ pth_write_sizet (hunk->text_length, stream);
+
+ /* Write the number of tokens in HUNK. */
+ pth_write_uint (VEC_length (cp_token, hunk->buffer), stream);
+
+ /* Write the tokens. */
+ for (j = 0; VEC_iterate (cp_token, hunk->buffer, j, token); j++)
+ pth_save_token (token, stream);
+}
+
+
+/* Save the #include directive INCLUDE to STREAM. */
+
+static void
+pth_save_include (pth_include *include, FILE *stream)
+{
+ pth_write_string (include->image->fname, strlen (include->image->fname),
+ stream);
+ pth_write_uint ((unsigned int) include->itype, stream);
+ pth_write_uint (include->angle_brackets, stream);
+ pth_write_string (include->iname, strlen (include->iname), stream);
+ pth_write_string (include->dname,
+ include->dname ? strlen (include->dname) : 0,
+ stream);
+}
+
+
+/* Save the PTH image IMAGE to a file. */
+
+static void
+pth_save_image (pth_image *image)
+{
+ FILE *stream;
+ cp_token_hunk *hunk;
+ unsigned i, num;
+ char *buf;
+ pth_include *include;
+
+ timevar_push (TV_PTH_SAVE);
+
+ /* Open the stream in append mode since we have already created
+ it in pth_new_image. */
+ stream = pth_file_for (image->fname, "wb");
+
+ /* Write an invalid header first to avoid leaving a seemingly
+ valid file in case of failure. */
+ buf = XCNEWVEC (char, pth_header_len ());
+ pth_write_bytes (buf, pth_header_len (), stream);
+
+ /* Write the include-hunk (IH) sequencing vector. */
+ num = VEC_length (char, image->ih_sequence);
+ pth_write_uint (num, stream);
+ if (num > 0)
+ pth_write_bytes (VEC_address (char, image->ih_sequence), num, stream);
+
+ /* Write the number of #include commands. */
+ pth_write_uint (VEC_length (pth_include_ptr, image->includes), stream);
+
+ /* Write all the #include commands used by IMAGE. */
+ for (i = 0; VEC_iterate (pth_include_ptr, image->includes, i, include); i++)
+ pth_save_include (include, stream);
+
+ /* Write the number of token caches in the cache. */
+ pth_write_uint (VEC_length (cp_token_hunk_ptr, image->token_hunks), stream);
+
+ /* Write all the token hunks in image. */
+ for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
+ pth_save_hunk (hunk, stream);
+
+ /* Now write a valid header. */
+ fseek (stream, 0, SEEK_SET);
+ pth_write_header (image, stream);
+
+ /* Clean up. */
+ fclose (stream);
+ free (buf);
+ image->save_p = false;
+
+ if (flag_pth_debug >= 3)
+ {
+ fprintf (stderr, "\nSaved image for %s:\n", image->fname);
+ pth_debug_image (image);
+ }
+
+ timevar_pop (TV_PTH_SAVE);
+}
+
+
+/* Given a type index TYPE_IDX and TYPE_KIND specifying the kind of type,
+ return a type from integer_types or global_trees. */
+
+static tree
+pth_get_type_from_index (unsigned type_idx, unsigned type_kind)
+{
+ if (type_kind == CPP_N_INTEGER)
+ return integer_types[type_idx];
+ else if (type_kind == CPP_N_FLOATING || type_kind == CPP_N_FRACT)
+ return global_trees[type_idx];
+ else if (type_kind == CPP_N_IMAGINARY)
+ {
+ /* We don't need a type for the complex number. The type is
+ associated with the real and imaginary parts. */
+ return NULL_TREE;
+ }
+ else
+ gcc_unreachable ();
+}
+
+
+/* Read an unsigned int into *VAR_P. */
+
+static void
+pth_read_uint (unsigned int *var_p, FILE *stream)
+{
+ size_t received = fread (var_p, sizeof *var_p, 1, stream);
+ gcc_assert (received == 1);
+}
+
+
+/* Read a size_t into *VAR_P. */
+
+static void
+pth_read_sizet (size_t *var_p, FILE *stream)
+{
+ size_t received = fread (var_p, sizeof *var_p, 1, stream);
+ gcc_assert (received == 1);
+}
+
+
+/* Read N bytes into P from STREAM. The caller is responsible
+ for allocating sufficient memory for P. */
+
+static inline void
+pth_read_bytes (void *p, size_t n, FILE *stream)
+{
+ size_t received = fread (p, 1, n, stream);
+ gcc_assert (received == n);
+}
+
+
+/* Read a string of up to MAX characters from STREAM into BUFFER.
+ Return the actual string length read from STREAM. The caller is
+ responsible for allocating sufficient memory for BUFFER. */
+
+static unsigned int
+pth_read_string (char *buffer, unsigned int max, FILE *stream)
+{
+ unsigned int length;
+ size_t received;
+
+ received = fread (&length, sizeof length, 1, stream);
+ gcc_assert (received == 1 && (length == -1U || length <= max));
+ if (length > 0 && length != -1U)
+ {
+ received = fread (buffer, 1, length, stream);
+ gcc_assert (received == length);
+ }
+
+ return length;
+}
+
+
+/* Read a string from STREAM allocating enough memory on the
+ heap to hold it.
+
+ This function assumes that strings are represented as a length
+ followed by the string content. A terminating '\0' is added
+ automatically. */
+
+static inline char *
+pth_read_string_alloc (FILE *stream)
+{
+ char *s;
+ unsigned int len;
+
+ pth_read_uint (&len, stream);
+
+ /* By convention, NULL strings are represented with length -1U. */
+ if (len == -1U)
+ return NULL;
+
+ s = XCNEWVEC (char, len + 1);
+ pth_read_bytes (s, len, stream);
+
+ return s;
+}
+
+
+/* Load a numeric value from file F. Return the corresponding tree. */
+
+static tree
+pth_load_number (FILE *f)
+{
+ unsigned type_idx, type_kind;
+ tree type, val;
+
+ pth_read_uint (&type_idx, f);
+ pth_read_uint (&type_kind, f);
+
+ type = pth_get_type_from_index (type_idx, type_kind);
+
+ if (type_kind == CPP_N_INTEGER)
+ {
+ HOST_WIDE_INT v[2];
+ pth_read_bytes (v, 2 * sizeof (HOST_WIDE_INT), f);
+ val = build_int_cst_wide (type, v[0], v[1]);
+ }
+ else if (type_kind == CPP_N_FLOATING)
+ {
+ REAL_VALUE_TYPE r;
+ pth_read_bytes (&r, sizeof (REAL_VALUE_TYPE), f);
+ val = build_real (type, r);
+ }
+ else if (type_kind == CPP_N_FRACT)
+ {
+ FIXED_VALUE_TYPE fv;
+ pth_read_bytes (&fv, sizeof (FIXED_VALUE_TYPE), f);
+ val = build_fixed (type, fv);
+ }
+ else if (type_kind == CPP_N_IMAGINARY)
+ {
+ tree r = pth_load_number (f);
+ tree i = pth_load_number (f);
+ val = build_complex (NULL_TREE, r, i);
+ }
+ else
+ gcc_unreachable ();
+
+ return val;
+}
+
+
+/* Load the tree value associated with TOKEN to file F. */
+
+static void
+pth_load_token_value (cp_token *token, FILE *f)
+{
+ char *str;
+
+ switch (token->type)
+ {
+ case CPP_TEMPLATE_ID:
+ case CPP_NESTED_NAME_SPECIFIER:
+ break;
+
+ case CPP_NAME:
+ str = pth_read_string_alloc (f);
+ token->u.value = get_identifier (str);
+ free (str);
+ break;
+
+ case CPP_KEYWORD:
+ token->u.value = ridpointers[token->keyword];
+ break;
+
+ case CPP_CHAR:
+ case CPP_WCHAR:
+ case CPP_CHAR16:
+ case CPP_CHAR32:
+ case CPP_NUMBER:
+ token->u.value = pth_load_number (f);
+ break;
+
+ case CPP_STRING:
+ case CPP_WSTRING:
+ case CPP_STRING16:
+ case CPP_STRING32:
+ str = pth_read_string_alloc (f);
+ token->u.value = build_string (strlen (str), str);
+ free (str);
+ break;
+
+ case CPP_PRAGMA:
+ /* Nothing to do. Field pragma_kind has already been loaded. */
+ break;
+
+ default:
+ pth_read_bytes (&token->u.value, sizeof (token->u.value), f);
+ gcc_assert (token->u.value == NULL);
+ }
+}
+
+
+/* Load the IDENTIFERS for a hunk from a STREAM. */
+
+static void
+pth_load_identifiers (cpp_idents_used *identifiers, FILE *stream)
+{
+ unsigned int j;
+ unsigned int max_length, num_entries;
+ char *buffer;
+ unsigned int ident_len, before_len, after_len;
+
+ pth_read_uint (&max_length, stream);
+ identifiers->max_length = max_length;
+ pth_read_uint (&num_entries, stream);
+ identifiers->num_entries = num_entries;
+ identifiers->entries = XCNEWVEC (cpp_ident_use, num_entries);
+ identifiers->strings = XCNEW (struct obstack);
+
+ /* Strings need no alignment. */
+ _obstack_begin (identifiers->strings, 0, 0,
+ (void *(*) (long)) xmalloc,
+ (void (*) (void *)) free);
+ obstack_alignment_mask (identifiers->strings) = 0;
+ /* FIXME pph: We probably need to free all these things somewhere. */
+
+ buffer = XCNEWVEC (char, max_length + 1);
+
+ /* Read the identifiers in HUNK. */
+ for (j = 0; j < num_entries; ++j)
+ {
+ ident_len = pth_read_string ( buffer, max_length, stream);
+ gcc_assert (ident_len > 0 && ident_len != -1U);
+ identifiers->entries[j].ident_len = ident_len;
+ identifiers->entries[j].ident_str =
+ (const char *) obstack_copy0 (identifiers->strings, buffer, ident_len);
+
+ before_len = pth_read_string ((char *) buffer, max_length, stream);
+ identifiers->entries[j].before_len = before_len;
+ if (before_len == -1U)
+ identifiers->entries[j].before_str = NULL;
+ else
+ identifiers->entries[j].before_str = (const char *)
+ obstack_copy0 (identifiers->strings, buffer, before_len);
+
+ after_len = pth_read_string ((char *) buffer, max_length, stream);
+ identifiers->entries[j].after_len = after_len;
+ if (after_len == -1U)
+ identifiers->entries[j].after_str = NULL;
+ else
+ identifiers->entries[j].after_str = (const char *)
+ obstack_copy0 (identifiers->strings, buffer, after_len);
+ }
+
+ free (buffer);
+}
+
+
+/* Load a hunk into the IMAGE from a STREAM. */
+
+static void
+pth_load_hunk (pth_image *image, FILE *stream)
+{
+ unsigned j, num_tokens;
+ cp_token_hunk *hunk;
+
+ hunk = ggc_alloc_cleared_cp_token_hunk ();
+
+ /* Setup the identifier list. */
+ pth_load_identifiers (&hunk->identifiers, stream);
+
+ /* Read the offset into the text file where this token starts. */
+ pth_read_sizet (&hunk->text_offset.cur, stream);
+ pth_read_sizet (&hunk->text_offset.line_base, stream);
+ pth_read_sizet (&hunk->text_offset.next_line, stream);
+
+ /* Read the text length of the hunk. */
+ pth_read_sizet (&hunk->text_length, stream);
+
+ /* Read the number of tokens in HUNK. */
+ pth_read_uint (&num_tokens, stream);
+
+ /* Read the tokens in the HUNK. */
+ hunk->buffer = VEC_alloc (cp_token, gc, num_tokens);
+ for (j = 0; j < num_tokens; j++)
+ {
+ cp_token *token = VEC_quick_push (cp_token, hunk->buffer, NULL);
+
+ /* Do not read the whole structure, the token value has
+ dynamic size as it contains swizzled pointers.
+ FIXME pph, restructure to allow bulk reads of the whole
+ section. */
+ pth_read_bytes (token, sizeof (cp_token) - sizeof (void *), stream);
+
+ /* FIXME pph. Use an arbitrary (but valid) location to avoid
+ confusing the rest of the compiler for now. */
+ token->location = input_location;
+
+ /* FIXME pph: verify that pth_load_token_value works with no tokens. */
+ pth_load_token_value (token, stream);
+ }
+ gcc_assert (num_tokens == VEC_length (cp_token, hunk->buffer));
+
+ VEC_quick_push (cp_token_hunk_ptr, image->token_hunks, hunk);
+}
+
+
+/* Create a new empty #include directive for NAME. ITYPE is one of
+ the supported include commands. ANGLE_BRACKETS is true if the
+ include used '<>'. */
+
+static pth_include *
+pth_create_include (enum include_type itype, bool angle_brackets,
+ const char *name)
+{
+ pth_include *include = ggc_alloc_cleared_pth_include ();
+ include->itype = itype;
+ include->angle_brackets = angle_brackets;
+ include->iname = (name) ? xstrdup (name) : name;
+
+ return include;
+}
+
+
+/* Load an #include directive for IMAGE from STREAM. */
+
+static void
+pth_load_include (pth_state *state, pth_image *image, cpp_reader *reader,
+ FILE *stream)
+{
+ char *s;
+ pth_include *include;
+ unsigned tmp;
+
+ include = pth_create_include (IT_INCLUDE, false, NULL);
+
+ s = pth_read_string_alloc (stream);
+ include->image = pth_image_lookup (state, s, reader);
+
+ pth_read_uint (&tmp, stream);
+ include->itype = (enum include_type) tmp;
+
+ pth_read_uint (&tmp, stream);
+ include->angle_brackets = (tmp != 0);
+
+ include->iname = pth_read_string_alloc (stream);
+ include->dname = pth_read_string_alloc (stream);
+
+ VEC_safe_push (pth_include_ptr, gc, image->includes, include);
+}
+
+
+/* Load a PTH image for LEXER using the READER. */
+
+static void
+pth_load_image (pth_state *state, pth_image *image, cpp_reader *reader)
+{
+ FILE *stream;
+ unsigned i, num;
+
+ timevar_push (TV_PTH_LOAD);
+
+ stream = pth_file_for (image->fname, "r+b");
+
+ /* Skip over the header, as we assume that it has already been
+ validated by pth_have_valid_image_for. */
+ fseek (stream, (long) pth_header_len (), SEEK_SET);
+
+ /* Read the include-hunk (IH) sequencing vector. */
+ pth_read_uint (&num, stream);
+ if (num > 0)
+ {
+ image->ih_sequence = VEC_alloc (char, gc, num);
+ VEC_safe_grow (char, gc, image->ih_sequence, num);
+ pth_read_bytes (VEC_address (char, image->ih_sequence), num, stream);
+ }
+
+ /* Read the number path names of all the files #included by
+ IMAGE->FNAME. */
+ pth_read_uint (&num, stream);
+ image->includes = VEC_alloc (pth_include_ptr, gc, num);
+
+ /* Now read all the path names #included by IMAGE->FNAME. */
+ for (i = 0; i < num; i++)
+ pth_load_include (state, image, reader, stream);
+
+ /* Read how many token hunks are contained in this image. */
+ pth_read_uint (&num, stream);
+ image->token_hunks = VEC_alloc (cp_token_hunk_ptr, gc, num);
+
+ PTH_STATS_INCR (hunks, num);
+
+ /* Read all the token hunks. */
+ for (i = 0; i < num; i++)
+ pth_load_hunk (image, stream);
+
+ fclose (stream);
+
+ /* Indicate that we have loaded this image from a file. */
+ image->loaded_p = true;
+ image->save_p = false;
+ image->used_p = false;
+
+ if (flag_pth_debug >= 3)
+ {
+ fprintf (stderr, "\nLoaded image for %s:\n", image->fname);
+ pth_debug_image (image);
+ }
+
+ timevar_pop (TV_PTH_LOAD);
+}
+
+
+/* Return true if FNAME has a PTH image that can be used. If an image
+ already exists, compute the MD5 digest for FNAME and store it
+ in IMAGE. */
+
+static bool
+pth_have_valid_image_for (const char *fname, pth_image *image)
+{
+ FILE *f = NULL;
+ struct stat s;
+ char *img_name, *id;
+ const char *good_id;
+ char saved_digest[DIGEST_LEN];
+
+ image->digest_computed_p = false;
+
+ img_name = pth_name_for (fname);
+ if (stat (img_name, &s) != 0)
+ goto invalid_img;
+
+ /* If the file exists, check if it has a valid signature. */
+ f = fopen (img_name, "r");
+
+ good_id = pth_id_str ();
+ id = XCNEWVEC (char, strlen (good_id) + 1);
+ pth_read_bytes (id, strlen (good_id), f);
+ if (strcmp (id, good_id) != 0)
+ goto invalid_img;
+
+ /* Now check if the MD5 digest stored in the image file matches the
+ digest for FNAME. */
+ pth_read_bytes (saved_digest, DIGEST_LEN, f);
+ pth_get_md5_digest (fname, image->digest);
+ image->digest_computed_p = true;
+ if (memcmp (image->digest, saved_digest, DIGEST_LEN) != 0)
+ goto invalid_img;
+
+ fclose (f);
+ return true;
+
+invalid_img:
+ if (f)
+ fclose (f);
+
+ return false;
+}
+
+
+/* Create a new PTH cache object for file FNAME. */
+
+static pth_image *
+pth_new_image (const char *fname)
+{
+ pth_image *image;
+
+ image = ggc_alloc_cleared_pth_image ();
+ image->fname = fname;
+
+ return image;
+}
+
+
+/* Return a cache image associated with file FNAME. STATE holds
+ the PTH cache to use. */
+
+pth_image *
+pth_image_lookup (pth_state *state, const char *fname, cpp_reader *reader)
+{
+ void **slot;
+ pth_image *image, e;
+
+ if (fname == NULL)
+ return NULL;
+
+ e.fname = fname;
+ slot = htab_find_slot (state->cache_dir, &e, INSERT);
+ if (*slot == NULL)
+ {
+ /* Create a new image and store it in the cache. */
+ image = pth_new_image (fname);
+ *slot = image;
+ VEC_safe_push (pth_image_ptr, gc, state->cache, image);
+
+ /* If a valid disk image already exists for FNAME, load it.
+ Otherwise, mark the memory image for processing and saving. */
+ if (pth_have_valid_image_for (fname, image))
+ pth_load_image (state, image, reader);
+ else
+ image->save_p = true;
+ }
+ else
+ image = *((pth_image **) slot);
+
+ return image;
+}
+
+
+/* Add all the tokens in HUNK to the end of LEXER->BUFFER. IMAGE is
+ the memory image holding HUNK. */
+
+static void
+pth_append_hunk (cp_lexer *lexer, pth_image *image, cp_token_hunk *hunk)
+{
+ cp_token *lexer_addr, *hunk_addr;
+ unsigned lexer_len, hunk_len;
+
+ PTH_STATS_INCR (valid_hunks, 1);
+
+ /* Apply all the identifiers used and defined by HUNK. */
+ cpp_lt_replay (parse_in, &hunk->identifiers);
+
+ /* If this file has been read in memory (e.g., by being #included
+ from a tainted file), advance the text buffer pointer to the end
+ of the hunk to avoid reading it again. */
+ if (image->buffer)
+ cpp_set_pos (image->buffer, hunk->text_offset);
+
+ hunk_len = VEC_length (cp_token, hunk->buffer);
+
+ /* Some hunks have no tokens and they are only useful for the
+ macros defined by them. This is useful when one or more
+ image files are tainted and need to be restored from their
+ character stream. */
+ if (hunk_len == 0)
+ return;
+
+ /* Determine the last location in LEXER->BUFFER before growing it. */
+ lexer_len = VEC_length (cp_token, lexer->buffer);
+ VEC_safe_grow (cp_token, gc, lexer->buffer, lexer_len + hunk_len);
+
+ /* Bulk copy all the tokens in HUNK to the end of LEXER->BUFFER. */
+ lexer_addr = VEC_address (cp_token, lexer->buffer);
+ hunk_addr = VEC_address (cp_token, hunk->buffer);
+ memcpy (&lexer_addr[lexer_len], hunk_addr, hunk_len * sizeof (cp_token));
+
+ if (flag_pth_debug >= 2)
+ {
+ fprintf (stderr, "\n=> ADDED TOKEN HUNK TO LEXER BUFFER");
+ if (flag_pth_debug >= 5)
+ pth_debug_hunk (hunk);
+ }
+}
+
+
+/* Return true if HUNK can be used in the current compilation
+ context of the cpp READER. It must validate the identifier state. */
+
+static bool
+pth_hunk_is_valid_p (pth_image *image, cp_token_hunk *hunk, cpp_reader *reader)
+{
+ bool verified;
+ cpp_ident_use *bad_use;
+ const char *cur_def;
+
+ timevar_push (TV_PTH_DEPENDENCY);
+ verified = cpp_lt_verify (reader, &hunk->identifiers, &bad_use, &cur_def);
+ if (!verified && flag_pth_debug >= 1)
+ {
+ fprintf (stderr, "PTH: %s failed verification: %s : <%s> -> <%s>\n",
+ pth_name_for (image->fname), bad_use->ident_str,
+ bad_use->before_str, cur_def);
+ }
+ PTH_STATS_INCR (verified_hunks, 1);
+ PTH_STATS_INCR (verified_identifiers, hunk->identifiers.num_entries);
+ timevar_pop (TV_PTH_DEPENDENCY);
+ return verified;
+}
+
+
+/* Return true if IMAGE can be used in the current compilation context. */
+
+static bool
+pth_image_can_be_used (pth_image *image)
+{
+ return image && image->loaded_p && !image->used_p;
+}
+
+
+/* Split NAME into its directory and file name components, storing them
+ in *DNAME_P and *FNAME_P. After using it, *DNAME_P should be freed
+ by the caller. */
+
+static void
+pth_get_dir_and_name (const char *name, char **dname_p, const char **fname_p)
+{
+ size_t len;
+
+ *fname_p = lbasename (name);
+ *dname_p = NULL;
+
+ len = *fname_p - name;
+ if (len > 0)
+ {
+ *dname_p = XNEWVEC (char, len + 1);
+ memcpy (*dname_p, name, len);
+ (*dname_p)[len] = '\0';
+ gcc_assert (IS_DIR_SEPARATOR ((*dname_p)[len - 1]));
+ }
+}
+
+
+/* Read tokens from the text stream in IMAGE->FNAME into LEXER.
+ If INCLUDE is not NULL, it describes how IMAGE->FNAME was
+ #included originally. Otherwise, it is assumed to be an
+ include command done with the flag -include.
+
+ This is used when an image is found to be tainted and tokens
+ need to be read from the original character stream. OFFSET
+ indicates how far into the character stream to start reading at. */
+
+static void
+pth_process_text_file (cp_lexer *lexer, pth_image *image, pth_include *include,
+ cpp_offset offset)
+{
+ bool prev_permissive, prev_inhibit_warnings;
+ bool pushed_p;
+ cpp_buffer *buffer;
+ lexer_state *state;
+
+ /* Emulate a #include directive on IMAGE->FNAME, if needed. Note
+ that if we are already inside the CPP buffer for IMAGE->FNAME
+ we should not include it again, since this will cause another
+ call to pth_file_change which will again register IMAGE->FNAME as
+ an include for the parent file. */
+ state = NULL;
+ if (image->buffer != cpp_get_buffer (parse_in))
+ {
+ if (include == NULL || include->itype == IT_INCLUDE_NEXT)
+ {
+ char *dname;
+ const char *fname;
+ pth_get_dir_and_name (image->fname, &dname, &fname);
+ pushed_p = cpp_push_include_type (parse_in, dname, fname, false,
+ IT_INCLUDE);
+
+ /* FIXME pph. We are leaking DNAME here. libcpp
+ wants the directory name in permanent storage so we
+ cannot free it, but we should put it in an obstack
+ so it can be reclaimed at some point. */
+ }
+ else
+ pushed_p = cpp_push_include_type (parse_in,
+ include->dname,
+ include->iname,
+ include->angle_brackets,
+ include->itype);
+
+ if (!pushed_p)
+ return;
+ }
+ else
+ {
+ /* Since we already have the buffer on top of the stack,
+ reset the state of the lexer to avoid skipping over it. */
+ state = cpp_reset_lexer_state (parse_in);
+ }
+
+ /* Inhibit libcpp error messages (ignore things like unmatched #endifs).
+ We need to do this because token hunks may span #if/#endif boundaries.
+ For instance,
+
+ #if <COND>
+ H1 [1]
+ #else
+ H2 [2]
+ #include "foo.h"
+ H3 [3]
+ #endif
+ H1 or H3 [4]
+
+ In this example we have 3 hunks (H1, H2 and H3). Depending on the
+ value of <COND> at image creation time, point [4] will belong to
+ hunk H1 (if <COND> was true) or hunk H3 (if <COND> was false).
+
+ When this image is loaded, if H3 cannot be applied because its
+ dependences fail to hold, then we will start pre-processing the
+ text for the file at the start of hunk H3. This will find a
+ dangling #endif which triggers a libcpp error. Since we know
+ that we are in the correct arm of the #if (after all H2 was
+ applied from the image), we can safely ignore the error. */
+ prev_permissive = global_dc->permissive;
+ prev_inhibit_warnings = global_dc->dc_inhibit_warnings;
+ global_dc->dc_inhibit_warnings = true;
+ global_dc->permissive = true;
+
+ /* Position the reader at OFFSET and request to stop reading at
+ the end of it. */
+ buffer = cpp_get_buffer (parse_in);
+ cpp_set_pos (buffer, offset);
+ cpp_return_at_eof (buffer, true);
+
+ /* Get tokens from IMAGE->FNAME. */
+ cp_lexer_get_tokens (lexer);
+
+ /* Since we read this file separately, the very last token in LEXER
+ will now contain an EOF, which we do not need. */
+ VEC_pop (cp_token, lexer->buffer);
+ cpp_return_at_eof (buffer, false);
+
+ /* Restore libcpp error/warnings. */
+ global_dc->permissive = prev_permissive;
+ global_dc->dc_inhibit_warnings = prev_inhibit_warnings;
+
+ /* Restore the parser state, if necessary. */
+ if (state)
+ cpp_restore_lexer_state (parse_in, state);
+}
+
+
+/* Populate LEXER->BUFFER with all the valid token hunks in
+ IMAGE. If possible, try to load token hunks from files
+ included by IMAGE as well.
+
+ This means that we try to load the whole transitive closure
+ starting at IMAGE until we find the first unloadable file.
+
+ Once we find the first unloadable token hunk, we skip the token
+ hunks from the character stream so that they don't need to be
+ pre-processed again.
+
+ If non-NULL, INCLUDE describes the #include command used to include
+ IMAGE->FNAME. */
+
+static void
+pth_image_to_lexer (cp_lexer *lexer, pth_image *image, pth_include *include)
+{
+ unsigned i, h_ix, i_ix;
+ char s;
+
+ /* If we are trying to apply the same image more than once,
+ something is wrong. We never create images for files that
+ are included more than once, so we should never try to apply
+ the same image more than once. */
+ gcc_assert (pth_image_can_be_used (image));
+
+ image->used_p = true;
+
+ if (flag_pth_debug >= 2)
+ {
+ fprintf (stderr, "\n<= INCORPORATING IMAGE %s INTO COMPILATION CONTEXT\n",
+ image->fname);
+ if (flag_pth_debug >= 3)
+ pth_debug_include (include);
+ }
+
+ PTH_STATS_INCR (valid_images, 1);
+
+ for (i = 0, h_ix = 0, i_ix = 0;
+ VEC_iterate (char, image->ih_sequence, i, s);
+ i++)
+ {
+ if (s == 'H')
+ {
+ cp_token_hunk *hunk;
+
+ hunk = VEC_index (cp_token_hunk_ptr, image->token_hunks, h_ix++);
+ if (pth_hunk_is_valid_p (image, hunk, parse_in))
+ pth_append_hunk (lexer, image, hunk);
+ else
+ {
+ PTH_STATS_INCR (invalid_hunks, 1);
+
+ pth_process_text_file (lexer, image, NULL, hunk->text_offset);
+
+ /* Since this hunk is invalid, assume that everything
+ downstream from this hunk is also invalid. FIXME pph,
+ it may be possible to optimize this. We should be
+ able to pre-process from text exactly
+ HUNK->TEXT_LENGTH characters instead of the whole
+ file. */
+ break;
+ }
+ }
+ else if (s == 'I')
+ {
+ pth_include *incdir;
+ pth_get_state ()->cur_image = image;
+ incdir = VEC_index (pth_include_ptr, image->includes, i_ix++);
+ if (pth_image_can_be_used (incdir->image))
+ pth_image_to_lexer (lexer, incdir->image, incdir);
+ else
+ pth_process_text_file (lexer, incdir->image, incdir,
+ cpp_buffer_start);
+ }
+ else
+ gcc_unreachable ();
+ }
+
+ /* If we just applied the tokens for the main input filename,
+ we need to append a CPP_EOF token, since that one is never
+ saved with the token hunks. */
+ if (pathnames_equal_p (image->fname, main_input_filename))
+ VEC_safe_push (cp_token, gc, lexer->buffer, &eof_token);
+
+ /* If IMAGE has a libcpp buffer associated with it, it means that a
+ file that was being pre-processed from text has #included IMAGE
+ and the pre-processor has executed the file change logic.
+
+ In that case, the pre-processor will want to finish processing
+ IMAGE's text, and since we have just applied its tokens from
+ the image, the result will be duplicate tokens. To prevent
+ this, we tell libcpp to skip over the whole text buffer
+ associated with IMAGE. */
+ if (image->buffer)
+ cpp_set_pos (image->buffer, cpp_buffer_end);
+
+ return;
+}
+
+
+/* Create a token hunk for IMAGE from the token buffer in
+ LEXER->BUFFER. The hunk will contain all the tokens starting at
+ IMAGE->HUNK_START_IX to the end of LEXER->BUFFER.
+
+ The new token hunk will be added to the end of IMAGE->TOKEN_HUNKS. */
+
+static void
+pth_lexer_to_image (pth_image *image, cp_lexer *lexer, cpp_reader *reader)
+{
+ cp_token *lexer_addr, *hunk_addr;
+ cp_token_hunk *hunk;
+ unsigned num_tokens, start_ix, end_ix;
+ cpp_offset pos;
+
+ /* Create a new token hunk. */
+ hunk = ggc_alloc_cleared_cp_token_hunk ();
+ VEC_safe_push (cp_token_hunk_ptr, gc, image->token_hunks, hunk);
+ VEC_safe_push (char, gc, image->ih_sequence, 'H');
+
+ /* The identifiers that may conflict with macros. */
+ if (flag_pth_debug >= 2)
+ cpp_lt_statistics (reader);
+ hunk->identifiers = cpp_lt_capture (reader);
+
+ /* Remember the text offset where this hunk started and its length. */
+ hunk->text_offset = image->hunk_text_offset;
+ pos = cpp_get_pos (image->buffer);
+ gcc_assert (pos.cur >= hunk->text_offset.cur);
+ hunk->text_length = pos.cur - hunk->text_offset.cur;
+
+ /* Compute the bounds for the new token hunk. */
+ start_ix = image->hunk_start_ix;
+ end_ix = VEC_length (cp_token, lexer->buffer);
+ gcc_assert (end_ix >= start_ix);
+ num_tokens = end_ix - start_ix;
+
+ if (num_tokens > 0)
+ {
+ /* Copy tokens from LEXER->BUFFER into the new hunk. */
+ hunk->buffer = VEC_alloc (cp_token, gc, num_tokens);
+ VEC_safe_grow (cp_token, gc, hunk->buffer, num_tokens);
+ lexer_addr = VEC_address (cp_token, lexer->buffer);
+ hunk_addr = VEC_address (cp_token, hunk->buffer);
+ memcpy (hunk_addr, &lexer_addr[start_ix], num_tokens * sizeof (cp_token));
+ }
+
+ if (flag_pth_debug >= 3)
+ {
+ fprintf (stderr, "\n=> SAVED HUNK TO IMAGE: %s\n", image->fname);
+ if (flag_pth_debug >= 5)
+ pth_debug_hunk (hunk);
+ }
+}
+
+
+/* Compute the effects of a file transition given the file change
+ described by MAP. On exit:
+
+ - *PREV_IMAGE_P will point to the image for the file that we just left,
+
+ - *NEW_IMAGE_P will point to the image for the file that we just
+ entered. If *NEW_IMAGE_P is NULL, it means that we just left
+ the last file in the translation unit, so there isn't anything
+ else to be done.
+
+ - *REASON_P will have the LC_* reason for the change. */
+
+static void
+pth_get_file_transition (const struct line_map *map, pth_image **prev_image_p,
+ pth_image **new_image_p, enum lc_reason *reason_p)
+{
+ const char *fname;
+ pth_state *state;
+
+ /* MAP is NULL when we leave the main file in this translation unit. */
+ if (map == NULL)
+ {
+ fname = NULL;
+ *reason_p = LC_LEAVE;
+ }
+ else
+ {
+ fname = map->to_file;
+ *reason_p = map->reason;
+ }
+
+ state = pth_get_state ();
+ *prev_image_p = state->cur_image;
+
+ /* FIXME pph. Sanitize use of PARSE_IN. Stick it in
+ pth_state together with lexer. */
+ *new_image_p = pth_image_lookup (state, fname, parse_in);
+}
+
+
+/* Do bookkeeping actions required when the pre-processor is leaving
+ file IMAGE->FNAME. READER is the cpp file reader object we
+ are using for lexing. */
+
+static void
+pth_leave_file (cpp_reader *reader, pth_image *image)
+{
+ pth_state *state;
+
+ /* We are only interested in processing IMAGE if we have decided to
+ save its image. */
+ if (!image->save_p)
+ return;
+
+ state = pth_get_state ();
+
+ /* If the image for the file we just finished is marked as
+ modified, create a new token hunk spanning from the token
+ that started the image to the current end of the lexer
+ buffer. */
+ pth_lexer_to_image (image, state->lexer, reader);
+}
+
+
+/* Do bookkeeping actions required when the pre-processor is entering
+ file IMAGE->FNAME for reason REASON. READER is the cpp file reader
+ object we are using for lexing. INCLUDE is the #include command
+ used to enter IMAGE->FNAME. It can be NULL in the case of the
+ top file in the translation unit. */
+
+static void
+pth_enter_file (cpp_reader *reader, pth_image *image, pth_include *include,
+ enum lc_reason reason)
+{
+ pth_state *state;
+
+ state = pth_get_state ();
+
+ /* Associate the current buffer with IMAGE. */
+ image->buffer = cpp_get_buffer (reader);
+
+ /* Complete the current #include command with the directory
+ and image for the file that we just switched to. */
+ if (include)
+ {
+ const char *dname = cpp_get_dir (cpp_get_file (image->buffer))->name;
+ include->image = image;
+ include->dname = (*dname) ? xstrdup (dname) : NULL;
+ }
+
+ /* If the file we are about to switch to has been loaded into an
+ image, try to get as many tokens as possible from the image
+ instead of the character stream. */
+ if (pth_image_can_be_used (image))
+ pth_image_to_lexer (state->lexer, image, include);
+
+ /* If IMAGE does not need to be saved, we are done. */
+ if (!image->save_p)
+ return;
+
+ /* Detect multiple inclusions of the same header file. When a file
+ is included more than once, each inclusion will usually produce
+ different token hunks (e.g., <stddef.h> is typically included
+ from different places with "arguments" in the form of #defines
+ that determine what the caller wants stddef.h to provide. See
+ <wchar.h> for an example).
+
+ This disrupts the validity of the image, as the hunks saved in it
+ no longer correspond to a single pre-processing of the file. We
+ avoid this problem by tainting the image and forcing the file to
+ be always processed from its character stream. */
+ if (reason == LC_ENTER && !VEC_empty (cp_token_hunk_ptr, image->token_hunks))
+ image->save_p = false;
+
+ /* The starting point for the next token hunk in the new
+ file image will be at the current last slot in
+ STATE->LEXER->BUFFER. */
+ image->hunk_start_ix = VEC_length (cp_token, state->lexer->buffer);
+
+ /* The new hunk starts at the current offset in the current
+ libcpp buffer. If this hunk is ever invalidated, this is
+ the offset at which to start pre-processing. */
+ image->hunk_text_offset = cpp_get_pos (image->buffer);
+}
+
+
+/* Callback from the pre-processor when changing in or out of a file.
+ READER is the pre-processor state. MAP is the line map for the
+ file that we are changing to. */
+
+static void
+pth_file_change (cpp_reader *reader, const struct line_map *map)
+{
+ enum lc_reason reason;
+ pth_state *state;
+ pth_image *prev_image, *new_image;
+
+ /* Call the previous file change handler, if it exists. */
+ state = pth_get_state ();
+ if (state->file_change_prev)
+ state->file_change_prev (reader, map);
+
+ /* When processing pre-processed output, we will see names like
+ '<built-in>' and '<command-line>'. Reject those.
+ ??? This rejects real path names that may start with '<', but
+ those should be rare. */
+ if (map && map->to_file && map->to_file[0] == '<')
+ return;
+
+ /* Ignore LC_RENAME events. They do not affect the actual image
+ that we are processing. */
+ if (map && map->reason == LC_RENAME)
+ return;
+
+ timevar_push (TV_PTH_MANAGE);
+
+ /* Get images for the file involved in the transition. */
+ pth_get_file_transition (map, &prev_image, &new_image, &reason);
+ gcc_assert (prev_image);
+
+ /* Ignore self-referential file change events. These can happen
+ when mixing token images with text buffers. */
+ if (prev_image == new_image)
+ {
+ timevar_pop (TV_PTH_MANAGE);
+ return;
+ }
+
+ /* Process the file we just left (get tokens from lexer buffer,
+ etc). */
+ pth_leave_file (reader, prev_image);
+
+ /* Process the file we are about to enter (try to use its tokens if
+ the file is valid, etc). */
+ if (new_image)
+ {
+ pth_include *include = NULL;
+
+ if (reason == LC_ENTER)
+ include = pth_create_include (state->new_itype,
+ state->new_angle_brackets,
+ state->new_iname);
+
+ pth_enter_file (reader, new_image, include, reason);
+
+ /* If we are LC_ENTERing NEW_IMAGE, it means that PREV_IMAGE has
+ #included NEW_IMAGE. In that case, add NEW_IMAGE to the list
+ of included files by PREV_IMAGE. */
+ if (reason == LC_ENTER)
+ {
+ PTH_STATS_INCR (included_files, 1);
+
+ if (prev_image->save_p)
+ {
+ gcc_assert (include->image == new_image);
+ VEC_safe_push (pth_include_ptr, gc, prev_image->includes,
+ include);
+ VEC_safe_push (char, gc, prev_image->ih_sequence, 'I');
+ }
+ }
+ }
+
+ /* Update the current image. */
+ state->cur_image = new_image;
+
+ timevar_pop (TV_PTH_MANAGE);
+}
+
+
+/* Record a #include or #include_next. */
+
+static void
+pth_include_handler (cpp_reader *reader ATTRIBUTE_UNUSED,
+ location_t loc ATTRIBUTE_UNUSED,
+ const unsigned char *dname,
+ const char *name,
+ int angle_brackets,
+ const cpp_token **tok_p ATTRIBUTE_UNUSED)
+{
+ pth_state *state;
+
+ state = pth_get_state ();
+
+ /* Remember the attributes for this #include command. This is
+ used in pth_file_change to register a new include event for
+ the parent file. */
+ if (strcmp ((const char *)dname, "include") == 0)
+ state->new_itype = IT_INCLUDE;
+ else if (strcmp ((const char *)dname, "include_next") == 0)
+ state->new_itype = IT_INCLUDE_NEXT;
+ else if (strcmp ((const char *)dname, "import") == 0)
+ state->new_itype = IT_IMPORT;
+ else
+ gcc_unreachable ();
+
+ state->new_angle_brackets = angle_brackets;
+ state->new_iname = name;
+}
+
+
+/* Initialize PTH support. LEXER is the main lexer object used for
+ pre-processing. */
+
+void
+pth_init (cp_lexer *lexer)
+{
+ pth_state *state;
+ cpp_callbacks *cb;
+ cpp_lookaside *table;
+
+ timevar_push (TV_PTH_INIT);
+
+ gcc_assert (flag_pth);
+
+ table = cpp_lt_exchange (parse_in, cpp_lt_create (/*2 to the power*/15,
+ flag_pth_debug));
+ gcc_assert (table == NULL);
+
+ memset (&pth_stats, 0, sizeof (pth_stats));
+
+ state = pth_get_state ();
+
+ /* If not using MD5 signatures, make sure that time stamps given
+ by stat() are smaller than DIGEST_LEN bytes. FIXME pph, this is
+ slighly hacky. */
+ if (!flag_pth_md5)
+ {
+ struct stat tmp;
+ gcc_assert (sizeof (tmp.st_mtime) < DIGEST_LEN);
+ }
+
+ /* Set an handler for file change events in libcpp. */
+ cb = cpp_get_callbacks (parse_in);
+ state->file_change_prev = cb->file_change;
+ cb->file_change = pth_file_change;
+ cb->include = pth_include_handler;
+
+ state->lexer = lexer;
+
+ /* Make sure that we have not tried to get any tokens yet. */
+ gcc_assert (VEC_empty (cp_token, lexer->buffer));
+
+ /* If we have a valid image for the main input file, populate as
+ many tokens from its transitive closure as possible. */
+ state->cur_image = pth_image_lookup (state, main_input_filename, parse_in);
+ pth_enter_file (parse_in, state->cur_image, NULL, LC_ENTER);
+
+ timevar_pop (TV_PTH_INIT);
+}
+
+
+/* Show statistics on PTH on FILE. If FILE is NULL, use pph_logfile.
+ LEXER is the lexer we just filled with tokens. This is usually
+ the same as pth_get_state()->lexer, but it may be NULL if PTH is
+ not enabled (in cases where we just want stats on pre-processed
+ files). */
+
+void
+pth_print_stats (FILE *file, cp_lexer *lexer)
+{
+ unsigned i, num_tokens, total_tokens;
+ pth_state *state;
+ pth_image *image;
+ const char *prev_fname;
+ cp_token *token;
+
+ if (file == NULL)
+ file = pph_logfile;
+
+ fprintf (file, "\nPTH statistics\n\n");
+ fprintf (file, "#included files: %lu\n", pth_stats.included_files);
+ fprintf (file, "Valid images: %lu\n", pth_stats.valid_images);
+ fprintf (file, "Token hunks: %lu\n", pth_stats.hunks);
+ fprintf (file, "Valid hunks: %lu\n", pth_stats.valid_hunks);
+ fprintf (file, "Invalid hunks: %lu\n", pth_stats.invalid_hunks);
+ fprintf (file, "Verified hunks: %lu\n", pth_stats.verified_hunks);
+ fprintf (file, "Verified identifiers: %lu\n", pth_stats.verified_identifiers);
+
+ state = pth_get_state ();
+ fprintf (file, "\n\nPTH image statistics (%u files)\n\n",
+ VEC_length (pth_image_ptr, state->cache));
+ for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
+ pth_show_image_stats (file, image);
+
+ fprintf (file, "\nToken counts per file in #include order:\n");
+ num_tokens = total_tokens = 0;
+ prev_fname = NULL;
+ for (i = 0; VEC_iterate (cp_token, lexer->buffer, i, token); i++)
+ {
+ const char *fname = LOCATION_FILE (token->location);
+
+ if (prev_fname == NULL)
+ prev_fname = fname;
+
+ if ((fname
+ && strcmp (fname, prev_fname) != 0)
+ || i == VEC_length (cp_token, lexer->buffer) - 1)
+ {
+ fprintf (file, "tokens: %u %s\n", num_tokens, lrealpath (prev_fname));
+ prev_fname = fname;
+ total_tokens += num_tokens;
+ num_tokens = 0;
+ }
+
+ num_tokens++;
+ }
+
+ /* The main lexer buffer should have one more token: CPP_EOF. */
+ if (total_tokens != VEC_length (cp_token, lexer->buffer) - 1)
+ fprintf (stderr, "*** WARNING: I counted %u, but there are %u\n",
+ total_tokens, VEC_length (cp_token, lexer->buffer));
+
+ fprintf (file, "\n");
+}
+
+
+/* Save all the header images that have been marked modified from
+ the incremental state. */
+
+void
+pth_finish (void)
+{
+ /* If PPH is enabled, do not save PTH images to prevent analysis problems
+ due to lack of location information in PTH images. FIXME pph:
+ Unneeded after we start saving proper location information. */
+ if (flag_pph_debug >= 1)
+ {
+ if (flag_pph_debug > 1)
+ fprintf (stderr, "*** WARNING: Not saving PTH images because PPH "
+ "is enabled\n");
+ }
+ else
+ {
+ pth_state *state;
+ pth_image *image;
+ size_t i;
+
+ state = pth_get_state ();
+ for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
+ if (image->save_p)
+ pth_save_image (image);
+ }
+}
+
+
+static void
+pph_log_exposed (cp_parser *parser, const char *end)
+{
+ if (flag_pph_debug >= 2)
+ {
+ cp_token *pos = cp_lexer_token_position (parser->lexer, false);
+ fprintf (pph_logfile, "PPH: %s exposed declaration at ", end);
+ pph_debug_location (pph_logfile, pos->location);
+ fprintf (pph_logfile, "\n");
+ }
+}
+
+
+/* Allocate the various arrays, maps and sets used to collect ASTs and
+ their dependencies during parsing. This memory is allocated and
+ freed for every grammar rule intercepted by pph_start_exposed() and
+ pph_stop_exposed(). */
+
+static void
+pph_allocate_catcher_memory (void)
+{
+ /* Note. pph_tree_catcher *must* be instantiated to indicate that
+ we are going to be catching trees during parsing. */
+ pph_tree_catcher = VEC_alloc (tree, heap, 5);
+ pph_decl_head_token_cache = pointer_map_create ();
+ pph_decl_body_token_cache = pointer_map_create ();
+ pph_decl_deps = XCNEW (struct pph_decl_deps_d);
+ pph_decl_deps->header = pointer_map_create ();
+ pph_decl_deps->body = pointer_map_create ();
+ pph_name_lookups = NULL;
+ pph_name_lookups_set = pointer_set_create ();
+ pph_nl_token_map = pointer_map_create ();
+}
+
+
+/* Free all the memory allocated by pph_allocate_catcher_memory. */
+
+static void
+pph_free_catcher_memory (void)
+{
+ VEC_free (tree, heap, pph_tree_catcher);
+
+ pointer_map_destroy (pph_decl_head_token_cache);
+ pph_decl_head_token_cache = NULL;
+
+ pointer_map_destroy (pph_decl_body_token_cache);
+ pph_decl_body_token_cache = NULL;
+
+ pointer_map_destroy (pph_decl_deps->header);
+ pointer_map_destroy (pph_decl_deps->body);
+ free (pph_decl_deps);
+ pph_decl_deps = NULL;
+
+ VEC_free (tree, heap, pph_name_lookups);
+
+ pointer_set_destroy (pph_name_lookups_set);
+ pph_name_lookups_set = NULL;
+
+ pointer_map_destroy (pph_nl_token_map);
+ pph_nl_token_map = NULL;
+}
+
+
+/* Start collecting ASTs and dependencies. */
+
+cp_token *
+pph_start_exposed (cp_parser *parser)
+{
+ if (flag_pph_debug >= 1)
+ {
+ timevar_push (TV_PPH_MANAGE);
+
+ if (flag_pph_debug >= 4)
+ fprintf (pph_logfile, "\n--------------------------------------------------------------------------\n");
+ pph_log_exposed (parser, "start");
+ pph_allocate_catcher_memory ();
+ timevar_pop (TV_PPH_MANAGE);
+
+ return parser->lexer->next_token; /* the first token */
+ }
+ else
+ return NULL;
+}
+
+/* Return the token cache associated with tree node T. */
+
+static VEC(cp_token, heap) *
+pph_lookup_head_token_cache_for (tree t)
+{
+ void **slot = pointer_map_contains (pph_decl_head_token_cache, t);
+ if (slot)
+ return ((VEC(cp_token, heap) *) *slot);
+
+ return NULL;
+}
+
+static VEC(cp_token, heap) *
+pph_lookup_body_token_cache_for (tree t)
+{
+ void **slot = pointer_map_contains (pph_decl_body_token_cache, t);
+ if (slot)
+ return ((VEC(cp_token, heap) *) *slot);
+
+ return NULL;
+}
+
+
+/* Set the token cache associated with tree node T to CACHE. */
+
+static void
+pph_set_head_token_cache_for (tree t, VEC(cp_token, heap) *cache)
+{
+ void **slot = pointer_map_insert (pph_decl_head_token_cache, t);
+ *slot = (void *) cache;
+}
+
+static void
+pph_set_body_token_cache_for (tree t, VEC(cp_token, heap) *cache)
+{
+ void **slot = pointer_map_insert (pph_decl_body_token_cache, t);
+ *slot = (void *) cache;
+}
+
+/* Emulate the copying of declarations into the parser cache. Deep
+ copy all the declarations in V. */
+
+static void
+pph_copy_decls_into_cache (VEC(tree, heap) *v)
+{
+ unsigned i;
+ static tree t_copy, type_copy, t;
+ void **slot;
+ VEC(tree, heap) *ast_cache, *old_pph_tree_catcher, *old_pph_name_lookups;
+ static struct pointer_map_t *hunk_to_decls_map = NULL;
+ static htab_t cache_dir = NULL;
+ const char *fname;
+
+ timevar_push (TV_PPH_CACHE_IN);
+
+ if (hunk_to_decls_map == NULL)
+ hunk_to_decls_map = pointer_map_create ();
+
+ if (cache_dir == NULL)
+ cache_dir = htab_create (10, htab_hash_pointer, htab_eq_pointer, 0);
+
+ /* We will be copying trees, which will call into the tree catching
+ routines. Prevent that. */
+ old_pph_tree_catcher = pph_tree_catcher;
+ old_pph_name_lookups = pph_name_lookups;
+ pph_tree_catcher = pph_name_lookups = NULL;
+
+ /* Copy every declaration in V into the cache. */
+ for (i = 0; VEC_iterate (tree, v, i, t); i++)
+ {
+ /* 1- Determine the token hunk H that owns T. We first determine
+ the PTH image and then which hunk inside that PTH image. For
+ choosing the hunk within the image, we simulate a second
+ hash table lookup hashing the location to the token hunk. */
+ pth_image *image, *hunk;
+ VEC(cp_token, heap) *head_tokens, *body_tokens;
+ cp_token *first;
+
+ head_tokens = pph_lookup_head_token_cache_for (t);
+ body_tokens = pph_lookup_body_token_cache_for (t);
+ if (VEC_empty (cp_token, head_tokens))
+ continue;
+ first = VEC_index (cp_token, head_tokens, 0);
+ fname = LOCATION_FILE (first->location);
+ slot = htab_find_slot (cache_dir, fname, INSERT);
+ if (*slot == NULL)
+ {
+ image = XCNEW (pth_image);
+ *slot = CONST_CAST (char *, fname);
+ }
+ else
+ image = *((pth_image **) slot);
+
+ /* For now, re-do the pth_image_lookup to simulate the lookup of
+ the hunk within the image. */
+ slot = htab_find_slot (cache_dir, fname, NO_INSERT);
+ hunk = *((pth_image **) slot);
+
+ /* Insert dummy uses for head_tokens, body_tokens and image. */
+ if (i > VEC_length (tree, v))
+ {
+ free (head_tokens);
+ free (body_tokens);
+ free (image);
+ }
+
+ /* 2- Find the tree cache associated with HUNK. */
+ slot = pointer_map_insert (hunk_to_decls_map, hunk);
+ ast_cache = (VEC(tree, heap) *) *slot;
+
+ /* 3- Copy T and its type into the cache associated with HUNK.
+ If T has a body (a FUNCTION_DECL), copy the body. FIXME pph,
+ copying ASTs will need new copying code to be implemented,
+ the current routines do not handle everything that can be
+ generated by the C++ FE. */
+ t_copy = copy_decl (t);
+ if (!type_copy || TREE_TYPE (t))
+ type_copy = copy_type (TREE_TYPE (t));
+ if (TREE_CODE (t) == FUNCTION_DECL)
+ walk_tree (&DECL_SAVED_TREE (t_copy), copy_tree_r, (void *)1, NULL);
+ VEC_safe_push (tree, heap, ast_cache, t_copy);
+ *slot = (void *) ast_cache;
+ }
+
+ PPH_STATS_INCR (cached_decls, VEC_length (tree, v));
+
+ /* Restore tree and lookup catchers. */
+ pph_tree_catcher = old_pph_tree_catcher;
+ pph_name_lookups = old_pph_name_lookups;
+
+ timevar_pop (TV_PPH_CACHE_IN);
+}
+
+
+/* Emulate the cache actions needed to get a declaration out of the
+ parser cache and instantiate it into the current compilation context. */
+
+static void
+pph_copy_decls_outof_cache (VEC(tree, heap) *v)
+{
+ unsigned i;
+ tree t;
+ static VEC(tree, heap) *compilation_context = NULL;
+ VEC(tree, heap) *old_pph_tree_catcher, *old_pph_name_lookups;
+
+ /* Conceptually, this will be called with a token hunk that contains
+ all the declarations that we want to instantiate. */
+ timevar_push (TV_PPH_CACHE_OUT);
+
+ /* We will be copying trees, which will call into the tree catching
+ routines. Prevent that. */
+ old_pph_tree_catcher = pph_tree_catcher;
+ old_pph_name_lookups = pph_name_lookups;
+ pph_tree_catcher = pph_name_lookups = NULL;
+
+ /* 1- Verify that the hunk is valid. Traverse all the declarations
+ checking that none have been tainted. */
+ for (i = 0; VEC_iterate (tree, v, i, t); i++)
+ {
+ /* If T is not valid, none of its users is valid. */
+ if (1 || TREE_VISITED (t))
+ {
+ unsigned j;
+ tree r;
+ for (j = 0; VEC_iterate (tree, v, j, r); j++)
+ TREE_VISITED (r) = TREE_VISITED (r);
+ }
+ }
+
+ /* 2- Copy all the trees in the hunk to the current compilation context. */
+ for (i = 0; VEC_iterate (tree, v, i, t); i++)
+ {
+ static tree t_copy, type_copy;
+
+ t_copy = copy_decl (t);
+ if (!type_copy || TREE_TYPE (t))
+ type_copy = copy_type (TREE_TYPE (t));
+ if (TREE_CODE (t) == FUNCTION_DECL)
+ walk_tree (&DECL_SAVED_TREE (t_copy), copy_tree_r, (void *)1, NULL);
+
+ /* Emulate restoration into compilation context. FIXME pph, this is
+ missing the name lookups that may be required. Estimate this
+ separately from the number of name lookup operations and the
+ time spent doing name lookups. */
+ VEC_safe_push (tree, heap, compilation_context, t_copy);
+ }
+
+ PPH_STATS_INCR (restored_decls, VEC_length (tree, v));
+
+ /* Restore tree and lookup catchers. */
+ pph_tree_catcher = old_pph_tree_catcher;
+ pph_name_lookups = old_pph_name_lookups;
+
+ timevar_pop (TV_PPH_CACHE_OUT);
+}
+
+void
+pph_stop_exposed (cp_parser *parser, cp_token *first_token)
+{
+ if (flag_pph_debug >= 1 && !VEC_empty (tree, pph_tree_catcher))
+ {
+ cp_token *last_token;
+
+ timevar_push (TV_PPH_MANAGE);
+
+ last_token = parser->lexer->next_token;
+ pph_print_trees_tokens (pph_tree_catcher, first_token, last_token);
+ pph_copy_decls_into_cache (pph_tree_catcher);
+ pph_copy_decls_outof_cache (pph_tree_catcher);
+ PPH_STATS_INCR (cached_refs, VEC_length(tree, pph_name_lookups));
+ pph_free_catcher_memory ();
+ if (flag_pph_debug >= 4)
+ pph_log_exposed (parser, "stop");
+
+ timevar_pop (TV_PPH_MANAGE);
+ }
+}
+
+
+/* PPH printing help. */
+
+static void
+pph_debug_tree (tree t, bool body)
+{
+ if (t == NULL)
+ {
+ fprintf (pph_logfile, "nulldecl");
+ return;
+ }
+
+ if (!DECL_P (t))
+ {
+ fprintf (pph_logfile, "__%s__", tree_code_name[TREE_CODE (t)]);
+ return;
+ }
+
+ if (flag_pph_decls >= 2)
+ fprintf (pph_logfile, "%s ", tree_code_name[TREE_CODE (t)]);
+ fprintf (pph_logfile, "%d", (DECL_UID (t) << 1) + body);
+ if (flag_pph_decls >= 1)
+ fprintf (pph_logfile, " '%s'", get_name (t));
+ if (flag_pph_decls >= 3)
+ {
+ fprintf (pph_logfile, " ");
+ pph_debug_loc_of_tree (pph_logfile, t);
+ if (flag_pph_decls >= 4)
+ fprintf (pph_logfile, " @%p", (void *) t);
+ }
+}
+
+static void
+pph_debug_type (tree t, bool body)
+{
+ tree t_decl;
+ if (t == NULL)
+ {
+ fprintf (pph_logfile, "nulltype");
+ return;
+ }
+ t_decl = get_type_decl (t);
+ if (t_decl == NULL)
+ fprintf (pph_logfile, "nameless");
+ else
+ pph_debug_tree (t_decl, body);
+}
+
+/* Return true if tree T has been caught already. */
+
+static bool
+pph_tree_caught_p (tree t)
+{
+ return (pph_lookup_head_token_cache_for (t) != NULL);
+}
+
+/* Collect the tokens needed for the head of DECL.
+ This assumes that the current token is positioned right after
+ the end of the declarator expression for DECL (i.e., it should
+ be called from grokdeclarator). */
+
+static VEC(cp_token, heap) *
+pph_catch_head_tokens_for (tree t)
+{
+ cp_token *tok, *last, *first;
+ cp_lexer *lexer;
+ VEC(cp_token, heap) *tokens;
+
+ gcc_assert (t != error_mark_node);
+
+ tokens = pph_lookup_head_token_cache_for (t);
+ if (tokens)
+ {
+ fprintf (stderr, "*** ");
+ pph_debug_location (stderr, input_location);
+ fprintf (stderr, ": Tried to catch head tokens more than once for: ");
+ print_generic_stmt (stderr, t, 0);
+ gcc_unreachable ();
+ }
+
+ lexer = the_parser->lexer;
+
+ /* Look for the tokens backwards until the first brace or semicolon. */
+ first = last = lexer->next_token;
+ for (tok = last - 1; tok >= VEC_address (cp_token, lexer->buffer); tok--)
+ {
+ if (tok->type == CPP_OPEN_BRACE
+ || tok->type == CPP_CLOSE_BRACE
+ || tok->type == CPP_SEMICOLON)
+ break;
+
+ first = tok;
+ }
+
+ /* Now include any trailing semicolon. */
+ if (last->type == CPP_SEMICOLON)
+ last++;
+
+ /* Add all the tokens in [FIRST, LAST) to TOKENS. */
+ for (tok = first; tok != last; tok++)
+ VEC_safe_push (cp_token, heap, tokens, tok);
+
+ pph_set_head_token_cache_for (t, tokens);
+
+ return tokens;
+}
+
+
+/* Collect the tokens needed for the body of DECL.
+ This assumes that the current token is positioned right after
+ the end of the declarator expression for DECL (i.e., it should
+ be called from grokdeclarator). */
+
+static VEC(cp_token, heap) *
+pph_catch_body_tokens_for (tree t)
+{
+ cp_token *tok, *last, *first;
+ cp_lexer *lexer;
+ VEC(cp_token, heap) *tokens;
+
+ gcc_assert (t != error_mark_node);
+
+ tokens = pph_lookup_body_token_cache_for (t);
+ if (tokens)
+ {
+ fprintf (stderr, "*** ");
+ pph_debug_location (stderr, input_location);
+ fprintf (stderr, ": Tried to catch body tokens more than once for: ");
+ print_generic_stmt (stderr, t, 0);
+ gcc_unreachable ();
+ }
+
+ lexer = the_parser->lexer;
+
+ /* Look for the tokens forwards until the closing brace or semicolon. */
+ first = last = lexer->next_token;
+ tok = first;
+ if (tok->type == CPP_EQ || tok->type == CPP_OPEN_PAREN)
+ {
+ /* Skip a variable-like definition. Find the semicolon. */
+ /* FIXME pph - This code changes with C++0x. */
+ for (; tok <= VEC_last (cp_token, lexer->buffer); tok++)
+ if (tok->type == CPP_SEMICOLON)
+ break;
+ last = tok;
+ }
+ else if (tok->type == CPP_OPEN_BRACE || tok->type == CPP_COLON)
+ {
+ /* Skip a class-like or function-like definition.
+ Skip to a left brace, then skip to the matching right brace. */
+ /* FIXME pph - This code changes with C++0x. */
+ int nesting = 0;
+ for (; tok <= VEC_last (cp_token, lexer->buffer); tok++)
+ if (tok->type == CPP_OPEN_BRACE)
+ nesting++;
+ else if (tok->type == CPP_CLOSE_BRACE)
+ {
+ if ( nesting <= 1)
+ break;
+ else
+ nesting--;
+ }
+ last = tok;
+ }
+ else
+ return NULL; /* no body */
+
+ /* Add all the tokens in [FIRST, LAST) to TOKENS. */
+ for (tok = first; tok <= last; tok++)
+ VEC_safe_push (cp_token, heap, tokens, tok);
+
+ pph_set_body_token_cache_for (t, tokens);
+
+ return tokens;
+}
+
+
+/* Return the dependencies for tree node T. If HEADER_P is true, it
+ returns the dependencies for the header of T's declaration.
+ Otherwise, it returns dependencies for T's body. */
+
+static VEC(tree,gc) *
+pph_lookup_dependencies_for (tree t, bool header_p)
+{
+ struct pointer_map_t *map;
+ void **slot;
+
+ map = (header_p) ? pph_decl_deps->header : pph_decl_deps->body;
+ slot = pointer_map_contains (map, t);
+ if (slot)
+ return ((VEC(tree,gc) *) *slot);
+
+ return NULL;
+}
+
+
+/* Set the dependencies for tree node T to DEPS. If HEADER_P is true,
+ DEPS are the dependencies for T's header. Otherwise, DEPS are the
+ dependencies for T's body. */
+
+static void
+pph_set_dependencies_for (tree t, VEC(tree,gc) *deps, bool header_p)
+{
+ void **slot;
+ struct pointer_map_t *map;
+
+ map = (header_p) ? pph_decl_deps->header : pph_decl_deps->body;
+ slot = pointer_map_insert (map, t);
+ *slot = (void *) deps;
+}
+
+#define PPH_ARTIFICIAL(t) \
+(DECL_ARTIFICIAL (t) \
+&& !(TREE_CODE (t) == TYPE_DECL && DECL_IMPLICIT_TYPEDEF_P (t)))
+
+static bool
+is_namespace (tree container)
+{
+ enum tree_code code;
+
+ if (container == NULL)
+ return true;
+
+ code = TREE_CODE (container);
+ if (code == NAMESPACE_DECL)
+ return true;
+
+ return false;
+}
+
+/* Find the exposed declaration containing a symbol lookup. */
+
+static tree
+pph_null_exposed (const char *reason)
+{
+ if (flag_pph_debug >= 3)
+ fprintf (pph_logfile, "%s\n", reason);
+ return NULL;
+}
+
+static tree
+pph_live_exposed (tree t, bool body)
+{
+ if (PPH_ARTIFICIAL (t))
+ return pph_null_exposed ("Artificial symbols are not exposed.");
+
+ if (flag_pph_debug >= 3)
+ {
+ if (t == NULL)
+ fprintf (pph_logfile, "(null)");
+ else
+ pph_debug_tree (t, body);
+ fprintf (pph_logfile, "\n");
+ }
+ return t;
+}
+
+static tree
+pph_find_exposed_for (tree t, bool *body)
+{
+ tree container;
+ enum tree_code code, t_code;
+ bool in_class;
+ *body = false; /* By default, we only depend on heads. */
+ for ( ; ; t = container, *body = true)
+ {
+ reclassify:
+ if (t == NULL)
+ {
+ PPH_STATS_INCR (bad_lookups, 1);
+ return pph_null_exposed ("NULLOID"); /* FIXME pph */
+ }
+ if (flag_pph_debug >= 3)
+ {
+ fprintf (pph_logfile, " exposed for ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, " is ");
+ }
+ code = TREE_CODE (t);
+ switch (code)
+ {
+ /* Types common to C and C++. */
+ case ARRAY_TYPE:
+ case BOOLEAN_TYPE:
+ case COMPLEX_TYPE:
+ case ENUMERAL_TYPE:
+ case FIXED_POINT_TYPE:
+ case FUNCTION_TYPE:
+ case INTEGER_TYPE:
+ case LANG_TYPE:
+ case METHOD_TYPE:
+ case OFFSET_TYPE:
+ case POINTER_TYPE:
+ case QUAL_UNION_TYPE:
+ case REAL_TYPE:
+ case RECORD_TYPE:
+ case REFERENCE_TYPE:
+ case UNION_TYPE:
+ case VECTOR_TYPE:
+ case VOID_TYPE:
+ /* C++-specific types. */
+ case BOUND_TEMPLATE_TEMPLATE_PARM:
+ case TEMPLATE_TEMPLATE_PARM:
+ case TEMPLATE_TYPE_PARM:
+ case TYPENAME_TYPE:
+ case TYPEOF_TYPE:
+ case UNBOUND_CLASS_TEMPLATE:
+ case TYPE_ARGUMENT_PACK:
+ case TYPE_PACK_EXPANSION:
+ case DECLTYPE_TYPE:
+ {
+ if (TYPE_NAME (t) == NULL)
+ return pph_null_exposed ("Anonymous Type");
+ else
+ t = TYPE_NAME (t);
+ /* FALLTHRU */
+ }
+
+ case TYPE_DECL:
+ {
+ container = DECL_CONTEXT (t);
+ in_class = container && CLASS_TYPE_P (container);
+ t_code = TREE_CODE (TREE_TYPE (t));
+ /* FIXME pph: Why DECL_TEMPLATE_TEMPLATE_PARM_P does not apply
+ here? It is a template template parameter, but the tree code
+ is inconsistent. */
+ if (DECL_TEMPLATE_PARM_P (t)
+ || t_code == TEMPLATE_TEMPLATE_PARM
+ || t_code == BOUND_TEMPLATE_TEMPLATE_PARM)
+ return pph_null_exposed ("TMPLPARM");
+
+ if (is_namespace (container))
+ return pph_live_exposed (t, *body);
+ break;
+ }
+
+ case VAR_DECL:
+ {
+ /* If var is lazy, depend on its body, not its head. */
+ tree enclass = DECL_CONTEXT (t);
+ bool in_class = enclass && CLASS_TYPE_P (enclass);
+ bool defined = DECL_INITIAL (t) != NULL;
+ /* FIXME pph: DECL_INITIALIZED_P (t) */
+ if (defined && (in_class || !DECL_THIS_EXTERN (t))
+ && DECL_INTEGRAL_CONSTANT_VAR_P (t))
+ *body = true;
+
+ container = DECL_CONTEXT (t);
+ in_class = container && CLASS_TYPE_P (container);
+ if (in_class && DECL_THIS_STATIC (t))
+ container = TYPE_CONTEXT (container);
+ if (is_namespace (container))
+ return pph_live_exposed (t, *body);
+ break;
+ }
+
+ case FUNCTION_DECL:
+ {
+ /* If function is lazy, depend on body. */
+ bool defined = DECL_INITIAL (t) != NULL;
+ if (defined && (DECL_DECLARED_INLINE_P (t)
+ || DECL_USE_TEMPLATE (t) != 2))
+ *body = true;
+
+ container = DECL_CONTEXT (t);
+ in_class = container && CLASS_TYPE_P (container);
+ if (in_class)
+ container = TYPE_CONTEXT (container);
+ if (is_namespace (container))
+ return pph_live_exposed (t, *body);;
+ break;
+ }
+
+ case TEMPLATE_DECL:
+ {
+ int generic = DECL_USE_TEMPLATE (t);
+ if (generic != 2)
+ {
+ t = DECL_TEMPLATE_RESULT (t);
+ if (flag_pph_debug >= 3)
+ fprintf (pph_logfile, "template redirected\n");
+ goto reclassify;
+ }
+ }
+
+ case SCOPE_REF:
+ return pph_null_exposed ("SCOPE_REF"); /* FIXME pph */
+
+ case OVERLOAD:
+ return pph_null_exposed ("OVERLOAD"); /* FIXME pph */
+
+ case BASELINK:
+ container = BASELINK_BINFO (t);
+ break;
+
+ case TREE_BINFO:
+ container = BINFO_TYPE (t);
+ break;
+
+ case TREE_LIST:
+ t = TREE_VALUE (t);
+ /* Fallthru */
+
+ default:
+ {
+ if (t == NULL)
+ {
+ PPH_STATS_INCR (bad_lookups, 1);
+ return pph_null_exposed ("NULLOID"); /* FIXME pph */
+ }
+ else if (!DECL_P (t))
+ {
+ PPH_STATS_INCR (bad_lookups, 1);
+ return pph_null_exposed ("BOZOID"); /* FIXME pph */
+ /*FIXME pph:
+ fatal_error ("Expecting a *_decl node. Got %s",
+ tree_code_name[TREE_CODE (t)]);
+ */
+ }
+
+ container = DECL_CONTEXT (t);
+ in_class = container && CLASS_TYPE_P (container);
+ if (is_namespace (container))
+ return pph_null_exposed ("UNKNOWN");
+ break;
+ }
+ }
+ if (flag_pph_debug >= 3)
+ {
+ pph_debug_tree (container, *body);
+ fprintf (pph_logfile, "\n");
+ }
+ }
+}
+
+
+/* Collect the AST nodes that node T depends on. HEADER_P is true if
+ we should collect ASTs from T's header. Otherwise, we collect
+ ASTs from T's body. */
+
+static VEC(tree,gc) *
+pph_catch_dependencies_for (tree t, bool header_p)
+{
+ VEC(cp_token, heap) *tokens;
+ unsigned i;
+ cp_token *tok;
+ VEC(tree,gc) *deps;
+
+ tokens = (header_p)
+ ? pph_lookup_head_token_cache_for (t)
+ : pph_lookup_body_token_cache_for (t);
+
+ if (tokens == NULL)
+ tokens = (header_p)
+ ? pph_catch_head_tokens_for (t)
+ : pph_catch_body_tokens_for (t);
+
+ deps = pph_lookup_dependencies_for (t, header_p);
+
+ for (i = 0; VEC_iterate (cp_token, tokens, i, tok); i++)
+ if (tok->type == CPP_NAME)
+ VEC_safe_push (tree, gc, deps, tok->u.value);
+
+ pph_set_dependencies_for (t, deps, header_p);
+
+ return deps;
+}
+
+
+/* Intercept tree node T by storing it in pph_tree_catcher and collecting
+ the tokens used in its instantiation. */
+
+void
+pph_catch_tree (tree t)
+{
+ /* Only collect trees if the parser instantiated pph_tree_catcher
+ and we are currently parsing from the main lexer. */
+ if (pph_tree_catcher && the_parser->lexer->buffer && !pph_tree_caught_p (t))
+ {
+ timevar_push (TV_PPH_MANAGE);
+
+ VEC_safe_push (tree, heap, pph_tree_catcher, t);
+ pph_catch_head_tokens_for (t);
+ pph_catch_body_tokens_for (t);
+ pph_catch_dependencies_for (t, true);
+ pph_catch_dependencies_for (t, false);
+
+ timevar_pop (TV_PPH_MANAGE);
+ }
+}
+
+
+/* Retract a caught tree. */
+
+void
+pph_uncatch_tree (tree t)
+{
+ /* Only uncollect trees if the parser instantiated pph_tree_catcher
+ and we are currently parsing from the main lexer. */
+ if (pph_tree_catcher && the_parser->lexer->buffer)
+ {
+ int i;
+ tree u;
+
+ timevar_push (TV_PPH_MANAGE);
+
+ /* Find the index; if present, remove it. */
+ for (i = 0; VEC_iterate (tree, pph_tree_catcher, i, u); i++)
+ {
+ if (u == t)
+ {
+ VEC_ordered_remove (tree, pph_tree_catcher, i);
+ break;
+ }
+ }
+
+ timevar_pop (TV_PPH_MANAGE);
+ }
+}
+
+
+/* Given a set of tokens TOKENS, return the symbols from pph_name_lookups
+ that occur in TOKENS. The returned vector is, then, the set of all
+ symbols that were resolved via name lookups during parsing. This set
+ is a subset of all the CPP_NAME tokens in TOKENS. */
+
+static void
+pph_locate_name_lookups_in (VEC(cp_token, heap) *tokens,
+ VEC(tree,gc) **heads_found,
+ VEC(tree,gc) **bodies_found)
+{
+ unsigned i;
+ tree t;
+ cp_token *first, *last;
+
+ *heads_found = NULL;
+ *bodies_found = NULL;
+
+ if (tokens == NULL || VEC_empty (cp_token, tokens))
+ return;
+
+ first = VEC_index (cp_token, tokens, 0);
+ last = VEC_last (cp_token, tokens);
+
+ for (i = 0; VEC_iterate (tree, pph_name_lookups, i, t); i++)
+ {
+ unsigned j;
+ cp_token *tok;
+ VEC(cp_token, heap) *lookup_locations;
+ void **slot;
+ bool pushed = false;
+
+ slot = pointer_map_contains (pph_nl_token_map, t);
+ gcc_assert (slot && *slot);
+ lookup_locations = (VEC(cp_token, heap) *) *slot;
+ for (j = 0; VEC_iterate (cp_token, lookup_locations, j, tok); j++)
+ {
+ if (tok->location >= first->location
+ && tok->location <= last->location)
+ {
+ if (!pushed)
+ {
+ bool body;
+ tree exposed = pph_find_exposed_for (t, &body);
+ if (exposed)
+ {
+ if (body)
+ VEC_safe_push (tree, gc, *bodies_found, exposed);
+ else
+ VEC_safe_push (tree, gc, *heads_found, exposed);
+ pushed = true;
+ }
+ }
+
+ /* Avoid double-counting lookups by removing the lookup
+ location after a class member declaration has found it.
+ To make that work, we must remove all redundant entries. */
+ if (flag_pph_debug >= 4)
+ {
+ fprintf (pph_logfile, " lookup in %p for ",
+ (void*)lookup_locations);
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, " found at ");
+ pph_debug_location (pph_logfile, tok->location);
+ fprintf (pph_logfile, "\n");
+ fprintf (pph_logfile, " vector length from %d",
+ VEC_length (cp_token, lookup_locations));
+
+ }
+ /* This code is slow, but VEC won't let me null entires. */
+ VEC_ordered_remove (cp_token, lookup_locations, j);
+ /* We have just shifted down all later entries,
+ and need to counteract the upcoming index increment. */
+ j--;
+ if (flag_pph_debug >= 4)
+ {
+ fprintf (pph_logfile, " to %d\n",
+ VEC_length (cp_token, lookup_locations));
+ }
+ }
+ }
+ }
+}
+
+
+/* Print all the trees in V and the tokens in the token range
+ [TOK1, TOK2). */
+
+static VEC(cp_token, heap) *
+pph_print_copy_tokens (cp_token *tok1, cp_token *tok2)
+{
+ cp_token *tok;
+ VEC(cp_token, heap) *vtok;
+
+ /* If TOK2 is CPP_EOF, it will have the address of eof_token, which
+ will make the loop below go off the deep end. Detect this and
+ make TOK2 the last token in the lexer buffer instead. */
+ if (tok2 == &eof_token)
+ tok2 = VEC_last (cp_token, the_parser->lexer->buffer);
+
+ vtok = NULL;
+ for (tok = tok1; tok != tok2; tok++)
+ VEC_safe_push (cp_token, heap, vtok, tok);
+
+ return vtok;
+}
+
+static void
+pph_print_token_range (VEC(tree,heap) *v, VEC(cp_token, heap) *vtok)
+{
+ unsigned i;
+ tree t;
+
+ if (flag_pph_debug >= 4)
+ {
+ fprintf (pph_logfile, "PPH: hunk location ");
+ pph_debug_location (pph_logfile, VEC_index (cp_token, vtok, 0)->location);
+ fprintf (pph_logfile, " to ");
+ pph_debug_location (pph_logfile, VEC_last (cp_token, vtok)->location);
+ fprintf (pph_logfile, "\n");
+ fprintf (pph_logfile, "PPH: hunk tokens ");
+ cp_lexer_dump_tokens (stderr, (VEC(cp_token, gc) *)vtok, 0);
+ fprintf (pph_logfile, "PPH: hunk ASTs:\n");
+ for (i = 0; VEC_iterate (tree, v, i, t); i++)
+ {
+ pph_debug_tree (t, true);
+ /* FIXME pph: this may not be right; we may not care. */
+ print_generic_stmt (stderr, t, 0);
+ }
+ fprintf (pph_logfile, "PPH: hunk decls:\n");
+ }
+}
+
+static void
+pph_print_dependence (bool user_body, bool used_body,
+ tree t, tree d)
+{
+ static bool prior_user_body = false;
+ static bool prior_used_body = false;
+ static tree prior_t = NULL;
+ static tree prior_d = NULL;
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " pd_base ");
+ pph_debug_tree (t, user_body);
+ fprintf (pph_logfile, " on ");
+ pph_debug_tree (d, used_body);
+ fprintf (pph_logfile, "\n");
+ }
+ if (t && d && DECL_P (t) && DECL_P (d) && (t != d || user_body != used_body))
+ {
+ if (PPH_ARTIFICIAL (t))
+ {
+ /* Okay, find the real symbol this articial one belongs to. */
+ d = pph_find_exposed_for (d, &used_body);
+ if (d == NULL)
+ return;
+ used_body = true;
+ }
+ if (user_body != prior_user_body
+ || used_body != prior_used_body
+ || t != prior_t
+ || d != prior_d)
+ {
+ fprintf (pph_logfile, "depend ");
+ pph_debug_tree (t, user_body);
+ fprintf (pph_logfile, " uses ");
+ pph_debug_tree (d, used_body);
+ fprintf (pph_logfile, "\n");
+ prior_user_body = user_body;
+ prior_used_body = used_body;
+ prior_t = t;
+ prior_d = d;
+ }
+ }
+}
+
+static void
+pph_print_depend_template (tree tmpl_info, tree t)
+{
+ tree tmpl_decl;
+ tree tmpl_ptrn;
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " pd_template ");
+ pph_debug_tree (t, true);
+ fprintf (pph_logfile, " %p", (void*)tmpl_info);
+ fprintf (pph_logfile, "\n");
+ }
+ tmpl_decl = TI_TEMPLATE (tmpl_info);
+ if (TREE_CODE (tmpl_decl) == OVERLOAD)
+ tmpl_decl = OVL_CURRENT (tmpl_decl);
+ tmpl_ptrn = DECL_TEMPLATE_RESULT (tmpl_decl);
+ if (tmpl_ptrn && t != tmpl_ptrn)
+ {
+ /* This is a template, but not the pattern. */
+ pph_print_dependence (true, true, t, tmpl_ptrn);
+ }
+}
+
+/* Print the dependence of a head of declaration
+ on the body of a type that the head uses directly.
+ If either of these is not exposed,
+ find the body of the exposed declaration that contains it. */
+
+static void
+pph_print_depend_decl (tree user, tree used)
+{
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " pd_decl ");
+ pph_debug_tree (user, false);
+ fprintf (pph_logfile, " on ");
+ pph_debug_tree (used, false);
+ fprintf (pph_logfile, "\n");
+ }
+ if (user != NULL)
+ {
+ if (used != NULL)
+ {
+ bool body;
+ tree exp_for_user = pph_find_exposed_for (user, &body);
+ tree exp_for_used = pph_find_exposed_for (used, &body);
+ if (exp_for_user && exp_for_used && exp_for_user != exp_for_used)
+ pph_print_dependence (exp_for_user != user, true,
+ exp_for_user, exp_for_used);
+ }
+ }
+}
+
+static void
+pph_print_depend_type (tree decl, tree type)
+{
+ tree type_decl;
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " pd_type ");
+ pph_debug_tree (decl, false);
+ fprintf (pph_logfile, " on ");
+ pph_debug_type (type, false);
+ fprintf (pph_logfile, "\n");
+ }
+ if (type != NULL)
+ {
+ type_decl = get_type_decl (type);
+ pph_print_depend_decl (decl, type_decl);
+ }
+}
+
+static void
+pph_print_depend_type_type (tree t)
+{
+ tree t_type;
+ tree field;
+
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " depending on typedecl type ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, "\n");
+ }
+
+ t_type = TREE_TYPE (t);
+ field = TYPE_FIELDS (t_type);
+ for (; field; field = TREE_CHAIN(field))
+ {
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " field ");
+ pph_debug_tree (field, false);
+ }
+ if (TREE_CODE (field) == FIELD_DECL)
+ {
+ tree f_type = TREE_TYPE (field);
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " of type ");
+ pph_debug_type (f_type, false);
+ if (DECL_FIELD_IS_BASE (field))
+ fprintf (pph_logfile, " is a base field!!\n");
+ else
+ fprintf (pph_logfile, " is a plain field\n");
+ }
+ pph_print_depend_type (t, f_type);
+ }
+ else if (TREE_CODE (field) == TYPE_DECL)
+ {
+ tree f_type = TREE_TYPE (field);
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " of type ");
+ pph_debug_type (f_type, false);
+ fprintf (pph_logfile, " is a type field\n");
+ }
+ pph_print_depend_type (t, f_type);
+ }
+ }
+
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " end of fields\n");
+ }
+}
+
+static void
+pph_print_depend_func_type (tree t)
+{
+ /* We must print a dependence of the head of the function
+ on the body of the types of its signature. */
+
+ tree args;
+ tree func_type;
+
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " depending on function type ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, "\n");
+ }
+
+ func_type = TREE_TYPE (t);
+ pph_print_depend_type (t, TREE_TYPE (func_type)); /* return type */
+ for (args = TYPE_ARG_TYPES (func_type); args; args = TREE_CHAIN (args))
+ pph_print_depend_type (t, TREE_VALUE (args)); /* parameter */
+
+ if (DECL_VIRTUAL_P (t))
+ {
+ tree ctx_type = DECL_CONTEXT (t);
+ tree ctx_decl = get_type_decl (ctx_type);
+ /* Virtual functions depend on containing class's body.*/
+ pph_print_depend_type (t, ctx_type);
+ /* The virtual class's body also depends on the function
+ for construction of the vtable. */
+ pph_print_dependence (true, true, ctx_decl, t);
+ }
+}
+
+static void
+pph_print_depend_var_type (tree t)
+{
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " depending on var/field type ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, "\n");
+ }
+
+ pph_print_depend_type (t, TREE_TYPE (t));
+}
+
+enum decl_exposure { HIDDEN, EXPOSED, NEEDED };
+
+static enum decl_exposure
+pph_get_decl_exposure (tree t)
+{
+ tree container;
+ tree type;
+ tree tmpl_info;
+ bool defined = false;
+ bool inlined = false;
+ bool needed = false;
+ int generic = 0;
+ enum tree_code code = TREE_CODE (t);
+
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " get_exposure for ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, "\n");
+ }
+
+ /* For DECL_USE_TEMPLATE and CLASSTYPE_USE_TEMPLATE,
+ 1=implicit instantiation
+ 2=partial or explicit specialization, e.g.:
+ template <> int min<int> (int, int),
+ 3=explicit instantiation, e.g.:
+ template int min<int> (int, int);
+ */
+
+ if (code == TYPE_DECL)
+ {
+ pph_print_depend_type_type (t);
+
+ container = DECL_CONTEXT (t);
+ if (!is_namespace (container))
+ return HIDDEN;
+ type = TREE_TYPE (t);
+ defined = COMPLETE_TYPE_P (type);
+
+ /* FIXME pph: Why DECL_TEMPLATE_TEMPLATE_PARM_P does not apply
+ here? It is a template template parameter, but the tree code
+ is inconsistent. */
+ if (DECL_TEMPLATE_PARM_P (t)
+ || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
+ || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
+ return HIDDEN;
+ if (CLASS_TYPE_P (t))
+ {
+ tmpl_info = CLASSTYPE_TEMPLATE_INFO (type);
+ generic = CLASSTYPE_USE_TEMPLATE (type);
+ }
+ else
+ {
+ tmpl_info = NULL;
+ generic = 0;
+ }
+ if (generic == 1)
+ return HIDDEN;
+ if (tmpl_info != NULL)
+ {
+ pph_print_depend_template (tmpl_info, t);
+ needed = defined && generic == 3;
+ }
+ else
+ {
+ needed = false;
+ }
+ }
+ else if (code == VAR_DECL)
+ {
+ tree enclass = DECL_CONTEXT (t);
+ bool in_class = enclass && CLASS_TYPE_P (enclass);
+ /* If the VAR_DECL is in a class, it must be a static member. */
+ container = enclass;
+ if (in_class)
+ container = TYPE_CONTEXT (enclass);
+
+ pph_print_depend_var_type (t);
+
+ if (!is_namespace (container))
+ return HIDDEN;
+ defined = DECL_INITIAL (t) != NULL /* FIXME pph: DECL_INITIALIZED_P (t) */;
+ type = TREE_TYPE (t);
+ needed = !((!defined && (in_class || DECL_THIS_EXTERN (t)))
+ || DECL_INTEGRAL_CONSTANT_VAR_P (t));
+ if (in_class)
+ {
+ tmpl_info = DECL_TEMPLATE_INFO (t);
+ generic = DECL_USE_TEMPLATE (t);
+ if (generic == 1)
+ return HIDDEN;
+ }
+ else
+ {
+ tmpl_info = NULL;
+ generic = 0;
+ }
+ if (tmpl_info != NULL)
+ {
+ pph_print_depend_template (tmpl_info, t);
+ needed = needed && generic == 3;
+ }
+ }
+ else if (code == FUNCTION_DECL)
+ {
+ if (flag_pph_debug >= 2)
+ {
+ fprintf (pph_logfile, " depending on function ");
+ pph_debug_tree (t, false);
+ fprintf (pph_logfile, "\n");
+ }
+
+ container = DECL_CONTEXT (t);
+ if (container && CLASS_TYPE_P (container))
+ container = TYPE_CONTEXT (DECL_CONTEXT (t));
+
+ pph_print_depend_func_type (t);
+
+ if (!is_namespace (container))
+ return HIDDEN;
+ inlined = DECL_DECLARED_INLINE_P (t);
+ defined = DECL_INITIAL (t) != NULL;
+ tmpl_info = DECL_TEMPLATE_INFO (t);
+ generic = DECL_USE_TEMPLATE (t);
+ if (tmpl_info != NULL)
+ {
+ if (generic == 2)
+ needed = defined && !inlined;
+ else
+ {
+ pph_print_depend_template (tmpl_info, t);
+ needed = defined && !inlined && generic == 3;
+ }
+ }
+ else
+ {
+ needed = defined && !inlined;
+ }
+ }
+ else
+ {
+ gcc_assert (code < MAX_TREE_CODES);
+ return HIDDEN;
+ }
+
+ if (needed)
+ return NEEDED;
+ else
+ return EXPOSED;
+}
+
+static void
+pph_print_dependences (bool user_body, bool used_body,
+ tree t, VEC(tree,gc) *deps)
+{
+ unsigned j;
+ tree d;
+ for (j = 0; VEC_iterate (tree, deps, j, d); j++)
+ pph_print_dependence (user_body, used_body, t, d);
+}
+
+/* Print the head of declaration T and its dependencies. N_HEAD_TOKENS
+ is the number of tokens taken by T's head. N_HEAD_ITOKENS is the
+ number of invisible tokens.
+
+ HEAD_TOKENS is the array of tokens in the head (note that the
+ length of this array may be different than N_HEAD_TOKENS, due to
+ adjustments made by the caller).
+
+ If CONTAINER is set, then T is a member of it. */
+
+static void
+pph_print_declaration_head (tree t, bool artificial, tree container,
+ unsigned n_head_tokens, unsigned n_head_invis,
+ VEC(cp_token, heap) *head_tokens)
+{
+ VEC(tree,gc) *sym_head_deps, *sym_body_deps;
+ enum tree_code code = TREE_CODE (t);
+
+ fprintf (pph_logfile, "declaration ");
+ pph_debug_tree (t, false);
+
+ fprintf (pph_logfile, " htok %u,%u", n_head_tokens, n_head_invis);
+
+ /*FIXME pph: We want to get rid of most artificial tokens;
+ this is temporary to find them. */
+ if (artificial)
+ fprintf (pph_logfile, " artificial");
+
+ if (container)
+ {
+ fprintf (pph_logfile, " mbrof ");
+ pph_debug_tree (get_type_decl (container), true);
+ }
+
+ fprintf (pph_logfile, "\n");
+
+ /* Template instances should depend on their pattern body. */
+ if (artificial)
+ {
+ if (code == TYPE_DECL)
+ {
+ tree t_type = TREE_TYPE (t);
+ if (CLASS_TYPE_P (t_type))
+ {
+ tree tmpl_info = CLASSTYPE_TEMPLATE_INFO (t_type);
+ if (tmpl_info != NULL)
+ pph_print_depend_template (tmpl_info, t);
+ }
+ }
+ else if (code == VAR_DECL || code == FUNCTION_DECL)
+ {
+ tree tmpl_info;
+ tmpl_info = (DECL_LANG_SPECIFIC (t)) ? DECL_TEMPLATE_INFO (t) : NULL;
+ if (tmpl_info != NULL)
+ pph_print_depend_template (tmpl_info, t);
+ }
+ }
+ else
+ {
+ /* From the name dependencies, determine symbol dependencies
+ by correlating the location of the looked-up symbols with
+ the tokens in HEAD_TOKENS and BODY_TOKENS. */
+ if (flag_pph_debug >= 2)
+ fprintf (pph_logfile, " begin normal dependences\n");
+ pph_locate_name_lookups_in (head_tokens, &sym_head_deps, &sym_body_deps);
+ pph_print_dependences (false, false, t, sym_head_deps);
+ pph_print_dependences (true, false, t, sym_body_deps);
+ if (flag_pph_debug >= 2)
+ fprintf (pph_logfile, " end normal dependences\n");
+ }
+}
+
+
+/* Print the head of declaration T and its dependencies. N_BODY_TOKENS
+ is the number of tokens taken by T's head. N_BODY_ITOKENS is the
+ number of invisible tokens.
+
+ BODY_TOKENS is the array of tokens in the head (note that the
+ length of this array may be different than N_BODY_TOKENS, due to
+ adjustments made by the caller).
+
+ EXPOSURE indicates the exposure of T.
+
+ N_SUBTOKENS is the number of tokens that declarations inside T's
+ body have used up, those should be subtracted from the total number
+ of tokens in T to avoid double counting. */
+
+static void
+pph_print_declaration_body (tree t, bool artificial,
+ enum decl_exposure exposure,
+ unsigned n_body_tokens, unsigned n_body_invis,
+ VEC(cp_token, heap) *body_tokens)
+{
+ VEC(tree,gc) *sym_head_deps, *sym_body_deps;
+ const char* msg;
+
+ fprintf (pph_logfile, "declaration ");
+ pph_debug_tree (t, true);
+
+ fprintf (pph_logfile, " btok %u,%u", n_body_tokens, n_body_invis);
+
+ /* FIXME pph: We want to get rid of most artificial tokens;
+ this is temporary to find them. */
+ if (artificial)
+ msg = "artificial";
+ else if (exposure == NEEDED)
+ msg = "needed";
+ else
+ msg = "lazy";
+ fprintf (pph_logfile, " %s", msg);
+
+ fprintf (pph_logfile, "\n");
+
+ pph_print_dependence (true, false, t, t); /* body depends on its head */
+
+ if (flag_pph_debug >= 2)
+ fprintf (pph_logfile, " begin normal dependences\n");
+ pph_locate_name_lookups_in (body_tokens, &sym_head_deps, &sym_body_deps);
+ pph_print_dependences (true, false, t, sym_head_deps);
+ pph_print_dependences (true, false, t, sym_body_deps);
+ if (flag_pph_debug >= 2)
+ fprintf (pph_logfile, " end normal dependences\n");
+}
+
+
+/* Compute the implicit cost of a method F. */
+
+static unsigned
+pph_find_special_methods (tree f)
+{
+ unsigned found = 0;
+ tree o;
+ if (TREE_CODE (f) == OVERLOAD)
+ {
+ for (o = f; o; o = OVL_NEXT (o))
+ found |= pph_find_special_methods (OVL_CURRENT (o));
+ }
+ else if (TREE_CODE (f) == TEMPLATE_DECL)
+ found |= pph_find_special_methods (DECL_TEMPLATE_RESULT (f));
+ else
+ {
+ gcc_assert (TREE_CODE (f) == FUNCTION_DECL);
+ if (DECL_ARTIFICIAL (f))
+ return found;
+ if (DECL_CONSTRUCTOR_P (f))
+ if (DECL_COPY_CONSTRUCTOR_P (f))
+ found |= (1<<2); /* copy constructor */
+ else
+ found |= (1<<1); /* default constructor */
+ else if (DECL_DESTRUCTOR_P (f))
+ found |= (1<<0); /* destructor */
+ else if (DECL_ASSIGNMENT_OPERATOR_P (f))
+ found |= (1<<3); /* copy assign op */
+ }
+ return found;
+}
+
+/* Compute the implicit cost of a class type T_TYPE. */
+
+static unsigned
+pph_implicit_class_cost (tree t_type)
+{
+ VEC(tree,gc) *methods;
+ unsigned idx;
+ unsigned mbrs;
+ unsigned cost = 0;
+ unsigned found = 0;
+
+ /* Gather general statistics. */
+ unsigned fields = fields_length (t_type); /* also direct bases */
+ unsigned vptr = (TYPE_POLYMORPHIC_P (t_type) ? 1 : 0);
+ unsigned slots = fields + vptr;
+ unsigned vbases = VEC_length (tree, CLASSTYPE_VBASECLASSES (t_type));
+ unsigned vtables = list_length (CLASSTYPE_VTABLES (t_type));
+
+ /* Assign cost of implicit special member variables. */
+ /* These costs are somewhat arbitrary. */
+ cost += 20 * (CLASSTYPE_TYPEINFO_VAR (t_type) != NULL); /* typeinfo */
+ cost += 4 * vbases * vtables; /* virtual tables */
+
+ /* Assign cost of implicit special member functions. */
+ /* First find them. */
+ methods = CLASSTYPE_METHOD_VEC (t_type);
+ if (methods != NULL)
+ for (idx = 0; idx < VEC_length (tree, methods); idx++)
+ {
+ tree ovld = VEC_index (tree, methods, idx);
+ if (ovld)
+ found |= pph_find_special_methods (ovld);
+ }
+ /* These costs are somewhat arbitrary. */
+ /* FIXME pph: These queries seem to not work for templates.
+ We can accept the inaccuracy for now. */
+ mbrs = slots * 2 + vbases * 4;
+ if (!(found & (1<<2))) /* copy constructor */
+ {
+ if (TYPE_HAS_TRIVIAL_COPY_ASSIGN (t_type))
+ cost += 4;
+ else
+ cost += (8 + 2*mbrs) * (vbases > 0 ? 2 : 1);
+ }
+ if (!(found & (1<<1))) /* default constructor */
+ if (!TYPE_HAS_TRIVIAL_DFLT (t_type))
+ cost += 4 + mbrs;
+ if (!(found & (1<<0))) /* destructor */
+ if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (t_type))
+ cost += (8 + 2*mbrs) * (vbases > 0 ? 2 : 1);
+ if (!(found & (1<<3))) /* copy assign op */
+ {
+ if (TYPE_HAS_TRIVIAL_COPY_ASSIGN (t_type))
+ cost += 4;
+ else
+ cost += (8 + 2*mbrs);
+ }
+
+ return cost;
+}
+
+
+/* Print declaration T with the given EXPOSURE. If T has a body with
+ N tokens, subtract N_SUBTOKENS from it before printing them.
+ This is used when printing class declarations. The caller first
+ prints all the declarations inside the class, followed by the
+ class declaration itself, to avoid double counting tokens in the class
+ body, they are subtracted from the total count.
+
+ PRIMARY is true when T is the very first declaration captured
+ during a pph_start_exposed/pph_stop_exposed region. If T is a
+ member of a class, and it happens to be the first declaration
+ captured, it means that T is an out-of-line definition.
+
+ If T is a member of a class, and PARENT is the TYPE_DECL for that
+ class, it means that we are printing the in-class declaration of T.
+ In that case, when we print the parent, we should subtract the
+ tokens attributed to T. So, in these cases return the total
+ number of tokens printed in T's head and body. Otherwise,
+ return 0. */
+
+static unsigned
+pph_print_declaration (tree t, enum decl_exposure exposure,
+ unsigned n_subtokens, bool primary, tree parent)
+{
+ tree container = NULL;
+ enum tree_code code = TREE_CODE (t);
+ bool is_member = false;
+ bool artificial = PPH_ARTIFICIAL (t);
+ bool print_head = true, print_body = true;
+
+ /* The cost of a declaration is proportional to the number of tokens.
+ Artificial symbols are not represented in the file, so they do
+ not have tokens. We represent their cost as a number of
+ invisible tokens. */
+ VEC(cp_token, heap) *head_tokens = pph_lookup_head_token_cache_for (t);
+ unsigned n_head_tokens = VEC_length (cp_token, head_tokens);
+ unsigned n_head_invis = 0;
+ VEC(cp_token, heap) *body_tokens = pph_lookup_body_token_cache_for (t);
+ unsigned n_body_tokens = VEC_length (cp_token, body_tokens);
+ unsigned n_body_invis = 0;
+ unsigned n_member_tokens = 0;
+
+ /* If this is a member of a class, count the number of tokens in the
+ member that overlap with the containing class. */
+ if (code == FUNCTION_DECL || code == VAR_DECL)
+ {
+ container = DECL_CONTEXT (t);
+ if (container && CLASS_TYPE_P (container))
+ {
+ is_member = true;
+ if (parent && container == TREE_TYPE (parent))
+ n_member_tokens = n_head_tokens + n_body_tokens;
+ }
+ }
+
+ /* Now we need to adjust costs, and head/body printing. */
+
+ if (code == VAR_DECL)
+ {
+ if (artificial)
+ /* Artificial static member variables get their token
+ counts from the calling expression, which isn't helpful.
+ Build the cost into the class instead. All of which
+ means suppress this decl. */
+ return 0;
+
+ if (DECL_NONTRIVIALLY_INITIALIZED_P (t)
+ && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
+ n_body_invis += 10;
+
+ if (is_member)
+ {
+ if (primary) /* Must be an out-of-line declaration/definition. */
+ {
+ /* Merge out-of-line member definitions into the body.
+ This merge prevents two heads for the same symbol. */
+ n_body_tokens += n_head_tokens;
+ n_body_invis += n_head_invis;
+ n_head_tokens = 0;
+ n_head_invis = 0;
+ print_head = false;
+ /* Out-of-line member variable declarations are definitions,
+ and hence need to be generated. */
+ exposure = NEEDED;
+ }
+ else /* Not primary; must be an in-line declaration/definition. */
+ {
+ /* The only var bodies in the class are manifest constants;
+ merge them into the head. */
+ n_head_tokens += n_body_tokens;
+ n_head_invis += n_body_invis;
+ n_body_tokens = 0;
+ n_body_invis = 0;
+ print_body = false;
+ }
+ }
+ else /* not is_member */
+ {
+ if (exposure == EXPOSED)
+ {
+ /* Merge manifest constants into the head.
+ This code sweeps up extern declarations with no bodies,
+ but that's okay. */
+ n_head_tokens += n_body_tokens;
+ n_head_invis += n_body_invis;
+ n_body_tokens = 0;
+ n_body_invis = 0;
+ print_body = false;
+ }
+ }
+ if (exposure == NEEDED)
+ n_body_invis += 4; /* For emitting the actual variable declaration. */
+ }
+ else if (code == FUNCTION_DECL)
+ {
+ /* Pure function declarations get no body. */
+ if (exposure == EXPOSED && !artificial
+ && n_body_tokens == 0 && n_body_invis == 0)
+ print_body = false;
+ if (artificial)
+ {
+ if (is_member)
+ {
+ /* Artificial special member functions get their token
+ counts from the calling expression, which isn't helpful.
+ Build the cost into the class instead. All of which
+ means suppress this decl. */
+ return 0;
+ }
+ }
+ }
+ else if (code == TYPE_DECL)
+ {
+ tree t_type = TREE_TYPE (t);
+
+ if (artificial)
+ return 0;
+
+ if (DECL_IMPLICIT_TYPEDEF_P (t)
+ && CLASS_TYPE_P (t_type)
+ && TYPE_LANG_SPECIFIC (t_type))
+ {
+ tree tmpl_info;
+ int generic;
+
+ n_body_invis += pph_implicit_class_cost (t_type);
+
+ tmpl_info = CLASSTYPE_TEMPLATE_INFO (t_type);
+ if (tmpl_info)
+ {
+ generic = CLASSTYPE_USE_TEMPLATE (t_type);
+ if (generic == 1)
+ {
+ /* Implicit instantiations have no visibile tokens. */
+ n_head_invis += n_head_tokens;
+ n_head_tokens = 0;
+ n_body_invis += n_body_tokens;
+ n_body_tokens = 0;
+ }
+ else if (generic == 3)
+ {
+ /* Explicit instantiations have no bodies,
+ but they are work. This approximation is
+ unjustified, but we are presuming that explicit
+ instantiations are rare in application code. */
+ n_body_invis += 15;
+ exposure = NEEDED;
+ }
+ if (generic != 2)
+ {
+ bool defined;
+ defined = CLASS_TYPE_P (t_type) && COMPLETE_TYPE_P (t_type);
+ if (defined)
+ pph_print_depend_template (tmpl_info, t);
+ }
+ }
+ else if (primary)
+ {
+ /* Now subtract the sum of members from the body of the class.
+ This prevents double counting when emitting the parent.
+ For non-primary class symbols, this value will be zero. */
+ gcc_assert (n_body_tokens >= n_subtokens);
+ n_body_tokens -= n_subtokens;
+ }
+ }
+ else if (TREE_CODE (t_type) == ENUMERAL_TYPE)
+ {
+ /* No additional work for enum. */
+ }
+ else
+ {
+ /* Not artificial, not a C++ class, not an enum;
+ so must be a pure typedef. They have no body. */
+ gcc_assert (n_body_tokens == 0 && n_body_invis == 0);
+ print_body = false;
+ }
+ }
+
+ if (print_head)
+ pph_print_declaration_head (t, artificial, (is_member) ? container : NULL,
+ n_head_tokens, n_head_invis, head_tokens);
+
+ if (print_body)
+ pph_print_declaration_body (t, artificial, exposure,
+ n_body_tokens, n_body_invis, body_tokens);
+
+ if (flag_pph_debug >= 4)
+ {
+ fprintf (pph_logfile, " Declarator head tokens: ");
+ cp_lexer_debug_tokens ((VEC(cp_token, gc) *)head_tokens);
+ fprintf (pph_logfile, " Declarator body tokens: ");
+ cp_lexer_debug_tokens ((VEC(cp_token, gc) *)body_tokens);
+ fprintf (pph_logfile, "\n");
+ }
+
+ return n_member_tokens;
+}
+
+static void
+pph_print_declarations (VEC(tree,heap) *v)
+{
+ unsigned i, j, n, first_ix;
+ tree t, first, parent;
+ enum decl_exposure exposure;
+ unsigned n_subtokens = 0;
+
+ if (VEC_empty (tree, v))
+ return;
+
+ /* If the first AST in V is a class/structure declaration, process
+ the sub-declarations first. This will accumulate the tokens in
+ the sub-declarations, so that when we print the class itself
+ we don't double count the tokens in its body. */
+
+ /* Skip over un-exposed declarations, like template parameters. */
+ n = VEC_length (tree, v);
+ for ( i = 0; VEC_iterate (tree, v, i, t); i++)
+ {
+ exposure = pph_get_decl_exposure (t);
+ if (exposure >= EXPOSED)
+ break;
+ }
+ if (i >= n)
+ return; /* No exposed decls. */
+
+ first = VEC_index (tree, v, i);
+ if (VEC_length (tree, v) > i+1
+ && TREE_CODE (first) == TYPE_DECL
+ && CLASS_TYPE_P (TREE_TYPE (first)))
+ {
+ parent = first;
+ first_ix = i+1;
+ }
+ else
+ {
+ parent = NULL;
+ first_ix = i;
+ }
+
+ for (j = first_ix; VEC_iterate (tree, v, j, t); j++)
+ {
+ exposure = pph_get_decl_exposure (t);
+ if (exposure >= EXPOSED)
+ n_subtokens += pph_print_declaration (t, exposure, 0U, i == j, parent);
+ }
+
+ /* If we didn't print the first declaration, print it now. */
+ if (first_ix > i)
+ {
+ exposure = pph_get_decl_exposure (first);
+ if (exposure >= EXPOSED)
+ pph_print_declaration (first, exposure, n_subtokens, true, NULL);
+ }
+}
+
+static void
+pph_print_trees_tokens (VEC(tree,heap) *v, cp_token *tok1, cp_token *tok2)
+{
+ VEC(cp_token, heap) *vtok;
+
+ vtok = pph_print_copy_tokens (tok1, tok2);
+ if (vtok == NULL)
+ return;
+
+ pph_print_token_range (v, vtok);
+ pph_print_declarations (v);
+ fprintf (pph_logfile, "\n");
+}
+
+
+/* Intercept the result of a name lookup operation requested by the
+ parser while we are intercepting AST creation. T is the result
+ of a name lookup done by the parser. If this is the first time
+ we see it, store it in pph_name_lookups. */
+
+void
+pph_catch_name_lookup (tree t)
+{
+ if (t == NULL_TREE || t == error_mark_node || pph_tree_catcher == NULL)
+ return;
+
+ timevar_push (TV_PPH_MANAGE);
+
+ PPH_STATS_INCR (name_lookups, 1);
+
+ if (the_parser->lexer)
+ {
+ /* If we are parsing, we are stopped one token past the identifier
+ that we have just looked up. Store the token where we have seen
+ this identifier so that we can determine whether the identifier
+ was accessed in a head or a body.
+
+ Note that we do this for every instance we find for T, so that
+ we can store all the locations where T was accessed from. */
+ VEC(cp_token, heap) *tokens;
+ cp_token *tok;
+ void **slot;
+
+ slot = pointer_map_insert (pph_nl_token_map, t);
+ tokens = (VEC(cp_token, heap) *) *slot;
+ tok = the_parser->lexer->next_token - 1;
+ VEC_safe_push (cp_token, heap, tokens, tok);
+ *slot = tokens;
+ }
+
+ /* Make sure we do not store the same decl more than once. */
+ if (pointer_set_insert (pph_name_lookups_set, t))
+ {
+ timevar_pop (TV_PPH_MANAGE);
+ return;
+ }
+
+ VEC_safe_push (tree, heap, pph_name_lookups, t);
+ timevar_pop (TV_PPH_MANAGE);
+}
+
+
+/* Print statistics for the PPH cache. */
+
+static void
+pph_print_stats (void)
+{
+ fprintf (stderr, "\nPPH cache statistics\n");
+ fprintf (stderr, "Number of tokens in the lexer: %lu\n",
+ pph_stats.lexed_tokens);
+ fprintf (stderr, "Number of tokens consumed by the parser: %lu\n",
+ pph_stats.parsed_tokens);
+ fprintf (stderr, "Number of declarations cached in: %lu\n",
+ pph_stats.cached_decls);
+ fprintf (stderr, "Number of declarations restored: %lu\n",
+ pph_stats.restored_decls);
+ fprintf (stderr, "Number of cached decl references: %lu\n",
+ pph_stats.cached_refs);
+ fprintf (stderr, "Number of name lookups: %lu\n",
+ pph_stats.name_lookups);
+ fprintf (stderr, "Number of bad lookups: %lu\n",
+ pph_stats.bad_lookups);
+}
+
+
+/* Initialize PPH support. */
+
+void
+pph_init (void)
+{
+ if (flag_pph_logfile)
+ {
+ pph_logfile = fopen (flag_pph_logfile, "w");
+ if (!pph_logfile)
+ fatal_error ("Cannot create %s for writing: %m", flag_pph_logfile);
+ }
+ else
+ pph_logfile = stdout;
+}
+
+
+/* Finalize PPH support. */
+
+void
+pph_finish (void)
+{
+ if (flag_pph_stats)
+ pph_print_stats ();
+
+ if (flag_pph_logfile)
+ fclose (pph_logfile);
+}
+
+#include "gt-cp-pph.h"
Index: cp/pph.h
===================================================================
--- cp/pph.h (revision 0)
+++ cp/pph.h (revision 0)
@@ -0,0 +1,303 @@
+/* Factored pre-tokenized header (PTH) support for C++
+ Copyright (C) 2010 Free Software Foundation, Inc.
+ Contributed by Lawrence Crowl <crowl@google.com> and
+ Diego Novillo <dnovillo@google.com>.
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#ifndef GCC_CP_PPH_H
+#define GCC_CP_PPH_H
+
+#include "line-map.h"
+#include "hashtab.h"
+#include "parser.h"
+#include "timevar.h"
+
+/* A set of contiguous tokens within a single file. */
+typedef struct GTY(()) cp_token_hunk
+{
+ /* Captured identifier and macro state. */
+ cpp_idents_used identifiers;
+
+ /* The array of tokens. */
+ VEC(cp_token,gc) *buffer;
+
+ /* Offset into the libcpp file buffer where this token hunk starts at.
+ If this token hunk is invalidated, the lexer is repositioned at
+ this offset into the file to start lexing again. */
+ cpp_offset text_offset;
+
+ /* Length of this hunk in characters. When the tokens in this hunk
+ are moved into the lexer buffer, the original character stream
+ is advanced this many characters to avoid future lexing from
+ seeing these tokens again. */
+ size_t text_length;
+} cp_token_hunk;
+
+typedef struct cp_token_hunk *cp_token_hunk_ptr;
+
+DEF_VEC_P (cp_token_hunk_ptr);
+DEF_VEC_ALLOC_P (cp_token_hunk_ptr,gc);
+
+/* Number of bytes in an MD5 signature. */
+#define DIGEST_LEN 16
+
+struct pth_image;
+typedef struct pth_image *pth_image_ptr;
+DEF_VEC_P (pth_image_ptr);
+DEF_VEC_ALLOC_P (pth_image_ptr,gc);
+
+DEF_VEC_ALLOC_I(char,gc);
+
+/* Description of a #include command. This records the #include type
+ used in the original source and the image included. It is used
+ to restore a file from its character stream in case that the
+ associated image is found to be tainted. */
+
+typedef struct GTY(()) pth_include
+{
+ /* The image to include. */
+ struct pth_image *image;
+
+ /* The #include command used: #include, #include_next or #import. */
+ enum include_type itype;
+
+ /* Nonzero if this include used angle brackets. */
+ unsigned int angle_brackets : 1;
+
+ /* Name used in the command used in this #include command. */
+ const char * GTY((skip)) iname;
+
+ /* Directory where INAME can be found. This is not necessarily
+ the same as lbasename (IMAGE->FNAME), but it is always true that
+ DNAME/INAME == IMAGE->FNAME. */
+ const char * GTY((skip)) dname;
+} pth_include;
+
+typedef struct pth_include *pth_include_ptr;
+DEF_VEC_P (pth_include_ptr);
+DEF_VEC_ALLOC_P (pth_include_ptr,gc);
+
+/* An entry in the incremental cache. Each entry represents
+ a single file in the translation unit. Tokens are saved in a linked
+ list of lexers, separated by file change events in the pre-processor.
+ Every time the preprocessor signals a file change, a new lexer for
+ this entry is created. */
+
+typedef struct GTY(()) pth_image
+{
+ /* Full path name. */
+ const char * GTY((skip)) fname;
+
+ /* MD5 sum for the contents of the original path name. */
+ unsigned char digest[DIGEST_LEN];
+
+ /* Vector of token hunks corresponding to this file, and this file
+ only. If this file includes other files, their tokens will not be
+ stored here. Each entry in this vector is a hunk of tokens
+ delimited by file change events. For instance, if a file is
+ laid out like this:
+
+ [ t1 t2 ... tN ]
+ #include "foo.h"
+ [ p1 p2 ... pM ]
+
+ The field token_caches will have two entries. One for the hunk
+ [t1, tN], the second one for the hunk [p1, pM]. */
+ VEC(cp_token_hunk_ptr,gc) *token_hunks;
+
+ /* Vector of files included by this file. */
+ VEC(pth_include_ptr,gc) *includes;
+
+ /* Sequencing string that describes how the elements from
+ TOKEN_HUNKS and INCLUDES are interleaved. Each character of this
+ string is either 'H' (hunk) or 'I' (include). This is used in
+ pth_image_to_lexer to know in what order should the hunks
+ and include files be processed.
+
+ FIXME pph, using a character string is heavy handed. A bitmap
+ would suffice, but for now this is easier and the space consumed
+ should not be too significant. */
+ VEC(char,gc) *ih_sequence;
+
+ /* True if this image needs to be flushed out to disk. */
+ unsigned int save_p : 1;
+
+ /* True if this image has been loaded from an image file. */
+ unsigned int loaded_p: 1;
+
+ /* True if this image has been incorporated into the current
+ compilation context. FIXME pph, should we keep track of this
+ at the hunk level? */
+ unsigned int used_p : 1;
+
+ /* True if we have computed the MD5 digest for FNAME. */
+ unsigned int digest_computed_p : 1;
+
+ /* Index into the lexer buffer where the next token hunk to be
+ created should start. This is managed by the file changing
+ logic in pth_file_change. */
+ unsigned hunk_start_ix;
+
+ /* Offset into the libcpp character buffer where the next token
+ hunk will be read from. */
+ cpp_offset hunk_text_offset;
+
+ /* libcpp buffer associated with IMAGE->FNAME. */
+ cpp_buffer * GTY((skip)) buffer;
+} pth_image;
+
+
+/* PTH state. This holds all the data needed to manage the PTH cache. */
+typedef struct GTY(()) pth_state
+{
+ /* The cache of pre-tokenized content. */
+ VEC(pth_image_ptr,gc) *cache;
+
+ /* Pointer map for speeding up cache lookups. */
+ htab_t GTY((param_is (struct pth_image))) cache_dir;
+
+ /* The current cache image being modified. */
+ pth_image *cur_image;
+
+ /* Attributes for the most recent #include command found by
+ pth_include_handler. */
+ enum include_type new_itype;
+ bool new_angle_brackets;
+ const char *new_iname;
+
+ /* The lexer used to pre-process the file. */
+ cp_lexer *lexer;
+
+ /* Previously registered file change callback. */
+ void (*file_change_prev) (cpp_reader *, const struct line_map *);
+} pth_state;
+
+
+/* Statistics on PTH. */
+
+struct pth_stats_d
+{
+ /* Number of files processed as a regular #include. */
+ size_t included_files;
+
+ /* Number of valid images. */
+ size_t valid_images;
+
+ /* Number of token hunks seen. */
+ size_t hunks;
+
+ /* Number of valid hunks copied from images. */
+ size_t valid_hunks;
+
+ /* Number of hunks that failed dependency checks. */
+ size_t invalid_hunks;
+
+ /* Number of verified hunks. */
+ size_t verified_hunks;
+
+ /* Number of verified identifiers. */
+ size_t verified_identifiers;
+};
+
+extern struct pth_stats_d pth_stats;
+
+#define PTH_STATS_INCR(CNT,N) \
+ do { \
+ if (flag_pth_stats) \
+ pth_stats.CNT += (N); \
+ } while (0)
+
+
+/* Statistics on PPH. */
+
+struct pph_stats_d
+{
+ /* Number of tokens parsed in this TU. */
+ size_t parsed_tokens;
+
+ /* Number of tokens in the lexer buffer. */
+ size_t lexed_tokens;
+
+ /* Number of declarations copied into the parser cache. */
+ size_t cached_decls;
+
+ /* Number of declarations restored from the parser cache. */
+ size_t restored_decls;
+
+ /* Number of references rebound when going in/out of the cache. */
+ size_t cached_refs;
+
+ /* Number of name lookups done by the parser. */
+ size_t name_lookups;
+
+ /* Number of decl lookups that were changed to something weird. */
+ size_t bad_lookups;
+};
+
+extern struct pph_stats_d pph_stats;
+
+#define PPH_STATS_INCR(CNT,N) \
+ do { \
+ if (flag_pph_stats) \
+ pph_stats.CNT += (N); \
+ } while (0)
+
+
+/* Maps for tracking decl dependencies. For each *_DECL tree intercepted
+ during parsing, we store the trees on which the node depends for
+ its declaration. Two maps are kept, one for the head of the declaration
+ and another for its body. */
+struct pph_decl_deps_d
+{
+ /* Symbol dependencies on the declaration header. */
+ struct pointer_map_t *header;
+
+ /* Symbol dependencies on the declaration body. */
+ struct pointer_map_t *body;
+};
+
+/* Global state. FIXME pph, get rid of these. */
+
+/* Log file where PPH analysis is written to. Controlled by
+ -fpph_logfile. If this flag is not given, stdout is used. */
+extern FILE *pph_logfile;
+
+#define PPH_POP_TIMEVAR_AND_RETURN(TV, T) \
+ do { \
+ pph_catch_name_lookup (T); \
+ POP_TIMEVAR_AND_RETURN(TV, T); \
+ } while (0)
+
+
+/* In pph.c */
+extern void pth_init (cp_lexer *);
+extern void pth_finish (void);
+extern void pth_debug_state (void);
+extern void pth_debug_token_hunks (pth_image *);
+extern pth_image *pth_image_lookup (pth_state *, const char *, cpp_reader *);
+extern pth_state *pth_get_state (void);
+extern void pth_print_stats (FILE *, cp_lexer *);
+extern cp_token *pph_start_exposed (cp_parser *);
+extern void pph_stop_exposed (cp_parser *, cp_token *);
+extern void pph_init (void);
+extern void pph_finish (void);
+extern void pph_catch_tree (tree);
+extern void pph_uncatch_tree (tree);
+extern void pph_catch_name_lookup (tree);
+
+#endif /* GCC_CP_PPH_H */
Index: cp/cp-lang.c
===================================================================
--- cp/cp-lang.c (revision 166209)
+++ cp/cp-lang.c (working copy)
@@ -33,6 +33,8 @@ along with GCC; see the file COPYING3.
#include "cp-objcp-common.h"
#include "hashtab.h"
#include "target.h"
+#include "parser.h"
+#include "pph.h"
enum c_language_kind c_language = clk_cxx;
static void cp_init_ts (void);
Index: cp/pt.c
===================================================================
--- cp/pt.c (revision 166209)
+++ cp/pt.c (working copy)
@@ -44,6 +44,7 @@ along with GCC; see the file COPYING3.
#include "timevar.h"
#include "tree-iterator.h"
#include "vecprim.h"
+#include "pph.h"
/* The type of functions taking a tree, and some additional data, and
returning an int. */
Index: cp/parser.c
===================================================================
--- cp/parser.c (revision 166209)
+++ cp/parser.c (working copy)
@@ -37,432 +37,20 @@ along with GCC; see the file COPYING3.
#include "cgraph.h"
#include "c-family/c-common.h"
#include "plugin.h"
-#include "timevar.h"
-#include "pointer-set.h"
-#include "fixed-value.h"
-#include "cpplib.h"
-#include "line-map.h"
-#include "md5.h"
-#include "hashtab.h"
-#include "tree-pass.h"
-#include "tree-inline.h"
#include "tree-pretty-print.h"
+#include "parser.h"
+#include "pph.h"
-
/* The lexer. */
/* The cp_lexer_* routines mediate between the lexer proper (in libcpp
and c-lex.c) and the C++ parser. */
-/* A token's value and its associated deferred access checks and
- qualifying scope. */
-
-struct GTY(()) tree_check {
- /* The value associated with the token. */
- tree value;
- /* The checks that have been associated with value. */
- VEC (deferred_access_check, gc)* checks;
- /* The token's qualifying scope (used when it is a
- CPP_NESTED_NAME_SPECIFIER). */
- tree qualifying_scope;
-};
-
-/* A C++ token. */
-
-typedef struct GTY (()) cp_token {
- /* The kind of token. */
- ENUM_BITFIELD (cpp_ttype) type : 8;
- /* If this token is a keyword, this value indicates which keyword.
- Otherwise, this value is RID_MAX. */
- ENUM_BITFIELD (rid) keyword : 8;
- /* Token flags. */
- unsigned char flags;
- /* Identifier for the pragma. */
- ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
- /* True if this token is from a context where it is implicitly extern "C" */
- BOOL_BITFIELD implicit_extern_c : 1;
- /* True for a CPP_NAME token that is not a keyword (i.e., for which
- KEYWORD is RID_MAX) iff this name was looked up and found to be
- ambiguous. An error has already been reported. */
- BOOL_BITFIELD ambiguous_p : 1;
- /* True for a token that has been purged. If a token is purged,
- it is no longer a valid token and it should be considered
- deleted. */
- BOOL_BITFIELD purged_p : 1;
- /* The location at which this token was found. */
- location_t location;
- /* The value associated with this token, if any. */
- union cp_token_value {
- /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
- struct tree_check* GTY((tag ("1"))) tree_check_value;
- /* Use for all other tokens. */
- tree GTY((tag ("0"))) value;
- } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
-} cp_token;
-
-DEF_VEC_O (cp_token);
-DEF_VEC_ALLOC_O (cp_token,gc);
-DEF_VEC_ALLOC_O (cp_token,heap);
-
-
-/* We use a stack of token pointer for saving token sets. */
-typedef struct cp_token *cp_token_position;
-DEF_VEC_P (cp_token_position);
-DEF_VEC_ALLOC_P (cp_token_position,heap);
-
-static cp_token eof_token =
+cp_token eof_token =
{
CPP_EOF, RID_MAX, 0, PRAGMA_NONE, false, false, false, 0, { NULL }
};
-/* The cp_lexer structure represents the C++ lexer. It is responsible
- for managing the token stream from the preprocessor and supplying
- it to the parser. Tokens are never added to the cp_lexer after
- it is created. */
-
-typedef struct GTY (()) cp_lexer {
- /* The memory allocated for the buffer. NULL if this lexer does not
- own the token buffer. */
- VEC(cp_token,gc) *buffer;
-
- /* A pointer just past the last available token. The tokens
- in this lexer are [buffer, last_token). */
- cp_token_position GTY ((skip)) last_token;
-
- /* The next available token. If NEXT_TOKEN is &eof_token, then there are
- no more available tokens. */
- cp_token_position GTY ((skip)) next_token;
-
- /* A stack indicating positions at which cp_lexer_save_tokens was
- called. The top entry is the most recent position at which we
- began saving tokens. If the stack is non-empty, we are saving
- tokens. */
- VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;
-
- /* The next lexer in a linked list of lexers. */
- struct cp_lexer *next;
-
- /* True if we should output debugging information. */
- bool debugging_p;
-
- /* True if we're in the context of parsing a pragma, and should not
- increment past the end-of-line marker. */
- bool in_pragma;
-} cp_lexer;
-
-DEF_VEC_O (cp_lexer);
-DEF_VEC_ALLOC_O (cp_lexer,heap);
-
-/* cp_token_cache is a range of tokens. There is no need to represent
- allocate heap memory for it, since tokens are never removed from the
- lexer's array. There is also no need for the GC to walk through
- a cp_token_cache, since everything in here is referenced through
- a lexer. */
-
-typedef struct GTY(()) cp_token_cache {
- /* The beginning of the token range. */
- cp_token * GTY((skip)) first;
-
- /* Points immediately after the last token in the range. */
- cp_token * GTY ((skip)) last;
-} cp_token_cache;
-
-typedef cp_token_cache *cp_token_cache_ptr;
-DEF_VEC_P (cp_token_cache_ptr);
-DEF_VEC_ALLOC_P (cp_token_cache_ptr,gc);
-
-struct cp_token_ident_d
-{
- unsigned int ident_len;
- const char *ident_str;
- unsigned int before_len;
- const char *before_str;
- unsigned int after_len;
- const char *after_str;
-};
-
-typedef struct cp_token_ident_d cp_token_ident;
-
-/* A set of contiguous tokens within a single file. */
-typedef struct GTY(()) cp_token_hunk
-{
- /* Captured identifier and macro state. */
- cpp_idents_used identifiers;
-
- /* The array of tokens. */
- VEC(cp_token,gc) *buffer;
-
- /* Offset into the libcpp file buffer where this token hunk starts at.
- If this token hunk is invalidated, the lexer is repositioned at
- this offset into the file to start lexing again. */
- cpp_offset text_offset;
-
- /* Length of this hunk in characters. When the tokens in this hunk
- are moved into the lexer buffer, the original character stream
- is advanced this many characters to avoid future lexing from
- seeing these tokens again. */
- size_t text_length;
-} cp_token_hunk;
-
-typedef struct cp_token_hunk *cp_token_hunk_ptr;
-
-DEF_VEC_P (cp_token_hunk_ptr);
-DEF_VEC_ALLOC_P (cp_token_hunk_ptr,gc);
-
-/* Number of bytes in an MD5 signature. */
-#define DIGEST_LEN 16
-
-struct pth_image;
-typedef struct pth_image *pth_image_ptr;
-DEF_VEC_P (pth_image_ptr);
-DEF_VEC_ALLOC_P (pth_image_ptr,gc);
-
-DEF_VEC_ALLOC_I(char,gc);
-
-/* Description of a #include command. This records the #include type
- used in the original source and the image included. It is used
- to restore a file from its character stream in case that the
- associated image is found to be tainted. */
-
-typedef struct GTY(()) pth_include
-{
- /* The image to include. */
- struct pth_image *image;
-
- /* The #include command used: #include, #include_next or #import. */
- enum include_type itype;
-
- /* Nonzero if this include used angle brackets. */
- unsigned int angle_brackets : 1;
-
- /* Name used in the command used in this #include command. */
- const char * GTY((skip)) iname;
-
- /* Directory where INAME can be found. This is not necessarily
- the same as lbasename (IMAGE->FNAME), but it is always true that
- DNAME/INAME == IMAGE->FNAME. */
- const char * GTY((skip)) dname;
-} pth_include;
-
-typedef struct pth_include *pth_include_ptr;
-DEF_VEC_P (pth_include_ptr);
-DEF_VEC_ALLOC_P (pth_include_ptr,gc);
-
-/* An entry in the incremental cache. Each entry represents
- a single file in the translation unit. Tokens are saved in a linked
- list of lexers, separated by file change events in the pre-processor.
- Every time the preprocessor signals a file change, a new lexer for
- this entry is created. */
-
-typedef struct GTY(()) pth_image
-{
- /* Full path name. */
- const char * GTY((skip)) fname;
-
- /* MD5 sum for the contents of the original path name. */
- unsigned char digest[DIGEST_LEN];
-
- /* Vector of token hunks corresponding to this file, and this file
- only. If this file includes other files, their tokens will not be
- stored here. Each entry in this vector is a hunk of tokens
- delimited by file change events. For instance, if a file is
- laid out like this:
-
- [ t1 t2 ... tN ]
- #include "foo.h"
- [ p1 p2 ... pM ]
-
- The field token_caches will have two entries. One for the hunk
- [t1, tN], the second one for the hunk [p1, pM]. */
- VEC(cp_token_hunk_ptr,gc) *token_hunks;
-
- /* Vector of files included by this file. */
- VEC(pth_include_ptr,gc) *includes;
-
- /* Sequencing string that describes how the elements from
- TOKEN_HUNKS and INCLUDES are interleaved. Each character of this
- string is either 'H' (hunk) or 'I' (include). This is used in
- pth_image_to_lexer to know in what order should the hunks
- and include files be processed.
-
- FIXME pph, using a character string is heavy handed. A bitmap
- would suffice, but for now this is easier and the space consumed
- should not be too significant. */
- VEC(char,gc) *ih_sequence;
-
- /* True if this image needs to be flushed out to disk. */
- unsigned int save_p : 1;
-
- /* True if this image has been loaded from an image file. */
- unsigned int loaded_p: 1;
-
- /* True if this image has been incorporated into the current
- compilation context. FIXME pph, should we keep track of this
- at the hunk level? */
- unsigned int used_p : 1;
-
- /* True if we have computed the MD5 digest for FNAME. */
- unsigned int digest_computed_p : 1;
-
- /* Index into the lexer buffer where the next token hunk to be
- created should start. This is managed by the file changing
- logic in pth_file_change. */
- unsigned hunk_start_ix;
-
- /* Offset into the libcpp character buffer where the next token
- hunk will be read from. */
- cpp_offset hunk_text_offset;
-
- /* libcpp buffer associated with IMAGE->FNAME. */
- cpp_buffer * GTY((skip)) buffer;
-} pth_image;
-
-
-/* PTH state. This holds all the data needed to manage the PTH cache. */
-typedef struct GTY(()) pth_state
-{
- /* The cache of pre-tokenized content. */
- VEC(pth_image_ptr,gc) *cache;
-
- /* Pointer map for speeding up cache lookups. */
- htab_t GTY((param_is (struct pth_image))) cache_dir;
-
- /* The current cache image being modified. */
- pth_image *cur_image;
-
- /* Attributes for the most recent #include command found by
- pth_include_handler. */
- enum include_type new_itype;
- bool new_angle_brackets;
- const char *new_iname;
-
- /* The lexer used to pre-process the file. */
- cp_lexer *lexer;
-
- /* Previously registered file change callback. */
- void (*file_change_prev) (cpp_reader *, const struct line_map *);
-} pth_state;
-
-
-/* Statistics on PTH. */
-
-struct pth_stats_d
-{
- /* Number of files processed as a regular #include. */
- size_t included_files;
-
- /* Number of valid images. */
- size_t valid_images;
-
- /* Number of token hunks seen. */
- size_t hunks;
-
- /* Number of valid hunks copied from images. */
- size_t valid_hunks;
-
- /* Number of hunks that failed dependency checks. */
- size_t invalid_hunks;
-
- /* Number of verified hunks. */
- size_t verified_hunks;
-
- /* Number of verified identifiers. */
- size_t verified_identifiers;
-};
-
-static struct pth_stats_d pth_stats;
-
-#define PTH_STATS_INCR(CNT,N) \
- do { \
- if (flag_pth_stats) \
- pth_stats.CNT += (N); \
- } while (0)
-
-
-/* Statistics on PPH. */
-
-struct pph_stats_d
-{
- /* Number of tokens parsed in this TU. */
- size_t parsed_tokens;
-
- /* Number of tokens in the lexer buffer. */
- size_t lexed_tokens;
-
- /* Number of declarations copied into the parser cache. */
- size_t cached_decls;
-
- /* Number of declarations restored from the parser cache. */
- size_t restored_decls;
-
- /* Number of references rebound when going in/out of the cache. */
- size_t cached_refs;
-
- /* Number of name lookups done by the parser. */
- size_t name_lookups;
-
- /* Number of decl lookups that were changed to something weird. */
- size_t bad_lookups;
-};
-
-static struct pph_stats_d pph_stats;
-
-#define PPH_STATS_INCR(CNT,N) \
- do { \
- if (flag_pph_stats) \
- pph_stats.CNT += (N); \
- } while (0)
-
-
-/* Cache of token ranges for head of symbol declarations. For each
- *_DECL tree intercepted during parsing, we store the vector of
- tokens that make up the head of the declaration for the node. */
-static struct pointer_map_t *pph_decl_head_token_cache = NULL;
-
-/* Cache of token ranges for body of symbol declarations. For each
- *_DECL tree intercepted during parsing, we store the vector of
- tokens that make up the body of the declaration for the node. */
-static struct pointer_map_t *pph_decl_body_token_cache = NULL;
-
-/* Maps for tracking decl dependencies. For each *_DECL tree intercepted
- during parsing, we store the trees on which the node depends for
- its declaration. Two maps are kept, one for the head of the declaration
- and another for its body. */
-struct pph_decl_deps_d
-{
- /* Symbol dependencies on the declaration header. */
- struct pointer_map_t *header;
-
- /* Symbol dependencies on the declaration body. */
- struct pointer_map_t *body;
-};
-
-/* Map of decl dependencies. */
-static struct pph_decl_deps_d *pph_decl_deps = NULL;
-
-/* Tree catcher for the incremental compiler. Whenever this array is
- allocated, make_node_stat() will push certain trees into this array. */
-static VEC(tree,heap) *pph_tree_catcher = NULL;
-
-/* Catcher for name lookups. This stores every name lookup performed
- on identifiers while we are catching ASTs in the parser. */
-static VEC(tree,heap) *pph_name_lookups = NULL;
-
-/* Since identifiers may be looked up more than once during parsing,
- this set prevents duplicate symbols from being placed in
- pph_name_lookups. */
-static struct pointer_set_t *pph_name_lookups_set = NULL;
-
-/* This map stores the token locations where a given symbol was looked
- up. When an identifier is looked up and resolved to symbol S, we
- check where the current token pointer is and save it in a vector
- associated with S. */
-static struct pointer_map_t *pph_nl_token_map = NULL;
-
-/* Log file where PPH analysis is written to. Controlled by
- -fpph_logfile. If this flag is not given, stdout is used. */
-static FILE *pph_logfile = NULL;
-
/* The various kinds of non integral constant we encounter. */
typedef enum non_integral_constant {
NIC_NONE,
@@ -587,8 +175,6 @@ typedef enum required_token {
/* Prototypes. */
-static void pph_print_trees_tokens (VEC(tree,heap) *, cp_token *, cp_token *);
-
static cp_lexer *cp_lexer_new_main
(void);
static cp_lexer *cp_lexer_new_from_tokens
@@ -597,8 +183,6 @@ static void cp_lexer_destroy
(cp_lexer *);
static int cp_lexer_saving_tokens
(const cp_lexer *);
-static cp_token_position cp_lexer_token_position
- (cp_lexer *, bool);
static cp_token *cp_lexer_token_at
(cp_lexer *, cp_token_position);
static void cp_lexer_get_preprocessor_token
@@ -655,25 +239,6 @@ static void cp_parser_initial_pragma
#define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token))
#define CP_SAVED_TOKEN_STACK 5
-/* A token type for keywords, as opposed to ordinary identifiers. */
-#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
-
-/* A token type for template-ids. If a template-id is processed while
- parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
- the value of the CPP_TEMPLATE_ID is whatever was returned by
- cp_parser_template_id. */
-#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
-
-/* A token type for nested-name-specifiers. If a
- nested-name-specifier is processed while parsing tentatively, it is
- replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
- CPP_NESTED_NAME_SPECIFIER is whatever was returned by
- cp_parser_nested_name_specifier_opt. */
-#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
-
-/* The number of token types, including C++-specific ones. */
-#define N_CP_TTYPES ((int) (CPP_NESTED_NAME_SPECIFIER + 1))
-
/* Variables. */
#ifdef ENABLE_CHECKING
@@ -688,7 +253,7 @@ int cp_unevaluated_operand;
/* Dump up to NUM tokens in BUFFER to FILE. If NUM is 0, dump all the
tokens. */
-static void
+void
cp_lexer_dump_tokens (FILE *file, VEC(cp_token,gc) *buffer, unsigned num)
{
unsigned i;
@@ -729,1461 +294,12 @@ cp_lexer_dump_tokens (FILE *file, VEC(cp
/* Dump all tokens in BUFFER to stderr. */
-static void
+void
cp_lexer_debug_tokens (VEC(cp_token,gc) *buffer)
{
cp_lexer_dump_tokens (stderr, buffer, 0);
}
-/* Return true if path P1 and path P2 point to the same file. */
-
-static inline bool
-pathnames_equal_p (const char *p1, const char *p2)
-{
- return strcmp (lrealpath (p1), lrealpath (p2)) == 0;
-}
-
-/* Expand and print location LOC to FILE. If FILE is NULL, pph_logfile
- is used. */
-
-static void
-pph_debug_location (FILE *file, location_t loc)
-{
- expanded_location xloc;
- file = (file) ? file : pph_logfile;
- xloc = expand_location (loc);
- fprintf (file, "%s:%d:%d", lrealpath (xloc.file), xloc.line, xloc.column);
-}
-
-
-/* Expand and print the location of tree T to FILE. If FILE is NULL,
- pph_logfile is used. */
-
-static void
-pph_debug_loc_of_tree (FILE *file, tree t)
-{
- pph_debug_location (file, DECL_SOURCE_LOCATION (t));
-}
-
-
-/* Hash and comparison functions for the directory of cached images. */
-
-static hashval_t
-pth_image_dir_hash (const void *p)
-{
- const char *s = lrealpath (((const pth_image *)p)->fname);
- return htab_hash_string (s);
-}
-
-
-static int
-pth_image_dir_eq (const void *p1, const void *p2)
-{
- const char *s1 = ((const pth_image *)p1)->fname;
- const char *s2 = ((const pth_image *)p2)->fname;
- return pathnames_equal_p (s1, s2);
-}
-
-
-
-static GTY(()) pth_state *pth_global_state = NULL;
-
-/* Return the global PTH state where the cache and its directory
- are stored. */
-
-static pth_state *
-pth_get_state (void)
-{
- if (pth_global_state == NULL)
- {
- pth_global_state = ggc_alloc_cleared_pth_state ();
- pth_global_state->cache_dir = htab_create_ggc (10, pth_image_dir_hash,
- pth_image_dir_eq, NULL);
- }
-
- return pth_global_state;
-}
-
-
-/* Return an identification string for a PTH image. */
-
-static const char *
-pth_id_str (void)
-{
- /* FIXME pph - Build a better identification string. */
- return "PTH0x42";
-}
-
-
-/* Return the number of bytes taken by the header of a PTH image. */
-
-static size_t
-pth_header_len (void)
-{
- /* The header of a PTH image contains:
- - An identification string (pth_id_str ())
- - The MD5 digest for the source file associated with the image.
- */
- return strlen (pth_id_str ()) + DIGEST_LEN;
-}
-
-
-#define PTH_EXTENSION ".pth"
-
-/* Return a new string with the extension PTH_EXTENSION appended to NAME. The
- caller is responsible for freeing the returned string. */
-
-static char *
-pth_name_for (const char *name)
-{
- size_t i, len;
- char *s;
-
- len = strlen (name) + sizeof (PTH_EXTENSION) + 1;
- s = XCNEWVEC (char, len);
- sprintf (s, "%s" PTH_EXTENSION, name);
-
- /* Make the file name unique and store it in the current directory. */
- for (i = 0; i < len - sizeof (PTH_EXTENSION) - 1; i++)
- if (!ISALNUM (s[i]))
- s[i] = '_';
-
- return s;
-}
-
-
-/* Open an image file for path NAME with MODE. */
-
-static FILE *
-pth_file_for (const char *name, const char *mode)
-{
- char *s;
- FILE *f;
-
- s = pth_name_for (name);
- f = fopen (s, mode);
- if (f == NULL)
- fatal_error ("can%'t open token stream file %s: %m", s);
- free (s);
-
- return f;
-}
-
-
-/* Compute the MD5 digest for FNAME. Store it in DIGEST. */
-
-static void
-pth_get_md5_digest (const char *fname, unsigned char digest[DIGEST_LEN])
-{
- if (flag_pth_md5)
- {
- FILE *f;
-
- timevar_push (TV_PTH_MD5);
-
- f = fopen (fname, "rb");
- if (f == NULL)
- fatal_error ("Cannot open %s for computing its digest: %m", fname);
-
- md5_stream (f, digest);
-
- fclose (f);
-
- timevar_pop (TV_PTH_MD5);
- }
- else
- {
- struct stat buf;
-
- if (stat (fname,&buf) != 0)
- fatal_error ("Cannot stat %s: %m", fname);
-
- memset (digest, 0, DIGEST_LEN);
- memcpy (digest, &buf.st_mtime, sizeof (buf.st_mtime));
- }
-}
-
-
-/* Compute an index value for TYPE suitable for restoring it later
- from global_trees[] or integer_types. The index is saved
- in TYPE_IX_P and the number category (one of CPP_N_INTEGER,
- CPP_N_FLOATING, etc) is saved in CATEGORY_P. */
-
-static void
-pth_get_index_from_type (tree type, unsigned *type_ix_p, unsigned *category_p)
-{
- void **val_p;
- static struct pointer_map_t *type_cache = NULL;
-
- /* For complex types we will just use the type of the components. */
- if (TREE_CODE (type) == COMPLEX_TYPE)
- {
- *type_ix_p = 0;
- *category_p = CPP_N_IMAGINARY;
- return;
- }
-
- if (type_cache == NULL)
- type_cache = pointer_map_create ();
-
- val_p = pointer_map_contains (type_cache, type);
- if (val_p)
- *type_ix_p = *((unsigned *) val_p);
- else
- {
- if (CP_INTEGRAL_TYPE_P (type))
- {
- unsigned i;
- for (i = itk_char; i < itk_none; i++)
- if (type == integer_types[i])
- {
- *type_ix_p = (unsigned) i;
- break;
- }
-
- gcc_assert (i != itk_none);
- }
- else if (FLOAT_TYPE_P (type) || FIXED_POINT_TYPE_P (type))
- {
- unsigned i;
-
- for (i = TI_ERROR_MARK; i < TI_MAX; i++)
- if (global_trees[i] == type)
- {
- *type_ix_p = (unsigned) i;
- break;
- }
-
- gcc_assert (i != TI_MAX);
- }
- else
- gcc_unreachable ();
- }
-
- if (CP_INTEGRAL_TYPE_P (type))
- *category_p = CPP_N_INTEGER;
- else if (FLOAT_TYPE_P (type))
- *category_p = CPP_N_FLOATING;
- else if (FIXED_POINT_TYPE_P (type))
- *category_p = CPP_N_FRACT;
- else
- gcc_unreachable ();
-}
-
-
-/* Write a uint VALUE to the STREAM. Return the number of bytes written. */
-
-static inline size_t
-pth_write_uint (unsigned int value, FILE *stream)
-{
- size_t sent = fwrite (&value, 1, sizeof (value), stream);
- gcc_assert (sent == sizeof (value));
- return sent;
-}
-
-
-/* Write a size_t VALUE to the STREAM. Return the number of bytes written. */
-
-static inline size_t
-pth_write_sizet (size_t value, FILE *stream)
-{
- size_t sent = fwrite (&value, 1, sizeof (value), stream);
- gcc_assert (sent == sizeof (value));
- return sent;
-}
-
-
-/* Write N bytes from P to STREAM. */
-
-static inline size_t
-pth_write_bytes (const void *p, size_t n, FILE *stream)
-{
- size_t sent = fwrite (p, 1, n, stream);
- gcc_assert (sent == n);
- return sent;
-}
-
-
-/* Write string STR and its LENGTH to STREAM. */
-
-static inline size_t
-pth_write_string (const char *str, unsigned int length, FILE *stream)
-{
- size_t sent;
-
- if (str == NULL)
- sent = pth_write_uint (-1, stream);
- else
- {
- sent = pth_write_uint (length, stream);
- if (length > 0)
- sent += pth_write_bytes (str, length, stream);
- }
-
- return sent;
-}
-
-
-/* Save the number VAL to file F. Return the number of bytes written. */
-
-static size_t
-pth_write_number (tree val, FILE *f)
-{
- unsigned type_idx, type_kind;
- size_t nbytes;
-
- pth_get_index_from_type (TREE_TYPE (val), &type_idx, &type_kind);
-
- nbytes = 0;
- nbytes += pth_write_uint (type_idx, f);
- nbytes += pth_write_uint (type_kind, f);
-
- if (type_kind == CPP_N_INTEGER)
- {
- HOST_WIDE_INT v[2];
-
- v[0] = TREE_INT_CST_LOW (val);
- v[1] = TREE_INT_CST_HIGH (val);
- nbytes += pth_write_bytes (v, 2 * sizeof (HOST_WIDE_INT), f);
- }
- else if (type_kind == CPP_N_FLOATING)
- {
- REAL_VALUE_TYPE r = TREE_REAL_CST (val);
- nbytes += pth_write_bytes (&r, sizeof (REAL_VALUE_TYPE), f);
- }
- else if (type_kind == CPP_N_FRACT)
- {
- FIXED_VALUE_TYPE fv = TREE_FIXED_CST (val);
- nbytes += pth_write_bytes (&fv, sizeof (FIXED_VALUE_TYPE), f);
- }
- else if (type_kind == CPP_N_IMAGINARY)
- {
- pth_write_number (TREE_REALPART (val), f);
- pth_write_number (TREE_IMAGPART (val), f);
- }
- else
- gcc_unreachable ();
-
- return nbytes;
-}
-
-
-/* Save the tree associated with TOKEN to file F. Return the number
- of bytes written. */
-
-static size_t
-pth_save_token_value (cp_token *token, FILE *f)
-{
- const char *str;
- size_t nbytes;
- unsigned len;
- tree val;
-
- val = token->u.value;
- nbytes = 0;
- switch (token->type)
- {
- case CPP_TEMPLATE_ID:
- case CPP_NESTED_NAME_SPECIFIER:
- break;
-
- case CPP_NAME:
- /* FIXME pph. Hash the strings and emit a string table. */
- str = IDENTIFIER_POINTER (val);
- len = IDENTIFIER_LENGTH (val);
- nbytes += pth_write_string (str, len, f);
- break;
-
- case CPP_KEYWORD:
- /* Nothing to do. We will reconstruct the keyword from
- ridpointers[token->keyword] at load time. */
- break;
-
- case CPP_CHAR:
- case CPP_WCHAR:
- case CPP_CHAR16:
- case CPP_CHAR32:
- case CPP_NUMBER:
- nbytes += pth_write_number (val, f);
- break;
-
- case CPP_STRING:
- case CPP_WSTRING:
- case CPP_STRING16:
- case CPP_STRING32:
- /* FIXME pph. Need to represent the type. */
- str = TREE_STRING_POINTER (val);
- len = TREE_STRING_LENGTH (val);
- nbytes += pth_write_string (str, len, f);
- break;
-
- case CPP_PRAGMA:
- /* Nothing to do. Field pragma_kind has already been written. */
- break;
-
- default:
- gcc_assert (token->u.value == NULL);
- nbytes += pth_write_bytes (&token->u.value, sizeof (token->u.value), f);
- }
-
- return nbytes;
-}
-
-
-/* Save TOKEN on file F. Return the number of bytes written on F. */
-
-static size_t
-pth_save_token (cp_token *token, FILE *f)
-{
- size_t nbytes;
-
- /* Do not write out the final field in TOKEN. It contains
- pointers that need to be pickled separately.
-
- FIXME pph - Need to also emit the location_t table so we can
- reconstruct it when reading the PTH state. */
- nbytes = pth_write_bytes (token, sizeof (cp_token) - sizeof (void *), f);
- nbytes += pth_save_token_value (token, f);
-
- return nbytes;
-}
-
-
-/* Write header information for IMAGE to STREAM. */
-
-static void
-pth_write_header (pth_image *image, FILE *stream)
-{
- size_t nbytes;
- const char *id = pth_id_str ();
-
- if (!image->digest_computed_p)
- {
- pth_get_md5_digest (image->fname, image->digest);
- image->digest_computed_p = true;
- }
-
- nbytes = pth_write_bytes (id, strlen (id), stream);
- nbytes += pth_write_bytes (image->digest, DIGEST_LEN, stream);
-
- gcc_assert (nbytes == pth_header_len ());
-}
-
-/* Dump a table of IDENTIFIERS to the STREAM. */
-
-static void
-pth_dump_identifiers (FILE *stream, cpp_idents_used *identifiers)
-{
- unsigned int idx, col = 1;
-
- fprintf (stream, "%u identifiers up to %u chars\n",
- identifiers->num_entries, identifiers->max_length);
- for (idx = 0; idx < identifiers->num_entries; ++idx)
- {
- cpp_ident_use *ident = identifiers->entries + idx;
-
- if (col + ident->ident_len >= 80)
- {
- fprintf (stream, "\n");
- col = 1;
- }
- if (ident->before_str || ident->after_str)
- {
- if (col > 1)
- fprintf (stream, "\n");
- fprintf (stream, " %s = %s -> %s\n", ident->ident_str,
- ident->before_str, ident->after_str);
- col = 1;
- }
- else
- {
- fprintf (stream, " %s", ident->ident_str);
- col += ident->ident_len;
- }
- }
- fprintf (stream, "\n");
-}
-
-/* Dump a debug log of the IDENTIFIERS. */
-
-void
-pth_debug_identifiers (cpp_idents_used *identifiers);
-
-void
-pth_debug_identifiers (cpp_idents_used *identifiers)
-{
- pth_dump_identifiers (stderr, identifiers);
-}
-
-/* Dump a HUNK to the STREAM. */
-
-static void
-pth_dump_hunk (FILE *stream, cp_token_hunk *hunk)
-{
- fprintf (stream, "Hunk location: { %lu, %lu, %lu }\n", hunk->text_offset.cur,
- hunk->text_offset.line_base, hunk->text_offset.next_line);
- fprintf (stream, "Hunk length: %lu characters\n", hunk->text_length);
- pth_dump_identifiers (stream, &hunk->identifiers);
- cp_lexer_dump_tokens (stream, hunk->buffer, 0);
-}
-
-/* Dump a debug log of the HUNK. */
-
-static void
-pth_debug_hunk (cp_token_hunk *hunk)
-{
- pth_dump_hunk (stderr, hunk);
-}
-
-
-/* Dump #include command INCLUDE to FILE. */
-
-static void
-pth_dump_include (FILE *f, pth_include *include)
-{
- if (include == NULL)
- return;
-
- if (include->itype == IT_INCLUDE)
- fprintf (f, "#include ");
- else if (include->itype == IT_INCLUDE_NEXT)
- fprintf (f, "#include_next ");
- else if (include->itype == IT_IMPORT)
- fprintf (f, "#import ");
- else
- fprintf (f, "#??? ");
-
- fprintf (f, "%c%s%c",
- (include->angle_brackets) ? '<' : '"',
- include->iname,
- (include->angle_brackets) ? '>' : '"');
-
- fprintf (f, " (found in %s)\n", include->dname);
-}
-
-
-/* Dump #include command INCLUDE to stderr. */
-
-static void
-pth_debug_include (pth_include *include)
-{
- pth_dump_include (stderr, include);
-}
-
-
-/* Recursive helper for pth_dump_token_hunks_1. VISITED keeps track of
- images that have already been dumped to avoid infinite recursion. */
-
-static void
-pth_dump_token_hunks_1 (FILE *f, pth_image *image,
- struct pointer_set_t *visited)
-{
- unsigned i, h_ix, i_ix;
- char s;
-
- if (pointer_set_insert (visited, image))
- return;
-
- fprintf (f, "LC_ENTER: %s {\n", image->fname);
-
- for (i = 0, h_ix = 0, i_ix = 0;
- VEC_iterate (char, image->ih_sequence, i, s);
- i++)
- {
- if (s == 'H')
- {
- cp_token_hunk *hunk;
- hunk = VEC_index (cp_token_hunk_ptr, image->token_hunks, h_ix++);
- pth_dump_hunk (f, hunk);
- }
- else if (s == 'I')
- {
- pth_include *include;
- include = VEC_index (pth_include_ptr, image->includes, i_ix++);
- pth_dump_include (f, include);
- pth_dump_token_hunks_1 (f, include->image, visited);
- }
- }
-
- fprintf (f, "LC_LEAVE: %s }\n", image->fname);
-}
-
-
-/* Dump all the tokens in IMAGE and the files included by it to F. */
-
-static void
-pth_dump_token_hunks (FILE *f, pth_image *image)
-{
- struct pointer_set_t *visited = pointer_set_create ();
- pth_dump_token_hunks_1 (f, image, visited);
- pointer_set_destroy (visited);
-}
-
-
-/* Dump all the tokens in IMAGE and the files included by it to stderr. */
-
-static void
-pth_debug_token_hunks (pth_image *image)
-{
- pth_dump_token_hunks (stderr, image);
-}
-
-
-/* Dump a debugging representation of IMAGE to F. */
-
-static void
-pth_dump_image (FILE *f, pth_image *image)
-{
- unsigned i;
- cp_token_hunk *hunk;
- pth_include *include;
- char s;
-
- if (image == NULL)
- return;
-
- fprintf (f, "Image for: %s\n", image->fname);
-
- fprintf (f, " MD5 digest: ");
- if (image->digest_computed_p)
- {
- for (i = 0; i < DIGEST_LEN; i++)
- fprintf (f, "%02x", image->digest[i]);
- fprintf (f, "\n");
- }
- else
- fprintf (f, "NOT COMPUTED\n");
-
- fprintf (f, " %u token hunks: { ",
- VEC_length (cp_token_hunk_ptr, image->token_hunks));
- for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
- fprintf (f, "%u ", VEC_length (cp_token, hunk->buffer));
- fprintf (f, "}\n");
-
- fprintf (f, " %u includes:\n",
- VEC_length (pth_include_ptr, image->includes));
- for (i = 0; VEC_iterate (pth_include_ptr, image->includes, i, include); i++)
- {
- fprintf (f, "\t");
- pth_dump_include (f, include);
- }
-
- fprintf (f, " Include-Hunk (IH) sequence: ");
- for (i = 0; VEC_iterate (char, image->ih_sequence, i, s); i++)
- fputc (s, f);
- fputc ('\n', f);
-
- if (image->loaded_p)
- fprintf (f, " Instantiated from image: %s\n", pth_name_for (image->fname));
- else
- {
- fprintf (f, " Instantiated from character stream: %s\n", image->fname);
-
- if (image->save_p)
- fprintf (f, " Will be saved to image: %s\n",
- pth_name_for (image->fname));
- else
- fprintf (f, " Will NOT be saved to an image (not include-guarded)\n");
- }
-
- if (image->used_p)
- fprintf (f, " Image already applied to current compilation context\n");
-
- if (flag_pth_debug >= 4)
- pth_dump_token_hunks (f, image);
-}
-
-
-/* Dump a debugging representation of IMAGE to stderr. */
-
-static void
-pth_debug_image (pth_image *image)
-{
- pth_dump_image (stderr, image);
-}
-
-
-/* Show statistics for PTH image IMAGE on FILE. if FILE is NULL, use
- pph_logfile. */
-
-static void
-pth_show_image_stats (FILE *file, pth_image *image)
-{
- unsigned i, num_tokens;
- cp_token_hunk *hunk;
-
- if (image == NULL)
- return;
-
- if (file == NULL)
- file = pph_logfile;
-
- num_tokens = 0;
- for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
- num_tokens += VEC_length (cp_token, hunk->buffer);
-
- fprintf (file, "%s: %u tokens, %u token hunks\n", image->fname, num_tokens,
- VEC_length (cp_token_hunk_ptr, image->token_hunks));
-}
-
-
-/* Dump the current PTH state to F. */
-
-static void
-pth_dump_state (FILE *f)
-{
- unsigned i;
- pth_state *state;
- pth_image *image;
-
- state = pth_get_state ();
- fprintf (f, "Incremental compilation state\n\n");
- fprintf (f, "%u file images\n", VEC_length (pth_image_ptr, state->cache));
- for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
- pth_dump_image (f, image);
-
- fprintf (f, "\nCurrent image being processed: %s\n",
- (state->cur_image) ? state->cur_image->fname : "NONE");
-
- if (state->lexer)
- {
- fprintf (f, "Tokens in main lexer:\n");
- cp_lexer_dump_tokens (f, state->lexer->buffer, 0);
- }
-}
-
-
-/* Dump the current PTH state to stderr. */
-
-static void
-pth_debug_state (void)
-{
- pth_dump_state (stderr);
-}
-
-
-/* Save the IDENTIFIERS to the STREAM. */
-
-static void
-pth_save_identifiers (cpp_idents_used *identifiers, FILE *stream)
-{
- unsigned int num_entries, id;
-
- num_entries = identifiers->num_entries;
- pth_write_uint (identifiers->max_length, stream);
- pth_write_uint (num_entries, stream);
-
- for ( id = 0; id < num_entries; ++id )
- {
- cpp_ident_use *entry = identifiers->entries + id;
-
- gcc_assert (entry->ident_len <= identifiers->max_length);
- pth_write_string (entry->ident_str, entry->ident_len, stream);
-
- gcc_assert (entry->before_len <= identifiers->max_length);
- pth_write_string (entry->before_str, entry->before_len, stream);
-
- gcc_assert (entry->after_len <= identifiers->max_length);
- pth_write_string (entry->after_str, entry->after_len, stream);
- }
-}
-
-/* Save the HUNK to the STREAM. */
-
-static void
-pth_save_hunk (cp_token_hunk *hunk, FILE *stream)
-{
- unsigned j;
- cp_token *token;
-
- if (flag_pth_debug >= 5)
- pth_debug_hunk (hunk);
-
- /* Write out the identifiers used by HUNK. */
- pth_save_identifiers (&hunk->identifiers, stream);
-
- /* Write the offset into the text file where this token starts. */
- pth_write_sizet (hunk->text_offset.cur, stream);
- pth_write_sizet (hunk->text_offset.line_base, stream);
- pth_write_sizet (hunk->text_offset.next_line, stream);
-
- /* Write the length of the hunk. */
- pth_write_sizet (hunk->text_length, stream);
-
- /* Write the number of tokens in HUNK. */
- pth_write_uint (VEC_length (cp_token, hunk->buffer), stream);
-
- /* Write the tokens. */
- for (j = 0; VEC_iterate (cp_token, hunk->buffer, j, token); j++)
- pth_save_token (token, stream);
-}
-
-
-/* Save the #include directive INCLUDE to STREAM. */
-
-static void
-pth_save_include (pth_include *include, FILE *stream)
-{
- pth_write_string (include->image->fname, strlen (include->image->fname),
- stream);
- pth_write_uint ((unsigned int) include->itype, stream);
- pth_write_uint (include->angle_brackets, stream);
- pth_write_string (include->iname, strlen (include->iname), stream);
- pth_write_string (include->dname,
- include->dname ? strlen (include->dname) : 0,
- stream);
-}
-
-
-/* Save the PTH image IMAGE to a file. */
-
-static void
-pth_save_image (pth_image *image)
-{
- FILE *stream;
- cp_token_hunk *hunk;
- unsigned i, num;
- char *buf;
- pth_include *include;
-
- timevar_push (TV_PTH_SAVE);
-
- /* Open the stream in append mode since we have already created
- it in pth_new_image. */
- stream = pth_file_for (image->fname, "wb");
-
- /* Write an invalid header first to avoid leaving a seemingly
- valid file in case of failure. */
- buf = XCNEWVEC (char, pth_header_len ());
- pth_write_bytes (buf, pth_header_len (), stream);
-
- /* Write the include-hunk (IH) sequencing vector. */
- num = VEC_length (char, image->ih_sequence);
- pth_write_uint (num, stream);
- if (num > 0)
- pth_write_bytes (VEC_address (char, image->ih_sequence), num, stream);
-
- /* Write the number of #include commands. */
- pth_write_uint (VEC_length (pth_include_ptr, image->includes), stream);
-
- /* Write all the #include commands used by IMAGE. */
- for (i = 0; VEC_iterate (pth_include_ptr, image->includes, i, include); i++)
- pth_save_include (include, stream);
-
- /* Write the number of token caches in the cache. */
- pth_write_uint (VEC_length (cp_token_hunk_ptr, image->token_hunks), stream);
-
- /* Write all the token hunks in image. */
- for (i = 0; VEC_iterate (cp_token_hunk_ptr, image->token_hunks, i, hunk); i++)
- pth_save_hunk (hunk, stream);
-
- /* Now write a valid header. */
- fseek (stream, 0, SEEK_SET);
- pth_write_header (image, stream);
-
- /* Clean up. */
- fclose (stream);
- free (buf);
- image->save_p = false;
-
- if (flag_pth_debug >= 3)
- {
- fprintf (stderr, "\nSaved image for %s:\n", image->fname);
- pth_debug_image (image);
- }
-
- timevar_pop (TV_PTH_SAVE);
-}
-
-
-/* Given a type index TYPE_IDX and TYPE_KIND specifying the kind of type,
- return a type from integer_types or global_trees. */
-
-static tree
-pth_get_type_from_index (unsigned type_idx, unsigned type_kind)
-{
- if (type_kind == CPP_N_INTEGER)
- return integer_types[type_idx];
- else if (type_kind == CPP_N_FLOATING || type_kind == CPP_N_FRACT)
- return global_trees[type_idx];
- else if (type_kind == CPP_N_IMAGINARY)
- {
- /* We don't need a type for the complex number. The type is
- associated with the real and imaginary parts. */
- return NULL_TREE;
- }
- else
- gcc_unreachable ();
-}
-
-
-/* Read an unsigned int into *VAR_P. */
-
-static void
-pth_read_uint (unsigned int *var_p, FILE *stream)
-{
- size_t received = fread (var_p, sizeof *var_p, 1, stream);
- gcc_assert (received == 1);
-}
-
-
-/* Read a size_t into *VAR_P. */
-
-static void
-pth_read_sizet (size_t *var_p, FILE *stream)
-{
- size_t received = fread (var_p, sizeof *var_p, 1, stream);
- gcc_assert (received == 1);
-}
-
-
-/* Read N bytes into P from STREAM. The caller is responsible
- for allocating sufficient memory for P. */
-
-static inline void
-pth_read_bytes (void *p, size_t n, FILE *stream)
-{
- size_t received = fread (p, 1, n, stream);
- gcc_assert (received == n);
-}
-
-
-/* Read a string of up to MAX characters from STREAM into BUFFER.
- Return the actual string length read from STREAM. The caller is
- responsible for allocating sufficient memory for BUFFER. */
-
-static unsigned int
-pth_read_string (char *buffer, unsigned int max, FILE *stream)
-{
- unsigned int length;
- size_t received;
-
- received = fread (&length, sizeof length, 1, stream);
- gcc_assert (received == 1 && (length == -1U || length <= max));
- if (length > 0 && length != -1U)
- {
- received = fread (buffer, 1, length, stream);
- gcc_assert (received == length);
- }
-
- return length;
-}
-
-
-/* Read a string from STREAM allocating enough memory on the
- heap to hold it.
-
- This function assumes that strings are represented as a length
- followed by the string content. A terminating '\0' is added
- automatically. */
-
-static inline char *
-pth_read_string_alloc (FILE *stream)
-{
- char *s;
- unsigned int len;
-
- pth_read_uint (&len, stream);
-
- /* By convention, NULL strings are represented with length -1U. */
- if (len == -1U)
- return NULL;
-
- s = XCNEWVEC (char, len + 1);
- pth_read_bytes (s, len, stream);
-
- return s;
-}
-
-
-/* Load a numeric value from file F. Return the corresponding tree. */
-
-static tree
-pth_load_number (FILE *f)
-{
- unsigned type_idx, type_kind;
- tree type, val;
-
- pth_read_uint (&type_idx, f);
- pth_read_uint (&type_kind, f);
-
- type = pth_get_type_from_index (type_idx, type_kind);
-
- if (type_kind == CPP_N_INTEGER)
- {
- HOST_WIDE_INT v[2];
- pth_read_bytes (v, 2 * sizeof (HOST_WIDE_INT), f);
- val = build_int_cst_wide (type, v[0], v[1]);
- }
- else if (type_kind == CPP_N_FLOATING)
- {
- REAL_VALUE_TYPE r;
- pth_read_bytes (&r, sizeof (REAL_VALUE_TYPE), f);
- val = build_real (type, r);
- }
- else if (type_kind == CPP_N_FRACT)
- {
- FIXED_VALUE_TYPE fv;
- pth_read_bytes (&fv, sizeof (FIXED_VALUE_TYPE), f);
- val = build_fixed (type, fv);
- }
- else if (type_kind == CPP_N_IMAGINARY)
- {
- tree r = pth_load_number (f);
- tree i = pth_load_number (f);
- val = build_complex (NULL_TREE, r, i);
- }
- else
- gcc_unreachable ();
-
- return val;
-}
-
-
-/* Load the tree value associated with TOKEN to file F. */
-
-static void
-pth_load_token_value (cp_token *token, FILE *f)
-{
- char *str;
-
- switch (token->type)
- {
- case CPP_TEMPLATE_ID:
- case CPP_NESTED_NAME_SPECIFIER:
- break;
-
- case CPP_NAME:
- str = pth_read_string_alloc (f);
- token->u.value = get_identifier (str);
- free (str);
- break;
-
- case CPP_KEYWORD:
- token->u.value = ridpointers[token->keyword];
- break;
-
- case CPP_CHAR:
- case CPP_WCHAR:
- case CPP_CHAR16:
- case CPP_CHAR32:
- case CPP_NUMBER:
- token->u.value = pth_load_number (f);
- break;
-
- case CPP_STRING:
- case CPP_WSTRING:
- case CPP_STRING16:
- case CPP_STRING32:
- str = pth_read_string_alloc (f);
- token->u.value = build_string (strlen (str), str);
- free (str);
- break;
-
- case CPP_PRAGMA:
- /* Nothing to do. Field pragma_kind has already been loaded. */
- break;
-
- default:
- pth_read_bytes (&token->u.value, sizeof (token->u.value), f);
- gcc_assert (token->u.value == NULL);
- }
-}
-
-
-/* Need forward declaration for pth_image_lookup due to circular
- dependency. */
-static pth_image *pth_image_lookup (pth_state *, const char *, cpp_reader *);
-
-
-/* Load the IDENTIFERS for a hunk from a STREAM. */
-
-static void
-pth_load_identifiers (cpp_idents_used *identifiers, FILE *stream)
-{
- unsigned int j;
- unsigned int max_length, num_entries;
- char *buffer;
- unsigned int ident_len, before_len, after_len;
-
- pth_read_uint (&max_length, stream);
- identifiers->max_length = max_length;
- pth_read_uint (&num_entries, stream);
- identifiers->num_entries = num_entries;
- identifiers->entries = XCNEWVEC (cpp_ident_use, num_entries);
- identifiers->strings = XCNEW (struct obstack);
-
- /* Strings need no alignment. */
- _obstack_begin (identifiers->strings, 0, 0,
- (void *(*) (long)) xmalloc,
- (void (*) (void *)) free);
- obstack_alignment_mask (identifiers->strings) = 0;
- /* FIXME pph: We probably need to free all these things somewhere. */
-
- buffer = XCNEWVEC (char, max_length + 1);
-
- /* Read the identifiers in HUNK. */
- for (j = 0; j < num_entries; ++j)
- {
- ident_len = pth_read_string ( buffer, max_length, stream);
- gcc_assert (ident_len > 0 && ident_len != -1U);
- identifiers->entries[j].ident_len = ident_len;
- identifiers->entries[j].ident_str =
- (const char *) obstack_copy0 (identifiers->strings, buffer, ident_len);
-
- before_len = pth_read_string ((char *) buffer, max_length, stream);
- identifiers->entries[j].before_len = before_len;
- if (before_len == -1U)
- identifiers->entries[j].before_str = NULL;
- else
- identifiers->entries[j].before_str = (const char *)
- obstack_copy0 (identifiers->strings, buffer, before_len);
-
- after_len = pth_read_string ((char *) buffer, max_length, stream);
- identifiers->entries[j].after_len = after_len;
- if (after_len == -1U)
- identifiers->entries[j].after_str = NULL;
- else
- identifiers->entries[j].after_str = (const char *)
- obstack_copy0 (identifiers->strings, buffer, after_len);
- }
-
- free (buffer);
-}
-
-
-/* Load a hunk into the IMAGE from a STREAM. */
-
-static void
-pth_load_hunk (pth_image *image, FILE *stream)
-{
- unsigned j, num_tokens;
- cp_token_hunk *hunk;
-
- hunk = ggc_alloc_cleared_cp_token_hunk ();
-
- /* Setup the identifier list. */
- pth_load_identifiers (&hunk->identifiers, stream);
-
- /* Read the offset into the text file where this token starts. */
- pth_read_sizet (&hunk->text_offset.cur, stream);
- pth_read_sizet (&hunk->text_offset.line_base, stream);
- pth_read_sizet (&hunk->text_offset.next_line, stream);
-
- /* Read the text length of the hunk. */
- pth_read_sizet (&hunk->text_length, stream);
-
- /* Read the number of tokens in HUNK. */
- pth_read_uint (&num_tokens, stream);
-
- /* Read the tokens in the HUNK. */
- hunk->buffer = VEC_alloc (cp_token, gc, num_tokens);
- for (j = 0; j < num_tokens; j++)
- {
- cp_token *token = VEC_quick_push (cp_token, hunk->buffer, NULL);
-
- /* Do not read the whole structure, the token value has
- dynamic size as it contains swizzled pointers.
- FIXME pph, restructure to allow bulk reads of the whole
- section. */
- pth_read_bytes (token, sizeof (cp_token) - sizeof (void *), stream);
-
- /* FIXME pph. Use an arbitrary (but valid) location to avoid
- confusing the rest of the compiler for now. */
- token->location = input_location;
-
- /* FIXME pph: verify that pth_load_token_value works with no tokens. */
- pth_load_token_value (token, stream);
- }
- gcc_assert (num_tokens == VEC_length (cp_token, hunk->buffer));
-
- VEC_quick_push (cp_token_hunk_ptr, image->token_hunks, hunk);
-}
-
-
-/* Create a new empty #include directive for NAME. ITYPE is one of
- the supported include commands. ANGLE_BRACKETS is true if the
- include used '<>'. */
-
-static pth_include *
-pth_create_include (enum include_type itype, bool angle_brackets,
- const char *name)
-{
- pth_include *include = ggc_alloc_cleared_pth_include ();
- include->itype = itype;
- include->angle_brackets = angle_brackets;
- include->iname = (name) ? xstrdup (name) : name;
-
- return include;
-}
-
-
-/* Load an #include directive for IMAGE from STREAM. */
-
-static void
-pth_load_include (pth_state *state, pth_image *image, cpp_reader *reader,
- FILE *stream)
-{
- char *s;
- pth_include *include;
- unsigned tmp;
-
- include = pth_create_include (IT_INCLUDE, false, NULL);
-
- s = pth_read_string_alloc (stream);
- include->image = pth_image_lookup (state, s, reader);
-
- pth_read_uint (&tmp, stream);
- include->itype = (enum include_type) tmp;
-
- pth_read_uint (&tmp, stream);
- include->angle_brackets = (tmp != 0);
-
- include->iname = pth_read_string_alloc (stream);
- include->dname = pth_read_string_alloc (stream);
-
- VEC_safe_push (pth_include_ptr, gc, image->includes, include);
-}
-
-
-/* Load a PTH image for LEXER using the READER. */
-
-static void
-pth_load_image (pth_state *state, pth_image *image, cpp_reader *reader)
-{
- FILE *stream;
- unsigned i, num;
-
- timevar_push (TV_PTH_LOAD);
-
- stream = pth_file_for (image->fname, "r+b");
-
- /* Skip over the header, as we assume that it has already been
- validated by pth_have_valid_image_for. */
- fseek (stream, (long) pth_header_len (), SEEK_SET);
-
- /* Read the include-hunk (IH) sequencing vector. */
- pth_read_uint (&num, stream);
- if (num > 0)
- {
- image->ih_sequence = VEC_alloc (char, gc, num);
- VEC_safe_grow (char, gc, image->ih_sequence, num);
- pth_read_bytes (VEC_address (char, image->ih_sequence), num, stream);
- }
-
- /* Read the number path names of all the files #included by
- IMAGE->FNAME. */
- pth_read_uint (&num, stream);
- image->includes = VEC_alloc (pth_include_ptr, gc, num);
-
- /* Now read all the path names #included by IMAGE->FNAME. */
- for (i = 0; i < num; i++)
- pth_load_include (state, image, reader, stream);
-
- /* Read how many token hunks are contained in this image. */
- pth_read_uint (&num, stream);
- image->token_hunks = VEC_alloc (cp_token_hunk_ptr, gc, num);
-
- PTH_STATS_INCR (hunks, num);
-
- /* Read all the token hunks. */
- for (i = 0; i < num; i++)
- pth_load_hunk (image, stream);
-
- fclose (stream);
-
- /* Indicate that we have loaded this image from a file. */
- image->loaded_p = true;
- image->save_p = false;
- image->used_p = false;
-
- if (flag_pth_debug >= 3)
- {
- fprintf (stderr, "\nLoaded image for %s:\n", image->fname);
- pth_debug_image (image);
- }
-
- timevar_pop (TV_PTH_LOAD);
-}
-
-
-/* Return true if FNAME has a PTH image that can be used. If an image
- already exists, compute the MD5 digest for FNAME and store it
- in IMAGE. */
-
-static bool
-pth_have_valid_image_for (const char *fname, pth_image *image)
-{
- FILE *f = NULL;
- struct stat s;
- char *img_name, *id;
- const char *good_id;
- char saved_digest[DIGEST_LEN];
-
- image->digest_computed_p = false;
-
- img_name = pth_name_for (fname);
- if (stat (img_name, &s) != 0)
- goto invalid_img;
-
- /* If the file exists, check if it has a valid signature. */
- f = fopen (img_name, "r");
-
- good_id = pth_id_str ();
- id = XCNEWVEC (char, strlen (good_id) + 1);
- pth_read_bytes (id, strlen (good_id), f);
- if (strcmp (id, good_id) != 0)
- goto invalid_img;
-
- /* Now check if the MD5 digest stored in the image file matches the
- digest for FNAME. */
- pth_read_bytes (saved_digest, DIGEST_LEN, f);
- pth_get_md5_digest (fname, image->digest);
- image->digest_computed_p = true;
- if (memcmp (image->digest, saved_digest, DIGEST_LEN) != 0)
- goto invalid_img;
-
- fclose (f);
- return true;
-
-invalid_img:
- if (f)
- fclose (f);
-
- return false;
-}
-
-
-/* Create a new PTH cache object for file FNAME. */
-
-static pth_image *
-pth_new_image (const char *fname)
-{
- pth_image *image;
-
- image = ggc_alloc_cleared_pth_image ();
- image->fname = fname;
-
- return image;
-}
-
-
-/* Return a cache image associated with file FNAME. STATE holds
- the PTH cache to use. */
-
-static pth_image *
-pth_image_lookup (pth_state *state, const char *fname, cpp_reader *reader)
-{
- void **slot;
- pth_image *image, e;
-
- if (fname == NULL)
- return NULL;
-
- e.fname = fname;
- slot = htab_find_slot (state->cache_dir, &e, INSERT);
- if (*slot == NULL)
- {
- /* Create a new image and store it in the cache. */
- image = pth_new_image (fname);
- *slot = image;
- VEC_safe_push (pth_image_ptr, gc, state->cache, image);
-
- /* If a valid disk image already exists for FNAME, load it.
- Otherwise, mark the memory image for processing and saving. */
- if (pth_have_valid_image_for (fname, image))
- pth_load_image (state, image, reader);
- else
- image->save_p = true;
- }
- else
- image = *((pth_image **) slot);
-
- return image;
-}
-
-
-/* Add all the tokens in HUNK to the end of LEXER->BUFFER. IMAGE is
- the memory image holding HUNK. */
-
-static void
-pth_append_hunk (cp_lexer *lexer, pth_image *image, cp_token_hunk *hunk)
-{
- cp_token *lexer_addr, *hunk_addr;
- unsigned lexer_len, hunk_len;
-
- PTH_STATS_INCR (valid_hunks, 1);
-
- /* Apply all the identifiers used and defined by HUNK. */
- cpp_lt_replay (parse_in, &hunk->identifiers);
-
- /* If this file has been read in memory (e.g., by being #included
- from a tainted file), advance the text buffer pointer to the end
- of the hunk to avoid reading it again. */
- if (image->buffer)
- cpp_set_pos (image->buffer, hunk->text_offset);
-
- hunk_len = VEC_length (cp_token, hunk->buffer);
-
- /* Some hunks have no tokens and they are only useful for the
- macros defined by them. This is useful when one or more
- image files are tainted and need to be restored from their
- character stream. */
- if (hunk_len == 0)
- return;
-
- /* Determine the last location in LEXER->BUFFER before growing it. */
- lexer_len = VEC_length (cp_token, lexer->buffer);
- VEC_safe_grow (cp_token, gc, lexer->buffer, lexer_len + hunk_len);
-
- /* Bulk copy all the tokens in HUNK to the end of LEXER->BUFFER. */
- lexer_addr = VEC_address (cp_token, lexer->buffer);
- hunk_addr = VEC_address (cp_token, hunk->buffer);
- memcpy (&lexer_addr[lexer_len], hunk_addr, hunk_len * sizeof (cp_token));
-
- if (flag_pth_debug >= 2)
- {
- fprintf (stderr, "\n=> ADDED TOKEN HUNK TO LEXER BUFFER");
- if (flag_pth_debug >= 5)
- pth_debug_hunk (hunk);
- }
-}
-
-
-/* Return true if HUNK can be used in the current compilation
- context of the cpp READER. It must validate the identifier state. */
-
-static bool
-pth_hunk_is_valid_p (pth_image *image, cp_token_hunk *hunk, cpp_reader *reader)
-{
- bool verified;
- cpp_ident_use *bad_use;
- const char *cur_def;
-
- timevar_push (TV_PTH_DEPENDENCY);
- verified = cpp_lt_verify (reader, &hunk->identifiers, &bad_use, &cur_def);
- if (!verified && flag_pth_debug >= 1)
- {
- fprintf (stderr, "PTH: %s failed verification: %s : <%s> -> <%s>\n",
- pth_name_for (image->fname), bad_use->ident_str,
- bad_use->before_str, cur_def);
- }
- PTH_STATS_INCR (verified_hunks, 1);
- PTH_STATS_INCR (verified_identifiers, hunk->identifiers.num_entries);
- timevar_pop (TV_PTH_DEPENDENCY);
- return verified;
-}
-
-
-/* Return true if IMAGE can be used in the current compilation context. */
-
-static bool
-pth_image_can_be_used (pth_image *image)
-{
- return image && image->loaded_p && !image->used_p;
-}
-
-
/* Return true if LEXER has a CPP_EOF at the end of the buffer. */
static inline bool
@@ -2196,7 +312,7 @@ cp_lexer_finished_p (cp_lexer *lexer)
/* Get tokens from the pre-processor character stream into LEXER. */
-static void
+void
cp_lexer_get_tokens (cp_lexer *lexer)
{
cp_token token;
@@ -2222,678 +338,6 @@ cp_lexer_get_tokens (cp_lexer *lexer)
}
-/* Split NAME into its directory and file name components, storing them
- in *DNAME_P and *FNAME_P. After using it, *DNAME_P should be freed
- by the caller. */
-
-static void
-pth_get_dir_and_name (const char *name, char **dname_p, const char **fname_p)
-{
- size_t len;
-
- *fname_p = lbasename (name);
- *dname_p = NULL;
-
- len = *fname_p - name;
- if (len > 0)
- {
- *dname_p = XNEWVEC (char, len + 1);
- memcpy (*dname_p, name, len);
- (*dname_p)[len] = '\0';
- gcc_assert (IS_DIR_SEPARATOR ((*dname_p)[len - 1]));
- }
-}
-
-
-/* Read tokens from the text stream in IMAGE->FNAME into LEXER.
- If INCLUDE is not NULL, it describes how IMAGE->FNAME was
- #included originally. Otherwise, it is assumed to be an
- include command done with the flag -include.
-
- This is used when an image is found to be tainted and tokens
- need to be read from the original character stream. OFFSET
- indicates how far into the character stream to start reading at. */
-
-static void
-pth_process_text_file (cp_lexer *lexer, pth_image *image, pth_include *include,
- cpp_offset offset)
-{
- bool prev_permissive, prev_inhibit_warnings;
- bool pushed_p;
- cpp_buffer *buffer;
- lexer_state *state;
-
- /* Emulate a #include directive on IMAGE->FNAME, if needed. Note
- that if we are already inside the CPP buffer for IMAGE->FNAME
- we should not include it again, since this will cause another
- call to pth_file_change which will again register IMAGE->FNAME as
- an include for the parent file. */
- state = NULL;
- if (image->buffer != cpp_get_buffer (parse_in))
- {
- if (include == NULL || include->itype == IT_INCLUDE_NEXT)
- {
- char *dname;
- const char *fname;
- pth_get_dir_and_name (image->fname, &dname, &fname);
- pushed_p = cpp_push_include_type (parse_in, dname, fname, false,
- IT_INCLUDE);
-
- /* FIXME pph. We are leaking DNAME here. libcpp
- wants the directory name in permanent storage so we
- cannot free it, but we should put it in an obstack
- so it can be reclaimed at some point. */
- }
- else
- pushed_p = cpp_push_include_type (parse_in,
- include->dname,
- include->iname,
- include->angle_brackets,
- include->itype);
-
- if (!pushed_p)
- return;
- }
- else
- {
- /* Since we already have the buffer on top of the stack,
- reset the state of the lexer to avoid skipping over it. */
- state = cpp_reset_lexer_state (parse_in);
- }
-
- /* Inhibit libcpp error messages (ignore things like unmatched #endifs).
- We need to do this because token hunks may span #if/#endif boundaries.
- For instance,
-
- #if <COND>
- H1 [1]
- #else
- H2 [2]
- #include "foo.h"
- H3 [3]
- #endif
- H1 or H3 [4]
-
- In this example we have 3 hunks (H1, H2 and H3). Depending on the
- value of <COND> at image creation time, point [4] will belong to
- hunk H1 (if <COND> was true) or hunk H3 (if <COND> was false).
-
- When this image is loaded, if H3 cannot be applied because its
- dependences fail to hold, then we will start pre-processing the
- text for the file at the start of hunk H3. This will find a
- dangling #endif which triggers a libcpp error. Since we know
- that we are in the correct arm of the #if (after all H2 was
- applied from the image), we can safely ignore the error. */
- prev_permissive = global_dc->permissive;
- prev_inhibit_warnings = global_dc->dc_inhibit_warnings;
- global_dc->dc_inhibit_warnings = true;
- global_dc->permissive = true;
-
- /* Position the reader at OFFSET and request to stop reading at
- the end of it. */
- buffer = cpp_get_buffer (parse_in);
- cpp_set_pos (buffer, offset);
- cpp_return_at_eof (buffer, true);
-
- /* Get tokens from IMAGE->FNAME. */
- cp_lexer_get_tokens (lexer);
-
- /* Since we read this file separately, the very last token in LEXER
- will now contain an EOF, which we do not need. */
- VEC_pop (cp_token, lexer->buffer);
- cpp_return_at_eof (buffer, false);
-
- /* Restore libcpp error/warnings. */
- global_dc->permissive = prev_permissive;
- global_dc->dc_inhibit_warnings = prev_inhibit_warnings;
-
- /* Restore the parser state, if necessary. */
- if (state)
- cpp_restore_lexer_state (parse_in, state);
-}
-
-
-/* Populate LEXER->BUFFER with all the valid token hunks in
- IMAGE. If possible, try to load token hunks from files
- included by IMAGE as well.
-
- This means that we try to load the whole transitive closure
- starting at IMAGE until we find the first unloadable file.
-
- Once we find the first unloadable token hunk, we skip the token
- hunks from the character stream so that they don't need to be
- pre-processed again.
-
- If non-NULL, INCLUDE describes the #include command used to include
- IMAGE->FNAME. */
-
-static void
-pth_image_to_lexer (cp_lexer *lexer, pth_image *image, pth_include *include)
-{
- unsigned i, h_ix, i_ix;
- char s;
-
- /* If we are trying to apply the same image more than once,
- something is wrong. We never create images for files that
- are included more than once, so we should never try to apply
- the same image more than once. */
- gcc_assert (pth_image_can_be_used (image));
-
- image->used_p = true;
-
- if (flag_pth_debug >= 2)
- {
- fprintf (stderr, "\n<= INCORPORATING IMAGE %s INTO COMPILATION CONTEXT\n",
- image->fname);
- if (flag_pth_debug >= 3)
- pth_debug_include (include);
- }
-
- PTH_STATS_INCR (valid_images, 1);
-
- for (i = 0, h_ix = 0, i_ix = 0;
- VEC_iterate (char, image->ih_sequence, i, s);
- i++)
- {
- if (s == 'H')
- {
- cp_token_hunk *hunk;
-
- hunk = VEC_index (cp_token_hunk_ptr, image->token_hunks, h_ix++);
- if (pth_hunk_is_valid_p (image, hunk, parse_in))
- pth_append_hunk (lexer, image, hunk);
- else
- {
- PTH_STATS_INCR (invalid_hunks, 1);
-
- pth_process_text_file (lexer, image, NULL, hunk->text_offset);
-
- /* Since this hunk is invalid, assume that everything
- downstream from this hunk is also invalid. FIXME pph,
- it may be possible to optimize this. We should be
- able to pre-process from text exactly
- HUNK->TEXT_LENGTH characters instead of the whole
- file. */
- break;
- }
- }
- else if (s == 'I')
- {
- pth_include *incdir;
- pth_get_state ()->cur_image = image;
- incdir = VEC_index (pth_include_ptr, image->includes, i_ix++);
- if (pth_image_can_be_used (incdir->image))
- pth_image_to_lexer (lexer, incdir->image, incdir);
- else
- pth_process_text_file (lexer, incdir->image, incdir,
- cpp_buffer_start);
- }
- else
- gcc_unreachable ();
- }
-
- /* If we just applied the tokens for the main input filename,
- we need to append a CPP_EOF token, since that one is never
- saved with the token hunks. */
- if (pathnames_equal_p (image->fname, main_input_filename))
- VEC_safe_push (cp_token, gc, lexer->buffer, &eof_token);
-
- /* If IMAGE has a libcpp buffer associated with it, it means that a
- file that was being pre-processed from text has #included IMAGE
- and the pre-processor has executed the file change logic.
-
- In that case, the pre-processor will want to finish processing
- IMAGE's text, and since we have just applied its tokens from
- the image, the result will be duplicate tokens. To prevent
- this, we tell libcpp to skip over the whole text buffer
- associated with IMAGE. */
- if (image->buffer)
- cpp_set_pos (image->buffer, cpp_buffer_end);
-
- return;
-}
-
-
-/* Create a token hunk for IMAGE from the token buffer in
- LEXER->BUFFER. The hunk will contain all the tokens starting at
- IMAGE->HUNK_START_IX to the end of LEXER->BUFFER.
-
- The new token hunk will be added to the end of IMAGE->TOKEN_HUNKS. */
-
-static void
-pth_lexer_to_image (pth_image *image, cp_lexer *lexer, cpp_reader *reader)
-{
- cp_token *lexer_addr, *hunk_addr;
- cp_token_hunk *hunk;
- unsigned num_tokens, start_ix, end_ix;
- cpp_offset pos;
-
- /* Create a new token hunk. */
- hunk = ggc_alloc_cleared_cp_token_hunk ();
- VEC_safe_push (cp_token_hunk_ptr, gc, image->token_hunks, hunk);
- VEC_safe_push (char, gc, image->ih_sequence, 'H');
-
- /* The identifiers that may conflict with macros. */
- if (flag_pth_debug >= 2)
- cpp_lt_statistics (reader);
- hunk->identifiers = cpp_lt_capture (reader);
-
- /* Remember the text offset where this hunk started and its length. */
- hunk->text_offset = image->hunk_text_offset;
- pos = cpp_get_pos (image->buffer);
- gcc_assert (pos.cur >= hunk->text_offset.cur);
- hunk->text_length = pos.cur - hunk->text_offset.cur;
-
- /* Compute the bounds for the new token hunk. */
- start_ix = image->hunk_start_ix;
- end_ix = VEC_length (cp_token, lexer->buffer);
- gcc_assert (end_ix >= start_ix);
- num_tokens = end_ix - start_ix;
-
- if (num_tokens > 0)
- {
- /* Copy tokens from LEXER->BUFFER into the new hunk. */
- hunk->buffer = VEC_alloc (cp_token, gc, num_tokens);
- VEC_safe_grow (cp_token, gc, hunk->buffer, num_tokens);
- lexer_addr = VEC_address (cp_token, lexer->buffer);
- hunk_addr = VEC_address (cp_token, hunk->buffer);
- memcpy (hunk_addr, &lexer_addr[start_ix], num_tokens * sizeof (cp_token));
- }
-
- if (flag_pth_debug >= 3)
- {
- fprintf (stderr, "\n=> SAVED HUNK TO IMAGE: %s\n", image->fname);
- if (flag_pth_debug >= 5)
- pth_debug_hunk (hunk);
- }
-}
-
-
-/* Compute the effects of a file transition given the file change
- described by MAP. On exit:
-
- - *PREV_IMAGE_P will point to the image for the file that we just left,
-
- - *NEW_IMAGE_P will point to the image for the file that we just
- entered. If *NEW_IMAGE_P is NULL, it means that we just left
- the last file in the translation unit, so there isn't anything
- else to be done.
-
- - *REASON_P will have the LC_* reason for the change. */
-
-static void
-pth_get_file_transition (const struct line_map *map, pth_image **prev_image_p,
- pth_image **new_image_p, enum lc_reason *reason_p)
-{
- const char *fname;
- pth_state *state;
-
- /* MAP is NULL when we leave the main file in this translation unit. */
- if (map == NULL)
- {
- fname = NULL;
- *reason_p = LC_LEAVE;
- }
- else
- {
- fname = map->to_file;
- *reason_p = map->reason;
- }
-
- state = pth_get_state ();
- *prev_image_p = state->cur_image;
-
- /* FIXME pph. Sanitize use of PARSE_IN. Stick it in
- pth_state together with lexer. */
- *new_image_p = pth_image_lookup (state, fname, parse_in);
-}
-
-
-/* Do bookkeeping actions required when the pre-processor is leaving
- file IMAGE->FNAME. READER is the cpp file reader object we
- are using for lexing. */
-
-static void
-pth_leave_file (cpp_reader *reader, pth_image *image)
-{
- pth_state *state;
-
- /* We are only interested in processing IMAGE if we have decided to
- save its image. */
- if (!image->save_p)
- return;
-
- state = pth_get_state ();
-
- /* If the image for the file we just finished is marked as
- modified, create a new token hunk spanning from the token
- that started the image to the current end of the lexer
- buffer. */
- pth_lexer_to_image (image, state->lexer, reader);
-}
-
-
-/* Do bookkeeping actions required when the pre-processor is entering
- file IMAGE->FNAME for reason REASON. READER is the cpp file reader
- object we are using for lexing. INCLUDE is the #include command
- used to enter IMAGE->FNAME. It can be NULL in the case of the
- top file in the translation unit. */
-
-static void
-pth_enter_file (cpp_reader *reader, pth_image *image, pth_include *include,
- enum lc_reason reason)
-{
- pth_state *state;
-
- state = pth_get_state ();
-
- /* Associate the current buffer with IMAGE. */
- image->buffer = cpp_get_buffer (reader);
-
- /* Complete the current #include command with the directory
- and image for the file that we just switched to. */
- if (include)
- {
- const char *dname = cpp_get_dir (cpp_get_file (image->buffer))->name;
- include->image = image;
- include->dname = (*dname) ? xstrdup (dname) : NULL;
- }
-
- /* If the file we are about to switch to has been loaded into an
- image, try to get as many tokens as possible from the image
- instead of the character stream. */
- if (pth_image_can_be_used (image))
- pth_image_to_lexer (state->lexer, image, include);
-
- /* If IMAGE does not need to be saved, we are done. */
- if (!image->save_p)
- return;
-
- /* Detect multiple inclusions of the same header file. When a file
- is included more than once, each inclusion will usually produce
- different token hunks (e.g., <stddef.h> is typically included
- from different places with "arguments" in the form of #defines
- that determine what the caller wants stddef.h to provide. See
- <wchar.h> for an example).
-
- This disrupts the validity of the image, as the hunks saved in it
- no longer correspond to a single pre-processing of the file. We
- avoid this problem by tainting the image and forcing the file to
- be always processed from its character stream. */
- if (reason == LC_ENTER && !VEC_empty (cp_token_hunk_ptr, image->token_hunks))
- image->save_p = false;
-
- /* The starting point for the next token hunk in the new
- file image will be at the current last slot in
- STATE->LEXER->BUFFER. */
- image->hunk_start_ix = VEC_length (cp_token, state->lexer->buffer);
-
- /* The new hunk starts at the current offset in the current
- libcpp buffer. If this hunk is ever invalidated, this is
- the offset at which to start pre-processing. */
- image->hunk_text_offset = cpp_get_pos (image->buffer);
-}
-
-
-/* Callback from the pre-processor when changing in or out of a file.
- READER is the pre-processor state. MAP is the line map for the
- file that we are changing to. */
-
-static void
-pth_file_change (cpp_reader *reader, const struct line_map *map)
-{
- enum lc_reason reason;
- pth_state *state;
- pth_image *prev_image, *new_image;
-
- /* Call the previous file change handler, if it exists. */
- state = pth_get_state ();
- if (state->file_change_prev)
- state->file_change_prev (reader, map);
-
- /* When processing pre-processed output, we will see names like
- '<built-in>' and '<command-line>'. Reject those.
- ??? This rejects real path names that may start with '<', but
- those should be rare. */
- if (map && map->to_file && map->to_file[0] == '<')
- return;
-
- /* Ignore LC_RENAME events. They do not affect the actual image
- that we are processing. */
- if (map && map->reason == LC_RENAME)
- return;
-
- timevar_push (TV_PTH_MANAGE);
-
- /* Get images for the file involved in the transition. */
- pth_get_file_transition (map, &prev_image, &new_image, &reason);
- gcc_assert (prev_image);
-
- /* Ignore self-referential file change events. These can happen
- when mixing token images with text buffers. */
- if (prev_image == new_image)
- {
- timevar_pop (TV_PTH_MANAGE);
- return;
- }
-
- /* Process the file we just left (get tokens from lexer buffer,
- etc). */
- pth_leave_file (reader, prev_image);
-
- /* Process the file we are about to enter (try to use its tokens if
- the file is valid, etc). */
- if (new_image)
- {
- pth_include *include = NULL;
-
- if (reason == LC_ENTER)
- include = pth_create_include (state->new_itype,
- state->new_angle_brackets,
- state->new_iname);
-
- pth_enter_file (reader, new_image, include, reason);
-
- /* If we are LC_ENTERing NEW_IMAGE, it means that PREV_IMAGE has
- #included NEW_IMAGE. In that case, add NEW_IMAGE to the list
- of included files by PREV_IMAGE. */
- if (reason == LC_ENTER)
- {
- PTH_STATS_INCR (included_files, 1);
-
- if (prev_image->save_p)
- {
- gcc_assert (include->image == new_image);
- VEC_safe_push (pth_include_ptr, gc, prev_image->includes,
- include);
- VEC_safe_push (char, gc, prev_image->ih_sequence, 'I');
- }
- }
- }
-
- /* Update the current image. */
- state->cur_image = new_image;
-
- timevar_pop (TV_PTH_MANAGE);
-}
-
-
-/* Record a #include or #include_next. */
-
-static void
-pth_include_handler (cpp_reader *reader ATTRIBUTE_UNUSED,
- location_t loc ATTRIBUTE_UNUSED,
- const unsigned char *dname,
- const char *name,
- int angle_brackets,
- const cpp_token **tok_p ATTRIBUTE_UNUSED)
-{
- pth_state *state;
-
- state = pth_get_state ();
-
- /* Remember the attributes for this #include command. This is
- used in pth_file_change to register a new include event for
- the parent file. */
- if (strcmp ((const char *)dname, "include") == 0)
- state->new_itype = IT_INCLUDE;
- else if (strcmp ((const char *)dname, "include_next") == 0)
- state->new_itype = IT_INCLUDE_NEXT;
- else if (strcmp ((const char *)dname, "import") == 0)
- state->new_itype = IT_IMPORT;
- else
- gcc_unreachable ();
-
- state->new_angle_brackets = angle_brackets;
- state->new_iname = name;
-}
-
-
-/* Initialize PTH support. LEXER is the main lexer object used for
- pre-processing. */
-
-static void
-pth_init (cp_lexer *lexer)
-{
- pth_state *state;
- cpp_callbacks *cb;
- cpp_lookaside *table;
-
- timevar_push (TV_PTH_INIT);
-
- gcc_assert (flag_pth);
-
- table = cpp_lt_exchange (parse_in, cpp_lt_create (/*2 to the power*/15,
- flag_pth_debug));
- gcc_assert (table == NULL);
-
- memset (&pth_stats, 0, sizeof (pth_stats));
-
- state = pth_get_state ();
-
- /* If not using MD5 signatures, make sure that time stamps given
- by stat() are smaller than DIGEST_LEN bytes. FIXME pph, this is
- slighly hacky. */
- if (!flag_pth_md5)
- {
- struct stat tmp;
- gcc_assert (sizeof (tmp.st_mtime) < DIGEST_LEN);
- }
-
- /* Set an handler for file change events in libcpp. */
- cb = cpp_get_callbacks (parse_in);
- state->file_change_prev = cb->file_change;
- cb->file_change = pth_file_change;
- cb->include = pth_include_handler;
-
- state->lexer = lexer;
-
- /* Make sure that we have not tried to get any tokens yet. */
- gcc_assert (VEC_empty (cp_token, lexer->buffer));
-
- /* If we have a valid image for the main input file, populate as
- many tokens from its transitive closure as possible. */
- state->cur_image = pth_image_lookup (state, main_input_filename, parse_in);
- pth_enter_file (parse_in, state->cur_image, NULL, LC_ENTER);
-
- timevar_pop (TV_PTH_INIT);
-}
-
-
-/* Show statistics on PTH on FILE. If FILE is NULL, use pph_logfile.
- LEXER is the lexer we just filled with tokens. This is usually
- the same as pth_get_state()->lexer, but it may be NULL if PTH is
- not enabled (in cases where we just want stats on pre-processed
- files). */
-
-static void
-pth_print_stats (FILE *file, cp_lexer *lexer)
-{
- unsigned i, num_tokens, total_tokens;
- pth_state *state;
- pth_image *image;
- const char *prev_fname;
- cp_token *token;
-
- if (file == NULL)
- file = pph_logfile;
-
- fprintf (file, "\nPTH statistics\n\n");
- fprintf (file, "#included files: %lu\n", pth_stats.included_files);
- fprintf (file, "Valid images: %lu\n", pth_stats.valid_images);
- fprintf (file, "Token hunks: %lu\n", pth_stats.hunks);
- fprintf (file, "Valid hunks: %lu\n", pth_stats.valid_hunks);
- fprintf (file, "Invalid hunks: %lu\n", pth_stats.invalid_hunks);
- fprintf (file, "Verified hunks: %lu\n", pth_stats.verified_hunks);
- fprintf (file, "Verified identifiers: %lu\n", pth_stats.verified_identifiers);
-
- state = pth_get_state ();
- fprintf (file, "\n\nPTH image statistics (%u files)\n\n",
- VEC_length (pth_image_ptr, state->cache));
- for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
- pth_show_image_stats (file, image);
-
- fprintf (file, "\nToken counts per file in #include order:\n");
- num_tokens = total_tokens = 0;
- prev_fname = NULL;
- for (i = 0; VEC_iterate (cp_token, lexer->buffer, i, token); i++)
- {
- const char *fname = LOCATION_FILE (token->location);
-
- if (prev_fname == NULL)
- prev_fname = fname;
-
- if ((fname
- && strcmp (fname, prev_fname) != 0)
- || i == VEC_length (cp_token, lexer->buffer) - 1)
- {
- fprintf (file, "tokens: %u %s\n", num_tokens, lrealpath (prev_fname));
- prev_fname = fname;
- total_tokens += num_tokens;
- num_tokens = 0;
- }
-
- num_tokens++;
- }
-
- /* The main lexer buffer should have one more token: CPP_EOF. */
- if (total_tokens != VEC_length (cp_token, lexer->buffer) - 1)
- fprintf (stderr, "*** WARNING: I counted %u, but there are %u\n",
- total_tokens, VEC_length (cp_token, lexer->buffer));
-
- fprintf (file, "\n");
-}
-
-
-/* Save all the header images that have been marked modified from
- the incremental state. */
-
-static void
-pth_finish (void)
-{
- /* If PPH is enabled, do not save PTH images to prevent analysis problems
- due to lack of location information in PTH images. FIXME pph:
- Unneeded after we start saving proper location information. */
- if (flag_pph_debug >= 1)
- {
- if (flag_pph_debug > 1)
- fprintf (stderr, "*** WARNING: Not saving PTH images because PPH "
- "is enabled\n");
- }
- else
- {
- pth_state *state;
- pth_image *image;
- size_t i;
-
- state = pth_get_state ();
- for (i = 0; VEC_iterate (pth_image_ptr, state->cache, i, image); i++)
- if (image->save_p)
- pth_save_image (image);
- }
-}
-
-
/* Allocate memory for a new lexer object and return it. */
static cp_lexer *
@@ -3008,7 +452,6 @@ cp_lexer_new_main (void)
return lexer;
}
-
/* Create a new lexer whose token stream is primed with the tokens in
CACHE. When these tokens are exhausted, no new tokens will be read. */
@@ -3058,7 +501,7 @@ cp_lexer_debugging_p (cp_lexer *lexer)
#endif /* ENABLE_CHECKING */
-static inline cp_token_position
+cp_token_position
cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
{
gcc_assert (!previous_p || lexer->next_token != &eof_token);
@@ -3964,19 +1407,6 @@ typedef struct cp_parser_binary_operatio
enum cp_parser_prec prec;
} cp_parser_binary_operations_map_node;
-/* The status of a tentative parse. */
-
-typedef enum cp_parser_status_kind
-{
- /* No errors have occurred. */
- CP_PARSER_STATUS_KIND_NO_ERROR,
- /* An error has occurred. */
- CP_PARSER_STATUS_KIND_ERROR,
- /* We are committed to this tentative parse, whether or not an error
- has occurred. */
- CP_PARSER_STATUS_KIND_COMMITTED
-} cp_parser_status_kind;
-
typedef struct cp_parser_expression_stack_entry
{
/* Left hand side of the binary operation we are currently
@@ -3997,21 +1427,6 @@ typedef struct cp_parser_expression_stac
typedef struct cp_parser_expression_stack_entry
cp_parser_expression_stack[NUM_PREC_VALUES];
-/* Context that is saved and restored when parsing tentatively. */
-typedef struct GTY (()) cp_parser_context {
- /* If this is a tentative parsing context, the status of the
- tentative parse. */
- enum cp_parser_status_kind status;
- /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
- that are looked up in this context must be looked up both in the
- scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
- the context of the containing expression. */
- tree object_type;
-
- /* The next parsing context in the stack. */
- struct cp_parser_context *next;
-} cp_parser_context;
-
/* Prototypes. */
/* Constructors and destructors. */
@@ -4102,174 +1517,6 @@ cp_parser_context_new (cp_parser_context
return context;
}
-/* An entry in a queue of function arguments that require post-processing. */
-
-typedef struct GTY(()) cp_default_arg_entry_d {
- /* The current_class_type when we parsed this arg. */
- tree class_type;
-
- /* The function decl itself. */
- tree decl;
-} cp_default_arg_entry;
-
-DEF_VEC_O(cp_default_arg_entry);
-DEF_VEC_ALLOC_O(cp_default_arg_entry,gc);
-
-/* An entry in a stack for member functions of local classes. */
-
-typedef struct GTY(()) cp_unparsed_functions_entry_d {
- /* Functions with default arguments that require post-processing.
- Functions appear in this list in declaration order. */
- VEC(cp_default_arg_entry,gc) *funs_with_default_args;
-
- /* Functions with defintions that require post-processing. Functions
- appear in this list in declaration order. */
- VEC(tree,gc) *funs_with_definitions;
-} cp_unparsed_functions_entry;
-
-DEF_VEC_O(cp_unparsed_functions_entry);
-DEF_VEC_ALLOC_O(cp_unparsed_functions_entry,gc);
-
-/* The cp_parser structure represents the C++ parser. */
-
-typedef struct GTY(()) cp_parser {
- /* The lexer from which we are obtaining tokens. */
- cp_lexer *lexer;
-
- /* The scope in which names should be looked up. If NULL_TREE, then
- we look up names in the scope that is currently open in the
- source program. If non-NULL, this is either a TYPE or
- NAMESPACE_DECL for the scope in which we should look. It can
- also be ERROR_MARK, when we've parsed a bogus scope.
-
- This value is not cleared automatically after a name is looked
- up, so we must be careful to clear it before starting a new look
- up sequence. (If it is not cleared, then `X::Y' followed by `Z'
- will look up `Z' in the scope of `X', rather than the current
- scope.) Unfortunately, it is difficult to tell when name lookup
- is complete, because we sometimes peek at a token, look it up,
- and then decide not to consume it. */
- tree scope;
-
- /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
- last lookup took place. OBJECT_SCOPE is used if an expression
- like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
- respectively. QUALIFYING_SCOPE is used for an expression of the
- form "X::Y"; it refers to X. */
- tree object_scope;
- tree qualifying_scope;
-
- /* A stack of parsing contexts. All but the bottom entry on the
- stack will be tentative contexts.
-
- We parse tentatively in order to determine which construct is in
- use in some situations. For example, in order to determine
- whether a statement is an expression-statement or a
- declaration-statement we parse it tentatively as a
- declaration-statement. If that fails, we then reparse the same
- token stream as an expression-statement. */
- cp_parser_context *context;
-
- /* True if we are parsing GNU C++. If this flag is not set, then
- GNU extensions are not recognized. */
- bool allow_gnu_extensions_p;
-
- /* TRUE if the `>' token should be interpreted as the greater-than
- operator. FALSE if it is the end of a template-id or
- template-parameter-list. In C++0x mode, this flag also applies to
- `>>' tokens, which are viewed as two consecutive `>' tokens when
- this flag is FALSE. */
- bool greater_than_is_operator_p;
-
- /* TRUE if default arguments are allowed within a parameter list
- that starts at this point. FALSE if only a gnu extension makes
- them permissible. */
- bool default_arg_ok_p;
-
- /* TRUE if we are parsing an integral constant-expression. See
- [expr.const] for a precise definition. */
- bool integral_constant_expression_p;
-
- /* TRUE if we are parsing an integral constant-expression -- but a
- non-constant expression should be permitted as well. This flag
- is used when parsing an array bound so that GNU variable-length
- arrays are tolerated. */
- bool allow_non_integral_constant_expression_p;
-
- /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
- been seen that makes the expression non-constant. */
- bool non_integral_constant_expression_p;
-
- /* TRUE if local variable names and `this' are forbidden in the
- current context. */
- bool local_variables_forbidden_p;
-
- /* TRUE if the declaration we are parsing is part of a
- linkage-specification of the form `extern string-literal
- declaration'. */
- bool in_unbraced_linkage_specification_p;
-
- /* TRUE if we are presently parsing a declarator, after the
- direct-declarator. */
- bool in_declarator_p;
-
- /* TRUE if we are presently parsing a template-argument-list. */
- bool in_template_argument_list_p;
-
- /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
- to IN_OMP_BLOCK if parsing OpenMP structured block and
- IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
- this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
- iteration-statement, OpenMP block or loop within that switch. */
-#define IN_SWITCH_STMT 1
-#define IN_ITERATION_STMT 2
-#define IN_OMP_BLOCK 4
-#define IN_OMP_FOR 8
-#define IN_IF_STMT 16
- unsigned char in_statement;
-
- /* TRUE if we are presently parsing the body of a switch statement.
- Note that this doesn't quite overlap with in_statement above.
- The difference relates to giving the right sets of error messages:
- "case not in switch" vs "break statement used with OpenMP...". */
- bool in_switch_statement_p;
-
- /* TRUE if we are parsing a type-id in an expression context. In
- such a situation, both "type (expr)" and "type (type)" are valid
- alternatives. */
- bool in_type_id_in_expr_p;
-
- /* TRUE if we are currently in a header file where declarations are
- implicitly extern "C". */
- bool implicit_extern_c;
-
- /* TRUE if strings in expressions should be translated to the execution
- character set. */
- bool translate_strings_p;
-
- /* TRUE if we are presently parsing the body of a function, but not
- a local class. */
- bool in_function_body;
-
- /* If non-NULL, then we are parsing a construct where new type
- definitions are not permitted. The string stored here will be
- issued as an error message if a type is defined. */
- const char *type_definition_forbidden_message;
-
- /* A stack used for member functions of local classes. The lists
- contained in an individual entry can only be processed once the
- outermost class being defined is complete. */
- VEC(cp_unparsed_functions_entry,gc) *unparsed_queues;
-
- /* The number of classes whose definitions are currently in
- progress. */
- unsigned num_classes_being_defined;
-
- /* The number of template parameter lists that apply directly to the
- current declaration. */
- unsigned num_template_parameter_lists;
-} cp_parser;
-
/* Managing the unparsed function queues. */
#define unparsed_funs_with_default_args \
@@ -11809,309 +9056,6 @@ cp_parser_already_scoped_statement (cp_p
}
}
-static void
-pph_log_exposed (cp_parser *parser, const char *end)
-{
- if (flag_pph_debug >= 2)
- {
- cp_token *pos = cp_lexer_token_position (parser->lexer, false);
- fprintf (pph_logfile, "PPH: %s exposed declaration at ", end);
- pph_debug_location (pph_logfile, pos->location);
- fprintf (pph_logfile, "\n");
- }
-}
-
-
-/* Allocate the various arrays, maps and sets used to collect ASTs and
- their dependencies during parsing. This memory is allocated and
- freed for every grammar rule intercepted by pph_start_exposed() and
- pph_stop_exposed(). */
-
-static void
-pph_allocate_catcher_memory (void)
-{
- /* Note. pph_tree_catcher *must* be instantiated to indicate that
- we are going to be catching trees during parsing. */
- pph_tree_catcher = VEC_alloc (tree, heap, 5);
- pph_decl_head_token_cache = pointer_map_create ();
- pph_decl_body_token_cache = pointer_map_create ();
- pph_decl_deps = XCNEW (struct pph_decl_deps_d);
- pph_decl_deps->header = pointer_map_create ();
- pph_decl_deps->body = pointer_map_create ();
- pph_name_lookups = NULL;
- pph_name_lookups_set = pointer_set_create ();
- pph_nl_token_map = pointer_map_create ();
-}
-
-
-/* Free all the memory allocated by pph_allocate_catcher_memory. */
-
-static void
-pph_free_catcher_memory (void)
-{
- VEC_free (tree, heap, pph_tree_catcher);
-
- pointer_map_destroy (pph_decl_head_token_cache);
- pph_decl_head_token_cache = NULL;
-
- pointer_map_destroy (pph_decl_body_token_cache);
- pph_decl_body_token_cache = NULL;
-
- pointer_map_destroy (pph_decl_deps->header);
- pointer_map_destroy (pph_decl_deps->body);
- free (pph_decl_deps);
- pph_decl_deps = NULL;
-
- VEC_free (tree, heap, pph_name_lookups);
-
- pointer_set_destroy (pph_name_lookups_set);
- pph_name_lookups_set = NULL;
-
- pointer_map_destroy (pph_nl_token_map);
- pph_nl_token_map = NULL;
-}
-
-
-/* Start collecting ASTs and dependencies. */
-
-static cp_token *
-pph_start_exposed (cp_parser *parser)
-{
- if (flag_pph_debug >= 1)
- {
- timevar_push (TV_PPH_MANAGE);
-
- if (flag_pph_debug >= 4)
- fprintf (pph_logfile, "\n--------------------------------------------------------------------------\n");
- pph_log_exposed (parser, "start");
- pph_allocate_catcher_memory ();
- timevar_pop (TV_PPH_MANAGE);
-
- return parser->lexer->next_token; /* the first token */
- }
- else
- return NULL;
-}
-
-/* Return the token cache associated with tree node T. */
-
-static VEC(cp_token, heap) *
-pph_lookup_head_token_cache_for (tree t)
-{
- void **slot = pointer_map_contains (pph_decl_head_token_cache, t);
- if (slot)
- return ((VEC(cp_token, heap) *) *slot);
-
- return NULL;
-}
-
-static VEC(cp_token, heap) *
-pph_lookup_body_token_cache_for (tree t)
-{
- void **slot = pointer_map_contains (pph_decl_body_token_cache, t);
- if (slot)
- return ((VEC(cp_token, heap) *) *slot);
-
- return NULL;
-}
-
-
-/* Set the token cache associated with tree node T to CACHE. */
-
-static void
-pph_set_head_token_cache_for (tree t, VEC(cp_token, heap) *cache)
-{
- void **slot = pointer_map_insert (pph_decl_head_token_cache, t);
- *slot = (void *) cache;
-}
-
-static void
-pph_set_body_token_cache_for (tree t, VEC(cp_token, heap) *cache)
-{
- void **slot = pointer_map_insert (pph_decl_body_token_cache, t);
- *slot = (void *) cache;
-}
-
-/* Emulate the copying of declarations into the parser cache. Deep
- copy all the declarations in V. */
-
-static void
-pph_copy_decls_into_cache (VEC(tree, heap) *v)
-{
- unsigned i;
- static tree t_copy, type_copy, t;
- void **slot;
- VEC(tree, heap) *ast_cache, *old_pph_tree_catcher, *old_pph_name_lookups;
- static struct pointer_map_t *hunk_to_decls_map = NULL;
- static htab_t cache_dir = NULL;
- const char *fname;
-
- timevar_push (TV_PPH_CACHE_IN);
-
- if (hunk_to_decls_map == NULL)
- hunk_to_decls_map = pointer_map_create ();
-
- if (cache_dir == NULL)
- cache_dir = htab_create (10, htab_hash_pointer, htab_eq_pointer, 0);
-
- /* We will be copying trees, which will call into the tree catching
- routines. Prevent that. */
- old_pph_tree_catcher = pph_tree_catcher;
- old_pph_name_lookups = pph_name_lookups;
- pph_tree_catcher = pph_name_lookups = NULL;
-
- /* Copy every declaration in V into the cache. */
- for (i = 0; VEC_iterate (tree, v, i, t); i++)
- {
- /* 1- Determine the token hunk H that owns T. We first determine
- the PTH image and then which hunk inside that PTH image. For
- choosing the hunk within the image, we simulate a second
- hash table lookup hashing the location to the token hunk. */
- pth_image *image, *hunk;
- VEC(cp_token, heap) *head_tokens, *body_tokens;
- cp_token *first;
-
- head_tokens = pph_lookup_head_token_cache_for (t);
- body_tokens = pph_lookup_body_token_cache_for (t);
- if (VEC_empty (cp_token, head_tokens))
- continue;
- first = VEC_index (cp_token, head_tokens, 0);
- fname = LOCATION_FILE (first->location);
- slot = htab_find_slot (cache_dir, fname, INSERT);
- if (*slot == NULL)
- {
- image = XCNEW (pth_image);
- *slot = CONST_CAST (char *, fname);
- }
- else
- image = *((pth_image **) slot);
-
- /* For now, re-do the pth_image_lookup to simulate the lookup of
- the hunk within the image. */
- slot = htab_find_slot (cache_dir, fname, NO_INSERT);
- hunk = *((pth_image **) slot);
-
- /* Insert dummy uses for head_tokens, body_tokens and image. */
- if (i > VEC_length (tree, v))
- {
- free (head_tokens);
- free (body_tokens);
- free (image);
- }
-
- /* 2- Find the tree cache associated with HUNK. */
- slot = pointer_map_insert (hunk_to_decls_map, hunk);
- ast_cache = (VEC(tree, heap) *) *slot;
-
- /* 3- Copy T and its type into the cache associated with HUNK.
- If T has a body (a FUNCTION_DECL), copy the body. FIXME pph,
- copying ASTs will need new copying code to be implemented,
- the current routines do not handle everything that can be
- generated by the C++ FE. */
- t_copy = copy_decl (t);
- if (!type_copy || TREE_TYPE (t))
- type_copy = copy_type (TREE_TYPE (t));
- if (TREE_CODE (t) == FUNCTION_DECL)
- walk_tree (&DECL_SAVED_TREE (t_copy), copy_tree_r, (void *)1, NULL);
- VEC_safe_push (tree, heap, ast_cache, t_copy);
- *slot = (void *) ast_cache;
- }
-
- PPH_STATS_INCR (cached_decls, VEC_length (tree, v));
-
- /* Restore tree and lookup catchers. */
- pph_tree_catcher = old_pph_tree_catcher;
- pph_name_lookups = old_pph_name_lookups;
-
- timevar_pop (TV_PPH_CACHE_IN);
-}
-
-
-/* Emulate the cache actions needed to get a declaration out of the
- parser cache and instantiate it into the current compilation context. */
-
-static void
-pph_copy_decls_outof_cache (VEC(tree, heap) *v)
-{
- unsigned i;
- tree t;
- static VEC(tree, heap) *compilation_context = NULL;
- VEC(tree, heap) *old_pph_tree_catcher, *old_pph_name_lookups;
-
- /* Conceptually, this will be called with a token hunk that contains
- all the declarations that we want to instantiate. */
- timevar_push (TV_PPH_CACHE_OUT);
-
- /* We will be copying trees, which will call into the tree catching
- routines. Prevent that. */
- old_pph_tree_catcher = pph_tree_catcher;
- old_pph_name_lookups = pph_name_lookups;
- pph_tree_catcher = pph_name_lookups = NULL;
-
- /* 1- Verify that the hunk is valid. Traverse all the declarations
- checking that none have been tainted. */
- for (i = 0; VEC_iterate (tree, v, i, t); i++)
- {
- /* If T is not valid, none of its users is valid. */
- if (1 || TREE_VISITED (t))
- {
- unsigned j;
- tree r;
- for (j = 0; VEC_iterate (tree, v, j, r); j++)
- TREE_VISITED (r) = TREE_VISITED (r);
- }
- }
-
- /* 2- Copy all the trees in the hunk to the current compilation context. */
- for (i = 0; VEC_iterate (tree, v, i, t); i++)
- {
- static tree t_copy, type_copy;
-
- t_copy = copy_decl (t);
- if (!type_copy || TREE_TYPE (t))
- type_copy = copy_type (TREE_TYPE (t));
- if (TREE_CODE (t) == FUNCTION_DECL)
- walk_tree (&DECL_SAVED_TREE (t_copy), copy_tree_r, (void *)1, NULL);
-
- /* Emulate restoration into compilation context. FIXME pph, this is
- missing the name lookups that may be required. Estimate this
- separately from the number of name lookup operations and the
- time spent doing name lookups. */
- VEC_safe_push (tree, heap, compilation_context, t_copy);
- }
-
- PPH_STATS_INCR (restored_decls, VEC_length (tree, v));
-
- /* Restore tree and lookup catchers. */
- pph_tree_catcher = old_pph_tree_catcher;
- pph_name_lookups = old_pph_name_lookups;
-
- timevar_pop (TV_PPH_CACHE_OUT);
-}
-
-static void
-pph_stop_exposed (cp_parser *parser, cp_token *first_token)
-{
- if (flag_pph_debug >= 1 && !VEC_empty (tree, pph_tree_catcher))
- {
- cp_token *last_token;
-
- timevar_push (TV_PPH_MANAGE);
-
- last_token = parser->lexer->next_token;
- pph_print_trees_tokens (pph_tree_catcher, first_token, last_token);
- pph_copy_decls_into_cache (pph_tree_catcher);
- pph_copy_decls_outof_cache (pph_tree_catcher);
- PPH_STATS_INCR (cached_refs, VEC_length(tree, pph_name_lookups));
- pph_free_catcher_memory ();
- if (flag_pph_debug >= 4)
- pph_log_exposed (parser, "stop");
-
- timevar_pop (TV_PPH_MANAGE);
- }
-}
-
-
/* Declarations [gram.dcl.dcl] */
/* Parse an optional declaration-sequence.
@@ -27646,1591 +24590,8 @@ cp_parser_omp_construct (cp_parser *pars
/* The parser. */
-static GTY (()) cp_parser *the_parser;
-
-/* PPH printing help. */
-
-static void
-pph_debug_tree (tree t, bool body)
-{
- if (t == NULL)
- {
- fprintf (pph_logfile, "nulldecl");
- return;
- }
-
- if (!DECL_P (t))
- {
- fprintf (pph_logfile, "__%s__", tree_code_name[TREE_CODE (t)]);
- return;
- }
-
- if (flag_pph_decls >= 2)
- fprintf (pph_logfile, "%s ", tree_code_name[TREE_CODE (t)]);
- fprintf (pph_logfile, "%d", (DECL_UID (t) << 1) + body);
- if (flag_pph_decls >= 1)
- fprintf (pph_logfile, " '%s'", get_name (t));
- if (flag_pph_decls >= 3)
- {
- fprintf (pph_logfile, " ");
- pph_debug_loc_of_tree (pph_logfile, t);
- if (flag_pph_decls >= 4)
- fprintf (pph_logfile, " @%p", (void *) t);
- }
-}
-
-static void
-pph_debug_type (tree t, bool body)
-{
- tree t_decl;
- if (t == NULL)
- {
- fprintf (pph_logfile, "nulltype");
- return;
- }
- t_decl = get_type_decl (t);
- if (t_decl == NULL)
- fprintf (pph_logfile, "nameless");
- else
- pph_debug_tree (t_decl, body);
-}
-
-/* Return true if tree T has been caught already. */
-
-static bool
-pph_tree_caught_p (tree t)
-{
- return (pph_lookup_head_token_cache_for (t) != NULL);
-}
-
-/* Collect the tokens needed for the head of DECL.
- This assumes that the current token is positioned right after
- the end of the declarator expression for DECL (i.e., it should
- be called from grokdeclarator). */
-
-static VEC(cp_token, heap) *
-pph_catch_head_tokens_for (tree t)
-{
- cp_token *tok, *last, *first;
- cp_lexer *lexer;
- VEC(cp_token, heap) *tokens;
-
- gcc_assert (t != error_mark_node);
-
- tokens = pph_lookup_head_token_cache_for (t);
- if (tokens)
- {
- fprintf (stderr, "*** ");
- pph_debug_location (stderr, input_location);
- fprintf (stderr, ": Tried to catch head tokens more than once for: ");
- print_generic_stmt (stderr, t, 0);
- gcc_unreachable ();
- }
-
- lexer = the_parser->lexer;
-
- /* Look for the tokens backwards until the first brace or semicolon. */
- first = last = lexer->next_token;
- for (tok = last - 1; tok >= VEC_address (cp_token, lexer->buffer); tok--)
- {
- if (tok->type == CPP_OPEN_BRACE
- || tok->type == CPP_CLOSE_BRACE
- || tok->type == CPP_SEMICOLON)
- break;
-
- first = tok;
- }
-
- /* Now include any trailing semicolon. */
- if (last->type == CPP_SEMICOLON)
- last++;
-
- /* Add all the tokens in [FIRST, LAST) to TOKENS. */
- for (tok = first; tok != last; tok++)
- VEC_safe_push (cp_token, heap, tokens, tok);
-
- pph_set_head_token_cache_for (t, tokens);
-
- return tokens;
-}
-
-
-/* Collect the tokens needed for the body of DECL.
- This assumes that the current token is positioned right after
- the end of the declarator expression for DECL (i.e., it should
- be called from grokdeclarator). */
-
-static VEC(cp_token, heap) *
-pph_catch_body_tokens_for (tree t)
-{
- cp_token *tok, *last, *first;
- cp_lexer *lexer;
- VEC(cp_token, heap) *tokens;
-
- gcc_assert (t != error_mark_node);
-
- tokens = pph_lookup_body_token_cache_for (t);
- if (tokens)
- {
- fprintf (stderr, "*** ");
- pph_debug_location (stderr, input_location);
- fprintf (stderr, ": Tried to catch body tokens more than once for: ");
- print_generic_stmt (stderr, t, 0);
- gcc_unreachable ();
- }
-
- lexer = the_parser->lexer;
-
- /* Look for the tokens forwards until the closing brace or semicolon. */
- first = last = lexer->next_token;
- tok = first;
- if (tok->type == CPP_EQ || tok->type == CPP_OPEN_PAREN)
- {
- /* Skip a variable-like definition. Find the semicolon. */
- /* FIXME pph - This code changes with C++0x. */
- for (; tok <= VEC_last (cp_token, lexer->buffer); tok++)
- if (tok->type == CPP_SEMICOLON)
- break;
- last = tok;
- }
- else if (tok->type == CPP_OPEN_BRACE || tok->type == CPP_COLON)
- {
- /* Skip a class-like or function-like definition.
- Skip to a left brace, then skip to the matching right brace. */
- /* FIXME pph - This code changes with C++0x. */
- int nesting = 0;
- for (; tok <= VEC_last (cp_token, lexer->buffer); tok++)
- if (tok->type == CPP_OPEN_BRACE)
- nesting++;
- else if (tok->type == CPP_CLOSE_BRACE)
- {
- if ( nesting <= 1)
- break;
- else
- nesting--;
- }
- last = tok;
- }
- else
- return NULL; /* no body */
-
- /* Add all the tokens in [FIRST, LAST) to TOKENS. */
- for (tok = first; tok <= last; tok++)
- VEC_safe_push (cp_token, heap, tokens, tok);
-
- pph_set_body_token_cache_for (t, tokens);
-
- return tokens;
-}
-
-
-/* Return the dependencies for tree node T. If HEADER_P is true, it
- returns the dependencies for the header of T's declaration.
- Otherwise, it returns dependencies for T's body. */
-
-static VEC(tree,gc) *
-pph_lookup_dependencies_for (tree t, bool header_p)
-{
- struct pointer_map_t *map;
- void **slot;
-
- map = (header_p) ? pph_decl_deps->header : pph_decl_deps->body;
- slot = pointer_map_contains (map, t);
- if (slot)
- return ((VEC(tree,gc) *) *slot);
-
- return NULL;
-}
-
-
-/* Set the dependencies for tree node T to DEPS. If HEADER_P is true,
- DEPS are the dependencies for T's header. Otherwise, DEPS are the
- dependencies for T's body. */
-
-static void
-pph_set_dependencies_for (tree t, VEC(tree,gc) *deps, bool header_p)
-{
- void **slot;
- struct pointer_map_t *map;
-
- map = (header_p) ? pph_decl_deps->header : pph_decl_deps->body;
- slot = pointer_map_insert (map, t);
- *slot = (void *) deps;
-}
-
-#define PPH_ARTIFICIAL(t) \
-(DECL_ARTIFICIAL (t) \
-&& !(TREE_CODE (t) == TYPE_DECL && DECL_IMPLICIT_TYPEDEF_P (t)))
-
-static bool
-is_namespace (tree container)
-{
- enum tree_code code;
-
- if (container == NULL)
- return true;
-
- code = TREE_CODE (container);
- if (code == NAMESPACE_DECL)
- return true;
-
- return false;
-}
-
-/* Find the exposed declaration containing a symbol lookup. */
-
-static tree
-pph_null_exposed (const char *reason)
-{
- if (flag_pph_debug >= 3)
- fprintf (pph_logfile, "%s\n", reason);
- return NULL;
-}
-
-static tree
-pph_live_exposed (tree t, bool body)
-{
- if (PPH_ARTIFICIAL (t))
- return pph_null_exposed ("Artificial symbols are not exposed.");
-
- if (flag_pph_debug >= 3)
- {
- if (t == NULL)
- fprintf (pph_logfile, "(null)");
- else
- pph_debug_tree (t, body);
- fprintf (pph_logfile, "\n");
- }
- return t;
-}
-
-static tree
-pph_find_exposed_for (tree t, bool *body)
-{
- tree container;
- enum tree_code code, t_code;
- bool in_class;
- *body = false; /* By default, we only depend on heads. */
- for ( ; ; t = container, *body = true)
- {
- reclassify:
- if (t == NULL)
- {
- PPH_STATS_INCR (bad_lookups, 1);
- return pph_null_exposed ("NULLOID"); /* FIXME pph */
- }
- if (flag_pph_debug >= 3)
- {
- fprintf (pph_logfile, " exposed for ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, " is ");
- }
- code = TREE_CODE (t);
- switch (code)
- {
- /* Types common to C and C++. */
- case ARRAY_TYPE:
- case BOOLEAN_TYPE:
- case COMPLEX_TYPE:
- case ENUMERAL_TYPE:
- case FIXED_POINT_TYPE:
- case FUNCTION_TYPE:
- case INTEGER_TYPE:
- case LANG_TYPE:
- case METHOD_TYPE:
- case OFFSET_TYPE:
- case POINTER_TYPE:
- case QUAL_UNION_TYPE:
- case REAL_TYPE:
- case RECORD_TYPE:
- case REFERENCE_TYPE:
- case UNION_TYPE:
- case VECTOR_TYPE:
- case VOID_TYPE:
- /* C++-specific types. */
- case BOUND_TEMPLATE_TEMPLATE_PARM:
- case TEMPLATE_TEMPLATE_PARM:
- case TEMPLATE_TYPE_PARM:
- case TYPENAME_TYPE:
- case TYPEOF_TYPE:
- case UNBOUND_CLASS_TEMPLATE:
- case TYPE_ARGUMENT_PACK:
- case TYPE_PACK_EXPANSION:
- case DECLTYPE_TYPE:
- {
- if (TYPE_NAME (t) == NULL)
- return pph_null_exposed ("Anonymous Type");
- else
- t = TYPE_NAME (t);
- /* FALLTHRU */
- }
-
- case TYPE_DECL:
- {
- container = DECL_CONTEXT (t);
- in_class = container && CLASS_TYPE_P (container);
- t_code = TREE_CODE (TREE_TYPE (t));
- /* FIXME pph: Why DECL_TEMPLATE_TEMPLATE_PARM_P does not apply
- here? It is a template template parameter, but the tree code
- is inconsistent. */
- if (DECL_TEMPLATE_PARM_P (t)
- || t_code == TEMPLATE_TEMPLATE_PARM
- || t_code == BOUND_TEMPLATE_TEMPLATE_PARM)
- return pph_null_exposed ("TMPLPARM");
-
- if (is_namespace (container))
- return pph_live_exposed (t, *body);
- break;
- }
-
- case VAR_DECL:
- {
- /* If var is lazy, depend on its body, not its head. */
- tree enclass = DECL_CONTEXT (t);
- bool in_class = enclass && CLASS_TYPE_P (enclass);
- bool defined = DECL_INITIAL (t) != NULL;
- /* FIXME pph: DECL_INITIALIZED_P (t) */
- if (defined && (in_class || !DECL_THIS_EXTERN (t))
- && DECL_INTEGRAL_CONSTANT_VAR_P (t))
- *body = true;
-
- container = DECL_CONTEXT (t);
- in_class = container && CLASS_TYPE_P (container);
- if (in_class && DECL_THIS_STATIC (t))
- container = TYPE_CONTEXT (container);
- if (is_namespace (container))
- return pph_live_exposed (t, *body);
- break;
- }
-
- case FUNCTION_DECL:
- {
- /* If function is lazy, depend on body. */
- bool defined = DECL_INITIAL (t) != NULL;
- if (defined && (DECL_DECLARED_INLINE_P (t)
- || DECL_USE_TEMPLATE (t) != 2))
- *body = true;
-
- container = DECL_CONTEXT (t);
- in_class = container && CLASS_TYPE_P (container);
- if (in_class)
- container = TYPE_CONTEXT (container);
- if (is_namespace (container))
- return pph_live_exposed (t, *body);;
- break;
- }
-
- case TEMPLATE_DECL:
- {
- int generic = DECL_USE_TEMPLATE (t);
- if (generic != 2)
- {
- t = DECL_TEMPLATE_RESULT (t);
- if (flag_pph_debug >= 3)
- fprintf (pph_logfile, "template redirected\n");
- goto reclassify;
- }
- }
-
- case SCOPE_REF:
- return pph_null_exposed ("SCOPE_REF"); /* FIXME pph */
-
- case OVERLOAD:
- return pph_null_exposed ("OVERLOAD"); /* FIXME pph */
-
- case BASELINK:
- container = BASELINK_BINFO (t);
- break;
-
- case TREE_BINFO:
- container = BINFO_TYPE (t);
- break;
-
- case TREE_LIST:
- t = TREE_VALUE (t);
- /* Fallthru */
-
- default:
- {
- if (t == NULL)
- {
- PPH_STATS_INCR (bad_lookups, 1);
- return pph_null_exposed ("NULLOID"); /* FIXME pph */
- }
- else if (!DECL_P (t))
- {
- PPH_STATS_INCR (bad_lookups, 1);
- return pph_null_exposed ("BOZOID"); /* FIXME pph */
- /*FIXME pph:
- fatal_error ("Expecting a *_decl node. Got %s",
- tree_code_name[TREE_CODE (t)]);
- */
- }
-
- container = DECL_CONTEXT (t);
- in_class = container && CLASS_TYPE_P (container);
- if (is_namespace (container))
- return pph_null_exposed ("UNKNOWN");
- break;
- }
- }
- if (flag_pph_debug >= 3)
- {
- pph_debug_tree (container, *body);
- fprintf (pph_logfile, "\n");
- }
- }
-}
-
-
-/* Collect the AST nodes that node T depends on. HEADER_P is true if
- we should collect ASTs from T's header. Otherwise, we collect
- ASTs from T's body. */
-
-static VEC(tree,gc) *
-pph_catch_dependencies_for (tree t, bool header_p)
-{
- VEC(cp_token, heap) *tokens;
- unsigned i;
- cp_token *tok;
- VEC(tree,gc) *deps;
-
- tokens = (header_p)
- ? pph_lookup_head_token_cache_for (t)
- : pph_lookup_body_token_cache_for (t);
-
- if (tokens == NULL)
- tokens = (header_p)
- ? pph_catch_head_tokens_for (t)
- : pph_catch_body_tokens_for (t);
-
- deps = pph_lookup_dependencies_for (t, header_p);
-
- for (i = 0; VEC_iterate (cp_token, tokens, i, tok); i++)
- if (tok->type == CPP_NAME)
- VEC_safe_push (tree, gc, deps, tok->u.value);
-
- pph_set_dependencies_for (t, deps, header_p);
-
- return deps;
-}
-
-
-/* Intercept tree node T by storing it in pph_tree_catcher and collecting
- the tokens used in its instantiation. */
-
-void
-pph_catch_tree (tree t)
-{
- /* Only collect trees if the parser instantiated pph_tree_catcher
- and we are currently parsing from the main lexer. */
- if (pph_tree_catcher && the_parser->lexer->buffer && !pph_tree_caught_p (t))
- {
- timevar_push (TV_PPH_MANAGE);
-
- VEC_safe_push (tree, heap, pph_tree_catcher, t);
- pph_catch_head_tokens_for (t);
- pph_catch_body_tokens_for (t);
- pph_catch_dependencies_for (t, true);
- pph_catch_dependencies_for (t, false);
-
- timevar_pop (TV_PPH_MANAGE);
- }
-}
-
-
-/* Retract a caught tree. */
-
-void
-pph_uncatch_tree (tree t)
-{
- /* Only uncollect trees if the parser instantiated pph_tree_catcher
- and we are currently parsing from the main lexer. */
- if (pph_tree_catcher && the_parser->lexer->buffer)
- {
- int i;
- tree u;
-
- timevar_push (TV_PPH_MANAGE);
-
- /* Find the index; if present, remove it. */
- for (i = 0; VEC_iterate (tree, pph_tree_catcher, i, u); i++)
- {
- if (u == t)
- {
- VEC_ordered_remove (tree, pph_tree_catcher, i);
- break;
- }
- }
-
- timevar_pop (TV_PPH_MANAGE);
- }
-}
-
-
-/* Given a set of tokens TOKENS, return the symbols from pph_name_lookups
- that occur in TOKENS. The returned vector is, then, the set of all
- symbols that were resolved via name lookups during parsing. This set
- is a subset of all the CPP_NAME tokens in TOKENS. */
-
-static void
-pph_locate_name_lookups_in (VEC(cp_token, heap) *tokens,
- VEC(tree,gc) **heads_found,
- VEC(tree,gc) **bodies_found)
-{
- unsigned i;
- tree t;
- cp_token *first, *last;
-
- *heads_found = NULL;
- *bodies_found = NULL;
-
- if (tokens == NULL || VEC_empty (cp_token, tokens))
- return;
-
- first = VEC_index (cp_token, tokens, 0);
- last = VEC_last (cp_token, tokens);
-
- for (i = 0; VEC_iterate (tree, pph_name_lookups, i, t); i++)
- {
- unsigned j;
- cp_token *tok;
- VEC(cp_token, heap) *lookup_locations;
- void **slot;
- bool pushed = false;
-
- slot = pointer_map_contains (pph_nl_token_map, t);
- gcc_assert (slot && *slot);
- lookup_locations = (VEC(cp_token, heap) *) *slot;
- for (j = 0; VEC_iterate (cp_token, lookup_locations, j, tok); j++)
- {
- if (tok->location >= first->location
- && tok->location <= last->location)
- {
- if (!pushed)
- {
- bool body;
- tree exposed = pph_find_exposed_for (t, &body);
- if (exposed)
- {
- if (body)
- VEC_safe_push (tree, gc, *bodies_found, exposed);
- else
- VEC_safe_push (tree, gc, *heads_found, exposed);
- pushed = true;
- }
- }
-
- /* Avoid double-counting lookups by removing the lookup
- location after a class member declaration has found it.
- To make that work, we must remove all redundant entries. */
- if (flag_pph_debug >= 4)
- {
- fprintf (pph_logfile, " lookup in %p for ",
- (void*)lookup_locations);
- pph_debug_tree (t, false);
- fprintf (pph_logfile, " found at ");
- pph_debug_location (pph_logfile, tok->location);
- fprintf (pph_logfile, "\n");
- fprintf (pph_logfile, " vector length from %d",
- VEC_length (cp_token, lookup_locations));
-
- }
- /* This code is slow, but VEC won't let me null entires. */
- VEC_ordered_remove (cp_token, lookup_locations, j);
- /* We have just shifted down all later entries,
- and need to counteract the upcoming index increment. */
- j--;
- if (flag_pph_debug >= 4)
- {
- fprintf (pph_logfile, " to %d\n",
- VEC_length (cp_token, lookup_locations));
- }
- }
- }
- }
-}
-
-
-/* Print all the trees in V and the tokens in the token range
- [TOK1, TOK2). */
-
-static VEC(cp_token, heap) *
-pph_print_copy_tokens (cp_token *tok1, cp_token *tok2)
-{
- cp_token *tok;
- VEC(cp_token, heap) *vtok;
-
- /* If TOK2 is CPP_EOF, it will have the address of eof_token, which
- will make the loop below go off the deep end. Detect this and
- make TOK2 the last token in the lexer buffer instead. */
- if (tok2 == &eof_token)
- tok2 = VEC_last (cp_token, the_parser->lexer->buffer);
-
- vtok = NULL;
- for (tok = tok1; tok != tok2; tok++)
- VEC_safe_push (cp_token, heap, vtok, tok);
-
- return vtok;
-}
-
-static void
-pph_print_token_range (VEC(tree,heap) *v, VEC(cp_token, heap) *vtok)
-{
- unsigned i;
- tree t;
-
- if (flag_pph_debug >= 4)
- {
- fprintf (pph_logfile, "PPH: hunk location ");
- pph_debug_location (pph_logfile, VEC_index (cp_token, vtok, 0)->location);
- fprintf (pph_logfile, " to ");
- pph_debug_location (pph_logfile, VEC_last (cp_token, vtok)->location);
- fprintf (pph_logfile, "\n");
- fprintf (pph_logfile, "PPH: hunk tokens ");
- cp_lexer_dump_tokens (stderr, (VEC(cp_token, gc) *)vtok, 0);
- fprintf (pph_logfile, "PPH: hunk ASTs:\n");
- for (i = 0; VEC_iterate (tree, v, i, t); i++)
- {
- pph_debug_tree (t, true);
- /* FIXME pph: this may not be right; we may not care. */
- print_generic_stmt (stderr, t, 0);
- }
- fprintf (pph_logfile, "PPH: hunk decls:\n");
- }
-}
-
-static void
-pph_print_dependence (bool user_body, bool used_body,
- tree t, tree d)
-{
- static bool prior_user_body = false;
- static bool prior_used_body = false;
- static tree prior_t = NULL;
- static tree prior_d = NULL;
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " pd_base ");
- pph_debug_tree (t, user_body);
- fprintf (pph_logfile, " on ");
- pph_debug_tree (d, used_body);
- fprintf (pph_logfile, "\n");
- }
- if (t && d && DECL_P (t) && DECL_P (d) && (t != d || user_body != used_body))
- {
- if (PPH_ARTIFICIAL (t))
- {
- /* Okay, find the real symbol this articial one belongs to. */
- d = pph_find_exposed_for (d, &used_body);
- if (d == NULL)
- return;
- used_body = true;
- }
- if (user_body != prior_user_body
- || used_body != prior_used_body
- || t != prior_t
- || d != prior_d)
- {
- fprintf (pph_logfile, "depend ");
- pph_debug_tree (t, user_body);
- fprintf (pph_logfile, " uses ");
- pph_debug_tree (d, used_body);
- fprintf (pph_logfile, "\n");
- prior_user_body = user_body;
- prior_used_body = used_body;
- prior_t = t;
- prior_d = d;
- }
- }
-}
-
-static void
-pph_print_depend_template (tree tmpl_info, tree t)
-{
- tree tmpl_decl;
- tree tmpl_ptrn;
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " pd_template ");
- pph_debug_tree (t, true);
- fprintf (pph_logfile, " %p", (void*)tmpl_info);
- fprintf (pph_logfile, "\n");
- }
- tmpl_decl = TI_TEMPLATE (tmpl_info);
- if (TREE_CODE (tmpl_decl) == OVERLOAD)
- tmpl_decl = OVL_CURRENT (tmpl_decl);
- tmpl_ptrn = DECL_TEMPLATE_RESULT (tmpl_decl);
- if (tmpl_ptrn && t != tmpl_ptrn)
- {
- /* This is a template, but not the pattern. */
- pph_print_dependence (true, true, t, tmpl_ptrn);
- }
-}
-
-/* Print the dependence of a head of declaration
- on the body of a type that the head uses directly.
- If either of these is not exposed,
- find the body of the exposed declaration that contains it. */
-
-static void
-pph_print_depend_decl (tree user, tree used)
-{
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " pd_decl ");
- pph_debug_tree (user, false);
- fprintf (pph_logfile, " on ");
- pph_debug_tree (used, false);
- fprintf (pph_logfile, "\n");
- }
- if (user != NULL)
- {
- if (used != NULL)
- {
- bool body;
- tree exp_for_user = pph_find_exposed_for (user, &body);
- tree exp_for_used = pph_find_exposed_for (used, &body);
- if (exp_for_user && exp_for_used && exp_for_user != exp_for_used)
- pph_print_dependence (exp_for_user != user, true,
- exp_for_user, exp_for_used);
- }
- }
-}
-
-static void
-pph_print_depend_type (tree decl, tree type)
-{
- tree type_decl;
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " pd_type ");
- pph_debug_tree (decl, false);
- fprintf (pph_logfile, " on ");
- pph_debug_type (type, false);
- fprintf (pph_logfile, "\n");
- }
- if (type != NULL)
- {
- type_decl = get_type_decl (type);
- pph_print_depend_decl (decl, type_decl);
- }
-}
-
-static void
-pph_print_depend_type_type (tree t)
-{
- tree t_type;
- tree field;
-
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " depending on typedecl type ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, "\n");
- }
-
- t_type = TREE_TYPE (t);
- field = TYPE_FIELDS (t_type);
- for (; field; field = TREE_CHAIN(field))
- {
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " field ");
- pph_debug_tree (field, false);
- }
- if (TREE_CODE (field) == FIELD_DECL)
- {
- tree f_type = TREE_TYPE (field);
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " of type ");
- pph_debug_type (f_type, false);
- if (DECL_FIELD_IS_BASE (field))
- fprintf (pph_logfile, " is a base field!!\n");
- else
- fprintf (pph_logfile, " is a plain field\n");
- }
- pph_print_depend_type (t, f_type);
- }
- else if (TREE_CODE (field) == TYPE_DECL)
- {
- tree f_type = TREE_TYPE (field);
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " of type ");
- pph_debug_type (f_type, false);
- fprintf (pph_logfile, " is a type field\n");
- }
- pph_print_depend_type (t, f_type);
- }
- }
-
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " end of fields\n");
- }
-}
-
-static void
-pph_print_depend_func_type (tree t)
-{
- /* We must print a dependence of the head of the function
- on the body of the types of its signature. */
-
- tree args;
- tree func_type;
-
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " depending on function type ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, "\n");
- }
-
- func_type = TREE_TYPE (t);
- pph_print_depend_type (t, TREE_TYPE (func_type)); /* return type */
- for (args = TYPE_ARG_TYPES (func_type); args; args = TREE_CHAIN (args))
- pph_print_depend_type (t, TREE_VALUE (args)); /* parameter */
-
- if (DECL_VIRTUAL_P (t))
- {
- tree ctx_type = DECL_CONTEXT (t);
- tree ctx_decl = get_type_decl (ctx_type);
- /* Virtual functions depend on containing class's body.*/
- pph_print_depend_type (t, ctx_type);
- /* The virtual class's body also depends on the function
- for construction of the vtable. */
- pph_print_dependence (true, true, ctx_decl, t);
- }
-}
-
-static void
-pph_print_depend_var_type (tree t)
-{
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " depending on var/field type ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, "\n");
- }
-
- pph_print_depend_type (t, TREE_TYPE (t));
-}
-
-enum decl_exposure { HIDDEN, EXPOSED, NEEDED };
-
-static enum decl_exposure
-pph_get_decl_exposure (tree t)
-{
- tree container;
- tree type;
- tree tmpl_info;
- bool defined = false;
- bool inlined = false;
- bool needed = false;
- int generic = 0;
- enum tree_code code = TREE_CODE (t);
-
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " get_exposure for ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, "\n");
- }
-
- /* For DECL_USE_TEMPLATE and CLASSTYPE_USE_TEMPLATE,
- 1=implicit instantiation
- 2=partial or explicit specialization, e.g.:
- template <> int min<int> (int, int),
- 3=explicit instantiation, e.g.:
- template int min<int> (int, int);
- */
-
- if (code == TYPE_DECL)
- {
- pph_print_depend_type_type (t);
-
- container = DECL_CONTEXT (t);
- if (!is_namespace (container))
- return HIDDEN;
- type = TREE_TYPE (t);
- defined = COMPLETE_TYPE_P (type);
-
- /* FIXME pph: Why DECL_TEMPLATE_TEMPLATE_PARM_P does not apply
- here? It is a template template parameter, but the tree code
- is inconsistent. */
- if (DECL_TEMPLATE_PARM_P (t)
- || TREE_CODE (type) == TEMPLATE_TEMPLATE_PARM
- || TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
- return HIDDEN;
- if (CLASS_TYPE_P (t))
- {
- tmpl_info = CLASSTYPE_TEMPLATE_INFO (type);
- generic = CLASSTYPE_USE_TEMPLATE (type);
- }
- else
- {
- tmpl_info = NULL;
- generic = 0;
- }
- if (generic == 1)
- return HIDDEN;
- if (tmpl_info != NULL)
- {
- pph_print_depend_template (tmpl_info, t);
- needed = defined && generic == 3;
- }
- else
- {
- needed = false;
- }
- }
- else if (code == VAR_DECL)
- {
- tree enclass = DECL_CONTEXT (t);
- bool in_class = enclass && CLASS_TYPE_P (enclass);
- /* If the VAR_DECL is in a class, it must be a static member. */
- container = enclass;
- if (in_class)
- container = TYPE_CONTEXT (enclass);
-
- pph_print_depend_var_type (t);
-
- if (!is_namespace (container))
- return HIDDEN;
- defined = DECL_INITIAL (t) != NULL /* FIXME pph: DECL_INITIALIZED_P (t) */;
- type = TREE_TYPE (t);
- needed = !((!defined && (in_class || DECL_THIS_EXTERN (t)))
- || DECL_INTEGRAL_CONSTANT_VAR_P (t));
- if (in_class)
- {
- tmpl_info = DECL_TEMPLATE_INFO (t);
- generic = DECL_USE_TEMPLATE (t);
- if (generic == 1)
- return HIDDEN;
- }
- else
- {
- tmpl_info = NULL;
- generic = 0;
- }
- if (tmpl_info != NULL)
- {
- pph_print_depend_template (tmpl_info, t);
- needed = needed && generic == 3;
- }
- }
- else if (code == FUNCTION_DECL)
- {
- if (flag_pph_debug >= 2)
- {
- fprintf (pph_logfile, " depending on function ");
- pph_debug_tree (t, false);
- fprintf (pph_logfile, "\n");
- }
-
- container = DECL_CONTEXT (t);
- if (container && CLASS_TYPE_P (container))
- container = TYPE_CONTEXT (DECL_CONTEXT (t));
-
- pph_print_depend_func_type (t);
-
- if (!is_namespace (container))
- return HIDDEN;
- inlined = DECL_DECLARED_INLINE_P (t);
- defined = DECL_INITIAL (t) != NULL;
- tmpl_info = DECL_TEMPLATE_INFO (t);
- generic = DECL_USE_TEMPLATE (t);
- if (tmpl_info != NULL)
- {
- if (generic == 2)
- needed = defined && !inlined;
- else
- {
- pph_print_depend_template (tmpl_info, t);
- needed = defined && !inlined && generic == 3;
- }
- }
- else
- {
- needed = defined && !inlined;
- }
- }
- else
- {
- gcc_assert (code < MAX_TREE_CODES);
- return HIDDEN;
- }
-
- if (needed)
- return NEEDED;
- else
- return EXPOSED;
-}
-
-static void
-pph_print_dependences (bool user_body, bool used_body,
- tree t, VEC(tree,gc) *deps)
-{
- unsigned j;
- tree d;
- for (j = 0; VEC_iterate (tree, deps, j, d); j++)
- pph_print_dependence (user_body, used_body, t, d);
-}
-
-/* Print the head of declaration T and its dependencies. N_HEAD_TOKENS
- is the number of tokens taken by T's head. N_HEAD_ITOKENS is the
- number of invisible tokens.
-
- HEAD_TOKENS is the array of tokens in the head (note that the
- length of this array may be different than N_HEAD_TOKENS, due to
- adjustments made by the caller).
-
- If CONTAINER is set, then T is a member of it. */
-
-static void
-pph_print_declaration_head (tree t, bool artificial, tree container,
- unsigned n_head_tokens, unsigned n_head_invis,
- VEC(cp_token, heap) *head_tokens)
-{
- VEC(tree,gc) *sym_head_deps, *sym_body_deps;
- enum tree_code code = TREE_CODE (t);
-
- fprintf (pph_logfile, "declaration ");
- pph_debug_tree (t, false);
-
- fprintf (pph_logfile, " htok %u,%u", n_head_tokens, n_head_invis);
-
- /*FIXME pph: We want to get rid of most artificial tokens;
- this is temporary to find them. */
- if (artificial)
- fprintf (pph_logfile, " artificial");
-
- if (container)
- {
- fprintf (pph_logfile, " mbrof ");
- pph_debug_tree (get_type_decl (container), true);
- }
-
- fprintf (pph_logfile, "\n");
-
- /* Template instances should depend on their pattern body. */
- if (artificial)
- {
- if (code == TYPE_DECL)
- {
- tree t_type = TREE_TYPE (t);
- if (CLASS_TYPE_P (t_type))
- {
- tree tmpl_info = CLASSTYPE_TEMPLATE_INFO (t_type);
- if (tmpl_info != NULL)
- pph_print_depend_template (tmpl_info, t);
- }
- }
- else if (code == VAR_DECL || code == FUNCTION_DECL)
- {
- tree tmpl_info;
- tmpl_info = (DECL_LANG_SPECIFIC (t)) ? DECL_TEMPLATE_INFO (t) : NULL;
- if (tmpl_info != NULL)
- pph_print_depend_template (tmpl_info, t);
- }
- }
- else
- {
- /* From the name dependencies, determine symbol dependencies
- by correlating the location of the looked-up symbols with
- the tokens in HEAD_TOKENS and BODY_TOKENS. */
- if (flag_pph_debug >= 2)
- fprintf (pph_logfile, " begin normal dependences\n");
- pph_locate_name_lookups_in (head_tokens, &sym_head_deps, &sym_body_deps);
- pph_print_dependences (false, false, t, sym_head_deps);
- pph_print_dependences (true, false, t, sym_body_deps);
- if (flag_pph_debug >= 2)
- fprintf (pph_logfile, " end normal dependences\n");
- }
-}
-
-
-/* Print the head of declaration T and its dependencies. N_BODY_TOKENS
- is the number of tokens taken by T's head. N_BODY_ITOKENS is the
- number of invisible tokens.
-
- BODY_TOKENS is the array of tokens in the head (note that the
- length of this array may be different than N_BODY_TOKENS, due to
- adjustments made by the caller).
-
- EXPOSURE indicates the exposure of T.
-
- N_SUBTOKENS is the number of tokens that declarations inside T's
- body have used up, those should be subtracted from the total number
- of tokens in T to avoid double counting. */
-
-static void
-pph_print_declaration_body (tree t, bool artificial,
- enum decl_exposure exposure,
- unsigned n_body_tokens, unsigned n_body_invis,
- VEC(cp_token, heap) *body_tokens)
-{
- VEC(tree,gc) *sym_head_deps, *sym_body_deps;
- const char* msg;
-
- fprintf (pph_logfile, "declaration ");
- pph_debug_tree (t, true);
-
- fprintf (pph_logfile, " btok %u,%u", n_body_tokens, n_body_invis);
-
- /* FIXME pph: We want to get rid of most artificial tokens;
- this is temporary to find them. */
- if (artificial)
- msg = "artificial";
- else if (exposure == NEEDED)
- msg = "needed";
- else
- msg = "lazy";
- fprintf (pph_logfile, " %s", msg);
-
- fprintf (pph_logfile, "\n");
-
- pph_print_dependence (true, false, t, t); /* body depends on its head */
-
- if (flag_pph_debug >= 2)
- fprintf (pph_logfile, " begin normal dependences\n");
- pph_locate_name_lookups_in (body_tokens, &sym_head_deps, &sym_body_deps);
- pph_print_dependences (true, false, t, sym_head_deps);
- pph_print_dependences (true, false, t, sym_body_deps);
- if (flag_pph_debug >= 2)
- fprintf (pph_logfile, " end normal dependences\n");
-}
-
-
-/* Compute the implicit cost of a method F. */
-
-static unsigned
-pph_find_special_methods (tree f)
-{
- unsigned found = 0;
- tree o;
- if (TREE_CODE (f) == OVERLOAD)
- {
- for (o = f; o; o = OVL_NEXT (o))
- found |= pph_find_special_methods (OVL_CURRENT (o));
- }
- else if (TREE_CODE (f) == TEMPLATE_DECL)
- found |= pph_find_special_methods (DECL_TEMPLATE_RESULT (f));
- else
- {
- gcc_assert (TREE_CODE (f) == FUNCTION_DECL);
- if (DECL_ARTIFICIAL (f))
- return found;
- if (DECL_CONSTRUCTOR_P (f))
- if (DECL_COPY_CONSTRUCTOR_P (f))
- found |= (1<<2); /* copy constructor */
- else
- found |= (1<<1); /* default constructor */
- else if (DECL_DESTRUCTOR_P (f))
- found |= (1<<0); /* destructor */
- else if (DECL_ASSIGNMENT_OPERATOR_P (f))
- found |= (1<<3); /* copy assign op */
- }
- return found;
-}
-
-/* Compute the implicit cost of a class type T_TYPE. */
-
-static unsigned
-pph_implicit_class_cost (tree t_type)
-{
- VEC(tree,gc) *methods;
- unsigned idx;
- unsigned mbrs;
- unsigned cost = 0;
- unsigned found = 0;
-
- /* Gather general statistics. */
- unsigned fields = fields_length (t_type); /* also direct bases */
- unsigned vptr = (TYPE_POLYMORPHIC_P (t_type) ? 1 : 0);
- unsigned slots = fields + vptr;
- unsigned vbases = VEC_length (tree, CLASSTYPE_VBASECLASSES (t_type));
- unsigned vtables = list_length (CLASSTYPE_VTABLES (t_type));
-
- /* Assign cost of implicit special member variables. */
- /* These costs are somewhat arbitrary. */
- cost += 20 * (CLASSTYPE_TYPEINFO_VAR (t_type) != NULL); /* typeinfo */
- cost += 4 * vbases * vtables; /* virtual tables */
-
- /* Assign cost of implicit special member functions. */
- /* First find them. */
- methods = CLASSTYPE_METHOD_VEC (t_type);
- if (methods != NULL)
- for (idx = 0; idx < VEC_length (tree, methods); idx++)
- {
- tree ovld = VEC_index (tree, methods, idx);
- if (ovld)
- found |= pph_find_special_methods (ovld);
- }
- /* These costs are somewhat arbitrary. */
- /* FIXME pph: These queries seem to not work for templates.
- We can accept the inaccuracy for now. */
- mbrs = slots * 2 + vbases * 4;
- if (!(found & (1<<2))) /* copy constructor */
- {
- if (TYPE_HAS_TRIVIAL_COPY_ASSIGN (t_type))
- cost += 4;
- else
- cost += (8 + 2*mbrs) * (vbases > 0 ? 2 : 1);
- }
- if (!(found & (1<<1))) /* default constructor */
- if (!TYPE_HAS_TRIVIAL_DFLT (t_type))
- cost += 4 + mbrs;
- if (!(found & (1<<0))) /* destructor */
- if (!TYPE_HAS_TRIVIAL_DESTRUCTOR (t_type))
- cost += (8 + 2*mbrs) * (vbases > 0 ? 2 : 1);
- if (!(found & (1<<3))) /* copy assign op */
- {
- if (TYPE_HAS_TRIVIAL_COPY_ASSIGN (t_type))
- cost += 4;
- else
- cost += (8 + 2*mbrs);
- }
-
- return cost;
-}
-
-
-/* Print declaration T with the given EXPOSURE. If T has a body with
- N tokens, subtract N_SUBTOKENS from it before printing them.
- This is used when printing class declarations. The caller first
- prints all the declarations inside the class, followed by the
- class declaration itself, to avoid double counting tokens in the class
- body, they are subtracted from the total count.
-
- PRIMARY is true when T is the very first declaration captured
- during a pph_start_exposed/pph_stop_exposed region. If T is a
- member of a class, and it happens to be the first declaration
- captured, it means that T is an out-of-line definition.
-
- If T is a member of a class, and PARENT is the TYPE_DECL for that
- class, it means that we are printing the in-class declaration of T.
- In that case, when we print the parent, we should subtract the
- tokens attributed to T. So, in these cases return the total
- number of tokens printed in T's head and body. Otherwise,
- return 0. */
-
-static unsigned
-pph_print_declaration (tree t, enum decl_exposure exposure,
- unsigned n_subtokens, bool primary, tree parent)
-{
- tree container = NULL;
- enum tree_code code = TREE_CODE (t);
- bool is_member = false;
- bool artificial = PPH_ARTIFICIAL (t);
- bool print_head = true, print_body = true;
-
- /* The cost of a declaration is proportional to the number of tokens.
- Artificial symbols are not represented in the file, so they do
- not have tokens. We represent their cost as a number of
- invisible tokens. */
- VEC(cp_token, heap) *head_tokens = pph_lookup_head_token_cache_for (t);
- unsigned n_head_tokens = VEC_length (cp_token, head_tokens);
- unsigned n_head_invis = 0;
- VEC(cp_token, heap) *body_tokens = pph_lookup_body_token_cache_for (t);
- unsigned n_body_tokens = VEC_length (cp_token, body_tokens);
- unsigned n_body_invis = 0;
- unsigned n_member_tokens = 0;
-
- /* If this is a member of a class, count the number of tokens in the
- member that overlap with the containing class. */
- if (code == FUNCTION_DECL || code == VAR_DECL)
- {
- container = DECL_CONTEXT (t);
- if (container && CLASS_TYPE_P (container))
- {
- is_member = true;
- if (parent && container == TREE_TYPE (parent))
- n_member_tokens = n_head_tokens + n_body_tokens;
- }
- }
-
- /* Now we need to adjust costs, and head/body printing. */
-
- if (code == VAR_DECL)
- {
- if (artificial)
- /* Artificial static member variables get their token
- counts from the calling expression, which isn't helpful.
- Build the cost into the class instead. All of which
- means suppress this decl. */
- return 0;
-
- if (DECL_NONTRIVIALLY_INITIALIZED_P (t)
- && !DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (t))
- n_body_invis += 10;
-
- if (is_member)
- {
- if (primary) /* Must be an out-of-line declaration/definition. */
- {
- /* Merge out-of-line member definitions into the body.
- This merge prevents two heads for the same symbol. */
- n_body_tokens += n_head_tokens;
- n_body_invis += n_head_invis;
- n_head_tokens = 0;
- n_head_invis = 0;
- print_head = false;
- /* Out-of-line member variable declarations are definitions,
- and hence need to be generated. */
- exposure = NEEDED;
- }
- else /* Not primary; must be an in-line declaration/definition. */
- {
- /* The only var bodies in the class are manifest constants;
- merge them into the head. */
- n_head_tokens += n_body_tokens;
- n_head_invis += n_body_invis;
- n_body_tokens = 0;
- n_body_invis = 0;
- print_body = false;
- }
- }
- else /* not is_member */
- {
- if (exposure == EXPOSED)
- {
- /* Merge manifest constants into the head.
- This code sweeps up extern declarations with no bodies,
- but that's okay. */
- n_head_tokens += n_body_tokens;
- n_head_invis += n_body_invis;
- n_body_tokens = 0;
- n_body_invis = 0;
- print_body = false;
- }
- }
- if (exposure == NEEDED)
- n_body_invis += 4; /* For emitting the actual variable declaration. */
- }
- else if (code == FUNCTION_DECL)
- {
- /* Pure function declarations get no body. */
- if (exposure == EXPOSED && !artificial
- && n_body_tokens == 0 && n_body_invis == 0)
- print_body = false;
- if (artificial)
- {
- if (is_member)
- {
- /* Artificial special member functions get their token
- counts from the calling expression, which isn't helpful.
- Build the cost into the class instead. All of which
- means suppress this decl. */
- return 0;
- }
- }
- }
- else if (code == TYPE_DECL)
- {
- tree t_type = TREE_TYPE (t);
-
- if (artificial)
- return 0;
-
- if (DECL_IMPLICIT_TYPEDEF_P (t)
- && CLASS_TYPE_P (t_type)
- && TYPE_LANG_SPECIFIC (t_type))
- {
- tree tmpl_info;
- int generic;
-
- n_body_invis += pph_implicit_class_cost (t_type);
-
- tmpl_info = CLASSTYPE_TEMPLATE_INFO (t_type);
- if (tmpl_info)
- {
- generic = CLASSTYPE_USE_TEMPLATE (t_type);
- if (generic == 1)
- {
- /* Implicit instantiations have no visibile tokens. */
- n_head_invis += n_head_tokens;
- n_head_tokens = 0;
- n_body_invis += n_body_tokens;
- n_body_tokens = 0;
- }
- else if (generic == 3)
- {
- /* Explicit instantiations have no bodies,
- but they are work. This approximation is
- unjustified, but we are presuming that explicit
- instantiations are rare in application code. */
- n_body_invis += 15;
- exposure = NEEDED;
- }
- if (generic != 2)
- {
- bool defined;
- defined = CLASS_TYPE_P (t_type) && COMPLETE_TYPE_P (t_type);
- if (defined)
- pph_print_depend_template (tmpl_info, t);
- }
- }
- else if (primary)
- {
- /* Now subtract the sum of members from the body of the class.
- This prevents double counting when emitting the parent.
- For non-primary class symbols, this value will be zero. */
- gcc_assert (n_body_tokens >= n_subtokens);
- n_body_tokens -= n_subtokens;
- }
- }
- else if (TREE_CODE (t_type) == ENUMERAL_TYPE)
- {
- /* No additional work for enum. */
- }
- else
- {
- /* Not artificial, not a C++ class, not an enum;
- so must be a pure typedef. They have no body. */
- gcc_assert (n_body_tokens == 0 && n_body_invis == 0);
- print_body = false;
- }
- }
-
- if (print_head)
- pph_print_declaration_head (t, artificial, (is_member) ? container : NULL,
- n_head_tokens, n_head_invis, head_tokens);
-
- if (print_body)
- pph_print_declaration_body (t, artificial, exposure,
- n_body_tokens, n_body_invis, body_tokens);
-
- if (flag_pph_debug >= 4)
- {
- fprintf (pph_logfile, " Declarator head tokens: ");
- cp_lexer_debug_tokens ((VEC(cp_token, gc) *)head_tokens);
- fprintf (pph_logfile, " Declarator body tokens: ");
- cp_lexer_debug_tokens ((VEC(cp_token, gc) *)body_tokens);
- fprintf (pph_logfile, "\n");
- }
-
- return n_member_tokens;
-}
-
-static void
-pph_print_declarations (VEC(tree,heap) *v)
-{
- unsigned i, j, n, first_ix;
- tree t, first, parent;
- enum decl_exposure exposure;
- unsigned n_subtokens = 0;
-
- if (VEC_empty (tree, v))
- return;
-
- /* If the first AST in V is a class/structure declaration, process
- the sub-declarations first. This will accumulate the tokens in
- the sub-declarations, so that when we print the class itself
- we don't double count the tokens in its body. */
-
- /* Skip over un-exposed declarations, like template parameters. */
- n = VEC_length (tree, v);
- for ( i = 0; VEC_iterate (tree, v, i, t); i++)
- {
- exposure = pph_get_decl_exposure (t);
- if (exposure >= EXPOSED)
- break;
- }
- if (i >= n)
- return; /* No exposed decls. */
-
- first = VEC_index (tree, v, i);
- if (VEC_length (tree, v) > i+1
- && TREE_CODE (first) == TYPE_DECL
- && CLASS_TYPE_P (TREE_TYPE (first)))
- {
- parent = first;
- first_ix = i+1;
- }
- else
- {
- parent = NULL;
- first_ix = i;
- }
-
- for (j = first_ix; VEC_iterate (tree, v, j, t); j++)
- {
- exposure = pph_get_decl_exposure (t);
- if (exposure >= EXPOSED)
- n_subtokens += pph_print_declaration (t, exposure, 0U, i == j, parent);
- }
-
- /* If we didn't print the first declaration, print it now. */
- if (first_ix > i)
- {
- exposure = pph_get_decl_exposure (first);
- if (exposure >= EXPOSED)
- pph_print_declaration (first, exposure, n_subtokens, true, NULL);
- }
-}
-
-static void
-pph_print_trees_tokens (VEC(tree,heap) *v, cp_token *tok1, cp_token *tok2)
-{
- VEC(cp_token, heap) *vtok;
-
- vtok = pph_print_copy_tokens (tok1, tok2);
- if (vtok == NULL)
- return;
-
- pph_print_token_range (v, vtok);
- pph_print_declarations (v);
- fprintf (pph_logfile, "\n");
-}
-
-
-/* Intercept the result of a name lookup operation requested by the
- parser while we are intercepting AST creation. T is the result
- of a name lookup done by the parser. If this is the first time
- we see it, store it in pph_name_lookups. */
-
-void
-pph_catch_name_lookup (tree t)
-{
- if (t == NULL_TREE || t == error_mark_node || pph_tree_catcher == NULL)
- return;
-
- timevar_push (TV_PPH_MANAGE);
-
- PPH_STATS_INCR (name_lookups, 1);
-
- if (the_parser->lexer)
- {
- /* If we are parsing, we are stopped one token past the identifier
- that we have just looked up. Store the token where we have seen
- this identifier so that we can determine whether the identifier
- was accessed in a head or a body.
-
- Note that we do this for every instance we find for T, so that
- we can store all the locations where T was accessed from. */
- VEC(cp_token, heap) *tokens;
- cp_token *tok;
- void **slot;
-
- slot = pointer_map_insert (pph_nl_token_map, t);
- tokens = (VEC(cp_token, heap) *) *slot;
- tok = the_parser->lexer->next_token - 1;
- VEC_safe_push (cp_token, heap, tokens, tok);
- *slot = tokens;
- }
-
- /* Make sure we do not store the same decl more than once. */
- if (pointer_set_insert (pph_name_lookups_set, t))
- {
- timevar_pop (TV_PPH_MANAGE);
- return;
- }
+GTY(()) cp_parser *the_parser;
- VEC_safe_push (tree, heap, pph_name_lookups, t);
- timevar_pop (TV_PPH_MANAGE);
-}
/* Special handling for the first token or line in the file. The first
thing in the file might be #pragma GCC pch_preprocess, which loads a
@@ -29409,58 +24770,6 @@ pragma_lex (tree *value)
return ret;
}
-
-/* Print statistics for the PPH cache. */
-
-static void
-pph_print_stats (void)
-{
- fprintf (stderr, "\nPPH cache statistics\n");
- fprintf (stderr, "Number of tokens in the lexer: %lu\n",
- pph_stats.lexed_tokens);
- fprintf (stderr, "Number of tokens consumed by the parser: %lu\n",
- pph_stats.parsed_tokens);
- fprintf (stderr, "Number of declarations cached in: %lu\n",
- pph_stats.cached_decls);
- fprintf (stderr, "Number of declarations restored: %lu\n",
- pph_stats.restored_decls);
- fprintf (stderr, "Number of cached decl references: %lu\n",
- pph_stats.cached_refs);
- fprintf (stderr, "Number of name lookups: %lu\n",
- pph_stats.name_lookups);
- fprintf (stderr, "Number of bad lookups: %lu\n",
- pph_stats.bad_lookups);
-}
-
-
-/* Initialize PPH support. */
-
-static void
-pph_init (void)
-{
- if (flag_pph_logfile)
- {
- pph_logfile = fopen (flag_pph_logfile, "w");
- if (!pph_logfile)
- fatal_error ("Cannot create %s for writing: %m", flag_pph_logfile);
- }
- else
- pph_logfile = stdout;
-}
-
-
-/* Finalize PPH support. */
-
-static void
-pph_finish (void)
-{
- if (flag_pph_stats)
- pph_print_stats ();
-
- if (flag_pph_logfile)
- fclose (pph_logfile);
-}
-
/* External interface. */
Index: cp/parser.h
===================================================================
--- cp/parser.h (revision 0)
+++ cp/parser.h (revision 0)
@@ -0,0 +1,375 @@
+/* Data structures and function exported by the C++ Parser.
+ Copyright (C) 2010 Free Software Foundation, Inc.
+
+ This file is part of GCC.
+
+ GCC is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3, or (at your option)
+ any later version.
+
+ GCC is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
+
+#ifndef GCC_CP_PARSER_H
+#define GCC_CP_PARSER_H
+
+#include "tree.h"
+#include "c-family/c-pragma.h"
+
+/* A token type for keywords, as opposed to ordinary identifiers. */
+#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
+
+/* A token type for template-ids. If a template-id is processed while
+ parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
+ the value of the CPP_TEMPLATE_ID is whatever was returned by
+ cp_parser_template_id. */
+#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
+
+/* A token type for nested-name-specifiers. If a
+ nested-name-specifier is processed while parsing tentatively, it is
+ replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
+ CPP_NESTED_NAME_SPECIFIER is whatever was returned by
+ cp_parser_nested_name_specifier_opt. */
+#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
+
+/* The number of token types, including C++-specific ones. */
+#define N_CP_TTYPES ((int) (CPP_NESTED_NAME_SPECIFIER + 1))
+
+/* A token's value and its associated deferred access checks and
+ qualifying scope. */
+
+struct GTY(()) tree_check {
+ /* The value associated with the token. */
+ tree value;
+ /* The checks that have been associated with value. */
+ VEC (deferred_access_check, gc)* checks;
+ /* The token's qualifying scope (used when it is a
+ CPP_NESTED_NAME_SPECIFIER). */
+ tree qualifying_scope;
+};
+
+/* A C++ token. */
+
+typedef struct GTY (()) cp_token {
+ /* The kind of token. */
+ ENUM_BITFIELD (cpp_ttype) type : 8;
+ /* If this token is a keyword, this value indicates which keyword.
+ Otherwise, this value is RID_MAX. */
+ ENUM_BITFIELD (rid) keyword : 8;
+ /* Token flags. */
+ unsigned char flags;
+ /* Identifier for the pragma. */
+ ENUM_BITFIELD (pragma_kind) pragma_kind : 6;
+ /* True if this token is from a context where it is implicitly extern "C" */
+ BOOL_BITFIELD implicit_extern_c : 1;
+ /* True for a CPP_NAME token that is not a keyword (i.e., for which
+ KEYWORD is RID_MAX) iff this name was looked up and found to be
+ ambiguous. An error has already been reported. */
+ BOOL_BITFIELD ambiguous_p : 1;
+ /* True for a token that has been purged. If a token is purged,
+ it is no longer a valid token and it should be considered
+ deleted. */
+ BOOL_BITFIELD purged_p : 1;
+ /* The location at which this token was found. */
+ location_t location;
+ /* The value associated with this token, if any. */
+ union cp_token_value {
+ /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */
+ struct tree_check* GTY((tag ("1"))) tree_check_value;
+ /* Use for all other tokens. */
+ tree GTY((tag ("0"))) value;
+ } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u;
+} cp_token;
+
+DEF_VEC_O (cp_token);
+DEF_VEC_ALLOC_O (cp_token,gc);
+DEF_VEC_ALLOC_O (cp_token,heap);
+
+/* We use a stack of token pointer for saving token sets. */
+typedef struct cp_token *cp_token_position;
+DEF_VEC_P (cp_token_position);
+DEF_VEC_ALLOC_P (cp_token_position,heap);
+
+/* The cp_lexer structure represents the C++ lexer. It is responsible
+ for managing the token stream from the preprocessor and supplying
+ it to the parser. Tokens are never added to the cp_lexer after
+ it is created. */
+
+typedef struct GTY (()) cp_lexer {
+ /* The memory allocated for the buffer. NULL if this lexer does not
+ own the token buffer. */
+ VEC(cp_token,gc) *buffer;
+
+ /* A pointer just past the last available token. The tokens
+ in this lexer are [buffer, last_token). */
+ cp_token_position GTY ((skip)) last_token;
+
+ /* The next available token. If NEXT_TOKEN is &eof_token, then there are
+ no more available tokens. */
+ cp_token_position GTY ((skip)) next_token;
+
+ /* A stack indicating positions at which cp_lexer_save_tokens was
+ called. The top entry is the most recent position at which we
+ began saving tokens. If the stack is non-empty, we are saving
+ tokens. */
+ VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens;
+
+ /* The next lexer in a linked list of lexers. */
+ struct cp_lexer *next;
+
+ /* True if we should output debugging information. */
+ bool debugging_p;
+
+ /* True if we're in the context of parsing a pragma, and should not
+ increment past the end-of-line marker. */
+ bool in_pragma;
+} cp_lexer;
+
+DEF_VEC_O (cp_lexer);
+DEF_VEC_ALLOC_O (cp_lexer,heap);
+
+/* cp_token_cache is a range of tokens. There is no need to represent
+ allocate heap memory for it, since tokens are never removed from the
+ lexer's array. There is also no need for the GC to walk through
+ a cp_token_cache, since everything in here is referenced through
+ a lexer. */
+
+typedef struct GTY(()) cp_token_cache {
+ /* The beginning of the token range. */
+ cp_token * GTY((skip)) first;
+
+ /* Points immediately after the last token in the range. */
+ cp_token * GTY ((skip)) last;
+} cp_token_cache;
+
+typedef cp_token_cache *cp_token_cache_ptr;
+DEF_VEC_P (cp_token_cache_ptr);
+DEF_VEC_ALLOC_P (cp_token_cache_ptr,gc);
+
+struct cp_token_ident_d
+{
+ unsigned int ident_len;
+ const char *ident_str;
+ unsigned int before_len;
+ const char *before_str;
+ unsigned int after_len;
+ const char *after_str;
+};
+
+typedef struct cp_token_ident_d cp_token_ident;
+
+/* An entry in a queue of function arguments that require post-processing. */
+
+typedef struct GTY(()) cp_default_arg_entry_d {
+ /* The current_class_type when we parsed this arg. */
+ tree class_type;
+
+ /* The function decl itself. */
+ tree decl;
+} cp_default_arg_entry;
+
+DEF_VEC_O(cp_default_arg_entry);
+DEF_VEC_ALLOC_O(cp_default_arg_entry,gc);
+
+/* An entry in a stack for member functions of local classes. */
+
+typedef struct GTY(()) cp_unparsed_functions_entry_d {
+ /* Functions with default arguments that require post-processing.
+ Functions appear in this list in declaration order. */
+ VEC(cp_default_arg_entry,gc) *funs_with_default_args;
+
+ /* Functions with defintions that require post-processing. Functions
+ appear in this list in declaration order. */
+ VEC(tree,gc) *funs_with_definitions;
+} cp_unparsed_functions_entry;
+
+DEF_VEC_O(cp_unparsed_functions_entry);
+DEF_VEC_ALLOC_O(cp_unparsed_functions_entry,gc);
+
+/* The status of a tentative parse. */
+
+typedef enum cp_parser_status_kind
+{
+ /* No errors have occurred. */
+ CP_PARSER_STATUS_KIND_NO_ERROR,
+ /* An error has occurred. */
+ CP_PARSER_STATUS_KIND_ERROR,
+ /* We are committed to this tentative parse, whether or not an error
+ has occurred. */
+ CP_PARSER_STATUS_KIND_COMMITTED
+} cp_parser_status_kind;
+
+
+/* Context that is saved and restored when parsing tentatively. */
+typedef struct GTY (()) cp_parser_context {
+ /* If this is a tentative parsing context, the status of the
+ tentative parse. */
+ enum cp_parser_status_kind status;
+ /* If non-NULL, we have just seen a `x->' or `x.' expression. Names
+ that are looked up in this context must be looked up both in the
+ scope given by OBJECT_TYPE (the type of `x' or `*x') and also in
+ the context of the containing expression. */
+ tree object_type;
+
+ /* The next parsing context in the stack. */
+ struct cp_parser_context *next;
+} cp_parser_context;
+
+
+/* The cp_parser structure represents the C++ parser. */
+
+typedef struct GTY(()) cp_parser {
+ /* The lexer from which we are obtaining tokens. */
+ cp_lexer *lexer;
+
+ /* The scope in which names should be looked up. If NULL_TREE, then
+ we look up names in the scope that is currently open in the
+ source program. If non-NULL, this is either a TYPE or
+ NAMESPACE_DECL for the scope in which we should look. It can
+ also be ERROR_MARK, when we've parsed a bogus scope.
+
+ This value is not cleared automatically after a name is looked
+ up, so we must be careful to clear it before starting a new look
+ up sequence. (If it is not cleared, then `X::Y' followed by `Z'
+ will look up `Z' in the scope of `X', rather than the current
+ scope.) Unfortunately, it is difficult to tell when name lookup
+ is complete, because we sometimes peek at a token, look it up,
+ and then decide not to consume it. */
+ tree scope;
+
+ /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the
+ last lookup took place. OBJECT_SCOPE is used if an expression
+ like "x->y" or "x.y" was used; it gives the type of "*x" or "x",
+ respectively. QUALIFYING_SCOPE is used for an expression of the
+ form "X::Y"; it refers to X. */
+ tree object_scope;
+ tree qualifying_scope;
+
+ /* A stack of parsing contexts. All but the bottom entry on the
+ stack will be tentative contexts.
+
+ We parse tentatively in order to determine which construct is in
+ use in some situations. For example, in order to determine
+ whether a statement is an expression-statement or a
+ declaration-statement we parse it tentatively as a
+ declaration-statement. If that fails, we then reparse the same
+ token stream as an expression-statement. */
+ cp_parser_context *context;
+
+ /* True if we are parsing GNU C++. If this flag is not set, then
+ GNU extensions are not recognized. */
+ bool allow_gnu_extensions_p;
+
+ /* TRUE if the `>' token should be interpreted as the greater-than
+ operator. FALSE if it is the end of a template-id or
+ template-parameter-list. In C++0x mode, this flag also applies to
+ `>>' tokens, which are viewed as two consecutive `>' tokens when
+ this flag is FALSE. */
+ bool greater_than_is_operator_p;
+
+ /* TRUE if default arguments are allowed within a parameter list
+ that starts at this point. FALSE if only a gnu extension makes
+ them permissible. */
+ bool default_arg_ok_p;
+
+ /* TRUE if we are parsing an integral constant-expression. See
+ [expr.const] for a precise definition. */
+ bool integral_constant_expression_p;
+
+ /* TRUE if we are parsing an integral constant-expression -- but a
+ non-constant expression should be permitted as well. This flag
+ is used when parsing an array bound so that GNU variable-length
+ arrays are tolerated. */
+ bool allow_non_integral_constant_expression_p;
+
+ /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has
+ been seen that makes the expression non-constant. */
+ bool non_integral_constant_expression_p;
+
+ /* TRUE if local variable names and `this' are forbidden in the
+ current context. */
+ bool local_variables_forbidden_p;
+
+ /* TRUE if the declaration we are parsing is part of a
+ linkage-specification of the form `extern string-literal
+ declaration'. */
+ bool in_unbraced_linkage_specification_p;
+
+ /* TRUE if we are presently parsing a declarator, after the
+ direct-declarator. */
+ bool in_declarator_p;
+
+ /* TRUE if we are presently parsing a template-argument-list. */
+ bool in_template_argument_list_p;
+
+ /* Set to IN_ITERATION_STMT if parsing an iteration-statement,
+ to IN_OMP_BLOCK if parsing OpenMP structured block and
+ IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement,
+ this is bitwise ORed with IN_SWITCH_STMT, unless parsing an
+ iteration-statement, OpenMP block or loop within that switch. */
+#define IN_SWITCH_STMT 1
+#define IN_ITERATION_STMT 2
+#define IN_OMP_BLOCK 4
+#define IN_OMP_FOR 8
+#define IN_IF_STMT 16
+ unsigned char in_statement;
+
+ /* TRUE if we are presently parsing the body of a switch statement.
+ Note that this doesn't quite overlap with in_statement above.
+ The difference relates to giving the right sets of error messages:
+ "case not in switch" vs "break statement used with OpenMP...". */
+ bool in_switch_statement_p;
+
+ /* TRUE if we are parsing a type-id in an expression context. In
+ such a situation, both "type (expr)" and "type (type)" are valid
+ alternatives. */
+ bool in_type_id_in_expr_p;
+
+ /* TRUE if we are currently in a header file where declarations are
+ implicitly extern "C". */
+ bool implicit_extern_c;
+
+ /* TRUE if strings in expressions should be translated to the execution
+ character set. */
+ bool translate_strings_p;
+
+ /* TRUE if we are presently parsing the body of a function, but not
+ a local class. */
+ bool in_function_body;
+
+ /* If non-NULL, then we are parsing a construct where new type
+ definitions are not permitted. The string stored here will be
+ issued as an error message if a type is defined. */
+ const char *type_definition_forbidden_message;
+
+ /* A stack used for member functions of local classes. The lists
+ contained in an individual entry can only be processed once the
+ outermost class being defined is complete. */
+ VEC(cp_unparsed_functions_entry,gc) *unparsed_queues;
+
+ /* The number of classes whose definitions are currently in
+ progress. */
+ unsigned num_classes_being_defined;
+
+ /* The number of template parameter lists that apply directly to the
+ current declaration. */
+ unsigned num_template_parameter_lists;
+} cp_parser;
+
+/* In parser.c */
+extern cp_token eof_token;
+extern GTY(()) cp_parser *the_parser;
+
+extern void cp_lexer_dump_tokens (FILE *, VEC(cp_token,gc) *, unsigned);
+extern void cp_lexer_get_tokens (cp_lexer *);
+extern cp_token_position cp_lexer_token_position (cp_lexer *, bool);
+extern void cp_lexer_debug_tokens (VEC(cp_token,gc) *);
+
+#endif /* GCC_CP_PARSER_H */
Index: cp/config-lang.in
===================================================================
--- cp/config-lang.in (revision 166209)
+++ cp/config-lang.in (working copy)
@@ -30,4 +30,4 @@ compilers="cc1plus\$(exeext)"
target_libs="target-libstdc++-v3"
-gtfiles="\$(srcdir)/cp/rtti.c \$(srcdir)/cp/mangle.c \$(srcdir)/cp/name-lookup.h \$(srcdir)/cp/name-lookup.c \$(srcdir)/cp/cp-tree.h \$(srcdir)/cp/decl.h \$(srcdir)/cp/call.c \$(srcdir)/cp/decl.c \$(srcdir)/cp/decl2.c \$(srcdir)/cp/pt.c \$(srcdir)/cp/repo.c \$(srcdir)/cp/semantics.c \$(srcdir)/cp/tree.c \$(srcdir)/cp/parser.c \$(srcdir)/cp/method.c \$(srcdir)/cp/typeck2.c \$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-lex.c \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.c \$(srcdir)/cp/class.c \$(srcdir)/cp/cp-objcp-common.c \$(srcdir)/cp/cp-lang.c"
+gtfiles="\$(srcdir)/cp/rtti.c \$(srcdir)/cp/mangle.c \$(srcdir)/cp/name-lookup.h \$(srcdir)/cp/name-lookup.c \$(srcdir)/cp/cp-tree.h \$(srcdir)/cp/decl.h \$(srcdir)/cp/call.c \$(srcdir)/cp/decl.c \$(srcdir)/cp/decl2.c \$(srcdir)/cp/pt.c \$(srcdir)/cp/repo.c \$(srcdir)/cp/semantics.c \$(srcdir)/cp/tree.c \$(srcdir)/cp/parser.h \$(srcdir)/cp/parser.c \$(srcdir)/cp/method.c \$(srcdir)/cp/typeck2.c \$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-lex.c \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.c \$(srcdir)/cp/class.c \$(srcdir)/cp/cp-objcp-common.c \$(srcdir)/cp/cp-lang.c \$(srcdir)/cp/pph.h \$(srcdir)/cp/pph.c"
Index: cp/call.c
===================================================================
--- cp/call.c (revision 166209)
+++ cp/call.c (working copy)
@@ -38,6 +38,7 @@ along with GCC; see the file COPYING3.
#include "target.h"
#include "convert.h"
#include "langhooks.h"
+#include "pph.h"
/* The various kinds of conversion. */
Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h (revision 166209)
+++ cp/cp-tree.h (working copy)
@@ -5632,18 +5632,6 @@ extern tree cxx_omp_clause_dtor (tree,
extern void cxx_omp_finish_clause (tree);
extern bool cxx_omp_privatize_by_reference (const_tree);
-/* In parser.c */
-
-#define PPH_POP_TIMEVAR_AND_RETURN(TV, T) \
- do { \
- pph_catch_name_lookup (T); \
- POP_TIMEVAR_AND_RETURN(TV, T); \
- } while (0)
-
-extern void pph_catch_tree (tree);
-extern void pph_uncatch_tree (tree);
-extern void pph_catch_name_lookup (tree);
-
/* -- end of C++ */
#endif /* ! GCC_CP_TREE_H */
Index: cp/name-lookup.c
===================================================================
--- cp/name-lookup.c (revision 166209)
+++ cp/name-lookup.c (working copy)
@@ -33,6 +33,7 @@ along with GCC; see the file COPYING3.
#include "debug.h"
#include "c-family/c-pragma.h"
#include "tree-pretty-print.h"
+#include "pph.h"
/* The bindings for a particular name in a particular scope. */