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

comparison gcc/lto-streamer-in.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Read the GIMPLE representation from a file stream.
-Copyright (C) 2009-2018 Free Software Foundation, Inc.
+Copyright (C) 2009-2020 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 "tree-ssa.h"
 #include "except.h"
 #include "cgraph.h"
 #include "cfgloop.h"
 #include "debug.h"
+#include "alloc-pool.h"
-struct freeing_string_slot_hasher : string_slot_hasher
+/* Allocator used to hold string slot entries for line map streaming.  */
-{
+static struct object_allocator<struct string_slot> *string_slot_allocator;
-static inline void remove (value_type *);
-};
-inline void
-freeing_string_slot_hasher::remove (value_type *v)
-{
-free (v);
-}
 /* The table to hold the file names.  */
-static hash_table<freeing_string_slot_hasher> *file_name_hash_table;
+static hash_table<string_slot_hasher> *file_name_hash_table;
+/* This obstack holds file names used in locators. Line map datastructures
+points here and thus it needs to be kept allocated as long as linemaps
+exists.  */
+static struct obstack file_name_obstack;
 /* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the
 number of valid tag values to check.  */
 /* Read LENGTH bytes from STREAM to ADDR.  */
 void
-lto_input_data_block (struct lto_input_block *ib, void *addr, size_t length)
+lto_input_data_block (class lto_input_block *ib, void *addr, size_t length)
 {
 size_t i;
 unsigned char *const buffer = (unsigned char *) addr;
 for (i = 0; i < length; i++)
 if (*slot == NULL)
 {
 char *saved_string;
 struct string_slot *new_slot;
-saved_string = (char *) xmalloc (len + 1);
+saved_string = XOBNEWVEC (&file_name_obstack, char, len + 1);
-new_slot = XCNEW (struct string_slot);
+new_slot = string_slot_allocator->allocate ();
 memcpy (saved_string, string, len + 1);
 new_slot->s = saved_string;
 new_slot->len = len;
 *slot = new_slot;
 return saved_string;
 or add it to the location cache.
 It is neccesary to call apply_location_cache to get *LOC updated.  */
 void
 lto_location_cache::input_location (location_t *loc, struct bitpack_d *bp,
-				    struct data_in *data_in)
+				    class data_in *data_in)
 {
 static const char *stream_file;
 static int stream_line;
 static int stream_col;
 static bool stream_sysp;
 or add it to the location cache.
 It is neccesary to call apply_location_cache to get *LOC updated.  */
 void
 lto_input_location (location_t *loc, struct bitpack_d *bp,
-		    struct data_in *data_in)
+		    class data_in *data_in)
 {
 data_in->location_cache.input_location (loc, bp, data_in);
 }
 /* Read location and return it instead of going through location caching.
 This should be used only when the resulting location is not going to be
 discarded.  */
 location_t
-stream_input_location_now (struct bitpack_d *bp, struct data_in *data_in)
+stream_input_location_now (struct bitpack_d *bp, class data_in *data_in)
 {
 location_t loc;
 stream_input_location (&loc, bp, data_in);
 data_in->location_cache.apply_location_cache ();
 return loc;
 be looked up in one of the symbol tables, otherwise read the pysical
 representation of the tree using stream_read_tree.  FN is the
 function scope for the read tree.  */
 tree
-lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in,
+lto_input_tree_ref (class lto_input_block *ib, class data_in *data_in,
 		    struct function *fn, enum LTO_tags tag)
 {
 unsigned HOST_WIDE_INT ix_u;
 tree result = NULL_TREE;
 /* Read and return a double-linked list of catch handlers from input
 block IB, using descriptors in DATA_IN.  */
 static struct eh_catch_d *
-lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
+lto_input_eh_catch_list (class lto_input_block *ib, class data_in *data_in,
 			 eh_catch *last_p)
 {
 eh_catch first;
 enum LTO_tags tag;
 /* Read and return EH region IX from input block IB, using descriptors
 in DATA_IN.  */
 static eh_region
-input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
+input_eh_region (class lto_input_block *ib, class data_in *data_in, int ix)
 {
 enum LTO_tags tag;
 eh_region r;
 /* Read the region header.  */
 /* Read and return EH landing pad IX from input block IB, using descriptors
 in DATA_IN.  */
 static eh_landing_pad
-input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
+input_eh_lp (class lto_input_block *ib, class data_in *data_in, int ix)
 {
 enum LTO_tags tag;
 eh_landing_pad lp;
 /* Read the landing pad header.  */
 /* Read the exception table for FN from IB using the data descriptors
 in DATA_IN.  */
 static void
-input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
+input_eh_regions (class lto_input_block *ib, class data_in *data_in,
 		  struct function *fn)
 {
 HOST_WIDE_INT i, root_region, len;
 enum LTO_tags tag;
 tag = streamer_read_record_start (ib);
 if (tag == LTO_null)
 return;
 lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
-/* If the file contains EH regions, then it was compiled with
--fexceptions.  In that case, initialize the backend EH
-machinery.  */
-lto_init_eh ();
 gcc_assert (fn->eh);
 root_region = streamer_read_hwi (ib);
 gcc_assert (root_region == (int) root_region);
 /* Read the CFG for function FN from input block IB.  */
 static void
-input_cfg (struct lto_input_block *ib, struct data_in *data_in,
+input_cfg (class lto_input_block *ib, class data_in *data_in,
 	   struct function *fn)
 {
 unsigned int bb_count;
 basic_block p_bb;
 unsigned int i;
 	{
 	  loops->larray->quick_push (NULL);
 	  continue;
 	}
-struct loop *loop = alloc_loop ();
+class loop *loop = alloc_loop ();
 loop->header = BASIC_BLOCK_FOR_FN (fn, header_index);
 loop->header->loop_father = loop;
 /* Read everything copy_loop_info copies.  */
 loop->estimate_state = streamer_read_enum (ib, loop_estimation, EST_LAST);
 	loop->nb_iterations_estimate = streamer_read_widest_int (ib);
 /* Read OMP SIMD related info.  */
 loop->safelen = streamer_read_hwi (ib);
 loop->unroll = streamer_read_hwi (ib);
+loop->owned_clique = streamer_read_hwi (ib);
 loop->dont_vectorize = streamer_read_hwi (ib);
 loop->force_vectorize = streamer_read_hwi (ib);
 loop->simduid = stream_read_tree (ib, data_in);
 place_new_loop (fn, loop);
 /* Read the SSA names array for function FN from DATA_IN using input
 block IB.  */
 static void
-input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
+input_ssa_names (class lto_input_block *ib, class data_in *data_in,
 		 struct function *fn)
 {
 unsigned int i, size;
 size = streamer_read_uhwi (ib);
 {
 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
 fatal_error (input_location,
 		     "Cgraph edge statement index out of range");
 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
+cedge->lto_stmt_uid = 0;
 if (!cedge->call_stmt)
 fatal_error (input_location,
 		     "Cgraph edge statement index not found");
 }
 for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
 {
 if (STMT_UID_NOT_IN_RANGE (cedge->lto_stmt_uid))
 fatal_error (input_location,
 		     "Cgraph edge statement index out of range");
 cedge->call_stmt = as_a <gcall *> (stmts[cedge->lto_stmt_uid - 1]);
+cedge->lto_stmt_uid = 0;
 if (!cedge->call_stmt)
 fatal_error (input_location, "Cgraph edge statement index not found");
 }
 for (i = 0; node->iterate_reference (i, ref); i++)
 if (ref->lto_stmt_uid)
 {
 	if (STMT_UID_NOT_IN_RANGE (ref->lto_stmt_uid))
 	  fatal_error (input_location,
 		       "Reference statement index out of range");
 	ref->stmt = stmts[ref->lto_stmt_uid - 1];
+	ref->lto_stmt_uid = 0;
 	if (!ref->stmt)
 	  fatal_error (input_location, "Reference statement index not found");
 }
 }
 /* Input the base body of struct function FN from DATA_IN
 using input block IB.  */
 static void
-input_struct_function_base (struct function *fn, struct data_in *data_in,
+input_struct_function_base (struct function *fn, class data_in *data_in,
-struct lto_input_block *ib)
+	                    class lto_input_block *ib)
 {
 struct bitpack_d bp;
 int len;
 /* Read the static chain and non-local goto save area.  */
 fn->stdarg = bp_unpack_value (&bp, 1);
 fn->has_nonlocal_label = bp_unpack_value (&bp, 1);
 fn->has_forced_label_in_static = bp_unpack_value (&bp, 1);
 fn->calls_alloca = bp_unpack_value (&bp, 1);
 fn->calls_setjmp = bp_unpack_value (&bp, 1);
+fn->calls_eh_return = bp_unpack_value (&bp, 1);
 fn->has_force_vectorize_loops = bp_unpack_value (&bp, 1);
 fn->has_simduid_loops = bp_unpack_value (&bp, 1);
 fn->va_list_fpr_size = bp_unpack_value (&bp, 8);
 fn->va_list_gpr_size = bp_unpack_value (&bp, 8);
 fn->last_clique = bp_unpack_value (&bp, sizeof (short) * 8);
 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
 static void
-input_function (tree fn_decl, struct data_in *data_in,
+input_function (tree fn_decl, class data_in *data_in,
-		struct lto_input_block *ib, struct lto_input_block *ib_cfg)
+		class lto_input_block *ib, class lto_input_block *ib_cfg,
+		cgraph_node *node)
 {
 struct function *fn;
 enum LTO_tags tag;
 gimple **stmts;
 basic_block bb;
-struct cgraph_node *node;
 tag = streamer_read_record_start (ib);
 lto_tag_check (tag, LTO_function);
 /* Read decls for parameters and args.  */
 /* We input IL in SSA form.  */
 cfun->gimple_df->in_ssa_p = true;
 gimple_register_cfg_hooks ();
-node = cgraph_node::get (fn_decl);
-if (!node)
-node = cgraph_node::create (fn_decl);
 input_struct_function_base (fn, data_in, ib);
 input_cfg (ib_cfg, data_in, fn);
 /* Read all the SSA names.  */
 input_ssa_names (ib, data_in, fn);
 	    {
 	      if (is_gimple_debug (stmt)
 		  && (gimple_debug_nonbind_marker_p (stmt)
 		      ? !MAY_HAVE_DEBUG_MARKER_STMTS
 		      : !MAY_HAVE_DEBUG_BIND_STMTS))
+		remove = true;
+	      /* In case the linemap overflows locations can be dropped
+		 to zero.  Thus do not keep nonsensical inline entry markers
+		 we'd later ICE on.  */
+	      tree block;
+	      if (gimple_debug_inline_entry_p (stmt)
+		  && (((block = gimple_block (stmt))
+		       && !inlined_function_outer_scope_p (block))
+		      || !debug_inline_points))
 		remove = true;
 	      if (is_gimple_call (stmt)
 		  && gimple_call_internal_p (stmt))
 		{
 		  bool replace = false;
 update_max_bb_count ();
 fixup_call_stmt_edges (node, stmts);
 execute_all_ipa_stmt_fixups (node, stmts);
-update_ssa (TODO_update_ssa_only_virtuals);
 free_dominance_info (CDI_DOMINATORS);
 free_dominance_info (CDI_POST_DOMINATORS);
 free (stmts);
 pop_cfun ();
 }
 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
 static void
-input_constructor (tree var, struct data_in *data_in,
+input_constructor (tree var, class data_in *data_in,
-		   struct lto_input_block *ib)
+		   class lto_input_block *ib)
 {
 DECL_INITIAL (var) = stream_read_tree (ib, data_in);
 }
 static void
 lto_read_body_or_constructor (struct lto_file_decl_data *file_data, struct symtab_node *node,
 			      const char *data, enum lto_section_type section_type)
 {
 const struct lto_function_header *header;
-struct data_in *data_in;
+class data_in *data_in;
 int cfg_offset;
 int main_offset;
 int string_offset;
 tree fn_decl = node->decl;
 			       file_data->mode_table);
 if (TREE_CODE (node->decl) == FUNCTION_DECL)
 	{
 	  lto_input_block ib_cfg (data + cfg_offset, header->cfg_size,
 				  file_data->mode_table);
-	  input_function (fn_decl, data_in, &ib_main, &ib_cfg);
+	  input_function (fn_decl, data_in, &ib_main, &ib_cfg,
+			  dyn_cast <cgraph_node *>(node));
 	}
 else
 input_constructor (fn_decl, data_in, &ib_main);
 data_in->location_cache.apply_location_cache ();
 /* And fixup types we streamed locally.  */
 /* Read the physical representation of a tree node EXPR from
 input block IB using the per-file context in DATA_IN.  */
 static void
-lto_read_tree_1 (struct lto_input_block *ib, struct data_in *data_in, tree expr)
+lto_read_tree_1 (class lto_input_block *ib, class data_in *data_in, tree expr)
 {
 /* Read all the bitfield values in EXPR.  Note that for LTO, we
 only write language-independent bitfields, so no more unpacking is
 needed.  */
 streamer_read_tree_bitfields (ib, data_in, expr);
 /* Read the physical representation of a tree node with tag TAG from
 input block IB using the per-file context in DATA_IN.  */
 static tree
-lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
+lto_read_tree (class lto_input_block *ib, class data_in *data_in,
 	       enum LTO_tags tag, hashval_t hash)
 {
 /* Instantiate a new tree node.  */
 tree result = streamer_alloc_tree (ib, data_in, tag);
 /* Populate the reader cache with trees materialized from the SCC
 following in the IB, DATA_IN stream.  */
 hashval_t
-lto_input_scc (struct lto_input_block *ib, struct data_in *data_in,
+lto_input_scc (class lto_input_block *ib, class data_in *data_in,
 	       unsigned *len, unsigned *entry_len)
 {
 /* A blob of unnamed tree nodes, fill the cache from it and
 recurse.  */
 unsigned size = streamer_read_uhwi (ib);
 /* Read a tree from input block IB using the per-file context in
 DATA_IN.  This context is used, for example, to resolve references
 to previously read nodes.  */
 tree
-lto_input_tree_1 (struct lto_input_block *ib, struct data_in *data_in,
+lto_input_tree_1 (class lto_input_block *ib, class data_in *data_in,
 		  enum LTO_tags tag, hashval_t hash)
 {
 tree result;
 gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
 return result;
 }
 tree
-lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
+lto_input_tree (class lto_input_block *ib, class data_in *data_in)
 {
 enum LTO_tags tag;
 /* Input and skip SCCs.  */
 while ((tag = streamer_read_record_start (ib)) == LTO_tree_scc)
 void
 lto_input_toplevel_asms (struct lto_file_decl_data *file_data, int order_base)
 {
 size_t len;
-const char *data = lto_get_section_data (file_data, LTO_section_asm,
+const char *data
-					   NULL, &len);
+= lto_get_summary_section_data (file_data, LTO_section_asm, &len);
 const struct lto_simple_header_with_strings *header
 = (const struct lto_simple_header_with_strings *) data;
 int string_offset;
-struct data_in *data_in;
+class data_in *data_in;
 tree str;
 if (! data)
 return;
 void
 lto_input_mode_table (struct lto_file_decl_data *file_data)
 {
 size_t len;
-const char *data = lto_get_section_data (file_data, LTO_section_mode_table,
+const char *data
-					   NULL, &len);
+= lto_get_summary_section_data (file_data, LTO_section_mode_table, &len);
 if (! data)
 {
 internal_error ("cannot read LTO mode table from %s",
 		      file_data->file_name);
 return;
 unsigned char *table = ggc_cleared_vec_alloc<unsigned char> (1 << 8);
 file_data->mode_table = table;
 const struct lto_simple_header_with_strings *header
 = (const struct lto_simple_header_with_strings *) data;
 int string_offset;
-struct data_in *data_in;
+class data_in *data_in;
 string_offset = sizeof (*header) + header->main_size;
 lto_input_block ib (data + sizeof (*header), header->main_size, NULL);
 data_in = lto_data_in_create (file_data, data + string_offset,
 				header->string_size, vNULL);
 		  table[m] = BLKmode;
 		  break;
 		}
 	      /* FALLTHRU */
 	    default:
-	      fatal_error (UNKNOWN_LOCATION, "unsupported mode %s\n", mname);
+	      /* This is only used for offloading-target compilations and
+		 is a user-facing error.  Give a better error message for
+		 the common modes; see also mode-classes.def.   */
+	      if (mclass == MODE_FLOAT)
+		fatal_error (UNKNOWN_LOCATION,
+			     "%s - %u-bit-precision floating-point numbers "
+			     "unsupported (mode %qs)", TARGET_MACHINE,
+			     prec.to_constant (), mname);
+	      else if (mclass == MODE_DECIMAL_FLOAT)
+		fatal_error (UNKNOWN_LOCATION,
+			     "%s - %u-bit-precision decimal floating-point "
+			     "numbers unsupported (mode %qs)", TARGET_MACHINE,
+			     prec.to_constant (), mname);
+	      else if (mclass == MODE_COMPLEX_FLOAT)
+		fatal_error (UNKNOWN_LOCATION,
+			     "%s - %u-bit-precision complex floating-point "
+			     "numbers unsupported (mode %qs)", TARGET_MACHINE,
+			     prec.to_constant (), mname);
+	      else if (mclass == MODE_INT)
+		fatal_error (UNKNOWN_LOCATION,
+			     "%s - %u-bit integer numbers unsupported (mode "
+			     "%qs)", TARGET_MACHINE, prec.to_constant (), mname);
+	      else
+		fatal_error (UNKNOWN_LOCATION, "%s - unsupported mode %qs",
+			     TARGET_MACHINE, mname);
 	      break;
 	    }
 	}
 }
 lto_data_in_delete (data_in);
 void
 lto_reader_init (void)
 {
 lto_streamer_init ();
 file_name_hash_table
-= new hash_table<freeing_string_slot_hasher> (37);
+= new hash_table<string_slot_hasher> (37);
+string_slot_allocator = new object_allocator <struct string_slot>
+				("line map file name hash");
+gcc_obstack_init (&file_name_obstack);
+}
+/* Free hash table used to stream in location file names.  */
+void
+lto_free_file_name_hash (void)
+{
+delete file_name_hash_table;
+file_name_hash_table = NULL;
+delete string_slot_allocator;
+string_slot_allocator = NULL;
+/* file_name_obstack must stay allocated since it is referred to by
+line map table.  */
 }
 /* Create a new data_in object for FILE_DATA. STRINGS is the string
 table to use with LEN strings.  RESOLUTIONS is the vector of linker
 resolutions (NULL if not using a linker plugin).  */
-struct data_in *
+class data_in *
 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
 		    unsigned len,
 		    vec<ld_plugin_symbol_resolution_t> resolutions)
 {
-struct data_in *data_in = new (struct data_in);
+class data_in *data_in = new (class data_in);
 data_in->file_data = file_data;
 data_in->strings = strings;
 data_in->strings_len = len;
 data_in->globals_resolution = resolutions;
 data_in->reader_cache = streamer_tree_cache_create (false, false, true);
 /* Remove DATA_IN.  */
 void
-lto_data_in_delete (struct data_in *data_in)
+lto_data_in_delete (class data_in *data_in)
 {
 data_in->globals_resolution.release ();
 streamer_tree_cache_delete (data_in->reader_cache);
 delete data_in;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/lto-streamer-in.c @ 145:1830386684a0