v8::base::bits Namespace Reference

Functions
	TEST (Bits, CountPopulation32)
	TEST (Bits, CountLeadingZeros32)
	TEST (Bits, CountTrailingZeros32)
	TEST (Bits, IsPowerOfTwo32)
	TEST (Bits, IsPowerOfTwo64)
	TEST (Bits, RoundUpToPowerOfTwo32)
	TEST (BitsDeathTest, DISABLE_IN_RELEASE(RoundUpToPowerOfTwo32))
	TEST (Bits, RoundDownToPowerOfTwo32)
	TEST (Bits, RotateRight32)
	TEST (Bits, RotateRight64)
	TEST (Bits, SignedAddOverflow32)
	TEST (Bits, SignedSubOverflow32)
uint32_t	RoundUpToPowerOfTwo32 (uint32_t value)
uint32_t	CountPopulation32 (uint32_t value)
uint32_t	CountLeadingZeros32 (uint32_t value)
uint32_t	CountTrailingZeros32 (uint32_t value)
bool	IsPowerOfTwo32 (uint32_t value)
bool	IsPowerOfTwo64 (uint64_t value)
uint32_t	RoundDownToPowerOfTwo32 (uint32_t value)
uint32_t	RotateRight32 (uint32_t value, uint32_t shift)
uint64_t	RotateRight64 (uint64_t value, uint64_t shift)
bool	SignedAddOverflow32 (int32_t lhs, int32_t rhs, int32_t *val)
bool	SignedSubOverflow32 (int32_t lhs, int32_t rhs, int32_t *val)

Function Documentation

CountLeadingZeros32()

uint32_t v8::base::bits::CountLeadingZeros32 ( uint32_t  value )

inline

Definition at line 38 of file bits.h.

                                                    {
#if V8_HAS_BUILTIN_CLZ
  return value ? __builtin_clz(value) : 32;
#elif V8_CC_MSVC
  unsigned long result;  // NOLINT(runtime/int)
  if (!_BitScanReverse(&result, value)) return 32;
  return static_cast<uint32_t>(31 - result);
#else
  value = value | (value >> 1);
  value = value | (value >> 2);
  value = value | (value >> 4);
  value = value | (value >> 8);
  value = value | (value >> 16);
  return CountPopulation32(~value);
#endif
}

References CountPopulation32().

Referenced by TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

CountPopulation32()

uint32_t v8::base::bits::CountPopulation32 ( uint32_t  value )

inline

Definition at line 22 of file bits.h.

                                                  {
#if V8_HAS_BUILTIN_POPCOUNT
  return __builtin_popcount(value);
#else
  value = ((value >> 1) & 0x55555555) + (value & 0x55555555);
  value = ((value >> 2) & 0x33333333) + (value & 0x33333333);
  value = ((value >> 4) & 0x0f0f0f0f) + (value & 0x0f0f0f0f);
  value = ((value >> 8) & 0x00ff00ff) + (value & 0x00ff00ff);
  value = ((value >> 16) & 0x0000ffff) + (value & 0x0000ffff);
  return value;
#endif
}

Referenced by v8::internal::BitVector::Count(), CountLeadingZeros32(), v8::internal::NumRegs(), and TEST().

Here is the caller graph for this function:

CountTrailingZeros32()

uint32_t v8::base::bits::CountTrailingZeros32 ( uint32_t  value )

inline

Definition at line 59 of file bits.h.

                                                     {
#if V8_HAS_BUILTIN_CTZ
  return value ? __builtin_ctz(value) : 32;
#elif V8_CC_MSVC
  unsigned long result;  // NOLINT(runtime/int)
  if (!_BitScanForward(&result, value)) return 32;
  return static_cast<uint32_t>(result);
#else
  if (value == 0) return 32;
  unsigned count = 0;
  for (value ^= value - 1; value >>= 1; ++count)
    ;
  return count;
#endif
}

Referenced by v8::internal::MarkCompactCollector::DiscoverAndEvacuateBlackObjectsOnPage(), v8::internal::DiscoverGreyObjectsOnPage(), and TEST().

Here is the caller graph for this function:

IsPowerOfTwo32()

bool v8::base::bits::IsPowerOfTwo32 ( uint32_t  value )

inline

Definition at line 77 of file bits.h.

                                           {
  return value && !(value & (value - 1));
}

