CbC/CbC_gcc: gcc/lto-streamer-out.c comparison

comparison gcc/lto-streamer-out.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Write the GIMPLE representation to a file stream.
-Copyright (C) 2009-2017 Free Software Foundation, Inc.
+Copyright (C) 2009-2018 Free Software Foundation, Inc.
 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
 Re-implemented by Diego Novillo <dnovillo@google.com>
 This file is part of GCC.
 #include "cgraph.h"
 #include "cfgloop.h"
 #include "builtins.h"
 #include "gomp-constants.h"
 #include "debug.h"
+#include "omp-offload.h"
+#include "print-tree.h"
 static void lto_write_tree (struct output_block*, tree, bool);
 /* Clear the line info stored in DATA_IN.  */
 struct output_block *
 create_output_block (enum lto_section_type section_type)
 {
 struct output_block *ob = XCNEW (struct output_block);
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Creating output block for %s\n",
+	     lto_section_name [section_type]);
 ob->section_type = section_type;
 ob->decl_state = lto_get_out_decl_state ();
 ob->main_stream = XCNEW (struct lto_output_stream);
 ob->string_stream = XCNEW (struct lto_output_stream);
 must go to global stream, because they may be used in the type
 definition.  */
 if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL)
 && DECL_CONTEXT (t))
 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t)), NULL_TREE);
-/* IMPORTED_DECL is put into BLOCK and thus it never can be shared.  */
+/* IMPORTED_DECL is put into BLOCK and thus it never can be shared.
+We should no longer need to stream it.  */
 else if (TREE_CODE (t) == IMPORTED_DECL)
-return false;
+gcc_unreachable ();
+else if (TREE_CODE (t) == LABEL_DECL)
+return FORCED_LABEL (t) || DECL_NONLOCAL (t);
 else if (((VAR_P (t) && !TREE_STATIC (t))
 	    || TREE_CODE (t) == TYPE_DECL
 	    || TREE_CODE (t) == CONST_DECL
 	    || TREE_CODE (t) == NAMELIST_DECL)
 	   && decl_function_context (t))
 #define DFS_follow_tree_edge(DEST) \
 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p)
 enum tree_code code;
+if (streamer_dump_file)
+{
+print_node_brief (streamer_dump_file, "    Streaming ",
+	 		expr, 4);
+fprintf (streamer_dump_file, "  to %s\n",
+	       lto_section_name [ob->section_type]);
+}
 code = TREE_CODE (expr);
 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
 {
 if (TREE_CODE (expr) != IDENTIFIER_NODE)
 	DFS_follow_tree_edge (TREE_TYPE (expr));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
 {
-for (unsigned i = 0; i < VECTOR_CST_NELTS (expr); ++i)
+unsigned int count = vector_cst_encoded_nelts (expr);
-	DFS_follow_tree_edge (VECTOR_CST_ELT (expr, i));
+for (unsigned int i = 0; i < count; ++i)
-}
+	DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr, i));
+}
+if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
+for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
+DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr, i));
 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 {
 DFS_follow_tree_edge (TREE_REALPART (expr));
 DFS_follow_tree_edge (TREE_IMAGPART (expr));
 /* Note, DECL_INITIAL is not handled here.  Since DECL_INITIAL needs
 	 special handling in LTO, it must be handled by streamer hooks.  */
 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr));
-/* Do not follow DECL_ABSTRACT_ORIGIN.  We cannot handle debug information
+/* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
-	 for early inlining so drop it on the floor instead of ICEing in
-	 dwarf2out.c.
-	 We however use DECL_ABSTRACT_ORIGIN == error_mark_node to mark
 	 declarations which should be eliminated by decl merging. Be sure none
 	 leaks to this point.  */
 gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node);
 DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr));
 if ((VAR_P (expr)
 	   || TREE_CODE (expr) == PARM_DECL)
 	  && DECL_HAS_VALUE_EXPR_P (expr))
 	DFS_follow_tree_edge (DECL_VALUE_EXPR (expr));
-if (VAR_P (expr))
+if (VAR_P (expr)
+	  && DECL_HAS_DEBUG_EXPR_P (expr))
 	DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr));
-}
-if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
-{
-if (TREE_CODE (expr) == TYPE_DECL)
-	DFS_follow_tree_edge (DECL_ORIGINAL_TYPE (expr));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 {
 /* Make sure we don't inadvertently set the assembler name.  */
 {
 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr));
 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr));
 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr));
 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr));
