Fix OBJ_TYPE_REF handling in ipa-cp

> > Bootstrapped/regtesed x86_64-linux. Martin, please can you review the change?
> > 
> > 	* ipa-prop.c (ipa_set_jf_known_type): Check that component type
> > 	is a record type with BINFO.
> > 	(detect_type_change_ssa):  Add comp_type argument.
> > 	(compute_complex_assign_jump_func): Add param_type argument; pass
> > 	it down to detect_type_change_ssa.
> > 	(compute_known_type_jump_func): Add expected_type parameter.
> > 	Do not bother tracking a non-polymorphic type.
> > 	(ipa_get_callee_param_type): New function.
> > 	(ipa_compute_jump_functions_for_edge): Pass down calle parm types.
> > 	(ipa_analyze_virtual_call_uses): Use class typee as argument
> > 	of detect_type_change_1.
> > 	(ipa_intraprocedural_devirtualization): Pass down class type.
> 
> Hopefully I'll get rid of the component_types in the jump functions
> and most of this won't be necesary.  Meanwhile, this is OK.
Indeed, I hope these will go.  I updated the patch to tree after your changes
and fixed the remaining uses of detect_type_change so detect_type_change_1 can
go completely.

Bootstrapped/regtested x86_64-linux and also tested with Firefox build,
comitted.

Interestingly, we now have smaller static counts of devirtualization on firefox
than two weeks ago.  It is not caused by this patch however.  While looking for
possible causes I also noticed we don't seem to handle invisible references
well.  Consider:

class A {virtual void b(void) { };};
class B : public A {virtual void b(void) { };};

void
q (class A a);
void
qq (class A *a);
void
t (class A a)
{
  q(a);
  qq(&a);
}
void
m()
{
  class B b;
  t(b);
}

With -O2 -fno-early-inling -flto I get:

m() ()
{
  struct B b;
  struct A D.2267;

  <bb 2>:
  B::B (&b);
  A::A (&D.2267, &b.D.2212);
  t (&D.2267);
  D.2267 ={v} {CLOBBER};
  b ={v} {CLOBBER};
  return;

}

t(A) (struct A & restrict a)
{ 
  struct A D.2242;

  <bb 2>:
  A::A (&D.2242, a_2(D));
  q (&D.2242);
  D.2242 ={v} {CLOBBER};
  qq (a_2(D));
  return;

}

I.e. t is called with invisible reference.
Now we get:
Jump functions:
  Jump functions of caller  m()/12:
    callsite  m()/12 -> t(A)/5 :
       param 0: UNKNOWN
    callsite  m()/12 -> A::A(A const&)/4 :
       param 0: KNOWN TYPE: base  struct A, offset 0, component struct A
       param 1: KNOWN TYPE: base  struct B, offset 0, component const struct A
    callsite  m()/12 -> B::B()/11 :
       param 0: KNOWN TYPE: base  struct B, offset 0, component struct B
  Jump functions of caller  t(A)/5:
    callsite  t(A)/5 -> qq(A*)/20 :
       param 0: PASS THROUGH: 0, op nop_expr, type_preserved
    callsite  t(A)/5 -> q(A)/19 :
       param 0: UNKNOWN
    callsite  t(A)/5 -> A::A(A const&)/4 : 
       param 0: KNOWN TYPE: base  struct A, offset 0, component struct A
       param 1: PASS THROUGH: 0, op nop_expr, type_preserved

I think m()->t() has no type and t->qq is pass thorugh. So we miss the
fact that t->qq is known type of A.
Do we need jump function that is PASS THROGH & KNOWN_TYPE at once?

Honza

	* ipa-prop.c (ipa_set_jf_known_type): Check that we add
	only records.
	(detect_type_change_1): Rename to ...
	(detect_type_change): ... this one; early return on non-polymorphic
	types.
	(detect_type_change_ssa): Add comp_type parameter; update	
	use of detect_type_change.
	(compute_complex_assign_jump_func): Add param_type parameter;
	update use of detect_type_change_ssa.
	(compute_complex_ancestor_jump_func): Likewise.
	(ipa_get_callee_param_type): New function.
	(ipa_compute_jump_functions_for_edge): Compute parameter type;
	update calls to the jump function computation functions.

Fix OBJ_TYPE_REF handling in ipa-cp

Commit Message

Patch