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

comparison gcc/lto-streamer-in.c @ 63:b7f97abdc517 gcc-4.6-20100522

update gcc from gcc-4.5.0 to gcc-4.6

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Mon, 24 May 2010 12:47:05 +0900
parents	77e2b8dfacca
children	f6334be47118

comparison

equal deleted inserted replaced

-:3c8a44c06a95
+:b7f97abdc517
 /* Read the GIMPLE representation from a file stream.
-Copyright 2009 Free Software Foundation, Inc.
+Copyright 2009, 2010 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.h"
 #include "expr.h"
 #include "flags.h"
 #include "params.h"
 #include "input.h"
-#include "varray.h"
 #include "hashtab.h"
 #include "basic-block.h"
 #include "tree-flow.h"
 #include "tree-pass.h"
 #include "cgraph.h"
 case LTO_const_decl_ref:
 case LTO_imported_decl_ref:
 case LTO_label_decl_ref:
 ix_u = lto_input_uleb128 (ib);
 result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
-if (TREE_CODE (result) == VAR_DECL)
-	varpool_mark_needed_node (varpool_node (result));
 break;
 default:
 gcc_unreachable ();
 }
 TREE_OPERAND (op, 0) = build1 (VIEW_CONVERT_EXPR, wanted_type,
 				   TREE_OPERAND (op, 0));
 }
 /* Fixup reference tree operands for substituted prevailing decls
-with mismatched types in STMT.  */
+with mismatched types in STMT.  This handles plain DECLs where
+we need the stmt for context to lookup the required type.  */
 static void
 maybe_fixup_decls (gimple stmt)
 {
 /* We have to fixup replaced decls here in case there were
 	{
 	  if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
 	    gimple_assign_set_rhs1 (stmt, build1 (VIEW_CONVERT_EXPR,
 						  TREE_TYPE (lhs), rhs));
 	}
-else if (handled_component_p (rhs))
-	maybe_fixup_handled_component (rhs);
 /* Then catch scalar stores.  */
 else if (TREE_CODE (lhs) == VAR_DECL)
 	{
 	  if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (rhs)))
 	    gimple_assign_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
 						 TREE_TYPE (rhs), lhs));
 	}
-else if (handled_component_p (lhs))
-	maybe_fixup_handled_component (lhs);
 }
 else if (is_gimple_call (stmt))
 {
 tree lhs = gimple_call_lhs (stmt);
 					  gimple_call_return_type (stmt)))
 	    gimple_call_set_lhs (stmt, build1 (VIEW_CONVERT_EXPR,
 					       gimple_call_return_type (stmt),
 					       lhs));
 	}
-else if (lhs && handled_component_p (lhs))
-	maybe_fixup_handled_component (lhs);
 /* Arguments, especially for varargs functions will be funny...  */
 }
 }
 	/* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
 	tree str;
 	stmt->gimple_asm.ni = lto_input_uleb128 (ib);
 	stmt->gimple_asm.no = lto_input_uleb128 (ib);
 	stmt->gimple_asm.nc = lto_input_uleb128 (ib);
+	stmt->gimple_asm.nl = lto_input_uleb128 (ib);
 	str = input_string_cst (data_in, ib);
 	stmt->gimple_asm.string = TREE_STRING_POINTER (str);
 }
 /* Fallthru  */
 case GIMPLE_DEBUG:
 for (i = 0; i < num_ops; i++)
 	{
 	  tree op = lto_input_tree (ib, data_in);
 	  gimple_set_op (stmt, i, op);
+	  if (!op)
-	  /* Fixup FIELD_DECLs.  */
+	    continue;
-	  while (op && handled_component_p (op))
+	  /* Fixup reference tree operands for substituted prevailing decls
+	     with mismatched types.  For plain VAR_DECLs we need to look
+	     at context to determine the wanted type - we do that below
+	     after the stmt is completed.  */
+	  if (TREE_CODE (op) == ADDR_EXPR
+	      && TREE_CODE (TREE_OPERAND (op, 0)) == VAR_DECL
+	      && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (op)),
+					     TREE_TYPE (op)))
+	    {
+	      TREE_OPERAND (op, 0)
+		= build1 (VIEW_CONVERT_EXPR, TREE_TYPE (TREE_TYPE (op)),
+			  TREE_OPERAND (op, 0));
+	      continue;
+	    }
+	  /* Fixup FIELD_DECLs in COMPONENT_REFs, they are not handled
+	     by decl merging.  */
+	  if (TREE_CODE (op) == ADDR_EXPR)
+	    op = TREE_OPERAND (op, 0);
+	  while (handled_component_p (op))
 	    {
 	      if (TREE_CODE (op) == COMPONENT_REF)
 		{
 		  tree field, type, tem;
 		  field = TREE_OPERAND (op, 1);
 		  type = DECL_CONTEXT (field);
 		  for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
 		    {
 		      if (tem == field
 			  || (TREE_TYPE (tem) == TREE_TYPE (field)
-			      && compare_field_offset (tem, field)))
+			      && DECL_NONADDRESSABLE_P (tem)
+				 == DECL_NONADDRESSABLE_P (field)
+			      && gimple_compare_field_offset (tem, field)))
 			break;
 		    }
 		  /* In case of type mismatches across units we can fail
 		     to unify some types and thus not find a proper
 		     field-decl here.  So only assert here if checking
 #endif
 		  if (tem != NULL_TREE)
 		    TREE_OPERAND (op, 1) = tem;
 		}
+	      /* Preserve the last handled component for the fixup of
+	         its operand below.  */
+	      if (!handled_component_p (TREE_OPERAND (op, 0)))
+		break;
 	      op = TREE_OPERAND (op, 0);
 	    }
