From patchwork Sat Sep 17 22:01:35 2011 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Lawrence Crowl X-Patchwork-Id: 115173 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 23F65B70DC for ; Sun, 18 Sep 2011 08:02:01 +1000 (EST) Received: (qmail 18590 invoked by alias); 17 Sep 2011 22:01:57 -0000 Received: (qmail 18582 invoked by uid 22791); 17 Sep 2011 22:01:55 -0000 X-SWARE-Spam-Status: No, hits=-2.1 required=5.0 tests=AWL, BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, RP_MATCHES_RCVD, SPF_HELO_PASS X-Spam-Check-By: sourceware.org Received: from smtp-out.google.com (HELO smtp-out.google.com) (216.239.44.51) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 17 Sep 2011 22:01:38 +0000 Received: from wpaz24.hot.corp.google.com (wpaz24.hot.corp.google.com [172.24.198.88]) by smtp-out.google.com with ESMTP id p8HM1bst016252; Sat, 17 Sep 2011 15:01:37 -0700 Received: from jade.mtv.corp.google.com (jade.mtv.corp.google.com [172.18.110.116]) by wpaz24.hot.corp.google.com with ESMTP id p8HM1aEe024743; Sat, 17 Sep 2011 15:01:36 -0700 Received: by jade.mtv.corp.google.com (Postfix, from userid 21482) id 0EF6A222661; Sat, 17 Sep 2011 15:01:35 -0700 (PDT) To: reply@codereview.appspotmail.com, dnovillo@google.com, gcc-patches@gcc.gnu.org Subject: [pph] Fix pph_read_tree_header. (issue5050045) Message-Id: <20110917220136.0EF6A222661@jade.mtv.corp.google.com> Date: Sat, 17 Sep 2011 15:01:35 -0700 (PDT) From: crowl@google.com (Lawrence Crowl) X-System-Of-Record: true X-IsSubscribed: yes Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Restructure pph_read_tree_header and pph_read_tree to do what their names say they do. In particular, generic tree handling from pph_read_tree_header to pph_read_tree. Add debugging routines pph_tree_code_text (to avoid out of bounds indexing on a bad tree code) and pph_dump_min_decl (to dump the minimal decl information). Rename the preprocessor lookaside table field pth_debug_level to debug_level (as PTH is gone). Adjust thess debug levels to mean 0 == none, 1 == statistics, 2 == verbose. Adjust the initialization in pph_init to reflect that. Tested on x64. --- This patch is available for review at http://codereview.appspot.com/5050045 Index: gcc/cp/ChangeLog.pph 2011-09-17 Lawrence Crowl * pph.h (pph_tree_code_text): New. (pph_dump_min_decl): New. * pph.c (pph_tree_code_text): New. Update users of tree_code_name to call this function instead, here and in other files. (pph_dump_min_decl): New. (pph_init): Adjust debug value to preprocessor's value. * pph-streamer-in.c (pph_read_tree_header): Move work unrelated to tree headers out of this function. * (pph_read_tree): Move that work here. * pt.c (pph_in_spec_entry_htab): Use pph_logfile instead of stderr. (pph_out_spec_entry_tables): Likewise. (pph_in_spec_entry_tables): Likewise. Index: libcpp/ChangeLog.pph 2011-09-17 Lawrence Crowl * internal.h (struct cpp_lookaside): Rename pth_debug_level to debug_level. * symtab.c (cpp_lt_create): Likewise. (cpp_lt_capture): Likewise. (lt_statistics): Likewise, and change values to 0 == none, 1 == statistics, 2 == verbose. (lt_query_macro): Likewise. Index: gcc/cp/pph.c =================================================================== --- gcc/cp/pph.c (revision 178797) +++ gcc/cp/pph.c (working copy) @@ -42,6 +42,25 @@ along with GCC; see the file COPYING3. -fpph_logfile. If this flag is not given, stdout is used. */ FILE *pph_logfile = NULL; +/* Convert a checked tree_code CODE to a string. */ + +const char* +pph_tree_code_text (enum tree_code code) +{ + gcc_assert (code <= TEMPLATE_INFO); + return tree_code_name[code]; +} + +/* Dump identifying information for a minimal DECL to FILE. */ + +void +pph_dump_min_decl (FILE *file, tree decl) +{ + expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (decl)); + print_generic_expr (file, DECL_NAME (decl), 0); + print_generic_expr (file, DECL_CONTEXT (decl), 0); + fprintf (file, "%s:%d", xloc.file, xloc.line); +} /* Dump a complicated name for tree T to FILE using FLAGS. See TDF_* in tree-pass.h for flags. */ @@ -50,7 +69,7 @@ void pph_dump_tree_name (FILE *file, tree t, int flags) { enum tree_code code = TREE_CODE (t); - fprintf (file, "%s\t", tree_code_name[code]); + fprintf (file, "%s\t", pph_tree_code_text (code)); if (code == FUNCTION_TYPE || code == METHOD_TYPE) { dump_function_to_file (t, file, flags); @@ -182,7 +201,7 @@ pph_init (void) cb->include = pph_include_handler; table = cpp_lt_exchange (parse_in, - cpp_lt_create (cpp_lt_order, flag_pph_debug)); + cpp_lt_create (cpp_lt_order, flag_pph_debug/2)); gcc_assert (table == NULL); /* If we are generating a PPH file, initialize the writer. */ Index: gcc/cp/pph.h =================================================================== --- gcc/cp/pph.h (revision 178797) +++ gcc/cp/pph.h (working copy) @@ -72,6 +72,8 @@ extern FILE *pph_logfile; /* In pph.c */ extern void pph_init (void); extern void pph_finish (void); +extern const char *pph_tree_code_text (enum tree_code code); +extern void pph_dump_min_decl (FILE *file, tree decl); extern void pph_dump_tree_name (FILE *file, tree t, int flags); extern void pph_dump_namespace (FILE *, tree ns); Index: gcc/cp/pph-streamer-in.c =================================================================== --- gcc/cp/pph-streamer-in.c (revision 178797) +++ gcc/cp/pph-streamer-in.c (working copy) @@ -1957,13 +1957,13 @@ pph_read_tree_body (pph_stream *stream, case OPTIMIZATION_NODE: case TARGET_OPTION_NODE: fatal_error ("PPH: unimplemented tree node '%s'", - tree_code_name[TREE_CODE (expr)]); + pph_tree_code_text (TREE_CODE (expr))); break; /* TREES UNRECOGNIZED */ default: fatal_error ("PPH: unrecognized tree node '%s'", - tree_code_name[TREE_CODE (expr)]); + pph_tree_code_text (TREE_CODE (expr))); } } @@ -2007,61 +2007,29 @@ pph_unpack_value_fields (struct bitpack_ /* Read a tree header from STREAM and allocate a memory instance for it. - Store the new tree in *EXPR_P and write it into the pickle cache at - slot IX. - - The return code will indicate whether the caller needs to keep - reading the body for *EXPR_P. Some trees are simple enough that - they are completely contained in the header. In these cases, no - more reading is necessary, so we return true. Otherwise, return - false to indicate that the caller should read the body of the tree. */ + Return the new tree. */ -static bool -pph_read_tree_header (pph_stream *stream, tree *expr_p, unsigned ix) +static tree +pph_read_tree_header (pph_stream *stream, enum LTO_tags tag) { - enum LTO_tags tag; - bool fully_read_p; + /* Find data. */ struct lto_input_block *ib = stream->encoder.r.ib; struct data_in *data_in = stream->encoder.r.data_in; - tag = streamer_read_record_start (ib); - gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS); - - if (tag == LTO_builtin_decl) - { - /* If we are going to read a built-in function, all we need is - the code and class. */ - *expr_p = streamer_get_builtin_tree (ib, data_in); - fully_read_p = true; - } - else if (tag == lto_tree_code_to_tag (INTEGER_CST)) - { - /* For integer constants we only need the type and its hi/low - words. */ - *expr_p = streamer_read_integer_cst (ib, data_in); - fully_read_p = true; - } - else - { struct bitpack_d bp; - /* Otherwise, materialize a new node from IB. This will also read - all the language-independent bitfields for the new tree. */ - *expr_p = streamer_alloc_tree (ib, data_in, tag); + /* Allocate the tree. */ + tree expr = streamer_alloc_tree (ib, data_in, tag); - /* Read the language-independent bitfields for *EXPR_P. */ - bp = streamer_read_tree_bitfields (ib, *expr_p); + /* Read the language-independent bitfields for expr. */ + bp = streamer_read_tree_bitfields (ib, expr); /* Unpack all language-dependent bitfields. */ - pph_unpack_value_fields (&bp, *expr_p); + pph_unpack_value_fields (&bp, expr); - fully_read_p = false; - } - /* Add *EXPR_P to the pickle cache at slot IX. */ - pph_cache_insert_at (&stream->cache, *expr_p, ix); - return fully_read_p; + return expr; } @@ -2069,15 +2037,20 @@ pph_read_tree_header (pph_stream *stream new tree from the PPH stream in DATA_IN. */ tree -pph_read_tree (struct lto_input_block *ib ATTRIBUTE_UNUSED, - struct data_in *data_in) +pph_read_tree (struct lto_input_block *ib_unused ATTRIBUTE_UNUSED, + struct data_in *root_data_in) { - pph_stream *stream = (pph_stream *) data_in->sdata; + /* Find data. */ + pph_stream *stream = (pph_stream *) root_data_in->sdata; + struct lto_input_block *ib = stream->encoder.r.ib; + struct data_in *data_in = stream->encoder.r.data_in; + tree expr; - bool fully_read_p; enum pph_record_marker marker; unsigned image_ix, ix; + enum LTO_tags tag; + /* Read record start and test cache. */ marker = pph_in_start_record (stream, &image_ix, &ix); if (marker == PPH_RECORD_END) return NULL; @@ -2087,10 +2060,30 @@ pph_read_tree (struct lto_input_block *i /* We did not find the tree in the pickle cache, allocate the tree by reading the header fields (different tree nodes need to be allocated in different ways). */ - fully_read_p = pph_read_tree_header (stream, &expr, ix); - if (!fully_read_p) - pph_read_tree_body (stream, expr); - + tag = streamer_read_record_start (ib); + gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS); + if (tag == LTO_builtin_decl) + { + /* If we are going to read a built-in function, all we need is + the code and class. */ + expr = streamer_get_builtin_tree (ib, data_in); + pph_cache_insert_at (&stream->cache, expr, ix); + } + else if (tag == lto_tree_code_to_tag (INTEGER_CST)) + { + /* For integer constants we only need the type and its hi/low + words. */ + expr = streamer_read_integer_cst (ib, data_in); + pph_cache_insert_at (&stream->cache, expr, ix); + } + else + { + /* Otherwise, materialize a new node from IB. This will also read + all the language-independent bitfields for the new tree. */ + expr = pph_read_tree_header (stream, tag); + pph_cache_insert_at (&stream->cache, expr, ix); + pph_read_tree_body (stream, expr); + } return expr; } Index: gcc/cp/pt.c =================================================================== --- gcc/cp/pt.c (revision 178797) +++ gcc/cp/pt.c (working copy) @@ -20304,7 +20304,7 @@ pph_in_spec_entry_htab (pph_stream *stre { unsigned count = pph_in_uint (stream); if (flag_pph_debug >= 2) - fprintf (stderr, "loading %d spec_entries\n", count ); + fprintf (pph_logfile, "PPH: loading %d spec_entries\n", count ); for (; count > 0; --count) { hashval_t hash; @@ -20327,10 +20327,10 @@ pph_out_spec_entry_tables (pph_stream *s { pph_out_spec_entry_htab (stream, &decl_specializations); if (flag_pph_dump_tree) - pph_dump_spec_entry_htab (stderr, "decl", &decl_specializations); + pph_dump_spec_entry_htab (pph_logfile, "decl", &decl_specializations); pph_out_spec_entry_htab (stream, &type_specializations); if (flag_pph_dump_tree) - pph_dump_spec_entry_htab (stderr, "type", &type_specializations); + pph_dump_spec_entry_htab (pph_logfile, "type", &type_specializations); } /* Load and merge all spec_entry tables from STREAM. */ @@ -20340,10 +20340,10 @@ pph_in_spec_entry_tables (pph_stream *st { pph_in_spec_entry_htab (stream, &decl_specializations); if (flag_pph_dump_tree) - pph_dump_spec_entry_htab (stderr, "decl", &decl_specializations); + pph_dump_spec_entry_htab (pph_logfile, "decl", &decl_specializations); pph_in_spec_entry_htab (stream, &type_specializations); if (flag_pph_dump_tree) - pph_dump_spec_entry_htab (stderr, "type", &type_specializations); + pph_dump_spec_entry_htab (pph_logfile, "type", &type_specializations); } Index: gcc/cp/pph-streamer.c =================================================================== --- gcc/cp/pph-streamer.c (revision 178797) +++ gcc/cp/pph-streamer.c (working copy) @@ -236,7 +236,8 @@ pph_trace (pph_stream *stream, const voi const_tree t = (const_tree) data; if (t) { - fprintf (pph_logfile, ", code=%s", tree_code_name[TREE_CODE (t)]); + enum tree_code code = TREE_CODE (t); + fprintf (pph_logfile, ", code=%s", pph_tree_code_text (code)); if (DECL_P (t)) { fprintf (pph_logfile, ", value="); Index: gcc/cp/pph-streamer-out.c =================================================================== --- gcc/cp/pph-streamer-out.c (revision 178797) +++ gcc/cp/pph-streamer-out.c (working copy) @@ -1709,13 +1709,13 @@ pph_write_tree_body (pph_stream *stream, case OPTIMIZATION_NODE: case TARGET_OPTION_NODE: fatal_error ("PPH: unimplemented tree node '%s'", - tree_code_name[TREE_CODE (expr)]); + pph_tree_code_text (TREE_CODE (expr))); break; /* TREES UNRECOGNIZED */ default: fatal_error ("PPH: unrecognized tree node '%s'", - tree_code_name[TREE_CODE (expr)]); + pph_tree_code_text (TREE_CODE (expr))); } } Index: libcpp/symtab.c =================================================================== --- libcpp/symtab.c (revision 178797) +++ libcpp/symtab.c (working copy) @@ -420,7 +420,7 @@ cpp_lt_create (unsigned int order, unsig (void (*) (void *)) free); obstack_alignment_mask (table->strings) = 0; - table->pth_debug_level = debug; + table->debug_level = debug; lt_clear_stats (table); return table; @@ -452,7 +452,7 @@ lt_statistics (struct cpp_lookaside *tab void cpp_lt_destroy (cpp_lookaside *table) { - if (table->pth_debug_level >= 2) + if (table->debug_level >= 1) lt_statistics (table); if (table->strings) { @@ -541,8 +541,8 @@ lt_query_macro (cpp_reader *reader, cpp_ } } - if (reader->lookaside_table->pth_debug_level >= 3) - fprintf (stderr, "PTH: macro %s is %s\n", + if (reader->lookaside_table->debug_level >= 2) + fprintf (stderr, "PPH: macro %s is %s\n", (const char *)cpp_node->ident.str, definition); @@ -626,7 +626,7 @@ cpp_lt_capture (cpp_reader *reader) { /* Allocate a new table. */ reader->lookaside_table = cpp_lt_create (aside->sticky_order, - aside->pth_debug_level); + aside->debug_level); cpp_lt_destroy (aside); /* May also dump statistics. */ } else @@ -634,7 +634,7 @@ cpp_lt_capture (cpp_reader *reader) /* Reuse the old table. */ /* Dump out the statistics. */ - if (aside->pth_debug_level >= 2) + if (aside->debug_level >= 2) { lt_statistics (aside); lt_clear_stats (aside); Index: libcpp/internal.h =================================================================== --- libcpp/internal.h (revision 178797) +++ libcpp/internal.h (working copy) @@ -358,7 +358,7 @@ struct cpp_lookaside { unsigned long long empties; /* Number of table empty/capture. */ /* Table debugging. */ - unsigned int pth_debug_level; + unsigned int debug_level; }; /* Lookup an identifer in the lookaside table,