[LLVMdev] RefineAbstractType

[Chris Lattner]

On Nov 12, 2008, at 2:59 PM, David Greene wrote:

> Is there some reason that RefineAbstractType doesn't recurse down  
> DerivedTypes
> and further resolve abstract types?

Because that would resolve two different types.  RefineAbstractType  
just refines the one type you request, and further uniques types based  
on it.

In fact, I strongly suspect that RefineAbstractType doesn't work if  
you give it something that isn't Opaque.  I'd recommend only using it  
on Opaque, not random abstract types.

> In Fortran it is possible to have a routine that takes a function  
> pointer to a
> routine with the same signature.  This is not possible to express in  
> C/C++.
> I'm not sure it's possible to express in LLVM either without using  
> varargs
> (opinions welcome).

Sure, LLVM is more general than C.  In LLVM, you can have a pointer  
that points to itself, for example:

%t = type %t*

which is "\1*" if you like up references.

I'm not sure what a function pointer that takes a pointer to itself  
has to do with opaque types, but you'd write it like this:


%t = type void (%t)*

or if you want the function:

%t = type void (%t*)

> 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.

-Chris