Referenced by v8::internal::MacroAssembler::AlignAndSetCSPForFrame(), v8::internal::AlignedAlloc(), v8::internal::InnerPointerToCodeCache::GetCacheEntry(), v8::internal::HashTable< Derived, Shape, Key >::GetProbe(), v8::internal::compiler::RepresentationChanger::GetRepresentationFor(), v8::internal::StubCache::Initialize(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Initialize(), v8::internal::InternalStringToInt(), v8::internal::MakeOrFindTwoCharacterString(), v8::internal::HashTable< Derived, Shape, Key >::New(), v8::internal::TemplateHashMapImpl< AllocationPolicy >::Probe(), v8::internal::compiler::RepresentationOf(), v8::internal::HBinaryOperation::RightIsPowerOf2(), v8::internal::MapSpace::RoundSizeDownToObjectAlignment(), v8::internal::CellSpace::RoundSizeDownToObjectAlignment(), v8::internal::PropertyCellSpace::RoundSizeDownToObjectAlignment(), v8::internal::compiler::RepresentationSelector::SetOutput(), v8::internal::NewSpace::SetUp(), TEST(), and v8::internal::WhichPowerOf2().

Here is the caller graph for this function:

IsPowerOfTwo64()

bool v8::base::bits::IsPowerOfTwo64 ( uint64_t  value )

inline

Definition at line 83 of file bits.h.

                                           {
  return value && !(value & (value - 1));
}

Referenced by v8::internal::MacroAssembler::Claim(), v8::internal::MacroAssembler::ClaimBySMI(), v8::internal::MacroAssembler::Drop(), v8::internal::MacroAssembler::DropBySMI(), and TEST().

Here is the caller graph for this function:

RotateRight32()

uint32_t v8::base::bits::RotateRight32 ( uint32_t  value, uint32_t  shift  )

inline

Definition at line 107 of file bits.h.

                                                              {
  if (shift == 0) return value;
  return (value >> shift) | (value << (32 - shift));
}

References shift.

Referenced by TEST(), and v8::internal::compiler::TEST_F().

Here is the caller graph for this function:

RotateRight64()

uint64_t v8::base::bits::RotateRight64 ( uint64_t  value, uint64_t  shift  )

inline

Definition at line 113 of file bits.h.

                                                              {
  if (shift == 0) return value;
  return (value >> shift) | (value << (64 - shift));
}

References shift.

Referenced by TEST().

Here is the caller graph for this function:

RoundDownToPowerOfTwo32()

uint32_t v8::base::bits::RoundDownToPowerOfTwo32 ( uint32_t  value )

inline

Definition at line 99 of file bits.h.

                                                        {
  if (value > 0x80000000u) return 0x80000000u;
  uint32_t result = RoundUpToPowerOfTwo32(value);
  if (result > value) result >>= 1;
  return result;
}

References RoundUpToPowerOfTwo32().

Referenced by v8::internal::MarkingDeque::Initialize(), and TEST().

Here is the call graph for this function:

Here is the caller graph for this function:

RoundUpToPowerOfTwo32()

uint32_t v8::base::bits::RoundUpToPowerOfTwo32

(

uint32_t

value

)

Definition at line 12 of file bits.cc.

                                               {
  DCHECK_LE(value, 0x80000000u);
  value = value - 1;
  value = value | (value >> 1);
  value = value | (value >> 2);
  value = value | (value >> 4);
  value = value | (value >> 8);
  value = value | (value >> 16);
  return value + 1;
}

References DCHECK_LE.

Referenced by v8::internal::OrderedHashTable< Derived, Iterator, entrysize >::Allocate(), v8::internal::HashTable< Derived, Shape, Key >::ComputeCapacity(), v8::internal::Heap::ConfigureHeap(), v8::base::GetPageSize(), RoundDownToPowerOfTwo32(), and TEST().

Here is the caller graph for this function:

SignedAddOverflow32()

bool v8::base::bits::SignedAddOverflow32 ( int32_t  lhs, int32_t  rhs, int32_t *  val  )

inline

Definition at line 122 of file bits.h.

                                                                        {
#if V8_HAS_BUILTIN_SADD_OVERFLOW
  return __builtin_sadd_overflow(lhs, rhs, val);
#else
  uint32_t res = static_cast<uint32_t>(lhs) + static_cast<uint32_t>(rhs);
  *val = bit_cast<int32_t>(res);
  return ((res ^ lhs) & (res ^ rhs) & (1U << 31)) != 0;
#endif
}

Referenced by TEST(), and v8::internal::compiler::TEST_F().

Here is the caller graph for this function:

SignedSubOverflow32()

bool v8::base::bits::SignedSubOverflow32 ( int32_t  lhs, int32_t  rhs, int32_t *  val  )

inline

Definition at line 136 of file bits.h.

                                                                        {
#if V8_HAS_BUILTIN_SSUB_OVERFLOW
  return __builtin_ssub_overflow(lhs, rhs, val);
#else
  uint32_t res = static_cast<uint32_t>(lhs) - static_cast<uint32_t>(rhs);
  *val = bit_cast<int32_t>(res);
  return ((res ^ lhs) & (res ^ ~rhs) & (1U << 31)) != 0;
#endif
}

Referenced by TEST(), and v8::internal::compiler::TEST_F().

Here is the caller graph for this function:

TEST() [1/12]

v8::base::bits::TEST	(	Bits	,
		CountLeadingZeros32
	)

Definition at line 31 of file bits-unittest.cc.

                                {
  EXPECT_EQ(32u, CountLeadingZeros32(0));
  EXPECT_EQ(31u, CountLeadingZeros32(1));
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_EQ(31u - shift, CountLeadingZeros32(1u << shift));
  }
  EXPECT_EQ(4u, CountLeadingZeros32(0x0f0f0f0f));
}

