Remove dependency on V8_TARGET_ARCH in v8.h

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 2697 matching lines @@
 };
 
 
 
 // --- I m p l e m e n t a t i o n ---
 
 
 namespace internal {
 
 
+template <size_t ptr_size> struct SmiConstants;
+
+// Smi constants for 32-bit systems.
+template <> struct SmiConstants<4> {
+  static const int kSmiTag = 0;

[Christian Plesner Hansen, 2009/10/16 09:39:10]

Some of these constants seems to be independent of pointer size.  Maybe move
them out to avoid duplication?

[Lasse Reichstein, 2009/10/16 10:19:11]

Done. This required moving the templates below the declaration of kSmiTagSize to
enable the SmiToInt function to reference the value.

+  static const int kSmiTagSize = 1;
+  static const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
+  static const int kSmiShiftSize = 0;
+  static const int kSmiValueSize = 31;
+  static inline int SmiToInt(internal::Object* value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Throw away top 32 bits and shift down (requires >> to be sign extending).
+    return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
+  }
+};
+
+// Smi constants for 64-bit systems.
+template <> struct SmiConstants<8> {
+  static const int kSmiTag = 0;
+  static const int kSmiTagSize = 1;
+  static const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
+  static const int kSmiShiftSize = 31;
+  static const int kSmiValueSize = 32;
+  static inline int SmiToInt(internal::Object* value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Shift down and throw away top 32 bits.
+    return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
+  }
+};
+
+
 // Tag information for HeapObject.
 const int kHeapObjectTag = 1;
 const int kHeapObjectTagSize = 2;
 const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
 
-#ifdef V8_TARGET_ARCH_X64
 // Tag information for Smi.
-const int kSmiTag = 0;
-const int kSmiTagSize = 1;
-const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
-const int kSmiShiftSize = 31;
-const int kSmiValueSize = 32;
-#else
-// Tag information for Smi.
-const int kSmiTag = 0;
-const int kSmiTagSize = 1;
-const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
-const int kSmiShiftSize = 0;
-const int kSmiValueSize = 31;
-#endif
+const int kSmiTag = SmiConstants<sizeof(void*)>::kSmiTag;
+const int kSmiTagSize = SmiConstants<sizeof(void*)>::kSmiTagSize;
+const intptr_t kSmiTagMask = SmiConstants<sizeof(void*)>::kSmiTagMask;
+const int kSmiShiftSize = SmiConstants<sizeof(void*)>::kSmiShiftSize;
+const int kSmiValueSize = SmiConstants<sizeof(void*)>::kSmiValueSize;
 
 /**
  * This class exports constants and functionality from within v8 that
  * is necessary to implement inline functions in the v8 api.  Don't
  * depend on functions and constants defined here.
  */
 class Internals {
  public:
 
   // These values match non-compiler-dependent values defined within
@@ skipping 16 matching lines @@
   static inline bool HasHeapObjectTag(internal::Object* value) {
     return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
             kHeapObjectTag);
   }
 
   static inline bool HasSmiTag(internal::Object* value) {
     return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag);
   }
 
   static inline int SmiValue(internal::Object* value) {
-#ifdef V8_TARGET_ARCH_X64
-    int shift_bits = kSmiTagSize + kSmiShiftSize;
-    // Shift down and throw away top 32 bits.
-    return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits);
-#else
-    int shift_bits = kSmiTagSize + kSmiShiftSize;
-    // Throw away top 32 bits and shift down (requires >> to be sign extending).
-    return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bits;
-#endif
+    return SmiConstants<sizeof(void*)>::SmiToInt(value);
   }
 
   static inline bool IsExternalTwoByteString(int instance_type) {
     int representation = (instance_type & kFullStringRepresentationMask);
     return representation == kExternalTwoByteRepresentationTag;
   }
 
   template <typename T>
   static inline T ReadField(Object* ptr, int offset) {
     uint8_t* addr = reinterpret_cast<uint8_t*>(ptr) + offset - kHeapObjectTag;
@@ skipping 336 matching lines @@
 
 }  // namespace v8
 
 
 #undef V8EXPORT
 #undef V8EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_