Roll V8 back to 3.6
Roll back to V8 3.6 to fix x86 build, we don't have ucontext.h.
This reverts commits:
5d4cdbf7a67d3662fa0bee4efdb7edd8daec9b0b
c7cc028aaeedbbfa11c11d0b7b243b3d9e837ed9
592a9fc1d8ea420377a2e7efd0600e20b058be2b
Bug: 5688872
Change-Id: Ic961bb5e65b778e98bbfb71cce71d99fa949e995
diff --git a/src/utils.h b/src/utils.h
index 1d40c98..cf7819e 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -1,4 +1,4 @@
-// Copyright 2012 the V8 project authors. All rights reserved.
+// Copyright 2011 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:
@@ -47,13 +47,13 @@
// Returns true iff x is a power of 2 (or zero). Cannot be used with the
// maximally negative value of the type T (the -1 overflows).
template <typename T>
-inline bool IsPowerOf2(T x) {
+static inline bool IsPowerOf2(T x) {
return IS_POWER_OF_TWO(x);
}
// X must be a power of 2. Returns the number of trailing zeros.
-inline int WhichPowerOf2(uint32_t x) {
+static inline int WhichPowerOf2(uint32_t x) {
ASSERT(IsPowerOf2(x));
ASSERT(x != 0);
int bits = 0;
@@ -88,7 +88,7 @@
// The C++ standard leaves the semantics of '>>' undefined for
// negative signed operands. Most implementations do the right thing,
// though.
-inline int ArithmeticShiftRight(int x, int s) {
+static inline int ArithmeticShiftRight(int x, int s) {
return x >> s;
}
@@ -97,7 +97,7 @@
// This allows conversion of Addresses and integral types into
// 0-relative int offsets.
template <typename T>
-inline intptr_t OffsetFrom(T x) {
+static inline intptr_t OffsetFrom(T x) {
return x - static_cast<T>(0);
}
@@ -106,14 +106,14 @@
// This allows conversion of 0-relative int offsets into Addresses and
// integral types.
template <typename T>
-inline T AddressFrom(intptr_t x) {
+static inline T AddressFrom(intptr_t x) {
return static_cast<T>(static_cast<T>(0) + x);
}
// Return the largest multiple of m which is <= x.
template <typename T>
-inline T RoundDown(T x, intptr_t m) {
+static inline T RoundDown(T x, int m) {
ASSERT(IsPowerOf2(m));
return AddressFrom<T>(OffsetFrom(x) & -m);
}
@@ -121,13 +121,13 @@
// Return the smallest multiple of m which is >= x.
template <typename T>
-inline T RoundUp(T x, intptr_t m) {
- return RoundDown<T>(static_cast<T>(x + m - 1), m);
+static inline T RoundUp(T x, int m) {
+ return RoundDown(x + m - 1, m);
}
template <typename T>
-int Compare(const T& a, const T& b) {
+static int Compare(const T& a, const T& b) {
if (a == b)
return 0;
else if (a < b)
@@ -138,26 +138,16 @@
template <typename T>
-int PointerValueCompare(const T* a, const T* b) {
+static int PointerValueCompare(const T* a, const T* b) {
return Compare<T>(*a, *b);
}
-// Compare function to compare the object pointer value of two
-// handlified objects. The handles are passed as pointers to the
-// handles.
-template<typename T> class Handle; // Forward declaration.
-template <typename T>
-int HandleObjectPointerCompare(const Handle<T>* a, const Handle<T>* b) {
- return Compare<T*>(*(*a), *(*b));
-}
-
-
// Returns the smallest power of two which is >= x. If you pass in a
// number that is already a power of two, it is returned as is.
// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
// figure 3-3, page 48, where the function is called clp2.
-inline uint32_t RoundUpToPowerOf2(uint32_t x) {
+static inline uint32_t RoundUpToPowerOf2(uint32_t x) {
ASSERT(x <= 0x80000000u);
x = x - 1;
x = x | (x >> 1);
@@ -169,23 +159,18 @@
}
-inline uint32_t RoundDownToPowerOf2(uint32_t x) {
- uint32_t rounded_up = RoundUpToPowerOf2(x);
- if (rounded_up > x) return rounded_up >> 1;
- return rounded_up;
-}
-
-template <typename T, typename U>
-inline bool IsAligned(T value, U alignment) {
+template <typename T>
+static inline bool IsAligned(T value, T alignment) {
+ ASSERT(IsPowerOf2(alignment));
return (value & (alignment - 1)) == 0;
}
// Returns true if (addr + offset) is aligned.
-inline bool IsAddressAligned(Address addr,
- intptr_t alignment,
- int offset = 0) {
+static inline bool IsAddressAligned(Address addr,
+ intptr_t alignment,
+ int offset) {
intptr_t offs = OffsetFrom(addr + offset);
return IsAligned(offs, alignment);
}
@@ -193,14 +178,14 @@
// Returns the maximum of the two parameters.
template <typename T>
-T Max(T a, T b) {
+static T Max(T a, T b) {
return a < b ? b : a;
}
// Returns the minimum of the two parameters.
template <typename T>
-T Min(T a, T b) {
+static T Min(T a, T b) {
return a < b ? a : b;
}
@@ -256,7 +241,7 @@
// Thomas Wang, Integer Hash Functions.
// http://www.concentric.net/~Ttwang/tech/inthash.htm
-inline uint32_t ComputeIntegerHash(uint32_t key, uint32_t seed) {
+static inline uint32_t ComputeIntegerHash(uint32_t key, uint32_t seed) {
uint32_t hash = key;
hash = hash ^ seed;
hash = ~hash + (hash << 15); // hash = (hash << 15) - hash - 1;
@@ -269,19 +254,7 @@
}
-inline uint32_t ComputeLongHash(uint64_t key) {
- uint64_t hash = key;
- hash = ~hash + (hash << 18); // hash = (hash << 18) - hash - 1;
- hash = hash ^ (hash >> 31);
- hash = hash * 21; // hash = (hash + (hash << 2)) + (hash << 4);
- hash = hash ^ (hash >> 11);
- hash = hash + (hash << 6);
- hash = hash ^ (hash >> 22);
- return (uint32_t) hash;
-}
-
-
-inline uint32_t ComputePointerHash(void* ptr) {
+static inline uint32_t ComputePointerHash(void* ptr) {
return ComputeIntegerHash(
static_cast<uint32_t>(reinterpret_cast<intptr_t>(ptr)),
v8::internal::kZeroHashSeed);
@@ -738,7 +711,7 @@
// Compare ASCII/16bit chars to ASCII/16bit chars.
template <typename lchar, typename rchar>
-inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) {
+static inline int CompareChars(const lchar* lhs, const rchar* rhs, int chars) {
const lchar* limit = lhs + chars;
#ifdef V8_HOST_CAN_READ_UNALIGNED
if (sizeof(*lhs) == sizeof(*rhs)) {
@@ -765,7 +738,7 @@
// Calculate 10^exponent.
-inline int TenToThe(int exponent) {
+static inline int TenToThe(int exponent) {
ASSERT(exponent <= 9);
ASSERT(exponent >= 1);
int answer = 10;
@@ -931,17 +904,9 @@
explicit EnumSet(T bits = 0) : bits_(bits) {}
bool IsEmpty() const { return bits_ == 0; }
bool Contains(E element) const { return (bits_ & Mask(element)) != 0; }
- bool ContainsAnyOf(const EnumSet& set) const {
- return (bits_ & set.bits_) != 0;
- }
void Add(E element) { bits_ |= Mask(element); }
- void Add(const EnumSet& set) { bits_ |= set.bits_; }
void Remove(E element) { bits_ &= ~Mask(element); }
- void Remove(const EnumSet& set) { bits_ &= ~set.bits_; }
- void RemoveAll() { bits_ = 0; }
- void Intersect(const EnumSet& set) { bits_ &= set.bits_; }
T ToIntegral() const { return bits_; }
- bool operator==(const EnumSet& set) { return bits_ == set.bits_; }
private:
T Mask(E element) const {