From 8e634eaa0b9e4441b98e4c53f06f4a17af9470a8 Mon Sep 17 00:00:00 2001 From: mstarzinger Date: Thu, 13 Aug 2015 07:02:22 -0700 Subject: [PATCH] Make some foo.h headers usable without foo-inl.h header. This CL us a pure refactoring that makes an empty compilation unit including just "foo.h" but not "foo-inl.h" compile without warnings or errors. This is needed to further reduce the header dependency tangle. R=rossberg@chromium.org Review URL: https://codereview.chromium.org/1290743005 Cr-Commit-Position: refs/heads/master@{#30158} --- src/conversions-inl.h | 63 +++++++++++++++++++++++++++++++++ src/conversions.h | 70 ++++++------------------------------- src/layout-descriptor-inl.h | 5 +++ src/layout-descriptor.h | 4 +-- src/types-inl.h | 14 -------- src/types.h | 8 +++-- 6 files changed, 85 insertions(+), 79 deletions(-) diff --git a/src/conversions-inl.h b/src/conversions-inl.h index ae87dc4d31..d9f16ade2e 100644 --- a/src/conversions-inl.h +++ b/src/conversions-inl.h @@ -18,6 +18,7 @@ #include "src/base/platform/platform.h" #include "src/conversions.h" #include "src/double.h" +#include "src/objects-inl.h" #include "src/scanner.h" #include "src/strtod.h" @@ -97,6 +98,68 @@ int32_t DoubleToInt32(double x) { } +bool IsSmiDouble(double value) { + return !IsMinusZero(value) && value >= Smi::kMinValue && + value <= Smi::kMaxValue && value == FastI2D(FastD2I(value)); +} + + +bool IsInt32Double(double value) { + return !IsMinusZero(value) && value >= kMinInt && value <= kMaxInt && + value == FastI2D(FastD2I(value)); +} + + +bool IsUint32Double(double value) { + return !IsMinusZero(value) && value >= 0 && value <= kMaxUInt32 && + value == FastUI2D(FastD2UI(value)); +} + + +int32_t NumberToInt32(Object* number) { + if (number->IsSmi()) return Smi::cast(number)->value(); + return DoubleToInt32(number->Number()); +} + + +uint32_t NumberToUint32(Object* number) { + if (number->IsSmi()) return Smi::cast(number)->value(); + return DoubleToUint32(number->Number()); +} + + +bool TryNumberToSize(Isolate* isolate, Object* number, size_t* result) { + SealHandleScope shs(isolate); + if (number->IsSmi()) { + int value = Smi::cast(number)->value(); + DCHECK(static_cast(Smi::kMaxValue) <= + std::numeric_limits::max()); + if (value >= 0) { + *result = static_cast(value); + return true; + } + return false; + } else { + DCHECK(number->IsHeapNumber()); + double value = HeapNumber::cast(number)->value(); + if (value >= 0 && value <= std::numeric_limits::max()) { + *result = static_cast(value); + return true; + } else { + return false; + } + } +} + + +size_t NumberToSize(Isolate* isolate, Object* number) { + size_t result = 0; + bool is_valid = TryNumberToSize(isolate, number, &result); + CHECK(is_valid); + return result; +} + + template bool SubStringEquals(Iterator* current, EndMark end, diff --git a/src/conversions.h b/src/conversions.h index 1413bc2eaa..666c2efb12 100644 --- a/src/conversions.h +++ b/src/conversions.h @@ -9,7 +9,6 @@ #include "src/base/logging.h" #include "src/handles.h" -#include "src/objects.h" #include "src/utils.h" namespace v8 { @@ -157,88 +156,41 @@ static inline bool IsMinusZero(double value) { } -static inline bool IsSmiDouble(double value) { - return !IsMinusZero(value) && value >= Smi::kMinValue && - value <= Smi::kMaxValue && value == FastI2D(FastD2I(value)); -} +static inline bool IsSmiDouble(double value); // Integer32 is an integer that can be represented as a signed 32-bit // integer. It has to be in the range [-2^31, 2^31 - 1]. // We also have to check for negative 0 as it is not an Integer32. -static inline bool IsInt32Double(double value) { - return !IsMinusZero(value) && - value >= kMinInt && - value <= kMaxInt && - value == FastI2D(FastD2I(value)); -} +static inline bool IsInt32Double(double value); // UInteger32 is an integer that can be represented as an unsigned 32-bit // integer. It has to be in the range [0, 2^32 - 1]. // We also have to check for negative 0 as it is not a UInteger32. -static inline bool IsUint32Double(double value) { - return !IsMinusZero(value) && - value >= 0 && - value <= kMaxUInt32 && - value == FastUI2D(FastD2UI(value)); -} +static inline bool IsUint32Double(double value); // Convert from Number object to C integer. -inline int32_t NumberToInt32(Object* number) { - if (number->IsSmi()) return Smi::cast(number)->value(); - return DoubleToInt32(number->Number()); -} - - -inline uint32_t NumberToUint32(Object* number) { - if (number->IsSmi()) return Smi::cast(number)->value(); - return DoubleToUint32(number->Number()); -} +inline int32_t NumberToInt32(Object* number); +inline uint32_t NumberToUint32(Object* number); double StringToDouble(UnicodeCache* unicode_cache, Handle string, int flags, double empty_string_val = 0.0); -inline bool TryNumberToSize(Isolate* isolate, - Object* number, size_t* result) { - SealHandleScope shs(isolate); - if (number->IsSmi()) { - int value = Smi::cast(number)->value(); - DCHECK(static_cast(Smi::kMaxValue) - <= std::numeric_limits::max()); - if (value >= 0) { - *result = static_cast(value); - return true; - } - return false; - } else { - DCHECK(number->IsHeapNumber()); - double value = HeapNumber::cast(number)->value(); - if (value >= 0 && - value <= std::numeric_limits::max()) { - *result = static_cast(value); - return true; - } else { - return false; - } - } -} +inline bool TryNumberToSize(Isolate* isolate, Object* number, size_t* result); + // Converts a number into size_t. -inline size_t NumberToSize(Isolate* isolate, - Object* number) { - size_t result = 0; - bool is_valid = TryNumberToSize(isolate, number, &result); - CHECK(is_valid); - return result; -} +inline size_t NumberToSize(Isolate* isolate, Object* number); // returns DoubleToString(StringToDouble(string)) == string bool IsSpecialIndex(UnicodeCache* unicode_cache, String* string); -} } // namespace v8::internal + +} // namespace internal +} // namespace v8 #endif // V8_CONVERSIONS_H_ diff --git a/src/layout-descriptor-inl.h b/src/layout-descriptor-inl.h index cb3325b31f..3771064c8f 100644 --- a/src/layout-descriptor-inl.h +++ b/src/layout-descriptor-inl.h @@ -56,6 +56,11 @@ bool LayoutDescriptor::GetIndexes(int field_index, int* layout_word_index, } +LayoutDescriptor* LayoutDescriptor::SetRawData(int field_index) { + return SetTagged(field_index, false); +} + + LayoutDescriptor* LayoutDescriptor::SetTagged(int field_index, bool tagged) { int layout_word_index; int layout_bit_index; diff --git a/src/layout-descriptor.h b/src/layout-descriptor.h index 0a14f53198..11d8d35f26 100644 --- a/src/layout-descriptor.h +++ b/src/layout-descriptor.h @@ -124,9 +124,7 @@ class LayoutDescriptor : public FixedTypedArray { V8_INLINE bool GetIndexes(int field_index, int* layout_word_index, int* layout_bit_index); - V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetRawData(int field_index) { - return SetTagged(field_index, false); - } + V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetRawData(int field_index); V8_INLINE MUST_USE_RESULT LayoutDescriptor* SetTagged(int field_index, bool tagged); diff --git a/src/types-inl.h b/src/types-inl.h index 762a11df30..084f5db812 100644 --- a/src/types-inl.h +++ b/src/types-inl.h @@ -67,13 +67,6 @@ bool TypeImpl::NowContains(i::Object* value) { // ----------------------------------------------------------------------------- // ZoneTypeConfig -// static -template -T* ZoneTypeConfig::null_handle() { - return NULL; -} - - // static template T* ZoneTypeConfig::handle(T* type) { @@ -281,13 +274,6 @@ void ZoneTypeConfig::range_set_double(ZoneTypeConfig::Range* range, int index, // ----------------------------------------------------------------------------- // HeapTypeConfig -// static -template -i::Handle HeapTypeConfig::null_handle() { - return i::Handle(); -} - - // static template i::Handle HeapTypeConfig::handle(T* type) { diff --git a/src/types.h b/src/types.h index 8d63908015..31ee95cbb4 100644 --- a/src/types.h +++ b/src/types.h @@ -6,8 +6,8 @@ #define V8_TYPES_H_ #include "src/conversions.h" -#include "src/factory.h" #include "src/handles.h" +#include "src/objects.h" #include "src/ostreams.h" namespace v8 { @@ -1003,7 +1003,7 @@ struct ZoneTypeConfig { static const int kRangeStructTag = 0x1000; - template static inline T* null_handle(); + template static inline T* null_handle() { return nullptr; } template static inline T* handle(T* type); template static inline T* cast(Type* type); @@ -1058,7 +1058,9 @@ struct HeapTypeConfig { static const int kRangeStructTag = 0xffff; - template static inline i::Handle null_handle(); + template static inline i::Handle null_handle() { + return i::Handle(); + } template static inline i::Handle handle(T* type); template static inline i::Handle cast(i::Handle type);