-DFS_follow_tree_edge (DECL_FCONTEXT (expr));
+gcc_checking_assert (!DECL_FCONTEXT (expr));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 {
-DFS_follow_tree_edge (DECL_VINDEX (expr));
+gcc_checking_assert (DECL_VINDEX (expr) == NULL);
 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr));
 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr));
 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr));
 }
 	 during fixup.  */
 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr));
 DFS_follow_tree_edge (TYPE_CONTEXT (expr));
 /* TYPE_CANONICAL is re-computed during type merging, so no need
 	 to follow it here.  */
-DFS_follow_tree_edge (TYPE_STUB_DECL (expr));
+/* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently
+	 it can not be freed by free_lang_data without triggering ICEs in
+	 langhooks.  */
 }
 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 {
 if (TREE_CODE (expr) == ENUMERAL_TYPE)
 }
 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
 {
 for (tree t = BLOCK_VARS (expr); t; t = TREE_CHAIN (t))
-	if (VAR_OR_FUNCTION_DECL_P (t)
+	{
-	    && DECL_EXTERNAL (t))
+	  /* We would have to stream externals in the block chain as
-	  /* We have to stream externals in the block chain as
+	     non-references but we should have dropped them in
-	     non-references.  See also
+	     free-lang-data.  */
-	     tree-streamer-out.c:streamer_write_chain.  */
+	  gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t));
-	  DFS_write_tree (ob, expr_state, t, ref_p, false);
-	else
 	  DFS_follow_tree_edge (t);
+	}
 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr));
+DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr));
-/* Follow BLOCK_ABSTRACT_ORIGIN for the limited cases we can
-	 handle - those that represent inlined function scopes.
-	 For the drop rest them on the floor instead of ICEing
-	 in dwarf2out.c, but keep the notion of whether the block
-	 is an inlined block by refering to itself for the sake of
-	 tree_nonartificial_location.  */
-if (inlined_function_outer_scope_p (expr))
-	{
-	  tree ultimate_origin = block_ultimate_origin (expr);
-	  DFS_follow_tree_edge (ultimate_origin);
-	}
-else if (BLOCK_ABSTRACT_ORIGIN (expr))
-	DFS_follow_tree_edge (expr);
 /* Do not follow BLOCK_NONLOCALIZED_VARS.  We cannot handle debug
 	 information for early inlined BLOCKs so drop it on the floor instead
 	 of ICEing in dwarf2out.c.  */
 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO
 	 is needed to build the empty BINFO node on the reader side.  */
 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t)
 	DFS_follow_tree_edge (t);
 DFS_follow_tree_edge (BINFO_OFFSET (expr));
 DFS_follow_tree_edge (BINFO_VTABLE (expr));
-DFS_follow_tree_edge (BINFO_VPTR_FIELD (expr));
+/* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX,
-/* The number of BINFO_BASE_ACCESSES has already been emitted in
+	 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
-	 EXPR's bitfield section.  */
+	 by C++ FE only.  */
-FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (expr), i, t)
-	DFS_follow_tree_edge (t);
-/* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
-	 and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
 }
 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 {
 unsigned i;
 	}
 else if (code == FIELD_DECL)
 	{
 	  hstate.add_flag (DECL_PACKED (t));
 	  hstate.add_flag (DECL_NONADDRESSABLE_P (t));
+	  hstate.add_flag (DECL_PADDING_P (t));
 	  hstate.add_int (DECL_OFFSET_ALIGN (t));
 	}
 else if (code == VAR_DECL)
 	{
 	  hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t));
 if (AGGREGATE_TYPE_P (t))
 	hstate.add_flag (TYPE_TYPELESS_STORAGE (t));
 hstate.commit_flag ();
 hstate.add_int (TYPE_PRECISION (t));
 hstate.add_int (TYPE_ALIGN (t));
+hstate.add_int (TYPE_EMPTY_P (t));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
 hstate.add (TRANSLATION_UNIT_LANGUAGE (t),
 			strlen (TRANSLATION_UNIT_LANGUAGE (t)));
 if (code != IDENTIFIER_NODE)
 	visit (TREE_TYPE (t));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
-for (unsigned i = 0; i < VECTOR_CST_NELTS (t); ++i)
+{
-visit (VECTOR_CST_ELT (t, i));
+unsigned int count = vector_cst_encoded_nelts (t);
+for (unsigned int i = 0; i < count; ++i)
+	visit (VECTOR_CST_ENCODED_ELT (t, i));
+}
+if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST))
+for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
+visit (POLY_INT_CST_COEFF (t, i));
 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
 {
 visit (TREE_REALPART (t));
 visit (TREE_IMAGPART (t));
 	visit (DECL_DEBUG_EXPR (t));
 /* ???  Hash DECL_INITIAL as streamed.  Needs the output-block to
 be able to call get_symbol_initial_value.  */
 }