References CountLeadingZeros32(), and shift.

Here is the call graph for this function:

TEST() [2/12]

v8::base::bits::TEST	(	Bits	,
		CountPopulation32
	)

Definition at line 21 of file bits-unittest.cc.

                              {
  EXPECT_EQ(0u, CountPopulation32(0));
  EXPECT_EQ(1u, CountPopulation32(1));
  EXPECT_EQ(8u, CountPopulation32(0x11111111));
  EXPECT_EQ(16u, CountPopulation32(0xf0f0f0f0));
  EXPECT_EQ(24u, CountPopulation32(0xfff0f0ff));
  EXPECT_EQ(32u, CountPopulation32(0xffffffff));
}

References CountPopulation32().

Here is the call graph for this function:

TEST() [3/12]

v8::base::bits::TEST	(	Bits	,
		CountTrailingZeros32
	)

Definition at line 41 of file bits-unittest.cc.

                                 {
  EXPECT_EQ(32u, CountTrailingZeros32(0));
  EXPECT_EQ(31u, CountTrailingZeros32(0x80000000));
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_EQ(shift, CountTrailingZeros32(1u << shift));
  }
  EXPECT_EQ(4u, CountTrailingZeros32(0xf0f0f0f0));
}

References CountTrailingZeros32(), and shift.

Here is the call graph for this function:

TEST() [4/12]

v8::base::bits::TEST	(	Bits	,
		IsPowerOfTwo32
	)

Definition at line 51 of file bits-unittest.cc.

                           {
  EXPECT_FALSE(IsPowerOfTwo32(0U));
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_TRUE(IsPowerOfTwo32(1U << shift));
    EXPECT_FALSE(IsPowerOfTwo32((1U << shift) + 5U));
    EXPECT_FALSE(IsPowerOfTwo32(~(1U << shift)));
  }
  TRACED_FORRANGE(uint32_t, shift, 2, 31) {
    EXPECT_FALSE(IsPowerOfTwo32((1U << shift) - 1U));
  }
  EXPECT_FALSE(IsPowerOfTwo32(0xffffffff));
}

References IsPowerOfTwo32(), shift, and U.

Here is the call graph for this function:

TEST() [5/12]

v8::base::bits::TEST	(	Bits	,
		IsPowerOfTwo64
	)

Definition at line 65 of file bits-unittest.cc.

                           {
  EXPECT_FALSE(IsPowerOfTwo64(0U));
  TRACED_FORRANGE(uint32_t, shift, 0, 63) {
    EXPECT_TRUE(IsPowerOfTwo64(V8_UINT64_C(1) << shift));
    EXPECT_FALSE(IsPowerOfTwo64((V8_UINT64_C(1) << shift) + 5U));
    EXPECT_FALSE(IsPowerOfTwo64(~(V8_UINT64_C(1) << shift)));
  }
  TRACED_FORRANGE(uint32_t, shift, 2, 63) {
    EXPECT_FALSE(IsPowerOfTwo64((V8_UINT64_C(1) << shift) - 1U));
  }
  EXPECT_FALSE(IsPowerOfTwo64(V8_UINT64_C(0xffffffffffffffff)));
}

References IsPowerOfTwo64(), shift, U, and V8_UINT64_C.

Here is the call graph for this function:

TEST() [6/12]

v8::base::bits::TEST	(	Bits	,
		RotateRight32
	)

Definition at line 105 of file bits-unittest.cc.

                          {
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_EQ(0u, RotateRight32(0u, shift));
  }
  EXPECT_EQ(1u, RotateRight32(1, 0));
  EXPECT_EQ(1u, RotateRight32(2, 1));
  EXPECT_EQ(0x80000000u, RotateRight32(1, 1));
}

References RotateRight32(), and shift.

Here is the call graph for this function:

TEST() [7/12]

v8::base::bits::TEST	(	Bits	,
		RotateRight64
	)

