[3/3] Remove known_type jump functions, type_preserved flags and more from ipa-prop

Hi,

this patch removes now completely unnecessary KNOWN_TYPE jump
functions, type_preserved fields from PASS_THROUGH and ANCESTOR jump
functions and type field from ANCESTOR jump functions because the
previous patch makes them unused.

This means most of dynamic type change detection is removed.  The only
one that is kept is the one ipa_analyze_virtual_call_uses where
indirect_infos are populated.  The main reason is that so far I have
not verified I can remove it there too but if so I'd prefer to do that
in a separate patch anyway.

The patch performs 30 insertions, 410 deletions and simplifies things
quite a bit so I'd like to see it committed along with the previous
two.  A very similar patch has passed bootstrap and testing on
x86_64-linux, testing of exactly this one is also underway.  I also
pan more tests on i686-linux and ppc64-aix.  OK for trunk if all goes
well?

Thanks,

Martin


2014-11-14  Martin Jambor  <mjambor@suse.cz>

	* ipa-prop.h (jump_func_type): Removed value IPA_JF_KNOWN_TYPE.
	(ipa_pass_through_data): Removed field type_preserved.
	(ipa_ancestor_jf_data): removed fields type and type_preserved.
	(ipa_jump_func): Removed field known_type.
	(ipa_get_jf_known_type_offset): Removed.
	(ipa_get_jf_known_type_base_type): Likewise.
	(ipa_get_jf_known_type_component_type): Likewise.
	(ipa_get_jf_ancestor_type): Likewise.
	* ipa-cp.c (print_ipcp_constant_value): Removed BINFO handling.
	(ipa_get_jf_pass_through_result): Likewise.
	(ipa_get_jf_ancestor_result): Always build ptr_node_type accesses.
	(values_equal_for_ipcp_p): Removed BINFO handling.
	(ipa_get_indirect_edge_target_1): Updated comment.
	* ipa-prop.c (ipa_print_node_jump_functions_for_edge): Removed handling
	of IPA_JF_KNOWN_TYPE jump functions.  Do not print removed fields.
	(ipa_set_jf_known_type): Removed.
	(ipa_set_jf_simple_pass_through): Do not set removed fields.  Update
	all callers.
	(ipa_set_jf_arith_pass_through): Likewise.
	(ipa_set_ancestor_jf): Likewise.
	(ipa_binfo_from_known_type_jfunc): Removed.
	(prop_type_change_info): Removed fields known_current_type and
	multiple_types_encountered.
	(extr_type_from_vtbl_ptr_store): Removed.
	(check_stmt_for_type_change): Do not attempt to identify changed type.
	(detect_type_change_from_memory_writes): Do not set the removed fields,
	always set jfunc to unknown.
	(compute_complex_assign_jump_func): Do not detect dynamic type change.
	(compute_complex_ancestor_jump_func): Likewise.
	(compute_known_type_jump_func): Removed.
	(ipa_compute_jump_functions_for_edge): Do not detect dynamic type
	change.  Do not comute known type jump functions.
	(combine_known_type_and_ancestor_jfs): Removed.
	(update_jump_functions_after_inlining): Removed handling of
	IPA_JF_KNOWN_TYPE jump functions.  Do not set removed fields.
	(ipa_write_jump_function): Do not stream removed fields or known type
	jump functions.
	(ipa_read_jump_function): Likewise.

> Hi,
> 
> this patch removes now completely unnecessary KNOWN_TYPE jump
> functions, type_preserved fields from PASS_THROUGH and ANCESTOR jump
> functions and type field from ANCESTOR jump functions because the
> previous patch makes them unused.
> 
> This means most of dynamic type change detection is removed.  The only
> one that is kept is the one ipa_analyze_virtual_call_uses where
> indirect_infos are populated.  The main reason is that so far I have
> not verified I can remove it there too but if so I'd prefer to do that
> in a separate patch anyway.
> 
> The patch performs 30 insertions, 410 deletions and simplifies things
> quite a bit so I'd like to see it committed along with the previous
> two.  A very similar patch has passed bootstrap and testing on
> x86_64-linux, testing of exactly this one is also underway.  I also
> pan more tests on i686-linux and ppc64-aix.  OK for trunk if all goes
> well?
> 
> Thanks,
> 
> Martin
> 
> 
> 2014-11-14  Martin Jambor  <mjambor@suse.cz>
> 
> 	* ipa-prop.h (jump_func_type): Removed value IPA_JF_KNOWN_TYPE.
> 	(ipa_pass_through_data): Removed field type_preserved.
> 	(ipa_ancestor_jf_data): removed fields type and type_preserved.
> 	(ipa_jump_func): Removed field known_type.
> 	(ipa_get_jf_known_type_offset): Removed.
> 	(ipa_get_jf_known_type_base_type): Likewise.
> 	(ipa_get_jf_known_type_component_type): Likewise.
> 	(ipa_get_jf_ancestor_type): Likewise.
> 	* ipa-cp.c (print_ipcp_constant_value): Removed BINFO handling.
> 	(ipa_get_jf_pass_through_result): Likewise.
> 	(ipa_get_jf_ancestor_result): Always build ptr_node_type accesses.
> 	(values_equal_for_ipcp_p): Removed BINFO handling.
> 	(ipa_get_indirect_edge_target_1): Updated comment.
> 	* ipa-prop.c (ipa_print_node_jump_functions_for_edge): Removed handling
> 	of IPA_JF_KNOWN_TYPE jump functions.  Do not print removed fields.
> 	(ipa_set_jf_known_type): Removed.
> 	(ipa_set_jf_simple_pass_through): Do not set removed fields.  Update
> 	all callers.
> 	(ipa_set_jf_arith_pass_through): Likewise.
> 	(ipa_set_ancestor_jf): Likewise.
> 	(ipa_binfo_from_known_type_jfunc): Removed.
> 	(prop_type_change_info): Removed fields known_current_type and
> 	multiple_types_encountered.
> 	(extr_type_from_vtbl_ptr_store): Removed.
> 	(check_stmt_for_type_change): Do not attempt to identify changed type.
> 	(detect_type_change_from_memory_writes): Do not set the removed fields,
> 	always set jfunc to unknown.
> 	(compute_complex_assign_jump_func): Do not detect dynamic type change.
> 	(compute_complex_ancestor_jump_func): Likewise.
> 	(compute_known_type_jump_func): Removed.
> 	(ipa_compute_jump_functions_for_edge): Do not detect dynamic type
> 	change.  Do not comute known type jump functions.
> 	(combine_known_type_and_ancestor_jfs): Removed.
> 	(update_jump_functions_after_inlining): Removed handling of
> 	IPA_JF_KNOWN_TYPE jump functions.  Do not set removed fields.
> 	(ipa_write_jump_function): Do not stream removed fields or known type
> 	jump functions.
> 	(ipa_read_jump_function): Likewise.