-if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
-{
-if (code == TYPE_DECL)
-	visit (DECL_ORIGINAL_TYPE (t));
-}
 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
 {
 if (DECL_ASSEMBLER_NAME_SET_P (t))
 	visit (DECL_ASSEMBLER_NAME (t));
 }
 {
 visit (DECL_FIELD_OFFSET (t));
 visit (DECL_BIT_FIELD_TYPE (t));
 visit (DECL_BIT_FIELD_REPRESENTATIVE (t));
 visit (DECL_FIELD_BIT_OFFSET (t));
-visit (DECL_FCONTEXT (t));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
 {
-visit (DECL_VINDEX (t));
 visit (DECL_FUNCTION_PERSONALITY (t));
 visit (DECL_FUNCTION_SPECIFIC_TARGET (t));
 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t));
 }
 visit (TYPE_MAIN_VARIANT (t));
 if (TYPE_FILE_SCOPE_P (t))
 	;
 else
 	visit (TYPE_CONTEXT (t));
-visit (TYPE_STUB_DECL (t));
 }
 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
 {
 if (code == ENUMERAL_TYPE)
 tree b;
 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b)
 	visit (b);
 visit (BINFO_OFFSET (t));
 visit (BINFO_VTABLE (t));
-visit (BINFO_VPTR_FIELD (t));
-FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t), i, b)
-	visit (b);
 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
-	 and BINFO_VPTR_INDEX; these are used by C++ FE only.  */
+	 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used
+	 by C++ FE only.  */
 }
 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
 {
 unsigned i;
 /* Protect against recursion which means disconnect between
 what tree edges we walk in the DFS walk and what edges
 	 we stream out.  */
 gcc_assert (!in_dfs_walk);
+if (streamer_dump_file)
+	{
+	  print_node_brief (streamer_dump_file, "   Streaming SCC of ",
+			    expr, 4);
+fprintf (streamer_dump_file, "\n");
+	}
 /* Start the DFS walk.  */
 /* Save ob state ... */
 /* let's see ... */
 in_dfs_walk = true;
 DFS (ob, expr, ref_p, this_ref_p, false);
 gcc_assert (existed_p);
 streamer_write_record_start (ob, LTO_tree_pickle_reference);
 streamer_write_uhwi (ob, ix);
 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
 			   lto_tree_code_to_tag (TREE_CODE (expr)));
+if (streamer_dump_file)
+	{
+	  print_node_brief (streamer_dump_file, "   Finished SCC of ",
+			    expr, 4);
+fprintf (streamer_dump_file, "\n\n");
+	}
 lto_stats.num_pickle_refs_output++;
 }
 }
 if (loop->any_estimate)
 	streamer_write_widest_int (ob, loop->nb_iterations_estimate);
 /* Write OMP SIMD related info.  */
 streamer_write_hwi (ob, loop->safelen);
+streamer_write_hwi (ob, loop->unroll);
 streamer_write_hwi (ob, loop->dont_vectorize);
 streamer_write_hwi (ob, loop->force_vectorize);
 stream_write_tree (ob, loop->simduid, true);
 }
 /* Output the function start and end loci.  */
 stream_output_location (ob, &bp, fn->function_start_locus);
 stream_output_location (ob, &bp, fn->function_end_locus);
