lucy-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Nick Wellnhofer <wellnho...@aevum.de>
Subject Re: [lucy-dev] Brittle struct ABI proof-of-concept
Date Tue, 08 May 2012 11:26:08 GMT
On 02/05/2012 03:58, Marvin Humphrey wrote:
> Greets,
>
> I've finished a proof-of-concept app which illustrates one approach to
> addressing Clownfish's brittle object struct issue.
>
> The files have been committed to a branch and the README explains the issue
> and the proposed solution in detail.
>
>    https://svn.apache.org/repos/asf/lucy/branches/LUCY-234-struct-ABI/README

Quoting the README:

> This proof-of-concept project adapts Clownfish-style OFFSET vars to encode
> both the method offset and fixup information.  The "pointer fixup" goes in the
> upper 32-bits, and the method offset goes in the lower 32 bits.
>
>     static inline void
>     Dog_speak(Dog *self) {
>         const uint64_t offsets = Dog_speak_OFFSETS;
>         void *const view = (char*)self + (int32_t)(offsets >> 32);
>         char *const method_address = *(char**)self + (uint32_t)offsets;
>         Dog_speak_t method = *((Dog_speak_t*)method_address);
>         method(view);
>     }

It's a very nice idea to tie method offsets and fixups together. But 
AFAICS this only works when a calling a method that is defined in the 
same class or the superclass of an object, not if it's defined in a 
subclass.

Here is an example: Dog overrides the Speak method of the Animal class, 
so the fixup for this method will be zero. If we invoke Dog_speak on a 
Dog object, the method will receive the Dog object directly and 
everything is fine.

Now suppose that a Dog object is passed to a function which accepts an 
Animal parameter. This means we have to pass dog->superself which is an 
Animal struct with a pointer to the Dog MetaClass. The function then 
invokes Animal_speak which is overridden by Dog_speak in Dog. This will 
use the method pointers, offsets and fixups of the Dog MetaClass. But 
using the zero fixup, the Animal object will be passed to Dog_speak 
which is wrong. In this case we'd need a negative fixup to "cast" the 
Animal object back to a Dog object.

It's possible to define separate fixups for the Animal struct inside the 
Dog object, but this would further complicate the MetaClass initialization.

Another thing I'm wondering about is how casting of objects to 
superclasses would work with the scheme you proposed. Casting to the 
parent class using ->superself is easy. But I think we'll need an 
additional mechanism for casts to superclasses further up in the hierarchy.

Nick

Mime
View raw message