[Vm-dev] 64-bit compilation beneath a 32-bit image...

David T. Lewis lewis at mail.msen.com
Wed Oct 13 03:21:52 UTC 2010

On Tue, Oct 12, 2010 at 07:21:25PM -0700, Eliot Miranda wrote:
> Hi David, John, All,
>     I'm working on integrating callbacks into the FFI and have the old
> version of callbacks working.  In integrating with Cog I've realised some
> cleanliness can come from a slightly different approach, the details of
> which are irrelevant to my question, which is, when we're running a 32-bit
> image above a 32-bit VM compiled in 64-bit mode, is there any way from the
> image we can ask the VM if it is 64-bit or 32-bit?  Am I to understand
> correctly that you, John, have arranged that when we're compiling the iOS VM
> on a 64-bit Mac OS X, sizeof(long) = 8, and everything still works?  If not,
> the question is moot.  If so, how from the image can I ask whether the VM is
> 64-bit, e.g. by asking what sizeof(long) or sizeof(void *) is?
> If there isn't a way, I propose we add vmParameterAt: 70 to answer the VM's
> underlying word size.  Tis is different to vmParameterAt: 40, which is the
> image's underlying word size.
> I need the answer to this so that when a callback tries to answer e.g. an
> integer result it can tell whether it should use some Alien signedLongAt: N
> or Alien signedLongLongAt: N to answer the result, and what machine code
> (x86 vs x86-64) to use for the callback thunk.

You definitely want to make a distinction between sizeof(long) and
sizeof(void *), because long can be defined differently on different
64-bit implementations. In particular, some 64-bit platforms have used
32-bit longs, so you can't rely on a single parameter for this.

In OSProcessPlugin, there are #primitiveSizeOfPointer and #primitiveSizeOfInt
primitives. Implementation is trivial, so these kinds of primitives could
be added to the interpreter or into whatever plugin you have associated
with the FFI. To me, a primitive seems more explicit in intent than a
vmParameter, and since you are likely to end up needing to know the size
of pointers, ints, longs, floats, etc, I would be inclined to do the
inquiries with explicit primitive calls rather than a set of VM parameters.

There is a large batch of changes that I did for the classic FFI mechanism
to make it work on 64-bit platforms (almost 3 years ago now - yikes!).
Details here:

And (probably outdated) patches:

I had intended to get this folded into the VM a long time ago, but it
is a fairly large change so I did not push it too hard. That said, if
you are doing new work on this, it might be worthwhile to get the old
FFI updated if only as a point of reference. Frankly I think it's too
much of a change to do in the December time frame (next release of VMs)
but perhaps as a new years resolution for next January?


More information about the Vm-dev mailing list