+/* Save the instance discriminator if present.  */
+int *instance_number_p = NULL;
+if (decl_to_instance_map)
+instance_number_p = decl_to_instance_map->get (fn->decl);
+bp_pack_value (&bp, !!instance_number_p, 1);
+if (instance_number_p)
+bp_pack_value (&bp, *instance_number_p, sizeof (int) * CHAR_BIT);
 streamer_write_bitpack (&bp);
 }
 /* Collect all leaf BLOCKs beyond ROOT into LEAFS.  */
 {
 tree function;
 struct function *fn;
 basic_block bb;
 struct output_block *ob;
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "\nStreaming body of %s\n",
+	     node->name ());
 function = node->decl;
 fn = DECL_STRUCT_FUNCTION (function);
 ob = create_output_block (LTO_section_function_body);
 /* We also stream abstract functions where we stream only stuff needed for
 debug info.  */
 if (gimple_has_body_p (function))
 {
+/* Fixup loops if required to match discovery done in the reader.  */
+loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
 streamer_write_uhwi (ob, 1);
 output_struct_function_base (ob, fn);
 /* Output all the SSA names used in the function.  */
 output_ssa_names (ob, fn);
 /* The terminator for this function.  */
 streamer_write_record_start (ob, LTO_null);
 output_cfg (ob, fn);
+loop_optimizer_finalize ();
 pop_cfun ();
 }
 else
 streamer_write_uhwi (ob, 0);
 /* Create a section to hold the pickled output of this function.   */
 produce_asm (ob, function);
 destroy_output_block (ob);
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Finished streaming %s\n",
+	     node->name ());
 }
 /* Output the body of function NODE->DECL.  */
 static void
 output_constructor (struct varpool_node *node)
 {
 tree var = node->decl;
 struct output_block *ob;
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "\nStreaming constructor of %s\n",
+	     node->name ());
 ob = create_output_block (LTO_section_function_body);
 clear_line_info (ob);
 ob->symbol = node;
 /* Create a section to hold the pickled output of this function.   */
 produce_asm (ob, var);
 destroy_output_block (ob);
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Finished streaming %s\n",
+	     node->name ());
 }
 /* Emit toplevel asms.  */
 lto_get_section_name (LTO_section_function_body, name, NULL);
 size_t i, j;
 struct lto_in_decl_state *in_state;
 struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Copying section for %s\n", name);
 lto_begin_section (section_name, false);
 free (section_name);
 /* We may have renamed the declaration, e.g., a static function.  */
 name = lto_get_decl_name_mapping (file_data, name);
 else if (!EXPR_P (t))
 *ws = 0;
 return NULL_TREE;
 }
+/* Remove functions that are no longer used from offload_funcs, and mark the
+remaining ones with DECL_PRESERVE_P.  */
+static void
+prune_offload_funcs (void)
+{
+if (!offload_funcs)
+return;
+unsigned ix, ix2;
+tree *elem_ptr;
+VEC_ORDERED_REMOVE_IF (*offload_funcs, ix, ix2, elem_ptr,
+			 cgraph_node::get (*elem_ptr) == NULL);
+tree fn_decl;
+FOR_EACH_VEC_ELT (*offload_funcs, ix, fn_decl)
+DECL_PRESERVE_P (fn_decl) = 1;
+}
 /* Main entry point from the pass manager.  */
 void
 lto_output (void)
 {
 struct lto_out_decl_state *decl_state;
 bitmap output = NULL;
 int i, n_nodes;
 lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder;
+prune_offload_funcs ();
 if (flag_checking)
 output = lto_bitmap_alloc ();
 /* Initialize the streamer.  */
 		  gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
 		  bitmap_set_bit (output, DECL_UID (node->decl));
 		}
 	      decl_state = lto_new_out_decl_state ();
 	      lto_push_out_decl_state (decl_state);
-	      if (gimple_has_body_p (node->decl) || !flag_wpa
+	      if (gimple_has_body_p (node->decl)
+		  || (!flag_wpa
+		      && flag_incremental_link != INCREMENTAL_LINK_LTO)
 		  /* Thunks have no body but they may be synthetized
 		     at WPA time.  */
 		  || DECL_ARGUMENTS (node->decl))
 		output_function (node);
 	      else
 		  bitmap_set_bit (output, DECL_UID (node->decl));
 		}
 	      decl_state = lto_new_out_decl_state ();
 	      lto_push_out_decl_state (decl_state);
 	      if (DECL_INITIAL (node->decl) != error_mark_node
-		  || !flag_wpa)
+		  || (!flag_wpa
+		      && flag_incremental_link != INCREMENTAL_LINK_LTO))
 		output_constructor (node);
 	      else
 		copy_function_or_variable (node);
 	      gcc_assert (lto_get_out_decl_state () == decl_state);
 	      lto_pop_out_decl_state ();
 const size_t size = lto_tree_ref_encoder_size (encoder);
 for (index = 0; index < size; index++)
 {
 t = lto_tree_ref_encoder_get_tree (encoder, index);
+if (streamer_dump_file)
+	{
+fprintf (streamer_dump_file, " %i:", (int)index);
+	  print_node_brief (streamer_dump_file, "", t, 4);
+fprintf (streamer_dump_file, "\n");
+	}
 if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL))
 	stream_write_tree (ob, t, false);
 }
 }
 unsigned slot_num;
 uint64_t size;
 const char *comdat;
 unsigned char c;