Definition at line 115 of file bits-unittest.cc.

                          {
  TRACED_FORRANGE(uint64_t, shift, 0, 63) {
    EXPECT_EQ(0u, RotateRight64(0u, shift));
  }
  EXPECT_EQ(1u, RotateRight64(1, 0));
  EXPECT_EQ(1u, RotateRight64(2, 1));
  EXPECT_EQ(V8_UINT64_C(0x8000000000000000), RotateRight64(1, 1));
}

References RotateRight64(), shift, and V8_UINT64_C.

Here is the call graph for this function:

TEST() [8/12]

v8::base::bits::TEST	(	Bits	,
		RoundDownToPowerOfTwo32
	)

Definition at line 95 of file bits-unittest.cc.

                                    {
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_EQ(1u << shift, RoundDownToPowerOfTwo32(1u << shift));
  }
  EXPECT_EQ(0u, RoundDownToPowerOfTwo32(0));
  EXPECT_EQ(4u, RoundDownToPowerOfTwo32(5));
  EXPECT_EQ(0x80000000u, RoundDownToPowerOfTwo32(0x80000001u));
}

References RoundDownToPowerOfTwo32(), and shift.

Here is the call graph for this function:

TEST() [9/12]

v8::base::bits::TEST	(	Bits	,
		RoundUpToPowerOfTwo32
	)

Definition at line 79 of file bits-unittest.cc.

                                  {
  TRACED_FORRANGE(uint32_t, shift, 0, 31) {
    EXPECT_EQ(1u << shift, RoundUpToPowerOfTwo32(1u << shift));
  }
  EXPECT_EQ(0u, RoundUpToPowerOfTwo32(0));
  EXPECT_EQ(4u, RoundUpToPowerOfTwo32(3));
  EXPECT_EQ(0x80000000u, RoundUpToPowerOfTwo32(0x7fffffffu));
}

References RoundUpToPowerOfTwo32(), and shift.

Here is the call graph for this function:

TEST() [10/12]

v8::base::bits::TEST	(	Bits	,
		SignedAddOverflow32
	)

Definition at line 125 of file bits-unittest.cc.

                                {
  int32_t val = 0;
  EXPECT_FALSE(SignedAddOverflow32(0, 0, &val));
  EXPECT_EQ(0, val);
  EXPECT_TRUE(
      SignedAddOverflow32(std::numeric_limits<int32_t>::max(), 1, &val));
  EXPECT_EQ(std::numeric_limits<int32_t>::min(), val);
  EXPECT_TRUE(
      SignedAddOverflow32(std::numeric_limits<int32_t>::min(), -1, &val));
  EXPECT_EQ(std::numeric_limits<int32_t>::max(), val);
  EXPECT_TRUE(SignedAddOverflow32(std::numeric_limits<int32_t>::max(),
                                  std::numeric_limits<int32_t>::max(), &val));
  EXPECT_EQ(-2, val);
  TRACED_FORRANGE(int32_t, i, 1, 50) {
    TRACED_FORRANGE(int32_t, j, 1, i) {
      EXPECT_FALSE(SignedAddOverflow32(i, j, &val));
      EXPECT_EQ(i + j, val);
    }
  }
}

References v8::internal::min(), and SignedAddOverflow32().

Here is the call graph for this function:

TEST() [11/12]

v8::base::bits::TEST	(	Bits	,
		SignedSubOverflow32
	)

Definition at line 147 of file bits-unittest.cc.

                                {
  int32_t val = 0;
  EXPECT_FALSE(SignedSubOverflow32(0, 0, &val));
  EXPECT_EQ(0, val);
  EXPECT_TRUE(
      SignedSubOverflow32(std::numeric_limits<int32_t>::min(), 1, &val));
  EXPECT_EQ(std::numeric_limits<int32_t>::max(), val);
  EXPECT_TRUE(
      SignedSubOverflow32(std::numeric_limits<int32_t>::max(), -1, &val));
  EXPECT_EQ(std::numeric_limits<int32_t>::min(), val);
  TRACED_FORRANGE(int32_t, i, 1, 50) {
    TRACED_FORRANGE(int32_t, j, 1, i) {
      EXPECT_FALSE(SignedSubOverflow32(i, j, &val));
      EXPECT_EQ(i - j, val);
    }
  }
}

References v8::internal::min(), and SignedSubOverflow32().

Here is the call graph for this function:

TEST() [12/12]

v8::base::bits::TEST	(	BitsDeathTest	,
		DISABLE_IN_RELEASE(RoundUpToPowerOfTwo32)
	)

Definition at line 89 of file bits-unittest.cc.

                                                               {
  ASSERT_DEATH_IF_SUPPORTED({ RoundUpToPowerOfTwo32(0x80000001u); },
                            "0x80000000");
}

References RoundUpToPowerOfTwo32().

Here is the call graph for this function: