Wrap external pointers more carefully.

include/v8.h

Index: include/v8.h
diff --git a/include/v8.h b/include/v8.h
index 883bfad9458ebc31c511ff3ba93568e2d1eab635..db7e24a4799c5d87e533b2c221e5b75f74ed712a 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -3432,9 +3432,14 @@ class Internals {
     return ReadField<uint8_t>(map, kMapInstanceTypeOffset);
   }
 
+  static inline void* GetExternalPointerFromSmi(internal::Object* smi) {
+    return reinterpret_cast<void*>(
+        reinterpret_cast<intptr_t>(smi) >> kSmiShiftSize);

[Lasse Reichstein, 2011/01/13 08:35:18]

I don't think this will work in 64-bit mode (kShiftSize is 31 there, so you lose
a LOT of bits). You need to use all the non-tag bits.
On the other hand, I guess you really meant kSmiTagSize.

We should just have a function (per pointer size) that embeds either an
arbitrary pointer, or just an aligned pointer, in a smi-tagged value (bit zero
is 0).

If the pointer is arbitrary, you need to throw away at least one bit. Probably
the most significant one (but you can't know that that is safe, e.g., in Windows
apps running with 3Gb user space). If it's aligned (like a stack pointer or
similar), we know that the low bit is zero, and we can cast it directly to Smi
and back.

E.g. put functions into SmiConstants<4> and SmiConstants<8> above.

+  }
+
   static inline void* GetExternalPointer(internal::Object* obj) {
     if (HasSmiTag(obj)) {
-      return obj;
+      return GetExternalPointerFromSmi(obj);
     } else if (GetInstanceType(obj) == kProxyType) {
       return ReadField<void*>(obj, kProxyProxyOffset);
     } else {