OK,
the type preserved tracking will need to go back otherwise we get missed
optimization (using agg preserved is very conservative estimate), but the
implementation needs to be different anyway. I will try to do that soon.

Honza
> 
> Index: src/gcc/ipa-cp.c
> ===================================================================
> --- src.orig/gcc/ipa-cp.c	2014-11-14 01:59:11.135700073 +0100
> +++ src/gcc/ipa-cp.c	2014-11-14 01:59:11.131700073 +0100
> @@ -340,12 +340,7 @@ ipcp_lattice<valtype>::is_single_const (
>  static void
>  print_ipcp_constant_value (FILE * f, tree v)
>  {
> -  if (TREE_CODE (v) == TREE_BINFO)
> -    {
> -      fprintf (f, "BINFO ");
> -      print_generic_expr (f, BINFO_TYPE (v), 0);
> -    }
> -  else if (TREE_CODE (v) == ADDR_EXPR
> +  if (TREE_CODE (v) == ADDR_EXPR
>  	   && TREE_CODE (TREE_OPERAND (v, 0)) == CONST_DECL)
>      {
>        fprintf (f, "& ");
> @@ -842,21 +837,10 @@ ipa_get_jf_pass_through_result (struct i
>  {
>    tree restype, res;
>  
> -  if (TREE_CODE (input) == TREE_BINFO)
> -    {
> -      if (ipa_get_jf_pass_through_type_preserved (jfunc))
> -	{
> -	  gcc_checking_assert (ipa_get_jf_pass_through_operation (jfunc)
> -			       == NOP_EXPR);
> -	  return input;
> -	}
> -      return NULL_TREE;
> -    }
> -
> +  gcc_checking_assert (is_gimple_ip_invariant (input));
>    if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
>      return input;
>  
> -  gcc_checking_assert (is_gimple_ip_invariant (input));
>    if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
>        == tcc_comparison)
>      restype = boolean_type_node;
> @@ -883,9 +867,7 @@ ipa_get_jf_ancestor_result (struct ipa_j
>        tree t = TREE_OPERAND (input, 0);
>        t = build_ref_for_offset (EXPR_LOCATION (t), t,
>  				ipa_get_jf_ancestor_offset (jfunc),
> -				ipa_get_jf_ancestor_type (jfunc)
> -				? ipa_get_jf_ancestor_type (jfunc)
> -				: ptr_type_node, NULL, false);
> +				ptr_type_node, NULL, false);
>        return build_fold_addr_expr (t);
>      }
>    else
> @@ -1051,9 +1033,6 @@ values_equal_for_ipcp_p (tree x, tree y)
>    if (x == y)
>      return true;
>  
> -  if (TREE_CODE (x) == TREE_BINFO || TREE_CODE (y) == TREE_BINFO)
> -    return false;
> -
>    if (TREE_CODE (x) ==  ADDR_EXPR
>        && TREE_CODE (y) ==  ADDR_EXPR
>        && TREE_CODE (TREE_OPERAND (x, 0)) == CONST_DECL
> @@ -1740,9 +1719,8 @@ propagate_constants_accross_call (struct
>  }
>  
>  /* If an indirect edge IE can be turned into a direct one based on KNOWN_VALS
> -   (which can contain both constants and binfos), KNOWN_CONTEXTS, KNOWN_AGGS or
> -   AGG_REPS return the destination.  The latter three can be NULL.  If AGG_REPS
> -   is not NULL, KNOWN_AGGS is ignored.  */
> +   KNOWN_CONTEXTS, KNOWN_AGGS or AGG_REPS return the destination.  The latter
> +   three can be NULL.  If AGG_REPS is not NULL, KNOWN_AGGS is ignored.  */
>  
>  static tree
>  ipa_get_indirect_edge_target_1 (struct cgraph_edge *ie,
> Index: src/gcc/ipa-prop.c
> ===================================================================
> --- src.orig/gcc/ipa-prop.c	2014-11-14 01:59:11.135700073 +0100
> +++ src/gcc/ipa-prop.c	2014-11-14 01:59:33.771700936 +0100
> @@ -303,15 +303,6 @@ ipa_print_node_jump_functions_for_edge (
>        fprintf (f, "       param %d: ", i);
>        if (type == IPA_JF_UNKNOWN)
>  	fprintf (f, "UNKNOWN\n");
> -      else if (type == IPA_JF_KNOWN_TYPE)
> -	{
> -	  fprintf (f, "KNOWN TYPE: base  ");
> -	  print_generic_expr (f, jump_func->value.known_type.base_type, 0);
> -	  fprintf (f, ", offset "HOST_WIDE_INT_PRINT_DEC", component ",
> -		   jump_func->value.known_type.offset);
> -	  print_generic_expr (f, jump_func->value.known_type.component_type, 0);
> -	  fprintf (f, "\n");
> -	}
>        else if (type == IPA_JF_CONST)
>  	{
>  	  tree val = jump_func->value.constant.value;
> @@ -340,21 +331,16 @@ ipa_print_node_jump_functions_for_edge (
>  	    }
>  	  if (jump_func->value.pass_through.agg_preserved)
>  	    fprintf (f, ", agg_preserved");
> -	  if (jump_func->value.pass_through.type_preserved)
> -	    fprintf (f, ", type_preserved");
>  	  fprintf (f, "\n");
>  	}
>        else if (type == IPA_JF_ANCESTOR)
>  	{
>  	  fprintf (f, "ANCESTOR: ");
> -	  fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC", ",
> +	  fprintf (f, "%d, offset "HOST_WIDE_INT_PRINT_DEC,
>  		   jump_func->value.ancestor.formal_id,
>  		   jump_func->value.ancestor.offset);
> -	  print_generic_expr (f, jump_func->value.ancestor.type, 0);
>  	  if (jump_func->value.ancestor.agg_preserved)
>  	    fprintf (f, ", agg_preserved");
> -	  if (jump_func->value.ancestor.type_preserved)
> -	    fprintf (f, ", type_preserved");
>  	  fprintf (f, "\n");
>  	}
>  
> @@ -460,28 +446,6 @@ ipa_print_all_jump_functions (FILE *f)
>      }
>  }
>  
> -/* Set JFUNC to be a known type jump function.  */
> -
> -static void
> -ipa_set_jf_known_type (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
> -		       tree base_type, tree component_type)
> -{
> -  /* Recording and propagating main variants increases change that types
> -     will match.  */
> -  base_type = TYPE_MAIN_VARIANT (base_type);
> -  component_type = TYPE_MAIN_VARIANT (component_type);
> -
> -  gcc_assert (contains_polymorphic_type_p (base_type)
> -	      && contains_polymorphic_type_p (component_type));
> -  if (!flag_devirtualize)
> -    return;
> -  jfunc->type = IPA_JF_KNOWN_TYPE;
> -  jfunc->value.known_type.offset = offset,
> -  jfunc->value.known_type.base_type = base_type;
> -  jfunc->value.known_type.component_type = component_type;
> -  gcc_assert (component_type);
> -}
> -
>  /* Set JFUNC to be a copy of another jmp (to be used by jump function
>     combination code).  The two functions will share their rdesc.  */
>  
> @@ -528,14 +492,13 @@ ipa_set_jf_constant (struct ipa_jump_fun
>  /* Set JFUNC to be a simple pass-through jump function.  */
>  static void
>  ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
> -				bool agg_preserved, bool type_preserved)
> +				bool agg_preserved)
>  {
>    jfunc->type = IPA_JF_PASS_THROUGH;
>    jfunc->value.pass_through.operand = NULL_TREE;
>    jfunc->value.pass_through.formal_id = formal_id;
>    jfunc->value.pass_through.operation = NOP_EXPR;
>    jfunc->value.pass_through.agg_preserved = agg_preserved;
> -  jfunc->value.pass_through.type_preserved = type_preserved;
>  }
>  
>  /* Set JFUNC to be an arithmetic pass through jump function.  */
> @@ -549,61 +512,18 @@ ipa_set_jf_arith_pass_through (struct ip
>    jfunc->value.pass_through.formal_id = formal_id;
>    jfunc->value.pass_through.operation = operation;
>    jfunc->value.pass_through.agg_preserved = false;
> -  jfunc->value.pass_through.type_preserved = false;
>  }
>  
>  /* Set JFUNC to be an ancestor jump function.  */
>  
>  static void
>  ipa_set_ancestor_jf (struct ipa_jump_func *jfunc, HOST_WIDE_INT offset,
> -		     tree type, int formal_id, bool agg_preserved,
> -		     bool type_preserved)
> +		     int formal_id, bool agg_preserved)
>  {
> -  if (!flag_devirtualize)
> -    type_preserved = false;
> -  if (!type_preserved)
> -    type = NULL_TREE;
> -  if (type)
> -    type = TYPE_MAIN_VARIANT (type);
> -  if (!type || !contains_polymorphic_type_p (type))
> -    type_preserved = false;
>    jfunc->type = IPA_JF_ANCESTOR;
>    jfunc->value.ancestor.formal_id = formal_id;
>    jfunc->value.ancestor.offset = offset;
> -  jfunc->value.ancestor.type = type_preserved ? type : NULL;
>    jfunc->value.ancestor.agg_preserved = agg_preserved;
> -  jfunc->value.ancestor.type_preserved = type_preserved;
> -}
> -
> -/* Extract the acual BINFO being described by JFUNC which must be a known type
> -   jump function.  */
> -
> -tree
> -ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *jfunc)
> -{
> -  if (!RECORD_OR_UNION_TYPE_P (jfunc->value.known_type.base_type))
> -    return NULL_TREE;
> -
> -  tree base_binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
> -
> -  if (!base_binfo)
> -    return NULL_TREE;
> -  /* FIXME: At LTO we can't propagate to non-polymorphic type, because
> -     we have no ODR equivalency on those.  This should be fixed by
> -     propagating on types rather than binfos that would make type
> -     matching here unnecesary.  */
> -  if (in_lto_p
> -      && (TREE_CODE (jfunc->value.known_type.component_type) != RECORD_TYPE
> -	  || !TYPE_BINFO (jfunc->value.known_type.component_type)
> -	  || !BINFO_VTABLE (TYPE_BINFO (jfunc->value.known_type.component_type))))
> -    {
> -      if (!jfunc->value.known_type.offset)
> -	return base_binfo;
> -      return NULL;
> -    }
> -  return get_binfo_at_offset (base_binfo,
> -			      jfunc->value.known_type.offset,
> -			      jfunc->value.known_type.component_type);
>  }
>  
>  /* Get IPA BB information about the given BB.  FBI is the context of analyzis
> @@ -627,14 +547,8 @@ struct prop_type_change_info
>    /* The declaration or SSA_NAME pointer of the base that we are checking for
>       type change.  */
>    tree object;
> -  /* If we actually can tell the type that the object has changed to, it is
> -     stored in this field.  Otherwise it remains NULL_TREE.  */
> -  tree known_current_type;
>    /* Set to true if dynamic type change has been detected.  */
>    bool type_maybe_changed;
> -  /* Set to true if multiple types have been encountered.  known_current_type
> -     must be disregarded in that case.  */
> -  bool multiple_types_encountered;
>  };
>  
>  /* Return true if STMT can modify a virtual method table pointer.
> @@ -702,57 +616,9 @@ stmt_may_be_vtbl_ptr_store (gimple stmt)
>    return true;
>  }
>  
> -/* If STMT can be proved to be an assignment to the virtual method table
> -   pointer of ANALYZED_OBJ and the type associated with the new table
> -   identified, return the type.  Otherwise return NULL_TREE.  */
> -
> -static tree
> -extr_type_from_vtbl_ptr_store (gimple stmt, struct prop_type_change_info *tci)
> -{
> -  HOST_WIDE_INT offset, size, max_size;
> -  tree lhs, rhs, base, binfo;
> -
> -  if (!gimple_assign_single_p (stmt))
> -    return NULL_TREE;
> -
> -  lhs = gimple_assign_lhs (stmt);
> -  rhs = gimple_assign_rhs1 (stmt);
> -  if (TREE_CODE (lhs) != COMPONENT_REF
> -      || !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)))
> -    return NULL_TREE;
> -
> -  base = get_ref_base_and_extent (lhs, &offset, &size, &max_size);
> -  if (offset != tci->offset
> -      || size != POINTER_SIZE
> -      || max_size != POINTER_SIZE)
> -    return NULL_TREE;
> -  if (TREE_CODE (base) == MEM_REF)
> -    {
> -      if (TREE_CODE (tci->object) != MEM_REF
> -	  || TREE_OPERAND (tci->object, 0) != TREE_OPERAND (base, 0)
> -	  || !tree_int_cst_equal (TREE_OPERAND (tci->object, 1),
> -				  TREE_OPERAND (base, 1)))
> -	return NULL_TREE;
> -    }
> -  else if (tci->object != base)
> -    return NULL_TREE;
> -
> -  binfo = vtable_pointer_value_to_binfo (rhs);
> -
> -  /* FIXME: vtable_pointer_value_to_binfo may return BINFO of a
> -     base of outer type.  In this case we would need to either
> -     work on binfos or translate it back to outer type and offset.
> -     KNOWN_TYPE jump functions are not ready for that, yet.  */
> -  if (!binfo || TYPE_BINFO (BINFO_TYPE (binfo)) != binfo)
> -   return NULL;
> -
> -  return BINFO_TYPE (binfo);
> -}
> -
> -/* Callback of walk_aliased_vdefs and a helper function for
> -   detect_type_change to check whether a particular statement may modify
> -   the virtual table pointer, and if possible also determine the new type of
> -   the (sub-)object.  It stores its result into DATA, which points to a
> +/* Callback of walk_aliased_vdefs and a helper function for detect_type_change
> +   to check whether a particular statement may modify the virtual table
> +   pointerIt stores its result into DATA, which points to a
>     prop_type_change_info structure.  */
>  
>  static bool
> @@ -763,14 +629,6 @@ check_stmt_for_type_change (ao_ref *ao A
>  
>    if (stmt_may_be_vtbl_ptr_store (stmt))
>      {
> -      tree type;
> -
> -      type = extr_type_from_vtbl_ptr_store (stmt, tci);
> -      gcc_assert (!type || TYPE_MAIN_VARIANT (type) == type);
> -      if (tci->type_maybe_changed
> -	  && type != tci->known_current_type)
> -	tci->multiple_types_encountered = true;
> -      tci->known_current_type = type;
>        tci->type_maybe_changed = true;
>        return true;
>      }
> @@ -885,25 +743,14 @@ detect_type_change_from_memory_writes (t
>  
>    tci.offset = offset;
>    tci.object = get_base_address (arg);
> -  tci.known_current_type = NULL_TREE;
>    tci.type_maybe_changed = false;
> -  tci.multiple_types_encountered = false;
>  
>    walk_aliased_vdefs (&ao, gimple_vuse (call), check_stmt_for_type_change,
>  		      &tci, NULL, &entry_reached);
>    if (!tci.type_maybe_changed)
>      return false;
>  
> -  if (!tci.known_current_type
> -      || tci.multiple_types_encountered
> -      || offset != 0
> -      /* When the walk reached function entry, it means that type
> -	 is set along some paths but not along others.  */
> -      || entry_reached)
> -    jfunc->type = IPA_JF_UNKNOWN;
> -  else
> -    ipa_set_jf_known_type (jfunc, 0, tci.known_current_type, comp_type);
> -
> +  jfunc->type = IPA_JF_UNKNOWN;
>    return true;
>  }
>  
> @@ -1354,13 +1201,7 @@ compute_complex_assign_jump_func (struct
>        else if (gimple_assign_single_p (stmt))
>  	{
>  	  bool agg_p = parm_ref_data_pass_through_p (fbi, index, call, tc_ssa);
> -	  bool type_p = false;
> -
> -	  if (param_type && POINTER_TYPE_P (param_type))
> -	    type_p = !detect_type_change_ssa (tc_ssa, TREE_TYPE (param_type),
> -					      call, jfunc);
> -	  if (type_p || jfunc->type == IPA_JF_UNKNOWN)
> -	    ipa_set_jf_simple_pass_through (jfunc, index, agg_p, type_p);
> +	  ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
>  	}
>        return;
>      }
> @@ -1386,16 +1227,8 @@ compute_complex_assign_jump_func (struct
>    /* Dynamic types are changed in constructors and destructors.  */
>    index = ipa_get_param_decl_index (info, SSA_NAME_VAR (ssa));
>    if (index >= 0 && param_type && POINTER_TYPE_P (param_type))
> -    {
> -      bool type_p = (contains_polymorphic_type_p (TREE_TYPE (param_type))
> -		     && !detect_type_change (op1, base, TREE_TYPE (param_type),
> -					     call, jfunc, offset));
> -      if (type_p || jfunc->type == IPA_JF_UNKNOWN)
> -	ipa_set_ancestor_jf (jfunc, offset,
> -			     type_p ? TREE_TYPE (param_type) : NULL, index,
> -			     parm_ref_data_pass_through_p (fbi, index,
> -							   call, ssa), type_p);
> -    }
> +    ipa_set_ancestor_jf (jfunc, offset,  index,
> +			 parm_ref_data_pass_through_p (fbi, index, call, ssa));
>  }
>  
>  /* Extract the base, offset and MEM_REF expression from a statement ASSIGN if
> @@ -1468,7 +1301,7 @@ static void
>  compute_complex_ancestor_jump_func (struct func_body_info *fbi,
>  				    struct ipa_node_params *info,
>  				    struct ipa_jump_func *jfunc,
> -				    gimple call, gimple phi, tree param_type)
> +				    gimple call, gimple phi)
>  {
>    HOST_WIDE_INT offset;
>    gimple assign, cond;
> @@ -1520,56 +1353,8 @@ compute_complex_ancestor_jump_func (stru
>  	return;
>      }
>  
> -  bool type_p = false;
> -  if (param_type && POINTER_TYPE_P (param_type)
> -      && contains_polymorphic_type_p (TREE_TYPE (param_type)))
> -    type_p = !detect_type_change (obj, expr, TREE_TYPE (param_type),
> -				  call, jfunc, offset);
> -  if (type_p || jfunc->type == IPA_JF_UNKNOWN)
> -    ipa_set_ancestor_jf (jfunc, offset, type_p ? TREE_TYPE (param_type) : NULL,
> -			 index,
> -			 parm_ref_data_pass_through_p (fbi, index, call, parm),
> -			 type_p);
> -}
> -
> -/* Given OP which is passed as an actual argument to a called function,
> -   determine if it is possible to construct a KNOWN_TYPE jump function for it
> -   and if so, create one and store it to JFUNC.
> -   EXPECTED_TYPE represents a type the argument should be in  */
> -
> -static void
> -compute_known_type_jump_func (tree op, struct ipa_jump_func *jfunc,
> -			      gimple call, tree expected_type)
> -{
> -  HOST_WIDE_INT offset, size, max_size;
> -  tree base;
> -
> -  if (!flag_devirtualize
> -      || TREE_CODE (op) != ADDR_EXPR
> -      || !contains_polymorphic_type_p (TREE_TYPE (TREE_TYPE (op)))
> -      /* Be sure expected_type is polymorphic.  */
> -      || !expected_type
> -      || !contains_polymorphic_type_p (expected_type))
> -    return;
> -
> -  op = TREE_OPERAND (op, 0);
> -  base = get_ref_base_and_extent (op, &offset, &size, &max_size);
> -  if (!DECL_P (base)
> -      || max_size == -1
> -      || max_size != size
> -      || !contains_polymorphic_type_p (TREE_TYPE (base)))
> -    return;
> -
> -  if (decl_maybe_in_construction_p (base, TREE_TYPE (base),
> -				    call, current_function_decl)
> -      /* Even if the var seems to be in construction by inline call stack,
> -	 we may work out the actual type by walking memory writes.  */
> -      && (is_global_var (base)
> -	  || detect_type_change (op, base, expected_type, call, jfunc, offset)))
> -    return;
> -
> -  ipa_set_jf_known_type (jfunc, offset, TREE_TYPE (base),
> -			 expected_type);
> +  ipa_set_ancestor_jf (jfunc, offset, index,
> +		       parm_ref_data_pass_through_p (fbi, index, call, parm));
>  }
>  
>  /* Inspect the given TYPE and return true iff it has the same structure (the
> @@ -1944,7 +1729,7 @@ ipa_compute_jump_functions_for_edge (str
>  	     for cycle.  */
>  	  if (parm_preserved_before_stmt_p (fbi, index, call, arg))
>  	    {
> -	      ipa_set_jf_simple_pass_through (jfunc, index, false, false);
> +	      ipa_set_jf_simple_pass_through (jfunc, index, false);
>  	      continue;
>  	    }
>  	}
> @@ -1955,16 +1740,9 @@ ipa_compute_jump_functions_for_edge (str
>  	      int index = ipa_get_param_decl_index (info, SSA_NAME_VAR (arg));
>  	      if (index >= 0)
>  		{
> -		  bool agg_p, type_p;
> +		  bool agg_p;
>  		  agg_p = parm_ref_data_pass_through_p (fbi, index, call, arg);
> -		  if (param_type && POINTER_TYPE_P (param_type))
> -		    type_p = !detect_type_change_ssa (arg, TREE_TYPE (param_type),
> -						      call, jfunc);
> -		  else
> -		    type_p = false;
> -		  if (type_p || jfunc->type == IPA_JF_UNKNOWN)
> -		    ipa_set_jf_simple_pass_through (jfunc, index, agg_p,
> -						    type_p);
> +		  ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
>  		}
>  	    }
>  	  else
> @@ -1975,15 +1753,9 @@ ipa_compute_jump_functions_for_edge (str
>  						  call, stmt, arg, param_type);
>  	      else if (gimple_code (stmt) == GIMPLE_PHI)
>  		compute_complex_ancestor_jump_func (fbi, info, jfunc,
> -						    call, stmt, param_type);
> +						    call, stmt);
>  	    }
>  	}
> -      else
> -	compute_known_type_jump_func (arg, jfunc, call,
> -				      param_type
> -				      && POINTER_TYPE_P (param_type)
> -				      ? TREE_TYPE (param_type)
> -				      : NULL);
>  
>        /* If ARG is pointer, we can not use its type to determine the type of aggregate
>  	 passed (because type conversions are ignored in gimple).  Usually we can
> @@ -2608,35 +2380,6 @@ ipa_analyze_node (struct cgraph_node *no
>    pop_cfun ();
>  }
>  
> -/* Update the jump function DST when the call graph edge corresponding to SRC is
> -   is being inlined, knowing that DST is of type ancestor and src of known
> -   type.  */
> -
> -static void
> -combine_known_type_and_ancestor_jfs (struct ipa_jump_func *src,
> -				     struct ipa_jump_func *dst)
> -{
> -  HOST_WIDE_INT combined_offset;
> -  tree combined_type;
> -
> -  if (!ipa_get_jf_ancestor_type_preserved (dst))
> -    {
> -      dst->type = IPA_JF_UNKNOWN;
> -      return;
> -    }
> -
> -  combined_offset = ipa_get_jf_known_type_offset (src)
> -    + ipa_get_jf_ancestor_offset (dst);
> -  combined_type = ipa_get_jf_ancestor_type (dst);
> -
> -  if (combined_type)
> -    ipa_set_jf_known_type (dst, combined_offset,
> -			   ipa_get_jf_known_type_base_type (src),
> -			   combined_type);
> -  else
> -    dst->type = IPA_JF_UNKNOWN;
> -}
> -
>  /* Update the jump functions associated with call graph edge E when the call
>     graph edge CS is being inlined, assuming that E->caller is already (possibly
>     indirectly) inlined into CS->callee and that E has not been inlined.  */
> @@ -2707,16 +2450,12 @@ update_jump_functions_after_inlining (st
>  		item->offset -= dst->value.ancestor.offset;
>  	    }
>  
> -	  if (src->type == IPA_JF_KNOWN_TYPE)
> -	    combine_known_type_and_ancestor_jfs (src, dst);
> -	  else if (src->type == IPA_JF_PASS_THROUGH
> -		   && src->value.pass_through.operation == NOP_EXPR)
> +	  if (src->type == IPA_JF_PASS_THROUGH
> +	      && src->value.pass_through.operation == NOP_EXPR)
>  	    {
>  	      dst->value.ancestor.formal_id = src->value.pass_through.formal_id;
>  	      dst->value.ancestor.agg_preserved &=
>  		src->value.pass_through.agg_preserved;
> -	      dst->value.ancestor.type_preserved &=
> -		src->value.pass_through.type_preserved;
>  	    }
>  	  else if (src->type == IPA_JF_ANCESTOR)
>  	    {
> @@ -2724,8 +2463,6 @@ update_jump_functions_after_inlining (st
>  	      dst->value.ancestor.offset += src->value.ancestor.offset;
>  	      dst->value.ancestor.agg_preserved &=
>  		src->value.ancestor.agg_preserved;
> -	      dst->value.ancestor.type_preserved &=
> -		src->value.ancestor.type_preserved;
>  	    }
>  	  else
>  	    dst->type = IPA_JF_UNKNOWN;
> @@ -2768,15 +2505,6 @@ update_jump_functions_after_inlining (st
>  		case IPA_JF_UNKNOWN:
>  		  dst->type = IPA_JF_UNKNOWN;
>  		  break;
> -		case IPA_JF_KNOWN_TYPE:
> -		  if (ipa_get_jf_pass_through_type_preserved (dst))
> -		    ipa_set_jf_known_type (dst,
> -					   ipa_get_jf_known_type_offset (src),
> -					   ipa_get_jf_known_type_base_type (src),
> -					   ipa_get_jf_known_type_component_type (src));
> -		  else
> -		    dst->type = IPA_JF_UNKNOWN;
> -		  break;
>  		case IPA_JF_CONST:
>  		  ipa_set_jf_cst_copy (dst, src);
>  		  break;
> @@ -2789,13 +2517,10 @@ update_jump_functions_after_inlining (st
>  
>  		    if (operation == NOP_EXPR)
>  		      {
> -			bool agg_p, type_p;
> +			bool agg_p;
>  			agg_p = dst_agg_p
>  			  && ipa_get_jf_pass_through_agg_preserved (src);
> -			type_p = ipa_get_jf_pass_through_type_preserved (src)
> -			  && ipa_get_jf_pass_through_type_preserved (dst);
> -			ipa_set_jf_simple_pass_through (dst, formal_id,
> -							agg_p, type_p);
> +			ipa_set_jf_simple_pass_through (dst, formal_id, agg_p);
>  		      }
>  		    else
>  		      {
> @@ -2807,16 +2532,13 @@ update_jump_functions_after_inlining (st
>  		  }
>  		case IPA_JF_ANCESTOR:
>  		  {
> -		    bool agg_p, type_p;
> +		    bool agg_p;
>  		    agg_p = dst_agg_p
>  		      && ipa_get_jf_ancestor_agg_preserved (src);
> -		    type_p = ipa_get_jf_ancestor_type_preserved (src)
> -		      && ipa_get_jf_pass_through_type_preserved (dst);
>  		    ipa_set_ancestor_jf (dst,
>  					 ipa_get_jf_ancestor_offset (src),
> -					 ipa_get_jf_ancestor_type (src),
>  					 ipa_get_jf_ancestor_formal_id (src),
> -					 agg_p, type_p);
> +					 agg_p);
>  		    break;
>  		  }
>  		default:
> @@ -4685,11 +4407,6 @@ ipa_write_jump_function (struct output_b
>      {
>      case IPA_JF_UNKNOWN:
>        break;
> -    case IPA_JF_KNOWN_TYPE:
> -      streamer_write_uhwi (ob, jump_func->value.known_type.offset);
> -      stream_write_tree (ob, jump_func->value.known_type.base_type, true);
> -      stream_write_tree (ob, jump_func->value.known_type.component_type, true);
> -      break;
>      case IPA_JF_CONST:
>        gcc_assert (
>  	  EXPR_LOCATION (jump_func->value.constant.value) == UNKNOWN_LOCATION);
> @@ -4702,7 +4419,6 @@ ipa_write_jump_function (struct output_b
>  	  streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
>  	  bp = bitpack_create (ob->main_stream);
>  	  bp_pack_value (&bp, jump_func->value.pass_through.agg_preserved, 1);
> -	  bp_pack_value (&bp, jump_func->value.pass_through.type_preserved, 1);
>  	  streamer_write_bitpack (&bp);
>  	}
>        else
> @@ -4713,11 +4429,9 @@ ipa_write_jump_function (struct output_b
>        break;
>      case IPA_JF_ANCESTOR:
>        streamer_write_uhwi (ob, jump_func->value.ancestor.offset);
> -      stream_write_tree (ob, jump_func->value.ancestor.type, true);
>        streamer_write_uhwi (ob, jump_func->value.ancestor.formal_id);
>        bp = bitpack_create (ob->main_stream);
>        bp_pack_value (&bp, jump_func->value.ancestor.agg_preserved, 1);
> -      bp_pack_value (&bp, jump_func->value.ancestor.type_preserved, 1);
>        streamer_write_bitpack (&bp);
>        break;
>      }
> @@ -4756,15 +4470,6 @@ ipa_read_jump_function (struct lto_input
>      case IPA_JF_UNKNOWN:
>        jump_func->type = IPA_JF_UNKNOWN;
>        break;
> -    case IPA_JF_KNOWN_TYPE:
> -      {
> -	HOST_WIDE_INT offset = streamer_read_uhwi (ib);
> -	tree base_type = stream_read_tree (ib, data_in);
> -	tree component_type = stream_read_tree (ib, data_in);
> -
> -	ipa_set_jf_known_type (jump_func, offset, base_type, component_type);
> -	break;
> -      }
>      case IPA_JF_CONST:
>        ipa_set_jf_constant (jump_func, stream_read_tree (ib, data_in), cs);
>        break;
> @@ -4775,9 +4480,7 @@ ipa_read_jump_function (struct lto_input
>  	  int formal_id =  streamer_read_uhwi (ib);
>  	  struct bitpack_d bp = streamer_read_bitpack (ib);
>  	  bool agg_preserved = bp_unpack_value (&bp, 1);
> -	  bool type_preserved = bp_unpack_value (&bp, 1);
> -	  ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved,
> -					  type_preserved);
> +	  ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved);
>  	}
>        else
>  	{
> @@ -4790,14 +4493,10 @@ ipa_read_jump_function (struct lto_input
>      case IPA_JF_ANCESTOR:
>        {
>  	HOST_WIDE_INT offset = streamer_read_uhwi (ib);
> -	tree type = stream_read_tree (ib, data_in);
>  	int formal_id = streamer_read_uhwi (ib);
>  	struct bitpack_d bp = streamer_read_bitpack (ib);
>  	bool agg_preserved = bp_unpack_value (&bp, 1);
> -	bool type_preserved = bp_unpack_value (&bp, 1);
> -
> -	ipa_set_ancestor_jf (jump_func, offset, type, formal_id, agg_preserved,
> -			     type_preserved);
> +	ipa_set_ancestor_jf (jump_func, offset, formal_id, agg_preserved);
>  	break;
>        }
>      }
> Index: src/gcc/ipa-prop.h
> ===================================================================
> --- src.orig/gcc/ipa-prop.h	2014-11-14 01:59:11.135700073 +0100
> +++ src/gcc/ipa-prop.h	2014-11-14 01:59:11.135700073 +0100
> @@ -51,11 +51,6 @@ along with GCC; see the file COPYING3.
>     parameter or can apply one simple binary operation to it (such jump
>     functions are called polynomial).
>  
> -   IPA_JF_KNOWN_TYPE is a special type of an "unknown" function that applies
> -   only to pointer parameters.  It means that even though we cannot prove that
> -   the passed value is an interprocedural constant, we still know the exact
> -   type of the containing object which may be valuable for devirtualization.
> -
>     Jump functions are computed in ipa-prop.c by function
>     update_call_notes_after_inlining.  Some information can be lost and jump
>     functions degraded accordingly when inlining, see
> @@ -64,7 +59,6 @@ along with GCC; see the file COPYING3.
>  enum jump_func_type
>  {
>    IPA_JF_UNKNOWN = 0,  /* newly allocated and zeroed jump functions default */
> -  IPA_JF_KNOWN_TYPE,        /* represented by field known_type */
>    IPA_JF_CONST,             /* represented by field costant */
>    IPA_JF_PASS_THROUGH,	    /* represented by field pass_through */
>    IPA_JF_ANCESTOR	    /* represented by field ancestor */
> @@ -113,11 +107,6 @@ struct GTY(()) ipa_pass_through_data
>       ipa_agg_jump_function).  The flag is used only when the operation is
>       NOP_EXPR.  */
>    unsigned agg_preserved : 1;
> -
> -  /* When set to true, we guarantee that, if there is a C++ object pointed to
> -     by this object, it does not undergo dynamic type change in the course of
> -     functions decribed by this jump function.  */
> -  unsigned type_preserved : 1;
>  };
>  
>  /* Structure holding data required to describe an ancestor pass-through
> @@ -127,18 +116,10 @@ struct GTY(()) ipa_ancestor_jf_data
>  {
>    /* Offset of the field representing the ancestor.  */
>    HOST_WIDE_INT offset;
> -  /* Type of the result.
> -     When TYPE_PRESERVED is false, TYPE is NULL, since it is only
> -     relevant for the devirtualization machinery.  */
> -  tree type;
>    /* Number of the caller's formal parameter being passed.  */
>    int formal_id;
>    /* Flag with the same meaning like agg_preserve in ipa_pass_through_data.  */
>    unsigned agg_preserved : 1;
> -  /* When set to true, we guarantee that, if there is a C++ object pointed to
> -     by this object, it does not undergo dynamic type change in the course of
> -     functions decribed by this jump function.  */
> -  unsigned type_preserved : 1;
>  };
>  
>  /* An element in an aggegate part of a jump function describing a known value
> @@ -189,7 +170,6 @@ struct GTY (()) ipa_jump_func
>       functions and member_cst holds constant c++ member functions.  */
>    union jump_func_value
>    {
> -    struct ipa_known_type_data GTY ((tag ("IPA_JF_KNOWN_TYPE"))) known_type;
>      struct ipa_constant_data GTY ((tag ("IPA_JF_CONST"))) constant;
>      struct ipa_pass_through_data GTY ((tag ("IPA_JF_PASS_THROUGH"))) pass_through;
>      struct ipa_ancestor_jf_data GTY ((tag ("IPA_JF_ANCESTOR"))) ancestor;
> @@ -197,34 +177,6 @@ struct GTY (()) ipa_jump_func
>  };
>  
>  
> -/* Return the offset of the component that is described by a known type jump
> -   function JFUNC.  */
> -
> -static inline HOST_WIDE_INT
> -ipa_get_jf_known_type_offset (struct ipa_jump_func *jfunc)
> -{
> -  gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
> -  return jfunc->value.known_type.offset;
> -}
> -
> -/* Return the base type of a known type jump function JFUNC.  */
> -
> -static inline tree
> -ipa_get_jf_known_type_base_type (struct ipa_jump_func *jfunc)
> -{
> -  gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
> -  return jfunc->value.known_type.base_type;
> -}
> -
> -/* Return the component type of a known type jump function JFUNC.  */
> -
> -static inline tree
> -ipa_get_jf_known_type_component_type (struct ipa_jump_func *jfunc)
> -{
> -  gcc_checking_assert (jfunc->type == IPA_JF_KNOWN_TYPE);
> -  return jfunc->value.known_type.component_type;
> -}
> -
>  /* Return the constant stored in a constant jump functin JFUNC.  */
>  
>  static inline tree
> @@ -297,15 +249,6 @@ ipa_get_jf_ancestor_offset (struct ipa_j
>    return jfunc->value.ancestor.offset;
>  }
>  
> -/* Return the result type of an ancestor jump function JFUNC.  */
> -
> -static inline tree
> -ipa_get_jf_ancestor_type (struct ipa_jump_func *jfunc)
> -{
> -  gcc_checking_assert (jfunc->type == IPA_JF_ANCESTOR);
> -  return jfunc->value.ancestor.type;
> -}
> -
>  /* Return the number of the caller's formal parameter that an ancestor jump
>     function JFUNC refers to.  */
>