-/* None of the following kinds of symbols are needed in the
+gcc_checking_assert (TREE_PUBLIC (t)
-symbol table.  */
+		       && (TREE_CODE (t) != FUNCTION_DECL
-if (!TREE_PUBLIC (t)
+			   || !fndecl_built_in_p (t))
-|| is_builtin_fn (t)
+		       && !DECL_ABSTRACT_P (t)
-|| DECL_ABSTRACT_P (t)
+		       && (!VAR_P (t) || !DECL_HARD_REGISTER (t)));
-|| (VAR_P (t) && DECL_HARD_REGISTER (t)))
-return;
 gcc_assert (VAR_OR_FUNCTION_DECL_P (t));
 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
 lto_write_data (&c, 1);
 lto_write_data (&size, 8);
 lto_write_data (&slot_num, 4);
 }
-/* Return true if NODE should appear in the plugin symbol table.  */
-bool
-output_symbol_p (symtab_node *node)
-{
-struct cgraph_node *cnode;
-if (!node->real_symbol_p ())
-return false;
-/* We keep external functions in symtab for sake of inlining
-and devirtualization.  We do not want to see them in symbol table as
-references unless they are really used.  */
-cnode = dyn_cast <cgraph_node *> (node);
-if (cnode && (!node->definition || DECL_EXTERNAL (cnode->decl))
-&& cnode->callers)
-return true;
-/* Ignore all references from external vars initializers - they are not really
-part of the compilation unit until they are used by folding.  Some symbols,
-like references to external construction vtables can not be referred to at all.
-We decide this at can_refer_decl_in_current_unit_p.  */
-if (!node->definition || DECL_EXTERNAL (node->decl))
-{
-int i;
-struct ipa_ref *ref;
-for (i = 0; node->iterate_referring (i, ref); i++)
-	{
-	  if (ref->use == IPA_REF_ALIAS)
-	    continue;
-if (is_a <cgraph_node *> (ref->referring))
-	    return true;
-	  if (!DECL_EXTERNAL (ref->referring->decl))
-	    return true;
-	}
-return false;
-}
-return true;
-}
 /* Write an IL symbol table to OB.
 SET and VSET are cgraph/varpool node sets we are outputting.  */
 static void
 produce_symtab (struct output_block *ob)
 for (lsei = lsei_start (encoder);
 !lsei_end_p (lsei); lsei_next (&lsei))
 {
 symtab_node *node = lsei_node (lsei);
-if (!output_symbol_p (node) || DECL_EXTERNAL (node->decl))
+if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
 	continue;
 write_symbol (cache, node->decl, &seen, false);
 }
 for (lsei = lsei_start (encoder);
 !lsei_end_p (lsei); lsei_next (&lsei))
 {
 symtab_node *node = lsei_node (lsei);
-if (!output_symbol_p (node) || !DECL_EXTERNAL (node->decl))
+if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ())
 	continue;
 write_symbol (cache, node->decl, &seen, false);
 }
 lto_end_section ();
 	  machine_mode m = (machine_mode) i;
 	  if ((GET_MODE_INNER (m) == m) ^ (pass == 0))
 	    continue;
 	  bp_pack_value (&bp, m, 8);
 	  bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m));
-	  bp_pack_value (&bp, GET_MODE_SIZE (m), 8);
+	  bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16);
-	  bp_pack_value (&bp, GET_MODE_PRECISION (m), 16);
+	  bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16);
 	  bp_pack_value (&bp, GET_MODE_INNER (m), 8);
-	  bp_pack_value (&bp, GET_MODE_NUNITS (m), 8);
+	  bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16);
 	  switch (GET_MODE_CLASS (m))
 	    {
 	    case MODE_FRACT:
 	    case MODE_UFRACT:
 	    case MODE_ACCUM:
 	delete out_state->streams[i].tree_hash_table;
 	out_state->streams[i].tree_hash_table = NULL;
 }
 /* Write the global symbols.  */
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Outputting global stream\n");
 lto_output_decl_state_streams (ob, out_state);
 num_fns = lto_function_decl_states.length ();
 for (idx = 0; idx < num_fns; idx++)
 {
 fn_out_state =
 	lto_function_decl_states[idx];
+if (streamer_dump_file)
+fprintf (streamer_dump_file, "Outputting stream for %s\n",
+		 IDENTIFIER_POINTER
+		    (DECL_ASSEMBLER_NAME (fn_out_state->fn_decl)));
 lto_output_decl_state_streams (ob, fn_out_state);
 }
 header.major_version = LTO_major_version;
 header.minor_version = LTO_minor_version;

Mercurial > hg > CbC > CbC_gcc

comparison gcc/lto-streamer-out.c @ 131:84e7813d76e9