v8.h   v8.h 
skipping to change at line 2452 skipping to change at line 2452
* *
* Instances of this class can be passed to v8::V8::HeapStatistics to * Instances of this class can be passed to v8::V8::HeapStatistics to
* get heap statistics from V8. * get heap statistics from V8.
*/ */
class V8EXPORT HeapStatistics { class V8EXPORT HeapStatistics {
public: public:
HeapStatistics(); HeapStatistics();
size_t total_heap_size() { return total_heap_size_; } size_t total_heap_size() { return total_heap_size_; }
size_t total_heap_size_executable() { return total_heap_size_executable_; } size_t total_heap_size_executable() { return total_heap_size_executable_; }
size_t used_heap_size() { return used_heap_size_; } size_t used_heap_size() { return used_heap_size_; }
size_t heap_size_limit() { return heap_size_limit_; }
private: private:
void set_total_heap_size(size_t size) { total_heap_size_ = size; } void set_total_heap_size(size_t size) { total_heap_size_ = size; }
void set_total_heap_size_executable(size_t size) { void set_total_heap_size_executable(size_t size) {
total_heap_size_executable_ = size; total_heap_size_executable_ = size;
} }
void set_used_heap_size(size_t size) { used_heap_size_ = size; } void set_used_heap_size(size_t size) { used_heap_size_ = size; }
void set_heap_size_limit(size_t size) { heap_size_limit_ = size; }
size_t total_heap_size_; size_t total_heap_size_;
size_t total_heap_size_executable_; size_t total_heap_size_executable_;
size_t used_heap_size_; size_t used_heap_size_;
size_t heap_size_limit_;
friend class V8; friend class V8;
}; };
/** /**
* Container class for static utility functions. * Container class for static utility functions.
*/ */
class V8EXPORT V8 { class V8EXPORT V8 {
public: public:
/** Set the callback to invoke in case of fatal errors. */ /** Set the callback to invoke in case of fatal errors. */
skipping to change at line 3276 skipping to change at line 3279
// Tag information for HeapObject. // Tag information for HeapObject.
const int kHeapObjectTag = 1; const int kHeapObjectTag = 1;
const int kHeapObjectTagSize = 2; const int kHeapObjectTagSize = 2;
const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1; const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
// Tag information for Smi. // Tag information for Smi.
const int kSmiTag = 0; const int kSmiTag = 0;
const int kSmiTagSize = 1; const int kSmiTagSize = 1;
const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1; const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
template <size_t ptr_size> struct SmiConstants; template <size_t ptr_size> struct SmiTagging;
// Smi constants for 32-bit systems. // Smi constants for 32-bit systems.
template <> struct SmiConstants<4> { template <> struct SmiTagging<4> {
static const int kSmiShiftSize = 0; static const int kSmiShiftSize = 0;
static const int kSmiValueSize = 31; static const int kSmiValueSize = 31;
static inline int SmiToInt(internal::Object* value) { static inline int SmiToInt(internal::Object* value) {
int shift_bits = kSmiTagSize + kSmiShiftSize; int shift_bits = kSmiTagSize + kSmiShiftSize;
// Throw away top 32 bits and shift down (requires >> to be sign extend ing). // Throw away top 32 bits and shift down (requires >> to be sign extend ing).
return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bit s; return static_cast<int>(reinterpret_cast<intptr_t>(value)) >> shift_bit s;
} }
// For 32-bit systems any 2 bytes aligned pointer can be encoded as smi
// with a plain reinterpret_cast.
static const intptr_t kEncodablePointerMask = 0x1;
static const int kPointerToSmiShift = 0;
}; };
// Smi constants for 64-bit systems. // Smi constants for 64-bit systems.
template <> struct SmiConstants<8> { template <> struct SmiTagging<8> {
static const int kSmiShiftSize = 31; static const int kSmiShiftSize = 31;
static const int kSmiValueSize = 32; static const int kSmiValueSize = 32;
static inline int SmiToInt(internal::Object* value) { static inline int SmiToInt(internal::Object* value) {
int shift_bits = kSmiTagSize + kSmiShiftSize; int shift_bits = kSmiTagSize + kSmiShiftSize;
// Shift down and throw away top 32 bits. // Shift down and throw away top 32 bits.
return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits ); return static_cast<int>(reinterpret_cast<intptr_t>(value) >> shift_bits );
} }
// To maximize the range of pointers that can be encoded
// in the available 32 bits, we require them to be 8 bytes aligned.
// This gives 2 ^ (32 + 3) = 32G address space covered.
// It might be not enough to cover stack allocated objects on some platfo
rms.
static const int kPointerAlignment = 3;
static const intptr_t kEncodablePointerMask =
~(intptr_t(0xffffffff) << kPointerAlignment);
static const int kPointerToSmiShift =
kSmiTagSize + kSmiShiftSize - kPointerAlignment;
}; };
const int kSmiShiftSize = SmiConstants<kApiPointerSize>::kSmiShiftSize; typedef SmiTagging<kApiPointerSize> PlatformSmiTagging;
const int kSmiValueSize = SmiConstants<kApiPointerSize>::kSmiValueSize; const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
const intptr_t kEncodablePointerMask =
PlatformSmiTagging::kEncodablePointerMask;
const int kPointerToSmiShift = PlatformSmiTagging::kPointerToSmiShift;
template <size_t ptr_size> struct InternalConstants; template <size_t ptr_size> struct InternalConstants;
// Internal constants for 32-bit systems. // Internal constants for 32-bit systems.
template <> struct InternalConstants<4> { template <> struct InternalConstants<4> {
static const int kStringResourceOffset = 3 * kApiPointerSize; static const int kStringResourceOffset = 3 * kApiPointerSize;
}; };
// Internal constants for 64-bit systems. // Internal constants for 64-bit systems.
template <> struct InternalConstants<8> { template <> struct InternalConstants<8> {
skipping to change at line 3349 skipping to change at line 3373
static inline bool HasHeapObjectTag(internal::Object* value) { static inline bool HasHeapObjectTag(internal::Object* value) {
return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) == return ((reinterpret_cast<intptr_t>(value) & kHeapObjectTagMask) ==
kHeapObjectTag); kHeapObjectTag);
} }
static inline bool HasSmiTag(internal::Object* value) { static inline bool HasSmiTag(internal::Object* value) {
return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag); return ((reinterpret_cast<intptr_t>(value) & kSmiTagMask) == kSmiTag);
} }
static inline int SmiValue(internal::Object* value) { static inline int SmiValue(internal::Object* value) {
return SmiConstants<kApiPointerSize>::SmiToInt(value); return PlatformSmiTagging::SmiToInt(value);
} }
static inline int GetInstanceType(internal::Object* obj) { static inline int GetInstanceType(internal::Object* obj) {
typedef internal::Object O; typedef internal::Object O;
O* map = ReadField<O*>(obj, kHeapObjectMapOffset); O* map = ReadField<O*>(obj, kHeapObjectMapOffset);
return ReadField<uint8_t>(map, kMapInstanceTypeOffset); return ReadField<uint8_t>(map, kMapInstanceTypeOffset);
} }
static inline void* GetExternalPointerFromSmi(internal::Object* value) {
const intptr_t address = reinterpret_cast<intptr_t>(value);
return reinterpret_cast<void*>(address >> kPointerToSmiShift);
}
static inline void* GetExternalPointer(internal::Object* obj) { static inline void* GetExternalPointer(internal::Object* obj) {
if (HasSmiTag(obj)) { if (HasSmiTag(obj)) {
return obj; return GetExternalPointerFromSmi(obj);
} else if (GetInstanceType(obj) == kProxyType) { } else if (GetInstanceType(obj) == kProxyType) {
return ReadField<void*>(obj, kProxyProxyOffset); return ReadField<void*>(obj, kProxyProxyOffset);
} else { } else {
return NULL; return NULL;
} }
} }
static inline bool IsExternalTwoByteString(int instance_type) { static inline bool IsExternalTwoByteString(int instance_type) {
int representation = (instance_type & kFullStringRepresentationMask); int representation = (instance_type & kFullStringRepresentationMask);
return representation == kExternalTwoByteRepresentationTag; return representation == kExternalTwoByteRepresentationTag;
 End of changes. 12 change blocks. 
7 lines changed or deleted 37 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/