Wrap external pointers more carefully.

include/v8.h

 // Copyright 2007-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 3414 matching lines @@
   static inline int SmiValue(internal::Object* value) {
     return SmiConstants<kApiPointerSize>::SmiToInt(value);
   }
 
   static inline int GetInstanceType(internal::Object* obj) {
     typedef internal::Object O;
     O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
     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 {
       return NULL;
     }
   }
 
   static inline bool IsExternalTwoByteString(int instance_type) {
     int representation = (instance_type & kFullStringRepresentationMask);
     return representation == kExternalTwoByteRepresentationTag;
@@ skipping 346 matching lines @@
 
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_