llvm dev - Nov 2008 - [LLVMdev] RefineAbstractType

On Wednesday 12 November 2008 18:58, Chris Lattner
wrote:
> On Nov 12, 2008, at 3:37 PM, David Greene wrote:
> >>> Unfortunately, calling
FunctionType::refineAbstractType(opaque, void
> >>> (...))
> >>> doesn't work because RefineAbstractType doesn't
recurse down into
> >>> the
> >>> pointee types.
> >>
> >> What types are you starting out with?  If you had the equivalent
of:
> >>
> >> %t1 = type opaque
> >> %t2 = type void(%t1*)
> >>
> >> and you refine t1 -> t2, it should work.
> >
> > I'm not sure it will.  %t1* is the "contained" type
inside the
> > FunctionType.
> > RefineAbstractTypes expects the OldType (%t1 in this case) to be in
> > the
> > contained type set.  Since a _pointer_ to %t1 is in the contained
> > set, it
> > doesn't see it.
>
> How is this any different than the struct case of {\2*} ?
I don't know.  All I know is when I called %t2->refineAbstractType(%t1,
%t2)
it didn't work.  That was the pointer of the question.  RefineAbstractTypes
doesn't "see" beyond the pointer type.

I think the answer is that I have to resolve the pointer type, not the 
function type:

%t1 = type opaque
%t1.5 = type %t1 *
%t2 = type void(%t1.5)

%t1.5->refineAbstractType(%t1, %t2)

                                                 -Dave

On Nov 12, 2008, at 5:07 PM, David Greene wrote:
> On Wednesday 12 November 2008 18:58, Chris Lattner wrote:
>> On Nov 12, 2008, at 3:37 PM, David Greene wrote:
>>>>> Unfortunately, calling
FunctionType::refineAbstractType(opaque,
>>>>> void
>>>>> (...))
>>>>> doesn't work because RefineAbstractType doesn't
recurse down into
>>>>> the
>>>>> pointee types.
>>>>
>>>> What types are you starting out with?  If you had the
equivalent
>>>> of:
>>>>
>>>> %t1 = type opaque
>>>> %t2 = type void(%t1*)
>>>>
>>>> and you refine t1 -> t2, it should work.
>>>
>>> I'm not sure it will.  %t1* is the "contained" type
inside the
>>> FunctionType.
>>> RefineAbstractTypes expects the OldType (%t1 in this case) to be in
>>> the
>>> contained type set.  Since a _pointer_ to %t1 is in the contained
>>> set, it
>>> doesn't see it.
>>
>> How is this any different than the struct case of {\2*} ?
>
> I don't know.  All I know is when I called %t2- 
> >refineAbstractType(%t1, %t2)
> it didn't work.  That was the pointer of the question.   
> RefineAbstractTypes
> doesn't "see" beyond the pointer type.
You shouldn't be refining the pointer, you should use:

t1->refineAbstractType(t2)

-Chris

On Wednesday 12 November 2008 19:13, Chris Lattner
wrote:
> On Nov 12, 2008, at 5:07 PM, David Greene wrote:
> > On Wednesday 12 November 2008 18:58, Chris Lattner wrote:
> >> On Nov 12, 2008, at 3:37 PM, David Greene wrote:
> >>>>> Unfortunately, calling
FunctionType::refineAbstractType(opaque,
> >>>>> void
> >>>>> (...))
> >>>>> doesn't work because RefineAbstractType
doesn't recurse down into
> >>>>> the
> >>>>> pointee types.
> >>>>
> >>>> What types are you starting out with?  If you had the
equivalent
> >>>> of:
> >>>>
> >>>> %t1 = type opaque
> >>>> %t2 = type void(%t1*)
> >>>>
> >>>> and you refine t1 -> t2, it should work.
> >>>
> >>> I'm not sure it will.  %t1* is the "contained"
type inside the
> >>> FunctionType.
> >>> RefineAbstractTypes expects the OldType (%t1 in this case) to
be in
> >>> the
> >>> contained type set.  Since a _pointer_ to %t1 is in the
contained
> >>> set, it
> >>> doesn't see it.
> >>
> >> How is this any different than the struct case of {\2*} ?
> >
> > I don't know.  All I know is when I called %t2-
> >
> > >refineAbstractType(%t1, %t2)
> >
> > it didn't work.  That was the pointer of the question.
> > RefineAbstractTypes
> > doesn't "see" beyond the pointer type.
>
> You shouldn't be refining the pointer, you should use:
>
> t1->refineAbstractType(t2)
Oh, I see.

Then what's the purpose of PointerType::refineAbstractType,
FunctionType::refineAbstractType, etc.?

                                                -Dave

On Wednesday 12 November 2008 19:13, Chris Lattner wrote:
> You shouldn't be refining the pointer, you should use:
>
> t1->refineAbstractType(t2)
Ok, I tried this and I get further.  But the type system seems to have trouble
when refining multiple types and those types resolve to the same thing.
I turned on DEBUG_MERGE_TYPES to illustrate:

*** First function type ***

TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
Derived new type: i32 *
TypeMap<>::add table contents:
 1. 0x3a4e910 [1 x i64]
Derived new type: [1 x i64]
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4eb60 [1 x i64] *
Derived new type: [1 x i64] *
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
Derived new type: i64 *
Derived new type: opaque
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
 4. 0x3a8c310 opaque *
Derived new type: opaque *
TypeMap<>::add table contents:
 1. 0x3a8c450 i32 (opaque *)
Derived new type: i32 (opaque *)
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
 4. 0x3a8c680 i32 (opaque *) *
 5. 0x3a8c310 opaque *
Derived new type: i32 (opaque *) *

*** First refinement ***