+	  /* Fixup reference tree operands for substituted prevailing decls
+	     with mismatched types.  */
+	  if (handled_component_p (op))
+	    maybe_fixup_handled_component (op);
 	}
 break;
 case GIMPLE_NOP:
 case GIMPLE_PREDICT:
 	  if (TREE_CODE (op) == SSA_NAME)
 	    SSA_NAME_DEF_STMT (op) = stmt;
 	}
 }
+/* Reset alias information.  */
+if (code == GIMPLE_CALL)
+gimple_call_reset_alias_info (stmt);
 /* Fixup reference tree operands for substituted prevailing decls
 with mismatched types.  */
 maybe_fixup_decls (stmt);
 /* Mark the statement modified so its operand vectors can be filled in.  */
 static void
 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
 {
 struct cgraph_edge *cedge;
 for (cedge = node->callees; cedge; cedge = cedge->next_callee)
+cedge->call_stmt = stmts[cedge->lto_stmt_uid];
+for (cedge = node->indirect_calls; cedge; cedge = cedge->next_callee)
 cedge->call_stmt = stmts[cedge->lto_stmt_uid];
 }
 /* Fixup call_stmt pointers in NODE and all clones.  */
 fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
 fn->stdarg = bp_unpack_value (bp, 1);
 fn->has_nonlocal_label = bp_unpack_value (bp, 1);
 fn->calls_alloca = bp_unpack_value (bp, 1);
 fn->calls_setjmp = bp_unpack_value (bp, 1);
-fn->function_frequency = (enum function_frequency) bp_unpack_value (bp, 2);
 fn->va_list_fpr_size = bp_unpack_value (bp, 8);
 fn->va_list_gpr_size = bp_unpack_value (bp, 8);
 bitpack_delete (bp);
+/* Input the current IL state of the function.  */
+fn->curr_properties = lto_input_uleb128 (ib);
 /* Read the static chain and non-local goto save area.  */
 fn->static_chain_decl = lto_input_tree (ib, data_in);
 fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
 input_function (fn_decl, data_in, &ib_main);
 /* We should now be in SSA.  */
 cfun->gimple_df->in_ssa_p = true;
-/* Fill in properties we know hold for the rebuilt CFG.  */
-cfun->curr_properties = PROP_ssa
-			      | PROP_cfg
-			      | PROP_gimple_any
-			      | PROP_gimple_lcf
-			      | PROP_gimple_leh
-			      | PROP_referenced_vars;
 /* Restore decl state */
 file_data->current_decl_state = file_data->global_decl_state;
 pop_cfun ();
 }
 get_resolution (struct data_in *data_in, unsigned index)
 {
 if (data_in->globals_resolution)
 {
 ld_plugin_symbol_resolution_t ret;
-gcc_assert (index < VEC_length (ld_plugin_symbol_resolution_t,
+/* We can have references to not emitted functions in
-				      data_in->globals_resolution));
+	 DECL_FUNCTION_PERSONALITY at least.  So we can and have
+	 to indeed return LDPR_UNKNOWN in some cases.   */
+if (VEC_length (ld_plugin_symbol_resolution_t,
+		      data_in->globals_resolution) <= index)
+	return LDPR_UNKNOWN;
 ret = VEC_index (ld_plugin_symbol_resolution_t,
 		       data_in->globals_resolution,
 		       index);
-gcc_assert (ret != LDPR_UNKNOWN);
 return ret;
 }
 else
 /* Delay resolution finding until decl merging.  */
 return LDPR_UNKNOWN;
 if (TREE_CODE (expr) == VAR_DECL)
 {
 DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
 DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
+DECL_IN_CONSTANT_POOL (expr) = (unsigned) bp_unpack_value (bp, 1);
 DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
 }
 if (VAR_OR_FUNCTION_DECL_P (expr))
 {
 TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 9);
 mode = (enum machine_mode) bp_unpack_value (bp, 7);
 SET_TYPE_MODE (expr, mode);
 TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
 TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
-TYPE_NEEDS_CONSTRUCTING(expr) = (unsigned) bp_unpack_value (bp, 1);
+TYPE_NEEDS_CONSTRUCTING (expr) = (unsigned) bp_unpack_value (bp, 1);
-if (TREE_CODE (expr) == UNION_TYPE)
+if (RECORD_OR_UNION_TYPE_P (expr))
-TYPE_TRANSPARENT_UNION (expr) = (unsigned) bp_unpack_value (bp, 1);
+TYPE_TRANSPARENT_AGGR (expr) = (unsigned) bp_unpack_value (bp, 1);
 TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
 TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
 TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
 	= (unsigned) bp_unpack_value (bp, 2);
 TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
 {
 if (TREE_CODE (expr) == ENUMERAL_TYPE)
 TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
 else if (TREE_CODE (expr) == ARRAY_TYPE)
 TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
-else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
+else if (RECORD_OR_UNION_TYPE_P (expr))
 TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
-else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
+else if (TREE_CODE (expr) == FUNCTION_TYPE
+	   || TREE_CODE (expr) == METHOD_TYPE)
 TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
 else if (TREE_CODE (expr) == VECTOR_TYPE)
 TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
 TYPE_SIZE (expr) = lto_input_tree (ib, data_in);

Mercurial > hg > CbC > CbC_gcc

comparison gcc/lto-streamer-in.c @ 63:b7f97abdc517 gcc-4.6-20100522