REFINING abstract type [0x3afd350 opaque] to [0x3a8c450 i32 (opaque *)]!
 REFINING user 0[0x3a8c310] of abstract type [0x3afd350 opaque] to [0x3a8c450 
i32 (opaque *)]!
RefineAbstractType(0x3afd350[opaque], 0x3a8c450 [i32 (opaque *)])
  remAbstractTypeUser[0x3afd350, opaque][0] User = 0x3a8c310
REFINING abstract type [0x3a8c310 i32 (\2) *] to [0x3a8c680 i32 (\2 *) *]!
Derived new type: opaque
  remAbstractTypeUser[0x3a8c450, i32 (\2 *)][1] User = 0x3a8c310
 REFINING user 0[0x3a8c450] of abstract type [0x3a8c310 i32 (\2) *] to 
[0x3a8c680 i32 (\2 *) *]!
RefineAbstractType(0x3a8c310[i32 (\2) *], 0x3a8c680 [i32 (\2 *) *])
  remAbstractTypeUser[0x3a8c310, i32 (\2) *][0] User = 0x3a8c450
typeIsREFINED type: 0x3a8c680 i32 (\2) *
  remAbstractTypeUser[0x3a8c680, i32 (\2) *][0] User = 0x3a8c450
typeIsREFINED type: 0x3a8c450 i32 (i32 (\2) *)
  remAbstractTypeUser[0x3a8c450, i32 (i32 (\2) *)][0] User = 0x3a8c680
  remAbstractTypeUser[0x3a8c810, opaque][0] User = 0x3a8c310
TypeMap<>::add table contents:
 1. 0x3a8c310 void ()
 2. 0x3a8c450 i32 (i32 (\2) *)

*** Ok, this all looks perfect at this point ***

*** Second function type ***

Derived new type: void ()
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
 4. 0x3a8cb40 void () *
 5. 0x3a8c680 i32 (\2) *
Derived new type: void () *
Derived new type: opaque
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
 4. 0x3a8cb40 void () *
 5. 0x3a8c680 i32 (\2) *
 6. 0x3a8d000 opaque *
Derived new type: opaque *
TypeMap<>::add table contents:
 1. 0x3a8c310 void ()
 2. 0x3a8c450 i32 (i32 (\2) *)
 3. 0x3a8d1c0 i32 (opaque *)
Derived new type: i32 (opaque *)
TypeMap<>::add table contents:
 1. 0x3a4e6a0 i32 *
 2. 0x3a4f140 i64 *
 3. 0x3a4eb60 [1 x i64] *
 4. 0x3a8cb40 void () *
 5. 0x3a8c680 i32 (\2) *
 6. 0x3a8d420 i32 (opaque *) *
 7. 0x3a8d000 opaque *
Derived new type: i32 (opaque *) *

*** Second refinement -- note that it's the same as the first refinement,
even "opaque" has the same address!  That seems suspicious to me. ***

REFINING abstract type [0x3afd350 opaque] to [0x3a8d1c0 i32 (opaque *)]!
 REFINING user 0[0x3a8d000] of abstract type [0x3afd350 opaque] to [0x3a8d1c0 
i32 (opaque *)]!
RefineAbstractType(0x3afd350[opaque], 0x3a8d1c0 [i32 (opaque *)])
  remAbstractTypeUser[0x3afd350, opaque][0] User = 0x3a8d000
REFINING abstract type [0x3a8d000 i32 (\2) *] to [0x3a8c680 i32 (\2) *]!
  remAbstractTypeUser[0x3a8d1c0, i32 (\2 *)][1] User = 0x3a8d000
 REFINING user 0[0x3a8d1c0] of abstract type [0x3a8d000 i32 (\2) *] to 
[0x3a8c680 i32 (\2) *]!
RefineAbstractType(0x3a8d000[i32 (\2) *], 0x3a8c680 [i32 (\2) *])
  remAbstractTypeUser[0x3a8d000, i32 (\2) *][0] User = 0x3a8d1c0
REFINING abstract type [0x3a8d1c0 i32 (i32 (\2) *)] to [0x3a8c450 i32 (i32 
(\2) *)]!
 REFINING user 0[0x3a8d420] of abstract type [0x3a8d1c0 i32 (i32 (\2) *)] to 
[0x3a8c450 i32 (i32 (\2) *)]!
RefineAbstractType(0x3a8d1c0[i32 (i32 (\2) *)], 0x3a8c450 [i32 (i32 (\2) *)])
  remAbstractTypeUser[0x3a8d1c0, i32 (i32 (\2) *)][0] User = 0x3a8d420
REFINING abstract type [0x3a8d420 i32 (i32 (\2) *) *] to [0x3a8c680 i32 (\2) 
*]!
  remAbstractTypeUser[0x3a8c810, opaque][2] User = 0x3a8d420
  remAbstractTypeUser[0x3a8c810, opaque][0] User = 0x3a8d000

*** BLAMMO! ***

llvm/lib/VMCore/Type.cpp:474: llvm::FunctionType::FunctionType(const 
llvm::Type*, const std::vector<const llvm::Type*, std::allocator<const 
llvm::Type*> >&, bool): Assertion `(Params[i]->isFirstClassType()
||
isa<OpaqueType>(Params[i])) && "Function arguments must be
value types!"'
failed.
Caught signal 6

Any idea what's happening?

Is it just the case that I shouldn't be doing two refinements that yield the
same type?  How do I know in general that that will happen?  Right now
I'm refining types at the earliest possible moment, as we go along
processing the code.  Is there a requirement to only refine after all types
have been created?  I can't wait until all of the code is seen in general
because we need to dump asm after processing each function -- we 
can't wait until we've seen all functions (=> we can't wait until
we've
seen all types to refine).

                                                -Dave