v8::base Namespace Reference

Namespaces
	anonymous_namespace{condition-variable-unittest.cc}
	anonymous_namespace{flags-unittest.cc}
	anonymous_namespace{platform-posix.cc}
	anonymous_namespace{platform-unittest.cc}
	anonymous_namespace{platform-win32.cc}
	anonymous_namespace{semaphore-unittest.cc}
	anonymous_namespace{time-unittest.cc}
	bits
	internal

Classes
struct	AtomicOps_x86CPUFeatureStruct
class	FINAL
struct	MagicNumbersForDivision
struct	LeakyInstanceTrait
struct	StaticallyAllocatedInstanceTrait
struct	DynamicallyAllocatedInstanceTrait
struct	DefaultConstructTrait
struct	DefaultCreateTrait
struct	ThreadSafeInitOnceTrait
struct	SingleThreadInitOnceTrait
struct	LazyInstanceImpl
struct	LazyStaticInstance
struct	LazyInstance
struct	LazyDynamicInstance
struct	OneArgFunction
class	PosixMemoryMappedFile
class	TimezoneCache
class	Win32Time
class	Win32MemoryMappedFile
class	OS
class	VirtualMemory
class	Thread
struct	CreateSemaphoreTrait
struct	LazySemaphore
class	KernelTimestampClock
class	RandomNumberGeneratorTest

Typedefs
typedef char	Atomic8
typedef int32_t	Atomic32
typedef intptr_t	AtomicWord
typedef char	__tsan_atomic8
typedef short	__tsan_atomic16
typedef int	__tsan_atomic32
typedef long	__tsan_atomic64
typedef char	__tsan_atomic128
typedef MagicNumbersForDivision< uint32_t >	M32
typedef MagicNumbersForDivision< uint64_t >	M64
typedef AtomicWord	OnceType
typedef void(*	NoArgFunction) ()
typedef void(*	PointerArgFunction) (void *arg)
typedef LazyStaticInstance< ConditionVariable, DefaultConstructTrait< ConditionVariable >, ThreadSafeInitOnceTrait >::type	LazyConditionVariable
typedef LazyStaticInstance< Mutex, DefaultConstructTrait< Mutex >, ThreadSafeInitOnceTrait >::type	LazyMutex
typedef LazyStaticInstance< RecursiveMutex, DefaultConstructTrait< RecursiveMutex >, ThreadSafeInitOnceTrait >::type	LazyRecursiveMutex
typedef IN PSTR	UserSearchPath
typedef IN PSTR IN BOOL	fInvadeProcess
typedef OUT PSTR	SearchPath
typedef OUT PSTR IN DWORD	SearchPathLength
typedef IN HANDLE	hFile
typedef IN HANDLE IN PSTR	ImageName
typedef IN HANDLE IN PSTR IN PSTR	ModuleName
typedef IN HANDLE IN PSTR IN PSTR IN DWORD64	BaseOfDll
typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 IN DWORD	SizeOfDll
typedef HANDLE	hProcess
typedef HANDLE HANDLE	hThread
typedef HANDLE HANDLE LPSTACKFRAME64	StackFrame
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID	ContextRecord
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64	ReadMemoryRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64	FunctionTableAccessRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64	GetModuleBaseRoutine
typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 PTRANSLATE_ADDRESS_ROUTINE64	TranslateAddress
typedef IN DWORD64	qwAddr
typedef IN DWORD64 OUT PDWORD64	pdwDisplacement
typedef IN DWORD64 OUT PDWORD64 OUT PIMAGEHLP_SYMBOL64	Symbol
typedef IN DWORD64 OUT PDWORD OUT PIMAGEHLP_LINE64	Line64
typedef DWORD64	AddrBase
typedef DWORD	th32ProcessID
typedef LPMODULEENTRY32W	lpme

Enumerations
enum	__tsan_memory_order {   __tsan_memory_order_relaxed , __tsan_memory_order_consume , __tsan_memory_order_acquire , __tsan_memory_order_release ,   __tsan_memory_order_acq_rel , __tsan_memory_order_seq_cst }
enum	{ ONCE_STATE_UNINITIALIZED = 0 , ONCE_STATE_EXECUTING_FUNCTION = 1 , ONCE_STATE_DONE = 2 }
enum	OutputMode { UNKNOWN , CONSOLE , ODS }

Functions
Atomic32	NoBarrier_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
Atomic32	NoBarrier_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic32	NoBarrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)
Atomic32	Barrier_AtomicIncrement (volatile Atomic32 *ptr, Atomic32 increment)
Atomic32	Acquire_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
Atomic32	Release_CompareAndSwap (volatile Atomic32 *ptr, Atomic32 old_value, Atomic32 new_value)
void	MemoryBarrier ()
void	NoBarrier_Store (volatile Atomic8 *ptr, Atomic8 value)
void	NoBarrier_Store (volatile Atomic32 *ptr, Atomic32 value)
void	Acquire_Store (volatile Atomic32 *ptr, Atomic32 value)
void	Release_Store (volatile Atomic32 *ptr, Atomic32 value)
Atomic8	NoBarrier_Load (volatile const Atomic8 *ptr)
Atomic32	NoBarrier_Load (volatile const Atomic32 *ptr)
Atomic32	Acquire_Load (volatile const Atomic32 *ptr)
Atomic32	Release_Load (volatile const Atomic32 *ptr)
Atomic64	NoBarrier_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
Atomic64	NoBarrier_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
Atomic64	NoBarrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)
Atomic64	Barrier_AtomicIncrement (volatile Atomic64 *ptr, Atomic64 increment)
Atomic64	Acquire_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
Atomic64	Release_CompareAndSwap (volatile Atomic64 *ptr, Atomic64 old_value, Atomic64 new_value)
void	NoBarrier_Store (volatile Atomic64 *ptr, Atomic64 value)
void	Acquire_Store (volatile Atomic64 *ptr, Atomic64 value)
void	Release_Store (volatile Atomic64 *ptr, Atomic64 value)
Atomic64	NoBarrier_Load (volatile const Atomic64 *ptr)
Atomic64	Acquire_Load (volatile const Atomic64 *ptr)
Atomic64	Release_Load (volatile const Atomic64 *ptr)
AtomicWord	NoBarrier_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
AtomicWord	NoBarrier_AtomicExchange (volatile AtomicWord *ptr, AtomicWord new_value)
AtomicWord	NoBarrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)
AtomicWord	Barrier_AtomicIncrement (volatile AtomicWord *ptr, AtomicWord increment)
AtomicWord	Acquire_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
AtomicWord	Release_CompareAndSwap (volatile AtomicWord *ptr, AtomicWord old_value, AtomicWord new_value)
void	NoBarrier_Store (volatile AtomicWord *ptr, AtomicWord value)
void	Acquire_Store (volatile AtomicWord *ptr, AtomicWord value)
void	Release_Store (volatile AtomicWord *ptr, AtomicWord value)
AtomicWord	NoBarrier_Load (volatile const AtomicWord *ptr)
AtomicWord	Acquire_Load (volatile const AtomicWord *ptr)
AtomicWord	Release_Load (volatile const AtomicWord *ptr)
__tsan_atomic8	__tsan_atomic8_load (const volatile __tsan_atomic8 *a, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_load (const volatile __tsan_atomic16 *a, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_load (const volatile __tsan_atomic32 *a, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_load (const volatile __tsan_atomic64 *a, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_load (const volatile __tsan_atomic128 *a, __tsan_memory_order mo)
void	__tsan_atomic8_store (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
void	__tsan_atomic16_store (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
void	__tsan_atomic32_store (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
void	__tsan_atomic64_store (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
void	__tsan_atomic128_store (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_exchange (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_exchange (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_exchange (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_exchange (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_exchange (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_add (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_add (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_add (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_add (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_add (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_and (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_and (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_and (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_and (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_and (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_or (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_or (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_or (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_or (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_or (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_xor (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_xor (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_xor (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_xor (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_xor (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
__tsan_atomic8	__tsan_atomic8_fetch_nand (volatile __tsan_atomic8 *a, __tsan_atomic8 v, __tsan_memory_order mo)
__tsan_atomic16	__tsan_atomic16_fetch_nand (volatile __tsan_atomic16 *a, __tsan_atomic16 v, __tsan_memory_order mo)
__tsan_atomic32	__tsan_atomic32_fetch_nand (volatile __tsan_atomic32 *a, __tsan_atomic32 v, __tsan_memory_order mo)
__tsan_atomic64	__tsan_atomic64_fetch_nand (volatile __tsan_atomic64 *a, __tsan_atomic64 v, __tsan_memory_order mo)
__tsan_atomic128	__tsan_atomic128_fetch_nand (volatile __tsan_atomic128 *a, __tsan_atomic128 v, __tsan_memory_order mo)
int	__tsan_atomic8_compare_exchange_weak (volatile __tsan_atomic8 *a, __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic16_compare_exchange_weak (volatile __tsan_atomic16 *a, __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic32_compare_exchange_weak (volatile __tsan_atomic32 *a, __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic64_compare_exchange_weak (volatile __tsan_atomic64 *a, __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic128_compare_exchange_weak (volatile __tsan_atomic128 *a, __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic8_compare_exchange_strong (volatile __tsan_atomic8 *a, __tsan_atomic8 *c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic16_compare_exchange_strong (volatile __tsan_atomic16 *a, __tsan_atomic16 *c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic32_compare_exchange_strong (volatile __tsan_atomic32 *a, __tsan_atomic32 *c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic64_compare_exchange_strong (volatile __tsan_atomic64 *a, __tsan_atomic64 *c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
int	__tsan_atomic128_compare_exchange_strong (volatile __tsan_atomic128 *a, __tsan_atomic128 *c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic8	__tsan_atomic8_compare_exchange_val (volatile __tsan_atomic8 *a, __tsan_atomic8 c, __tsan_atomic8 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic16	__tsan_atomic16_compare_exchange_val (volatile __tsan_atomic16 *a, __tsan_atomic16 c, __tsan_atomic16 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic32	__tsan_atomic32_compare_exchange_val (volatile __tsan_atomic32 *a, __tsan_atomic32 c, __tsan_atomic32 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic64	__tsan_atomic64_compare_exchange_val (volatile __tsan_atomic64 *a, __tsan_atomic64 c, __tsan_atomic64 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
__tsan_atomic128	__tsan_atomic128_compare_exchange_val (volatile __tsan_atomic128 *a, __tsan_atomic128 c, __tsan_atomic128 v, __tsan_memory_order mo, __tsan_memory_order fail_mo)
void	__tsan_atomic_thread_fence (__tsan_memory_order mo)
void	__tsan_atomic_signal_fence (__tsan_memory_order mo)
Atomic32	Acquire_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic32	Release_AtomicExchange (volatile Atomic32 *ptr, Atomic32 new_value)
Atomic64	Acquire_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
Atomic64	Release_AtomicExchange (volatile Atomic64 *ptr, Atomic64 new_value)
	TEST (CPUTest, FeatureImplications)
	TEST (CPUTest, RequiredFeatures)
template<class T >
std::ostream &	operator<< (std::ostream &os, const MagicNumbersForDivision< T > &mag)
static M32	s32 (int32_t d)
static M64	s64 (int64_t d)
static M32	u32 (uint32_t d)
static M64	u64 (uint64_t d)
	TEST (DivisionByConstant, Signed32)
	TEST (DivisionByConstant, Unsigned32)
	TEST (DivisionByConstant, Signed64)
	TEST (DivisionByConstant, Unsigned64)
template<class T >
MagicNumbersForDivision< T >	SignedDivisionByConstant (T d)
template<class T >
MagicNumbersForDivision< T >	UnsignedDivisionByConstant (T d, unsigned leading_zeros)
template MagicNumbersForDivision< uint32_t >	SignedDivisionByConstant (uint32_t d)
template MagicNumbersForDivision< uint64_t >	SignedDivisionByConstant (uint64_t d)
template MagicNumbersForDivision< uint32_t >	UnsignedDivisionByConstant (uint32_t d, unsigned leading_zeros)
template MagicNumbersForDivision< uint64_t >	UnsignedDivisionByConstant (uint64_t d, unsigned leading_zeros)
	TEST (FlagsTest, BasicOperations)
	TEST (FlagsTest, NamespaceScope)
	TEST (FlagsTest, ClassScope)
void	DumpBacktrace ()
void	CallOnceImpl (OnceType *once, PointerArgFunction init_func, void *arg)
void	CallOnce (OnceType *once, NoArgFunction init_func)
template<typename Arg >
void	CallOnce (OnceType *once, typename OneArgFunction< Arg * >::type init_func, Arg *arg)
	TEST (ConditionVariable, WaitForAfterNofityOnSameThread)
	TEST (ConditionVariable, MultipleThreadsWithSeparateConditionVariables)
	TEST (ConditionVariable, MultipleThreadsWithSharedSeparateConditionVariables)
	TEST (ConditionVariable, LoopIncrement)
	TEST (Mutex, LockGuardMutex)
	TEST (Mutex, LockGuardRecursiveMutex)
	TEST (Mutex, LockGuardLazyMutex)
	TEST (Mutex, LockGuardLazyRecursiveMutex)
	TEST (Mutex, MultipleMutexes)
	TEST (Mutex, MultipleRecursiveMutexes)
static void *	RandomizedVirtualAlloc (size_t size, int action, int protection)
static unsigned	StringToLong (char *buffer)
static void	SetThreadName (const char *name)
static void *	ThreadEntry (void *arg)
static Thread::LocalStorageKey	PthreadKeyToLocalKey (pthread_key_t pthread_key)
static pthread_key_t	LocalKeyToPthreadKey (Thread::LocalStorageKey local_key)
	TEST (OS, GetCurrentProcessId)
	TEST (Thread, SelfJoin)
	TEST_F (ThreadLocalStorageTest, DoTest)
static bool	HasConsole ()
static void	VPrintHelper (FILE *stream, const char *format, va_list args)
static size_t	GetPageSize ()
static void *	RandomizedVirtualAlloc (size_t size, int action, int protection)
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymInitialize))(IN HANDLE hProcess
typedef	DWORD (__stdcall *DLL_FUNC_TYPE(SymGetOptions))(VOID)
typedef	DWORD (__stdcall *DLL_FUNC_TYPE(SymSetOptions))(IN DWORD SymOptions)
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSearchPath))(IN HANDLE hProcess
typedef	DWORD64 (__stdcall *DLL_FUNC_TYPE(SymLoadModule64))(IN HANDLE hProcess
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(StackWalk64))(DWORD MachineType
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetSymFromAddr64))(IN HANDLE hProcess
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(SymGetLineFromAddr64))(IN HANDLE hProcess
typedef	PVOID (__stdcall *DLL_FUNC_TYPE(SymFunctionTableAccess64))(HANDLE hProcess
typedef	DWORD64 (__stdcall *DLL_FUNC_TYPE(SymGetModuleBase64))(HANDLE hProcess
typedef	HANDLE (__stdcall *DLL_FUNC_TYPE(CreateToolhelp32Snapshot))(DWORD dwFlags
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(Module32FirstW))(HANDLE hSnapshot
typedef	BOOL (__stdcall *DLL_FUNC_TYPE(Module32NextW))(HANDLE hSnapshot
static bool	LoadDbgHelpAndTlHelp32 ()
static std::vector< OS::SharedLibraryAddress >	LoadSymbols (HANDLE process_handle)
static unsigned int __stdcall	ThreadEntry (void *arg)
	TEST (Semaphore, ProducerConsumer)
	TEST (Semaphore, WaitAndSignal)
	TEST (Semaphore, WaitFor)
	TEST (TimeDelta, FromAndIn)
	TEST (Time, JsTime)
	TEST (Time, NowResolution)
	TEST (TimeTicks, NowResolution)
	TEST (TimeTicks, HighResolutionNowResolution)
	TEST (TimeTicks, IsMonotonic)
Time	operator+ (const TimeDelta &delta, const Time &time)
TimeTicks	operator+ (const TimeDelta &delta, const TimeTicks &ticks)
template<typename Dst , typename Src >
bool	IsValueInRangeForNumericType (Src value)
template<typename Dst , typename Src >
Dst	checked_cast (Src value)
template<typename Dst , typename Src >
Dst	saturated_cast (Src value)
	TEST (SysInfoTest, NumberOfProcessors)
	TEST (SysInfoTest, DISABLE_ON_NACL(AmountOfPhysicalMemory))
	TEST (SysInfoTest, AmountOfVirtualMemory)
	TEST_P (RandomNumberGeneratorTest, NextIntWithMaxValue)
	TEST_P (RandomNumberGeneratorTest, NextBooleanReturnsFalseOrTrue)
	TEST_P (RandomNumberGeneratorTest, NextDoubleReturnsValueBetween0And1)
	INSTANTIATE_TEST_CASE_P (RandomSeeds, RandomNumberGeneratorTest, ::testing::Values(INT_MIN, -1, 0, 1, 42, 100, 1234567890, 987654321, INT_MAX))

Variables
struct AtomicOps_x86CPUFeatureStruct	AtomicOps_Internalx86CPUFeatures
static const int	kMmapFd = -1
static const int	kMmapFdOffset = 0
static const int	kMmapFd = -1
static const int	kMmapFdOffset = 0
static const int	kMmapFd = VM_MAKE_TAG(255)
static const off_t	kMmapFdOffset = 0
static const int	kMmapFd = -1
static const int	kMmapFdOffset = 0
static LazyInstance< RandomNumberGenerator >::type	platform_random_number_generator = LAZY_INSTANCE_INITIALIZER
static const pthread_t	kNoThread = (pthread_t) 0
static const int	kMmapFd = -1
static const int	kMmapFdOffset = 0
static const int	kMmapFd = -1
static const int	kMmapFdOffset = 0
static OutputMode	output_mode = UNKNOWN
static LazyInstance< RandomNumberGenerator >::type	platform_random_number_generator = LAZY_INSTANCE_INITIALIZER
static const HANDLE	kNoThread = INVALID_HANDLE_VALUE
static LazyStaticInstance< KernelTimestampClock, DefaultConstructTrait< KernelTimestampClock >, ThreadSafeInitOnceTrait >::type	kernel_tick_clock
static const int	kMaxRuns = 12345
static LazyMutex	entropy_mutex = LAZY_MUTEX_INITIALIZER
static RandomNumberGenerator::EntropySource	entropy_source = NULL

Typedef Documentation

__tsan_atomic128

typedef char v8::base::__tsan_atomic128

Definition at line 30 of file atomicops_internals_tsan.h.

__tsan_atomic16

typedef short v8::base::__tsan_atomic16

Definition at line 21 of file atomicops_internals_tsan.h.

__tsan_atomic32

typedef int v8::base::__tsan_atomic32

Definition at line 22 of file atomicops_internals_tsan.h.

__tsan_atomic64

typedef long v8::base::__tsan_atomic64

Definition at line 23 of file atomicops_internals_tsan.h.

__tsan_atomic8

typedef char v8::base::__tsan_atomic8

Definition at line 20 of file atomicops_internals_tsan.h.

AddrBase

typedef DWORD64 v8::base::AddrBase

Definition at line 994 of file platform-win32.cc.

Atomic32

typedef int32_t v8::base::Atomic32

Definition at line 44 of file atomicops.h.

Atomic8

typedef char v8::base::Atomic8

Definition at line 43 of file atomicops.h.

AtomicWord

typedef intptr_t v8::base::AtomicWord

Definition at line 57 of file atomicops.h.

BaseOfDll

typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 v8::base::BaseOfDll

Definition at line 969 of file platform-win32.cc.

ContextRecord

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID v8::base::ContextRecord

Definition at line 976 of file platform-win32.cc.

fInvadeProcess

typedef IN PSTR IN BOOL v8::base::fInvadeProcess

Definition at line 957 of file platform-win32.cc.

FunctionTableAccessRoutine

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 v8::base::FunctionTableAccessRoutine

Definition at line 978 of file platform-win32.cc.

GetModuleBaseRoutine

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 v8::base::GetModuleBaseRoutine

Definition at line 979 of file platform-win32.cc.

hFile

typedef IN HANDLE v8::base::hFile

Definition at line 966 of file platform-win32.cc.

hProcess

typedef HANDLE v8::base::hProcess

Definition at line 973 of file platform-win32.cc.

hThread

typedef HANDLE HANDLE v8::base::hThread

Definition at line 974 of file platform-win32.cc.

ImageName

typedef IN HANDLE IN PSTR v8::base::ImageName

Definition at line 967 of file platform-win32.cc.

LazyConditionVariable

typedef LazyStaticInstance< ConditionVariable, DefaultConstructTrait<ConditionVariable>, ThreadSafeInitOnceTrait>::type v8::base::LazyConditionVariable

Definition at line 112 of file condition-variable.h.

LazyMutex

typedef LazyStaticInstance<Mutex, DefaultConstructTrait<Mutex>, ThreadSafeInitOnceTrait>::type v8::base::LazyMutex

Definition at line 105 of file mutex.h.

LazyRecursiveMutex

typedef LazyStaticInstance<RecursiveMutex, DefaultConstructTrait<RecursiveMutex>, ThreadSafeInitOnceTrait>::type v8::base::LazyRecursiveMutex

Definition at line 186 of file mutex.h.

Line64

typedef IN DWORD64 OUT PDWORD OUT PIMAGEHLP_LINE64 v8::base::Line64

Definition at line 990 of file platform-win32.cc.

lpme

typedef LPMODULEENTRY32W v8::base::lpme

Definition at line 1004 of file platform-win32.cc.

M32

typedef MagicNumbersForDivision<uint32_t> v8::base::M32

Definition at line 26 of file division-by-constant-unittest.cc.

M64

typedef MagicNumbersForDivision<uint64_t> v8::base::M64

Definition at line 27 of file division-by-constant-unittest.cc.

ModuleName

typedef IN HANDLE IN PSTR IN PSTR v8::base::ModuleName

Definition at line 968 of file platform-win32.cc.

NoArgFunction

typedef void(* v8::base::NoArgFunction) ()

Definition at line 72 of file once.h.

OnceType

typedef AtomicWord v8::base::OnceType

Definition at line 60 of file once.h.

pdwDisplacement

typedef IN DWORD64 OUT PDWORD v8::base::pdwDisplacement

Definition at line 984 of file platform-win32.cc.

PointerArgFunction

typedef void(* v8::base::PointerArgFunction) (void *arg)

Definition at line 73 of file once.h.

qwAddr

typedef IN DWORD64 v8::base::qwAddr

Definition at line 983 of file platform-win32.cc.

ReadMemoryRoutine

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 v8::base::ReadMemoryRoutine

Definition at line 977 of file platform-win32.cc.

SearchPath

typedef OUT PSTR v8::base::SearchPath

Definition at line 962 of file platform-win32.cc.

SearchPathLength

typedef OUT PSTR IN DWORD v8::base::SearchPathLength

Definition at line 963 of file platform-win32.cc.

SizeOfDll

typedef IN HANDLE IN PSTR IN PSTR IN DWORD64 IN DWORD v8::base::SizeOfDll

Definition at line 970 of file platform-win32.cc.

StackFrame

typedef HANDLE HANDLE LPSTACKFRAME64 v8::base::StackFrame

Definition at line 975 of file platform-win32.cc.

Symbol

typedef IN DWORD64 OUT PDWORD64 OUT PIMAGEHLP_SYMBOL64 v8::base::Symbol

Definition at line 985 of file platform-win32.cc.

th32ProcessID

typedef DWORD v8::base::th32ProcessID

Definition at line 1002 of file platform-win32.cc.

TranslateAddress

typedef HANDLE HANDLE LPSTACKFRAME64 PVOID PREAD_PROCESS_MEMORY_ROUTINE64 PFUNCTION_TABLE_ACCESS_ROUTINE64 PGET_MODULE_BASE_ROUTINE64 PTRANSLATE_ADDRESS_ROUTINE64 v8::base::TranslateAddress

Definition at line 980 of file platform-win32.cc.

UserSearchPath

typedef IN PSTR v8::base::UserSearchPath

Definition at line 956 of file platform-win32.cc.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
ONCE_STATE_UNINITIALIZED
ONCE_STATE_EXECUTING_FUNCTION
ONCE_STATE_DONE

Definition at line 66 of file once.h.

     {
  ONCE_STATE_UNINITIALIZED = 0,
  ONCE_STATE_EXECUTING_FUNCTION = 1,
  ONCE_STATE_DONE = 2
};

__tsan_memory_order

enum v8::base::__tsan_memory_order

Enumerator
__tsan_memory_order_relaxed
__tsan_memory_order_consume
__tsan_memory_order_acquire
__tsan_memory_order_release
__tsan_memory_order_acq_rel
__tsan_memory_order_seq_cst

Definition at line 34 of file atomicops_internals_tsan.h.

             {
  __tsan_memory_order_relaxed,
  __tsan_memory_order_consume,
  __tsan_memory_order_acquire,
  __tsan_memory_order_release,
  __tsan_memory_order_acq_rel,
  __tsan_memory_order_seq_cst,
} __tsan_memory_order;

OutputMode

enum v8::base::OutputMode

Enumerator
UNKNOWN
CONSOLE
ODS

Definition at line 533 of file platform-win32.cc.

                {
  UNKNOWN,  // Output method has not yet been determined.
  CONSOLE,  // Output is written to stdout.
  ODS       // Output is written to debug facility.
};

Function Documentation

__tsan_atomic128_compare_exchange_strong()

int v8::base::__tsan_atomic128_compare_exchange_strong	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128 *	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic128_compare_exchange_val()

__tsan_atomic128 v8::base::__tsan_atomic128_compare_exchange_val	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic128_compare_exchange_weak()

int v8::base::__tsan_atomic128_compare_exchange_weak	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128 *	c,
		__tsan_atomic128	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic128_exchange()

__tsan_atomic128 v8::base::__tsan_atomic128_exchange	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_fetch_add()

__tsan_atomic128 v8::base::__tsan_atomic128_fetch_add	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_fetch_and()

__tsan_atomic128 v8::base::__tsan_atomic128_fetch_and	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_fetch_nand()

__tsan_atomic128 v8::base::__tsan_atomic128_fetch_nand	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_fetch_or()

__tsan_atomic128 v8::base::__tsan_atomic128_fetch_or	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_fetch_xor()

__tsan_atomic128 v8::base::__tsan_atomic128_fetch_xor	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic128_load()

__tsan_atomic128 v8::base::__tsan_atomic128_load	(	const volatile __tsan_atomic128 *	a,
		__tsan_memory_order	mo
	)

__tsan_atomic128_store()

void v8::base::__tsan_atomic128_store	(	volatile __tsan_atomic128 *	a,
		__tsan_atomic128	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_compare_exchange_strong()

int v8::base::__tsan_atomic16_compare_exchange_strong	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16 *	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic16_compare_exchange_val()

__tsan_atomic16 v8::base::__tsan_atomic16_compare_exchange_val	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic16_compare_exchange_weak()

int v8::base::__tsan_atomic16_compare_exchange_weak	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16 *	c,
		__tsan_atomic16	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic16_exchange()

__tsan_atomic16 v8::base::__tsan_atomic16_exchange	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_fetch_add()

__tsan_atomic16 v8::base::__tsan_atomic16_fetch_add	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_fetch_and()

__tsan_atomic16 v8::base::__tsan_atomic16_fetch_and	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_fetch_nand()

__tsan_atomic16 v8::base::__tsan_atomic16_fetch_nand	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_fetch_or()

__tsan_atomic16 v8::base::__tsan_atomic16_fetch_or	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_fetch_xor()

__tsan_atomic16 v8::base::__tsan_atomic16_fetch_xor	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic16_load()

__tsan_atomic16 v8::base::__tsan_atomic16_load	(	const volatile __tsan_atomic16 *	a,
		__tsan_memory_order	mo
	)

__tsan_atomic16_store()

void v8::base::__tsan_atomic16_store	(	volatile __tsan_atomic16 *	a,
		__tsan_atomic16	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_compare_exchange_strong()

int v8::base::__tsan_atomic32_compare_exchange_strong	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32 *	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic32_compare_exchange_val()

__tsan_atomic32 v8::base::__tsan_atomic32_compare_exchange_val	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic32_compare_exchange_weak()

int v8::base::__tsan_atomic32_compare_exchange_weak	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32 *	c,
		__tsan_atomic32	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic32_exchange()

__tsan_atomic32 v8::base::__tsan_atomic32_exchange	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

Referenced by Acquire_AtomicExchange(), and Release_AtomicExchange().

Here is the caller graph for this function:

__tsan_atomic32_fetch_add()

__tsan_atomic32 v8::base::__tsan_atomic32_fetch_add	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_fetch_and()

__tsan_atomic32 v8::base::__tsan_atomic32_fetch_and	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_fetch_nand()

__tsan_atomic32 v8::base::__tsan_atomic32_fetch_nand	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_fetch_or()

__tsan_atomic32 v8::base::__tsan_atomic32_fetch_or	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_fetch_xor()

__tsan_atomic32 v8::base::__tsan_atomic32_fetch_xor	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic32_load()

__tsan_atomic32 v8::base::__tsan_atomic32_load	(	const volatile __tsan_atomic32 *	a,
		__tsan_memory_order	mo
	)

__tsan_atomic32_store()

void v8::base::__tsan_atomic32_store	(	volatile __tsan_atomic32 *	a,
		__tsan_atomic32	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_compare_exchange_strong()

int v8::base::__tsan_atomic64_compare_exchange_strong	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64 *	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic64_compare_exchange_val()

__tsan_atomic64 v8::base::__tsan_atomic64_compare_exchange_val	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic64_compare_exchange_weak()

int v8::base::__tsan_atomic64_compare_exchange_weak	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64 *	c,
		__tsan_atomic64	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic64_exchange()

__tsan_atomic64 v8::base::__tsan_atomic64_exchange	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

Referenced by Acquire_AtomicExchange(), and Release_AtomicExchange().

Here is the caller graph for this function:

__tsan_atomic64_fetch_add()

__tsan_atomic64 v8::base::__tsan_atomic64_fetch_add	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_fetch_and()

__tsan_atomic64 v8::base::__tsan_atomic64_fetch_and	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_fetch_nand()

__tsan_atomic64 v8::base::__tsan_atomic64_fetch_nand	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_fetch_or()

__tsan_atomic64 v8::base::__tsan_atomic64_fetch_or	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_fetch_xor()

__tsan_atomic64 v8::base::__tsan_atomic64_fetch_xor	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic64_load()

__tsan_atomic64 v8::base::__tsan_atomic64_load	(	const volatile __tsan_atomic64 *	a,
		__tsan_memory_order	mo
	)

__tsan_atomic64_store()

void v8::base::__tsan_atomic64_store	(	volatile __tsan_atomic64 *	a,
		__tsan_atomic64	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_compare_exchange_strong()

int v8::base::__tsan_atomic8_compare_exchange_strong	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8 *	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic8_compare_exchange_val()

__tsan_atomic8 v8::base::__tsan_atomic8_compare_exchange_val	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic8_compare_exchange_weak()

int v8::base::__tsan_atomic8_compare_exchange_weak	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8 *	c,
		__tsan_atomic8	v,
		__tsan_memory_order	mo,
		__tsan_memory_order	fail_mo
	)

__tsan_atomic8_exchange()

__tsan_atomic8 v8::base::__tsan_atomic8_exchange	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_fetch_add()

__tsan_atomic8 v8::base::__tsan_atomic8_fetch_add	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_fetch_and()

__tsan_atomic8 v8::base::__tsan_atomic8_fetch_and	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_fetch_nand()

__tsan_atomic8 v8::base::__tsan_atomic8_fetch_nand	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_fetch_or()

__tsan_atomic8 v8::base::__tsan_atomic8_fetch_or	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_fetch_xor()

__tsan_atomic8 v8::base::__tsan_atomic8_fetch_xor	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic8_load()

__tsan_atomic8 v8::base::__tsan_atomic8_load	(	const volatile __tsan_atomic8 *	a,
		__tsan_memory_order	mo
	)

__tsan_atomic8_store()

void v8::base::__tsan_atomic8_store	(	volatile __tsan_atomic8 *	a,
		__tsan_atomic8	v,
		__tsan_memory_order	mo
	)

__tsan_atomic_signal_fence()

void v8::base::__tsan_atomic_signal_fence

(

__tsan_memory_order

mo

)

__tsan_atomic_thread_fence()

void v8::base::__tsan_atomic_thread_fence

(

__tsan_memory_order

mo

)

Acquire_AtomicExchange() [1/2]

Atomic32 v8::base::Acquire_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 200 of file atomicops_internals_tsan.h.

                                                           {
  return __tsan_atomic32_exchange(ptr, new_value,
      __tsan_memory_order_acquire);
}

References __tsan_atomic32_exchange(), and __tsan_memory_order_acquire.

Here is the call graph for this function:

Acquire_AtomicExchange() [2/2]

Atomic64 v8::base::Acquire_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 290 of file atomicops_internals_tsan.h.

                                                           {
  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_acquire);
}

References __tsan_atomic64_exchange(), and __tsan_memory_order_acquire.

Here is the call graph for this function:

Acquire_CompareAndSwap() [1/3]

Atomic32 v8::base::Acquire_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 102 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic32 prev;
 
  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
  MemoryBarrier();
 
  return prev;
}

References MemoryBarrier(), and NoBarrier_CompareAndSwap().

Referenced by Acquire_CompareAndSwap(), CallOnceImpl(), and v8::internal::MemoryChunk::TryParallelSweeping().

Here is the call graph for this function:

Here is the caller graph for this function:

Acquire_CompareAndSwap() [2/3]

Atomic64 v8::base::Acquire_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 252 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic64 prev;
 
  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
  MemoryBarrier();
 
  return prev;
}

References MemoryBarrier(), and NoBarrier_CompareAndSwap().

Here is the call graph for this function:

Acquire_CompareAndSwap() [3/3]

AtomicWord v8::base::Acquire_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 51 of file atomicops_internals_atomicword_compat.h.

                                                               {
  return v8::base::Acquire_CompareAndSwap(
      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
}

References Acquire_CompareAndSwap().

Here is the call graph for this function:

Acquire_Load() [1/3]

Atomic32 v8::base::Acquire_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 154 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic32 value;
 
  __asm__ __volatile__ (  // NOLINT
    "ldar %w[value], %[ptr]  \n\t"
    : [value]"=r" (value)
    : [ptr]"Q" (*ptr)
    : "memory"
  );  // NOLINT
 
  return value;
}

Referenced by Acquire_Load(), CallOnce(), CallOnceImpl(), v8::internal::MemoryChunk::next_chunk(), v8::internal::MemoryChunk::parallel_sweeping(), v8::internal::SamplingCircularQueue< T, Length >::Peek(), v8::internal::MemoryChunk::prev_chunk(), v8::internal::SweeperThread::Run(), v8::internal::OptimizingCompilerThread::Run(), and v8::internal::SamplingCircularQueue< T, Length >::StartEnqueue().

Here is the caller graph for this function:

Acquire_Load() [2/3]

Atomic64 v8::base::Acquire_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 296 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic64 value;
 
  __asm__ __volatile__ (  // NOLINT
    "ldar %x[value], %[ptr]  \n\t"
    : [value]"=r" (value)
    : [ptr]"Q" (*ptr)
    : "memory"
  );  // NOLINT
 
  return value;
}

Acquire_Load() [3/3]

AtomicWord v8::base::Acquire_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 85 of file atomicops_internals_atomicword_compat.h.

                                                               {
  return v8::base::Acquire_Load(
      reinterpret_cast<volatile const Atomic32*>(ptr));
}

References Acquire_Load().

Here is the call graph for this function:

Acquire_Store() [1/3]

void v8::base::Acquire_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 132 of file atomicops_internals_arm64_gcc.h.

                                                                  {
  *ptr = value;
  MemoryBarrier();
}

References MemoryBarrier().

Referenced by Acquire_Store().

Here is the call graph for this function:

Here is the caller graph for this function:

Acquire_Store() [2/3]

void v8::base::Acquire_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 278 of file atomicops_internals_arm64_gcc.h.

                                                                  {
  *ptr = value;
  MemoryBarrier();
}

References MemoryBarrier().

Here is the call graph for this function:

Acquire_Store() [3/3]

void v8::base::Acquire_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 70 of file atomicops_internals_atomicword_compat.h.

                                                                      {
  return v8::base::Acquire_Store(
      reinterpret_cast<volatile Atomic32*>(ptr), value);
}

References Acquire_Store().

Here is the call graph for this function:

Barrier_AtomicIncrement() [1/3]

Atomic32 v8::base::Barrier_AtomicIncrement ( volatile Atomic32 *  ptr, Atomic32  increment  )

inline

Definition at line 91 of file atomicops_internals_arm64_gcc.h.

                                                            {
  Atomic32 result;
 
  MemoryBarrier();
  result = NoBarrier_AtomicIncrement(ptr, increment);
  MemoryBarrier();
 
  return result;
}

References MemoryBarrier(), and NoBarrier_AtomicIncrement().

Referenced by Barrier_AtomicIncrement().

Here is the call graph for this function:

Here is the caller graph for this function:

Barrier_AtomicIncrement() [2/3]

Atomic64 v8::base::Barrier_AtomicIncrement ( volatile Atomic64 *  ptr, Atomic64  increment  )

inline

Definition at line 241 of file atomicops_internals_arm64_gcc.h.

                                                            {
  Atomic64 result;
 
  MemoryBarrier();
  result = NoBarrier_AtomicIncrement(ptr, increment);
  MemoryBarrier();
 
  return result;
}

References MemoryBarrier(), and NoBarrier_AtomicIncrement().

Here is the call graph for this function:

Barrier_AtomicIncrement() [3/3]

AtomicWord v8::base::Barrier_AtomicIncrement ( volatile AtomicWord *  ptr, AtomicWord  increment  )

inline

Definition at line 45 of file atomicops_internals_atomicword_compat.h.

                                                                {
  return Barrier_AtomicIncrement(
      reinterpret_cast<volatile Atomic32*>(ptr), increment);
}

References Barrier_AtomicIncrement().

Here is the call graph for this function:

BOOL() [1/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPEModule32FirstW

)

BOOL() [2/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPEModule32NextW

)

BOOL() [3/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPEStackWalk64

)

BOOL() [4/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetLineFromAddr64

)

BOOL() [5/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetSearchPath

)

BOOL() [6/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPESymGetSymFromAddr64

)

BOOL() [7/7]

typedef v8::base::BOOL

(

__stdcall *

DLL_FUNC_TYPESymInitialize

)

Referenced by LoadSymbols().

Here is the caller graph for this function:

CallOnce() [1/2]

void v8::base::CallOnce ( OnceType *  once, NoArgFunction  init_func  )

inline

Definition at line 82 of file once.h.

                                                              {
  if (Acquire_Load(once) != ONCE_STATE_DONE) {
    CallOnceImpl(once, reinterpret_cast<PointerArgFunction>(init_func), NULL);
  }
}

References Acquire_Load(), CallOnceImpl(), NULL, and ONCE_STATE_DONE.

Referenced by v8::internal::BuiltinFunctionTable::functions(), v8::base::ThreadSafeInitOnceTrait::Init(), v8::internal::V8::InitializeOncePerProcess(), and v8::internal::Heap::SetUp().

Here is the call graph for this function:

Here is the caller graph for this function:

CallOnce() [2/2]

template<typename Arg >

void v8::base::CallOnce ( OnceType *  once, typename OneArgFunction< Arg * >::type  init_func, Arg *  arg  )

inline

Definition at line 90 of file once.h.

                                                           {
  if (Acquire_Load(once) != ONCE_STATE_DONE) {
    CallOnceImpl(once, reinterpret_cast<PointerArgFunction>(init_func),
        static_cast<void*>(arg));
  }
}

References Acquire_Load(), CallOnceImpl(), and ONCE_STATE_DONE.

Here is the call graph for this function:

CallOnceImpl()

void v8::base::CallOnceImpl	(	OnceType *	once,
		PointerArgFunction	init_func,
		void *	arg
	)

Definition at line 18 of file once.cc.

                                                                           {
  AtomicWord state = Acquire_Load(once);
  // Fast path. The provided function was already executed.
  if (state == ONCE_STATE_DONE) {
    return;
  }
 
  // The function execution did not complete yet. The once object can be in one
  // of the two following states:
  //   - UNINITIALIZED: We are the first thread calling this function.
  //   - EXECUTING_FUNCTION: Another thread is already executing the function.
  //
  // First, try to change the state from UNINITIALIZED to EXECUTING_FUNCTION
  // atomically.
  state = Acquire_CompareAndSwap(
      once, ONCE_STATE_UNINITIALIZED, ONCE_STATE_EXECUTING_FUNCTION);
  if (state == ONCE_STATE_UNINITIALIZED) {
    // We are the first thread to call this function, so we have to call the
    // function.
    init_func(arg);
    Release_Store(once, ONCE_STATE_DONE);
  } else {
    // Another thread has already started executing the function. We need to
    // wait until it completes the initialization.
    while (state == ONCE_STATE_EXECUTING_FUNCTION) {
#ifdef _WIN32
      ::Sleep(0);
#else
      sched_yield();
#endif
      state = Acquire_Load(once);
    }
  }
}

References Acquire_CompareAndSwap(), Acquire_Load(), ONCE_STATE_DONE, ONCE_STATE_EXECUTING_FUNCTION, ONCE_STATE_UNINITIALIZED, and Release_Store().

Referenced by CallOnce().

Here is the call graph for this function:

Here is the caller graph for this function:

checked_cast()

template<typename Dst , typename Src >

Dst v8::base::checked_cast ( Src  value )

inline

Definition at line 30 of file safe_conversions.h.

                                   {
  CHECK(IsValueInRangeForNumericType<Dst>(value));
  return static_cast<Dst>(value);
}

References CHECK.

DumpBacktrace()

void v8::base::DumpBacktrace

(

)

Definition at line 22 of file logging.cc.

                     {
#if V8_LIBC_GLIBC || V8_OS_BSD
  void* trace[100];
  int size = backtrace(trace, arraysize(trace));
  char** symbols = backtrace_symbols(trace, size);
  OS::PrintError("\n==== C stack trace ===============================\n\n");
  if (size == 0) {
    OS::PrintError("(empty)\n");
  } else if (symbols == NULL) {
    OS::PrintError("(no symbols)\n");
  } else {
    for (int i = 1; i < size; ++i) {
      OS::PrintError("%2d: ", i);
      char mangled[201];
      if (sscanf(symbols[i], "%*[^(]%*[(]%200[^)+]", mangled) == 1) {  // NOLINT
        int status;
        size_t length;
        char* demangled = abi::__cxa_demangle(mangled, NULL, &length, &status);
        OS::PrintError("%s\n", demangled != NULL ? demangled : mangled);
        free(demangled);
      } else {
        OS::PrintError("??\n");
      }
    }
  }
  free(symbols);
#elif V8_OS_QNX
  char out[1024];
  bt_accessor_t acc;
  bt_memmap_t memmap;
  bt_init_accessor(&acc, BT_SELF);
  bt_load_memmap(&acc, &memmap);
  bt_sprn_memmap(&memmap, out, sizeof(out));
  OS::PrintError(out);
  bt_addr_t trace[100];
  int size = bt_get_backtrace(&acc, trace, arraysize(trace));
  OS::PrintError("\n==== C stack trace ===============================\n\n");
  if (size == 0) {
    OS::PrintError("(empty)\n");
  } else {
    bt_sprnf_addrs(&memmap, trace, size, const_cast<char*>("%a\n"),
                   out, sizeof(out), NULL);
    OS::PrintError(out);
  }
  bt_unload_memmap(&memmap);
  bt_release_accessor(&acc);
#endif  // V8_LIBC_GLIBC || V8_OS_BSD
}

References arraysize, NULL, v8::base::OS::PrintError(), and size.

Referenced by V8_Fatal().

Here is the call graph for this function:

Here is the caller graph for this function:

DWORD() [1/2]

typedef v8::base::DWORD

(

__stdcall *

DLL_FUNC_TYPESymGetOptions

)

Referenced by v8::base::OS::Guard(), loadiJIT_Funcs(), LoadSymbols(), v8::base::OS::ProtectCode(), and v8::base::Win32Time::SetToCurrentTime().

Here is the caller graph for this function:

DWORD() [2/2]

typedef v8::base::DWORD

(

__stdcall *

DLL_FUNC_TYPESymSetOptions

)

DWORD64() [1/2]

typedef v8::base::DWORD64

(

__stdcall *

DLL_FUNC_TYPESymGetModuleBase64

)

DWORD64() [2/2]

typedef v8::base::DWORD64

(

__stdcall *

DLL_FUNC_TYPESymLoadModule64

)

Referenced by LoadSymbols().

Here is the caller graph for this function:

GetPageSize()

static size_t v8::base::GetPageSize ( )

static

Definition at line 699 of file platform-win32.cc.

                            {
  static size_t page_size = 0;
  if (page_size == 0) {
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    page_size = base::bits::RoundUpToPowerOfTwo32(info.dwPageSize);
  }
  return page_size;
}

References v8::base::bits::RoundUpToPowerOfTwo32().

Here is the call graph for this function:

HANDLE()

typedef v8::base::HANDLE

(

__stdcall *

DLL_FUNC_TYPECreateToolhelp32Snapshot

)

Referenced by LoadSymbols().

Here is the caller graph for this function:

HasConsole()

static bool v8::base::HasConsole ( )

static

Definition at line 543 of file platform-win32.cc.

                         {
  // Only check the first time. Eventual race conditions are not a problem,
  // because all threads will eventually determine the same mode.
  if (output_mode == UNKNOWN) {
    // We cannot just check that the standard output is attached to a console
    // because this would fail if output is redirected to a file. Therefore we
    // say that a process does not have an output console if either the
    // standard output handle is invalid or its file type is unknown.
    if (GetStdHandle(STD_OUTPUT_HANDLE) != INVALID_HANDLE_VALUE &&
        GetFileType(GetStdHandle(STD_OUTPUT_HANDLE)) != FILE_TYPE_UNKNOWN)
      output_mode = CONSOLE;
    else
      output_mode = ODS;
  }
  return output_mode == CONSOLE;
}

References CONSOLE, ODS, output_mode, and UNKNOWN.

Referenced by VPrintHelper().

Here is the caller graph for this function:

INSTANTIATE_TEST_CASE_P()

v8::base::INSTANTIATE_TEST_CASE_P	(	RandomSeeds	,
		RandomNumberGeneratorTest	,
		::testing::Values(INT_MIN, -1, 0, 1, 42, 100, 1234567890, 987654321, INT_MAX)
	)

IsValueInRangeForNumericType()

template<typename Dst , typename Src >

bool v8::base::IsValueInRangeForNumericType ( Src  value )

inline

Definition at line 21 of file safe_conversions.h.

                                                    {
  return internal::DstRangeRelationToSrcRange<Dst>(value) ==
         internal::RANGE_VALID;
}

References v8::base::internal::RANGE_VALID.

LoadDbgHelpAndTlHelp32()

static bool v8::base::LoadDbgHelpAndTlHelp32 ( )

static

Definition at line 1020 of file platform-win32.cc.

                                     {
  static bool dbghelp_loaded = false;
 
  if (dbghelp_loaded) return true;
 
  HMODULE module;
 
  // Load functions from the dbghelp.dll module.
  module = LoadLibrary(TEXT("dbghelp.dll"));
  if (module == NULL) {
    return false;
  }
 
#define LOAD_DLL_FUNC(name)                                                 \
  DLL_FUNC_VAR(name) =                                                      \
      reinterpret_cast<DLL_FUNC_TYPE(name)>(GetProcAddress(module, #name));
 
DBGHELP_FUNCTION_LIST(LOAD_DLL_FUNC)
 
#undef LOAD_DLL_FUNC
 
  // Load functions from the kernel32.dll module (the TlHelp32.h function used
  // to be in tlhelp32.dll but are now moved to kernel32.dll).
  module = LoadLibrary(TEXT("kernel32.dll"));
  if (module == NULL) {
    return false;
  }
 
#define LOAD_DLL_FUNC(name)                                                 \
  DLL_FUNC_VAR(name) =                                                      \
      reinterpret_cast<DLL_FUNC_TYPE(name)>(GetProcAddress(module, #name));
 
TLHELP32_FUNCTION_LIST(LOAD_DLL_FUNC)
 
#undef LOAD_DLL_FUNC
 
  // Check that all functions where loaded.
  bool result =
#define DLL_FUNC_LOADED(name) (DLL_FUNC_VAR(name) != NULL) &&
 
DBGHELP_FUNCTION_LIST(DLL_FUNC_LOADED)
TLHELP32_FUNCTION_LIST(DLL_FUNC_LOADED)
 
#undef DLL_FUNC_LOADED
  true;
 
  dbghelp_loaded = result;
  return result;
  // NOTE: The modules are never unloaded and will stay around until the
  // application is closed.
}

References DBGHELP_FUNCTION_LIST, DLL_FUNC_LOADED, LOAD_DLL_FUNC, NULL, and TLHELP32_FUNCTION_LIST.

LoadSymbols()

static std::vector<OS::SharedLibraryAddress> v8::base::LoadSymbols ( HANDLE  process_handle )

static

Definition at line 1079 of file platform-win32.cc.

                           {
  static std::vector<OS::SharedLibraryAddress> result;
 
  static bool symbols_loaded = false;
 
  if (symbols_loaded) return result;
 
  BOOL ok;
 
  // Initialize the symbol engine.
  ok = _SymInitialize(process_handle,  // hProcess
                      NULL,            // UserSearchPath
                      false);          // fInvadeProcess
  if (!ok) return result;
 
  DWORD options = _SymGetOptions();
  options |= SYMOPT_LOAD_LINES;
  options |= SYMOPT_FAIL_CRITICAL_ERRORS;
  options = _SymSetOptions(options);
 
  char buf[OS::kStackWalkMaxNameLen] = {0};
  ok = _SymGetSearchPath(process_handle, buf, OS::kStackWalkMaxNameLen);
  if (!ok) {
    int err = GetLastError();
    OS::Print("%d\n", err);
    return result;
  }
 
  HANDLE snapshot = _CreateToolhelp32Snapshot(
      TH32CS_SNAPMODULE,       // dwFlags
      GetCurrentProcessId());  // th32ProcessId
  if (snapshot == INVALID_HANDLE_VALUE) return result;
  MODULEENTRY32W module_entry;
  module_entry.dwSize = sizeof(module_entry);  // Set the size of the structure.
  BOOL cont = _Module32FirstW(snapshot, &module_entry);
  while (cont) {
    DWORD64 base;
    // NOTE the SymLoadModule64 function has the peculiarity of accepting a
    // both unicode and ASCII strings even though the parameter is PSTR.
    base = _SymLoadModule64(
        process_handle,                                       // hProcess
        0,                                                    // hFile
        reinterpret_cast<PSTR>(module_entry.szExePath),       // ImageName
        reinterpret_cast<PSTR>(module_entry.szModule),        // ModuleName
        reinterpret_cast<DWORD64>(module_entry.modBaseAddr),  // BaseOfDll
        module_entry.modBaseSize);                            // SizeOfDll
    if (base == 0) {
      int err = GetLastError();
      if (err != ERROR_MOD_NOT_FOUND &&
          err != ERROR_INVALID_HANDLE) {
        result.clear();
        return result;
      }
    }
    int lib_name_length = WideCharToMultiByte(
        CP_UTF8, 0, module_entry.szExePath, -1, NULL, 0, NULL, NULL);
    std::string lib_name(lib_name_length, 0);
    WideCharToMultiByte(CP_UTF8, 0, module_entry.szExePath, -1, &lib_name[0],
                        lib_name_length, NULL, NULL);
    result.push_back(OS::SharedLibraryAddress(
        lib_name, reinterpret_cast<unsigned int>(module_entry.modBaseAddr),
        reinterpret_cast<unsigned int>(module_entry.modBaseAddr +
                                       module_entry.modBaseSize)));
    cont = _Module32NextW(snapshot, &module_entry);
  }
  CloseHandle(snapshot);
 
  symbols_loaded = true;
  return result;
}

References BOOL(), DWORD(), DWORD64(), v8::base::OS::GetCurrentProcessId(), v8::base::OS::GetLastError(), HANDLE(), v8::base::OS::kStackWalkMaxNameLen, NULL, v8::base::OS::Print(), and snapshot().

Here is the call graph for this function:

LocalKeyToPthreadKey()

static pthread_key_t v8::base::LocalKeyToPthreadKey ( Thread::LocalStorageKey  local_key )

static

Definition at line 568 of file platform-posix.cc.

                                                                           {
#if V8_OS_CYGWIN
  STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
  intptr_t ptr_key = static_cast<intptr_t>(local_key);
  return reinterpret_cast<pthread_key_t>(ptr_key);
#else
  return static_cast<pthread_key_t>(local_key);
#endif
}

References STATIC_ASSERT.

Referenced by v8::base::Thread::DeleteThreadLocalKey(), v8::base::Thread::GetThreadLocal(), and v8::base::Thread::SetThreadLocal().

Here is the caller graph for this function:

MemoryBarrier()

void v8::base::MemoryBarrier ( )

inline

Definition at line 13 of file atomicops_internals_arm64_gcc.h.

                            {
  __asm__ __volatile__ ("dmb ish" ::: "memory");  // NOLINT
}

Referenced by Acquire_CompareAndSwap(), Acquire_Store(), Barrier_AtomicIncrement(), v8::internal::SamplingCircularQueue< T, Length >::Peek(), Release_CompareAndSwap(), Release_Load(), and v8::internal::SamplingCircularQueue< T, Length >::StartEnqueue().

Here is the caller graph for this function:

NoBarrier_AtomicExchange() [1/3]

Atomic32 v8::base::NoBarrier_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 50 of file atomicops_internals_arm64_gcc.h.

                                                             {
  Atomic32 result;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                    \n\t"
    "ldxr %w[result], %[ptr]               \n\t"  // Load the previous value.
    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
    : [result]"=&r" (result),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [new_value]"r" (new_value)
    : "memory"
  );  // NOLINT
 
  return result;
}

Referenced by NoBarrier_AtomicExchange().

Here is the caller graph for this function:

NoBarrier_AtomicExchange() [2/3]

Atomic64 v8::base::NoBarrier_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 200 of file atomicops_internals_arm64_gcc.h.

                                                             {
  Atomic64 result;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                    \n\t"
    "ldxr %[result], %[ptr]                \n\t"
    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
    "cbnz %w[temp], 0b                     \n\t"
    : [result]"=&r" (result),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [new_value]"r" (new_value)
    : "memory"
  );  // NOLINT
 
  return result;
}

NoBarrier_AtomicExchange() [3/3]

AtomicWord v8::base::NoBarrier_AtomicExchange ( volatile AtomicWord *  ptr, AtomicWord  new_value  )

inline

Definition at line 33 of file atomicops_internals_atomicword_compat.h.

                                                                 {
  return NoBarrier_AtomicExchange(
      reinterpret_cast<volatile Atomic32*>(ptr), new_value);
}

References NoBarrier_AtomicExchange().

Here is the call graph for this function:

NoBarrier_AtomicIncrement() [1/3]

Atomic32 v8::base::NoBarrier_AtomicIncrement ( volatile Atomic32 *  ptr, Atomic32  increment  )

inline

Definition at line 70 of file atomicops_internals_arm64_gcc.h.

                                                              {
  Atomic32 result;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                       \n\t"
    "ldxr %w[result], %[ptr]                  \n\t"  // Load the previous value.
    "add %w[result], %w[result], %w[increment]\n\t"
    "stxr %w[temp], %w[result], %[ptr]        \n\t"  // Try to store the result.
    "cbnz %w[temp], 0b                        \n\t"  // Retry on failure.
    : [result]"=&r" (result),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [increment]"IJr" (increment)
    : "memory"
  );  // NOLINT
 
  return result;
}

Referenced by v8::internal::ThreadId::AllocateThreadId(), Barrier_AtomicIncrement(), v8::internal::Sampler::DecreaseProfilingDepth(), v8::internal::Sampler::IncreaseProfilingDepth(), v8::internal::Isolate::Isolate(), and NoBarrier_AtomicIncrement().

Here is the caller graph for this function:

NoBarrier_AtomicIncrement() [2/3]

Atomic64 v8::base::NoBarrier_AtomicIncrement ( volatile Atomic64 *  ptr, Atomic64  increment  )

inline

Definition at line 220 of file atomicops_internals_arm64_gcc.h.

                                                              {
  Atomic64 result;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                     \n\t"
    "ldxr %[result], %[ptr]                 \n\t"
    "add %[result], %[result], %[increment] \n\t"
    "stxr %w[temp], %[result], %[ptr]       \n\t"
    "cbnz %w[temp], 0b                      \n\t"
    : [result]"=&r" (result),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [increment]"IJr" (increment)
    : "memory"
  );  // NOLINT
 
  return result;
}

NoBarrier_AtomicIncrement() [3/3]

AtomicWord v8::base::NoBarrier_AtomicIncrement ( volatile AtomicWord *  ptr, AtomicWord  increment  )

inline

Definition at line 39 of file atomicops_internals_atomicword_compat.h.

                                                                  {
  return NoBarrier_AtomicIncrement(
      reinterpret_cast<volatile Atomic32*>(ptr), increment);
}

References NoBarrier_AtomicIncrement().

Here is the call graph for this function:

NoBarrier_CompareAndSwap() [1/3]

Atomic32 v8::base::NoBarrier_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 25 of file atomicops_internals_arm64_gcc.h.

                                                             {
  Atomic32 prev;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                    \n\t"
    "ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value.
    "cmp %w[prev], %w[old_value]           \n\t"
    "bne 1f                                \n\t"
    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
    "1:                                    \n\t"
    : [prev]"=&r" (prev),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [old_value]"IJr" (old_value),
      [new_value]"r" (new_value)
    : "cc", "memory"
  );  // NOLINT
 
  return prev;
}

Referenced by Acquire_CompareAndSwap(), NoBarrier_CompareAndSwap(), Release_CompareAndSwap(), and v8::internal::UpdatePointer().

Here is the caller graph for this function:

NoBarrier_CompareAndSwap() [2/3]

Atomic64 v8::base::NoBarrier_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 175 of file atomicops_internals_arm64_gcc.h.

                                                             {
  Atomic64 prev;
  int32_t temp;
 
  __asm__ __volatile__ (  // NOLINT
    "0:                                    \n\t"
    "ldxr %[prev], %[ptr]                  \n\t"
    "cmp %[prev], %[old_value]             \n\t"
    "bne 1f                                \n\t"
    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
    "cbnz %w[temp], 0b                     \n\t"
    "1:                                    \n\t"
    : [prev]"=&r" (prev),
      [temp]"=&r" (temp),
      [ptr]"+Q" (*ptr)
    : [old_value]"IJr" (old_value),
      [new_value]"r" (new_value)
    : "cc", "memory"
  );  // NOLINT
 
  return prev;
}

NoBarrier_CompareAndSwap() [3/3]

AtomicWord v8::base::NoBarrier_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 26 of file atomicops_internals_atomicword_compat.h.

                                                                 {
  return NoBarrier_CompareAndSwap(
      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
}

References NoBarrier_CompareAndSwap().

Here is the call graph for this function:

NoBarrier_Load() [1/4]

Atomic32 v8::base::NoBarrier_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 150 of file atomicops_internals_arm64_gcc.h.

                                                             {
  return *ptr;
}

NoBarrier_Load() [2/4]

Atomic64 v8::base::NoBarrier_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 292 of file atomicops_internals_arm64_gcc.h.

                                                             {
  return *ptr;
}

NoBarrier_Load() [3/4]

Atomic8 v8::base::NoBarrier_Load ( volatile const Atomic8 *  ptr )

inline

Definition at line 146 of file atomicops_internals_arm64_gcc.h.

                                                           {
  return *ptr;
}

Referenced by v8::internal::StoreBuffer::FindPointersToNewSpaceInRegion(), v8::internal::Sampler::IsActive(), v8::internal::Sampler::IsProfiling(), v8::internal::StoreBuffer::IteratePointersInStoreBuffer(), NoBarrier_Load(), and v8::internal::FreeListCategory::top().

Here is the caller graph for this function:

NoBarrier_Load() [4/4]

AtomicWord v8::base::NoBarrier_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 80 of file atomicops_internals_atomicword_compat.h.

                                                                 {
  return NoBarrier_Load(
      reinterpret_cast<volatile const Atomic32*>(ptr));
}

References NoBarrier_Load().

Here is the call graph for this function:

NoBarrier_Store() [1/4]

void v8::base::NoBarrier_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 128 of file atomicops_internals_arm64_gcc.h.

                                                                    {
  *ptr = value;
}

NoBarrier_Store() [2/4]

void v8::base::NoBarrier_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 274 of file atomicops_internals_arm64_gcc.h.

                                                                    {
  *ptr = value;
}

NoBarrier_Store() [3/4]

void v8::base::NoBarrier_Store ( volatile Atomic8 *  ptr, Atomic8  value  )

inline

Definition at line 124 of file atomicops_internals_arm64_gcc.h.

                                                                  {
  *ptr = value;
}

Referenced by v8::internal::FreeListCategory::Concatenate(), v8::internal::VisitorDispatchTable< Callback >::CopyFrom(), NoBarrier_Store(), v8::internal::OptimizingCompilerThread::OptimizingCompilerThread(), v8::internal::FreeListNode::set_next(), v8::internal::FreeListCategory::set_top(), v8::internal::Sampler::SetActive(), v8::internal::Sampler::SetHasProcessingThread(), and v8::internal::SweeperThread::SweeperThread().

Here is the caller graph for this function:

NoBarrier_Store() [4/4]

void v8::base::NoBarrier_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 65 of file atomicops_internals_atomicword_compat.h.

                                                                        {
  NoBarrier_Store(
      reinterpret_cast<volatile Atomic32*>(ptr), value);
}

References NoBarrier_Store().

Here is the call graph for this function:

operator+() [1/2]

Time v8::base::operator+ ( const TimeDelta &  delta, const Time &  time  )

inline

Definition at line 283 of file time.h.

                                                                {
  return time + delta;
}

operator+() [2/2]

TimeTicks v8::base::operator+ ( const TimeDelta &  delta, const TimeTicks &  ticks  )

inline

Definition at line 394 of file time.h.

                                                                           {
  return ticks + delta;
}

operator<<()

template<class T >

std::ostream& v8::base::operator<<	(	std::ostream &	os,
		const MagicNumbersForDivision< T > &	mag
	)

Definition at line 17 of file division-by-constant-unittest.cc.

                                                                {
  return os << "{ multiplier: " << mag.multiplier << ", shift: " << mag.shift
            << ", add: " << mag.add << " }";
}

References v8::base::MagicNumbersForDivision< T >::add, v8::base::MagicNumbersForDivision< T >::multiplier, and v8::base::MagicNumbersForDivision< T >::shift.

PthreadKeyToLocalKey()

static Thread::LocalStorageKey v8::base::PthreadKeyToLocalKey ( pthread_key_t  pthread_key )

static

Definition at line 554 of file platform-posix.cc.

                                                                             {
#if V8_OS_CYGWIN
  // We need to cast pthread_key_t to Thread::LocalStorageKey in two steps
  // because pthread_key_t is a pointer type on Cygwin. This will probably not
  // work on 64-bit platforms, but Cygwin doesn't support 64-bit anyway.
  STATIC_ASSERT(sizeof(Thread::LocalStorageKey) == sizeof(pthread_key_t));
  intptr_t ptr_key = reinterpret_cast<intptr_t>(pthread_key);
  return static_cast<Thread::LocalStorageKey>(ptr_key);
#else
  return static_cast<Thread::LocalStorageKey>(pthread_key);
#endif
}

References STATIC_ASSERT.

Referenced by v8::base::Thread::CreateThreadLocalKey().

Here is the caller graph for this function:

PVOID()

typedef v8::base::PVOID

(

__stdcall *

DLL_FUNC_TYPESymFunctionTableAccess64

)

RandomizedVirtualAlloc() [1/2]

static void* v8::base::RandomizedVirtualAlloc ( size_t  size, int  action, int  protection  )

static

Definition at line 182 of file platform-cygwin.cc.

                                                                             {
  LPVOID base = NULL;
 
  if (protection == PAGE_EXECUTE_READWRITE || protection == PAGE_NOACCESS) {
    // For exectutable pages try and randomize the allocation address
    for (size_t attempts = 0; base == NULL && attempts < 3; ++attempts) {
      base = VirtualAlloc(OS::GetRandomMmapAddr(), size, action, protection);
    }
  }
 
  // After three attempts give up and let the OS find an address to use.
  if (base == NULL) base = VirtualAlloc(NULL, size, action, protection);
 
  return base;
}

References v8::base::OS::GetRandomMmapAddr(), NULL, and size.

Referenced by v8::base::VirtualMemory::ReserveRegion().

Here is the call graph for this function:

Here is the caller graph for this function:

RandomizedVirtualAlloc() [2/2]

static void* v8::base::RandomizedVirtualAlloc ( size_t  size, int  action, int  protection  )

static

Definition at line 757 of file platform-win32.cc.

                                                                             {
  LPVOID base = NULL;
 
  if (protection == PAGE_EXECUTE_READWRITE || protection == PAGE_NOACCESS) {
    // For exectutable pages try and randomize the allocation address
    for (size_t attempts = 0; base == NULL && attempts < 3; ++attempts) {
      base = VirtualAlloc(OS::GetRandomMmapAddr(), size, action, protection);
    }
  }
 
  // After three attempts give up and let the OS find an address to use.
  if (base == NULL) base = VirtualAlloc(NULL, size, action, protection);
 
  return base;
}

References v8::base::OS::GetRandomMmapAddr(), NULL, and size.

Here is the call graph for this function:

Release_AtomicExchange() [1/2]

Atomic32 v8::base::Release_AtomicExchange ( volatile Atomic32 *  ptr, Atomic32  new_value  )

inline

Definition at line 206 of file atomicops_internals_tsan.h.

                                                           {
  return __tsan_atomic32_exchange(ptr, new_value,
      __tsan_memory_order_release);
}

References __tsan_atomic32_exchange(), and __tsan_memory_order_release.

Here is the call graph for this function:

Release_AtomicExchange() [2/2]

Atomic64 v8::base::Release_AtomicExchange ( volatile Atomic64 *  ptr, Atomic64  new_value  )

inline

Definition at line 295 of file atomicops_internals_tsan.h.

                                                           {
  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_release);
}

References __tsan_atomic64_exchange(), and __tsan_memory_order_release.

Here is the call graph for this function:

Release_CompareAndSwap() [1/3]

Atomic32 v8::base::Release_CompareAndSwap ( volatile Atomic32 *  ptr, Atomic32  old_value, Atomic32  new_value  )

inline

Definition at line 113 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic32 prev;
 
  MemoryBarrier();
  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 
  return prev;
}

References MemoryBarrier(), and NoBarrier_CompareAndSwap().

Referenced by Release_CompareAndSwap().

Here is the call graph for this function:

Here is the caller graph for this function:

Release_CompareAndSwap() [2/3]

Atomic64 v8::base::Release_CompareAndSwap ( volatile Atomic64 *  ptr, Atomic64  old_value, Atomic64  new_value  )

inline

Definition at line 263 of file atomicops_internals_arm64_gcc.h.

                                                           {
  Atomic64 prev;
 
  MemoryBarrier();
  prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 
  return prev;
}

References MemoryBarrier(), and NoBarrier_CompareAndSwap().

Here is the call graph for this function:

Release_CompareAndSwap() [3/3]

AtomicWord v8::base::Release_CompareAndSwap ( volatile AtomicWord *  ptr, AtomicWord  old_value, AtomicWord  new_value  )

inline

Definition at line 58 of file atomicops_internals_atomicword_compat.h.

                                                               {
  return v8::base::Release_CompareAndSwap(
      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
}

References Release_CompareAndSwap().

Here is the call graph for this function:

Release_Load() [1/3]

Atomic32 v8::base::Release_Load ( volatile const Atomic32 *  ptr )

inline

Definition at line 167 of file atomicops_internals_arm64_gcc.h.

                                                           {
  MemoryBarrier();
  return *ptr;
}

References MemoryBarrier().

Referenced by Release_Load().

Here is the call graph for this function:

Here is the caller graph for this function:

Release_Load() [2/3]

Atomic64 v8::base::Release_Load ( volatile const Atomic64 *  ptr )

inline

Definition at line 309 of file atomicops_internals_arm64_gcc.h.

                                                           {
  MemoryBarrier();
  return *ptr;
}

References MemoryBarrier().

Here is the call graph for this function:

Release_Load() [3/3]

AtomicWord v8::base::Release_Load ( volatile const AtomicWord *  ptr )

inline

Definition at line 90 of file atomicops_internals_atomicword_compat.h.

                                                               {
  return v8::base::Release_Load(
      reinterpret_cast<volatile const Atomic32*>(ptr));
}

References Release_Load().

Here is the call graph for this function:

Release_Store() [1/3]

void v8::base::Release_Store ( volatile Atomic32 *  ptr, Atomic32  value  )

inline

Definition at line 137 of file atomicops_internals_arm64_gcc.h.

                                                                  {
  __asm__ __volatile__ (  // NOLINT
    "stlr %w[value], %[ptr]  \n\t"
    : [ptr]"=Q" (*ptr)
    : [value]"r" (value)
    : "memory"
  );  // NOLINT
}

Referenced by CallOnceImpl(), v8::internal::SamplingCircularQueue< T, Length >::FinishEnqueue(), v8::internal::OptimizingCompilerThread::Flush(), Release_Store(), v8::internal::SamplingCircularQueue< T, Length >::Remove(), v8::internal::OptimizingCompilerThread::Run(), v8::internal::MemoryChunk::set_next_chunk(), v8::internal::MemoryChunk::set_parallel_sweeping(), v8::internal::MemoryChunk::set_prev_chunk(), v8::internal::SweeperThread::Stop(), and v8::internal::OptimizingCompilerThread::Stop().

Here is the caller graph for this function:

Release_Store() [2/3]

void v8::base::Release_Store ( volatile Atomic64 *  ptr, Atomic64  value  )

inline

Definition at line 283 of file atomicops_internals_arm64_gcc.h.

                                                                  {
  __asm__ __volatile__ (  // NOLINT
    "stlr %x[value], %[ptr]  \n\t"
    : [ptr]"=Q" (*ptr)
    : [value]"r" (value)
    : "memory"
  );  // NOLINT
}

Release_Store() [3/3]

void v8::base::Release_Store ( volatile AtomicWord *  ptr, AtomicWord  value  )

inline

Definition at line 75 of file atomicops_internals_atomicword_compat.h.

                                                                      {
  return v8::base::Release_Store(
      reinterpret_cast<volatile Atomic32*>(ptr), value);
}

References Release_Store().

Here is the call graph for this function:

s32()

static M32 v8::base::s32 ( int32_t  d )

static

Definition at line 30 of file division-by-constant-unittest.cc.

                          {
  return SignedDivisionByConstant<uint32_t>(static_cast<uint32_t>(d));
}

Referenced by TEST().

Here is the caller graph for this function:

s64()

static M64 v8::base::s64 ( int64_t  d )

static

Definition at line 35 of file division-by-constant-unittest.cc.

                          {
  return SignedDivisionByConstant<uint64_t>(static_cast<uint64_t>(d));
}

Referenced by TEST().

Here is the caller graph for this function:

saturated_cast()

template<typename Dst , typename Src >

Dst v8::base::saturated_cast ( Src  value )

inline

Definition at line 39 of file safe_conversions.h.

                                     {
  // Optimization for floating point values, which already saturate.
  if (std::numeric_limits<Dst>::is_iec559)
    return static_cast<Dst>(value);
 
  switch (internal::DstRangeRelationToSrcRange<Dst>(value)) {
    case internal::RANGE_VALID:
      return static_cast<Dst>(value);
 
    case internal::RANGE_UNDERFLOW:
      return std::numeric_limits<Dst>::min();
 
    case internal::RANGE_OVERFLOW:
      return std::numeric_limits<Dst>::max();
 
    // Should fail only on attempting to assign NaN to a saturated integer.
    case internal::RANGE_INVALID:
      CHECK(false);
      return std::numeric_limits<Dst>::max();
  }
 
  UNREACHABLE();
  return static_cast<Dst>(value);
}

References CHECK, v8::internal::min(), v8::base::internal::RANGE_INVALID, v8::base::internal::RANGE_OVERFLOW, v8::base::internal::RANGE_UNDERFLOW, v8::base::internal::RANGE_VALID, and UNREACHABLE.

Here is the call graph for this function:

SetThreadName()

static void v8::base::SetThreadName ( const char *  name )

static

Definition at line 471 of file platform-posix.cc.

                                            {
#if V8_OS_DRAGONFLYBSD || V8_OS_FREEBSD || V8_OS_OPENBSD
  pthread_set_name_np(pthread_self(), name);
#elif V8_OS_NETBSD
  STATIC_ASSERT(Thread::kMaxThreadNameLength <= PTHREAD_MAX_NAMELEN_NP);
  pthread_setname_np(pthread_self(), "%s", name);
#elif V8_OS_MACOSX
  // pthread_setname_np is only available in 10.6 or later, so test
  // for it at runtime.
  int (*dynamic_pthread_setname_np)(const char*);
  *reinterpret_cast<void**>(&dynamic_pthread_setname_np) =
    dlsym(RTLD_DEFAULT, "pthread_setname_np");
  if (dynamic_pthread_setname_np == NULL)
    return;
 
  // Mac OS X does not expose the length limit of the name, so hardcode it.
  static const int kMaxNameLength = 63;
  STATIC_ASSERT(Thread::kMaxThreadNameLength <= kMaxNameLength);
  dynamic_pthread_setname_np(name);
#elif defined(PR_SET_NAME)
  prctl(PR_SET_NAME,
        reinterpret_cast<unsigned long>(name),  // NOLINT
        0, 0, 0);
#endif
}

References v8::base::Thread::kMaxThreadNameLength, name, NULL, and STATIC_ASSERT.

Referenced by ThreadEntry().

Here is the caller graph for this function:

SignedDivisionByConstant() [1/3]

template<class T >

MagicNumbersForDivision< T > v8::base::SignedDivisionByConstant

(

T

d

)

Definition at line 23 of file division-by-constant.cc.

                                                         {
  STATIC_ASSERT(static_cast<T>(0) < static_cast<T>(-1));
  DCHECK(d != static_cast<T>(-1) && d != 0 && d != 1);
  const unsigned bits = static_cast<unsigned>(sizeof(T)) * 8;
  const T min = (static_cast<T>(1) << (bits - 1));
  const bool neg = (min & d) != 0;
  const T ad = neg ? (0 - d) : d;
  const T t = min + (d >> (bits - 1));
  const T anc = t - 1 - t % ad;  // Absolute value of nc
  unsigned p = bits - 1;         // Init. p.
  T q1 = min / anc;              // Init. q1 = 2**p/|nc|.
  T r1 = min - q1 * anc;         // Init. r1 = rem(2**p, |nc|).
  T q2 = min / ad;               // Init. q2 = 2**p/|d|.
  T r2 = min - q2 * ad;          // Init. r2 = rem(2**p, |d|).
  T delta;
  do {
    p = p + 1;
    q1 = 2 * q1;      // Update q1 = 2**p/|nc|.
    r1 = 2 * r1;      // Update r1 = rem(2**p, |nc|).
    if (r1 >= anc) {  // Must be an unsigned comparison here.
      q1 = q1 + 1;
      r1 = r1 - anc;
    }
    q2 = 2 * q2;     // Update q2 = 2**p/|d|.
    r2 = 2 * r2;     // Update r2 = rem(2**p, |d|).
    if (r2 >= ad) {  // Must be an unsigned comparison here.
      q2 = q2 + 1;
      r2 = r2 - ad;
    }
    delta = ad - r2;
  } while (q1 < delta || (q1 == delta && r1 == 0));
  T mul = q2 + 1;
  return {neg ? (0 - mul) : mul, p - bits, false};
}

References DCHECK, v8::internal::min(), v8::internal::q1, v8::internal::q2, v8::internal::r1, v8::internal::r2, STATIC_ASSERT, and T.

Here is the call graph for this function:

SignedDivisionByConstant() [2/3]

template MagicNumbersForDivision<uint32_t> v8::base::SignedDivisionByConstant

(

uint32_t

d

)

SignedDivisionByConstant() [3/3]

template MagicNumbersForDivision<uint64_t> v8::base::SignedDivisionByConstant

(

uint64_t

d

)

StringToLong()

static unsigned v8::base::StringToLong ( char *  buffer )

static

Definition at line 119 of file platform-freebsd.cc.

                                           {
  return static_cast<unsigned>(strtol(buffer, NULL, 16));  // NOLINT
}

References NULL.

TEST() [1/33]

v8::base::TEST	(	ConditionVariable	,
		LoopIncrement
	)

Definition at line 269 of file condition-variable-unittest.cc.

                                       {
  static const int kMaxThreadCount = 16;
  Mutex mutex;
  ConditionVariable cv;
  for (int thread_count = 1; thread_count < kMaxThreadCount; ++thread_count) {
    int limit = thread_count * 10;
    int counter = 0;
 
    // Setup the threads.
    Thread** threads = new Thread* [thread_count];
    for (int n = 0; n < thread_count; ++n) {
      threads[n] = new LoopIncrementThread(n, &counter, limit, thread_count,
                                           &cv, &mutex);
    }
 
    // Start all threads.
    for (int n = thread_count - 1; n >= 0; --n) {
      threads[n]->Start();
    }
 
    // Join and cleanup all threads.
    for (int n = 0; n < thread_count; ++n) {
      threads[n]->Join();
      delete threads[n];
    }
    delete[] threads;
 
    EXPECT_EQ(limit, counter);
  }
}

References v8::base::Thread::Join(), and v8::base::Thread::Start().

Here is the call graph for this function:

TEST() [2/33]

v8::base::TEST	(	ConditionVariable	,
		MultipleThreadsWithSeparateConditionVariables
	)

Definition at line 60 of file condition-variable-unittest.cc.

                                                                       {
  static const int kThreadCount = 128;
  ThreadWithMutexAndConditionVariable threads[kThreadCount];
 
  for (int n = 0; n < kThreadCount; ++n) {
    LockGuard<Mutex> lock_guard(&threads[n].mutex_);
    EXPECT_FALSE(threads[n].running_);
    EXPECT_FALSE(threads[n].finished_);
    threads[n].Start();
    // Wait for nth thread to start.
    while (!threads[n].running_) {
      threads[n].cv_.Wait(&threads[n].mutex_);
    }
  }
 
  for (int n = kThreadCount - 1; n >= 0; --n) {
    LockGuard<Mutex> lock_guard(&threads[n].mutex_);
    EXPECT_TRUE(threads[n].running_);
    EXPECT_FALSE(threads[n].finished_);
  }
 
  for (int n = 0; n < kThreadCount; ++n) {
    LockGuard<Mutex> lock_guard(&threads[n].mutex_);
    EXPECT_TRUE(threads[n].running_);
    EXPECT_FALSE(threads[n].finished_);
    // Tell the nth thread to quit.
    threads[n].running_ = false;
    threads[n].cv_.NotifyOne();
  }
 
  for (int n = kThreadCount - 1; n >= 0; --n) {
    // Wait for nth thread to quit.
    LockGuard<Mutex> lock_guard(&threads[n].mutex_);
    while (!threads[n].finished_) {
      threads[n].cv_.Wait(&threads[n].mutex_);
    }
    EXPECT_FALSE(threads[n].running_);
    EXPECT_TRUE(threads[n].finished_);
  }
 
  for (int n = 0; n < kThreadCount; ++n) {
    threads[n].Join();
    LockGuard<Mutex> lock_guard(&threads[n].mutex_);
    EXPECT_FALSE(threads[n].running_);
    EXPECT_TRUE(threads[n].finished_);
  }
}

TEST() [3/33]

v8::base::TEST	(	ConditionVariable	,
		MultipleThreadsWithSharedSeparateConditionVariables
	)

Definition at line 141 of file condition-variable-unittest.cc.

                                                                             {
  static const int kThreadCount = 128;
  ThreadWithSharedMutexAndConditionVariable threads[kThreadCount];
  ConditionVariable cv;
  Mutex mutex;
 
  for (int n = 0; n < kThreadCount; ++n) {
    threads[n].mutex_ = &mutex;
    threads[n].cv_ = &cv;
  }
 
  // Start all threads.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = 0; n < kThreadCount; ++n) {
      EXPECT_FALSE(threads[n].running_);
      EXPECT_FALSE(threads[n].finished_);
      threads[n].Start();
    }
  }
 
  // Wait for all threads to start.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = kThreadCount - 1; n >= 0; --n) {
      while (!threads[n].running_) {
        cv.Wait(&mutex);
      }
    }
  }
 
  // Make sure that all threads are running.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = 0; n < kThreadCount; ++n) {
      EXPECT_TRUE(threads[n].running_);
      EXPECT_FALSE(threads[n].finished_);
    }
  }
 
  // Tell all threads to quit.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = kThreadCount - 1; n >= 0; --n) {
      EXPECT_TRUE(threads[n].running_);
      EXPECT_FALSE(threads[n].finished_);
      // Tell the nth thread to quit.
      threads[n].running_ = false;
    }
    cv.NotifyAll();
  }
 
  // Wait for all threads to quit.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = 0; n < kThreadCount; ++n) {
      while (!threads[n].finished_) {
        cv.Wait(&mutex);
      }
    }
  }
 
  // Make sure all threads are finished.
  {
    LockGuard<Mutex> lock_guard(&mutex);
    for (int n = kThreadCount - 1; n >= 0; --n) {
      EXPECT_FALSE(threads[n].running_);
      EXPECT_TRUE(threads[n].finished_);
    }
  }
 
  // Join all threads.
  for (int n = 0; n < kThreadCount; ++n) {
    threads[n].Join();
  }
}

TEST() [4/33]

v8::base::TEST	(	ConditionVariable	,
		WaitForAfterNofityOnSameThread
	)

Definition at line 14 of file condition-variable-unittest.cc.

                                                        {
  for (int n = 0; n < 10; ++n) {
    Mutex mutex;
    ConditionVariable cv;
 
    LockGuard<Mutex> lock_guard(&mutex);
 
    cv.NotifyOne();
    EXPECT_FALSE(cv.WaitFor(&mutex, TimeDelta::FromMicroseconds(n)));
 
    cv.NotifyAll();
    EXPECT_FALSE(cv.WaitFor(&mutex, TimeDelta::FromMicroseconds(n)));
  }
}

TEST() [5/33]

v8::base::TEST	(	CPUTest	,
		FeatureImplications
	)

Definition at line 11 of file cpu-unittest.cc.

                                   {
  CPU cpu;
 
  // ia32 and x64 features
  EXPECT_TRUE(!cpu.has_sse() || cpu.has_mmx());
  EXPECT_TRUE(!cpu.has_sse2() || cpu.has_sse());
  EXPECT_TRUE(!cpu.has_sse3() || cpu.has_sse2());
  EXPECT_TRUE(!cpu.has_ssse3() || cpu.has_sse3());
  EXPECT_TRUE(!cpu.has_sse41() || cpu.has_sse3());
  EXPECT_TRUE(!cpu.has_sse42() || cpu.has_sse41());
 
  // arm features
  EXPECT_TRUE(!cpu.has_vfp3_d32() || cpu.has_vfp3());
}

TEST() [6/33]

v8::base::TEST	(	CPUTest	,
		RequiredFeatures
	)

Definition at line 27 of file cpu-unittest.cc.

                                {
  CPU cpu;
 
#if V8_HOST_ARCH_ARM
  EXPECT_TRUE(cpu.has_fpu());
#endif
 
#if V8_HOST_ARCH_IA32
  EXPECT_TRUE(cpu.has_fpu());
  EXPECT_TRUE(cpu.has_sahf());
#endif
 
#if V8_HOST_ARCH_X64
  EXPECT_TRUE(cpu.has_fpu());
  EXPECT_TRUE(cpu.has_cmov());
  EXPECT_TRUE(cpu.has_mmx());
  EXPECT_TRUE(cpu.has_sse());
  EXPECT_TRUE(cpu.has_sse2());
#endif
}

TEST() [7/33]

v8::base::TEST	(	DivisionByConstant	,
		Signed32
	)

Definition at line 44 of file division-by-constant-unittest.cc.

                                   {
  EXPECT_EQ(M32(0x99999999U, 1, false), s32(-5));
  EXPECT_EQ(M32(0x55555555U, 1, false), s32(-3));
  int32_t d = -1;
  for (unsigned k = 1; k <= 32 - 1; ++k) {
    d *= 2;
    EXPECT_EQ(M32(0x7FFFFFFFU, k - 1, false), s32(d));
  }
  for (unsigned k = 1; k <= 32 - 2; ++k) {
    EXPECT_EQ(M32(0x80000001U, k - 1, false), s32(1 << k));
  }
  EXPECT_EQ(M32(0x55555556U, 0, false), s32(3));
  EXPECT_EQ(M32(0x66666667U, 1, false), s32(5));
  EXPECT_EQ(M32(0x2AAAAAABU, 0, false), s32(6));
  EXPECT_EQ(M32(0x92492493U, 2, false), s32(7));
  EXPECT_EQ(M32(0x38E38E39U, 1, false), s32(9));
  EXPECT_EQ(M32(0x66666667U, 2, false), s32(10));
  EXPECT_EQ(M32(0x2E8BA2E9U, 1, false), s32(11));
  EXPECT_EQ(M32(0x2AAAAAABU, 1, false), s32(12));
  EXPECT_EQ(M32(0x51EB851FU, 3, false), s32(25));
  EXPECT_EQ(M32(0x10624DD3U, 3, false), s32(125));
  EXPECT_EQ(M32(0x68DB8BADU, 8, false), s32(625));
}

References s32().

Here is the call graph for this function:

TEST() [8/33]

v8::base::TEST	(	DivisionByConstant	,
		Signed64
	)

Definition at line 88 of file division-by-constant-unittest.cc.

                                   {
  EXPECT_EQ(M64(0x9999999999999999ULL, 1, false), s64(-5));
  EXPECT_EQ(M64(0x5555555555555555ULL, 1, false), s64(-3));
  int64_t d = -1;
  for (unsigned k = 1; k <= 64 - 1; ++k) {
    d *= 2;
    EXPECT_EQ(M64(0x7FFFFFFFFFFFFFFFULL, k - 1, false), s64(d));
  }
  for (unsigned k = 1; k <= 64 - 2; ++k) {
    EXPECT_EQ(M64(0x8000000000000001ULL, k - 1, false), s64(1LL << k));
  }
  EXPECT_EQ(M64(0x5555555555555556ULL, 0, false), s64(3));
  EXPECT_EQ(M64(0x6666666666666667ULL, 1, false), s64(5));
  EXPECT_EQ(M64(0x2AAAAAAAAAAAAAABULL, 0, false), s64(6));
  EXPECT_EQ(M64(0x4924924924924925ULL, 1, false), s64(7));
  EXPECT_EQ(M64(0x1C71C71C71C71C72ULL, 0, false), s64(9));
  EXPECT_EQ(M64(0x6666666666666667ULL, 2, false), s64(10));
  EXPECT_EQ(M64(0x2E8BA2E8BA2E8BA3ULL, 1, false), s64(11));
  EXPECT_EQ(M64(0x2AAAAAAAAAAAAAABULL, 1, false), s64(12));
  EXPECT_EQ(M64(0xA3D70A3D70A3D70BULL, 4, false), s64(25));
  EXPECT_EQ(M64(0x20C49BA5E353F7CFULL, 4, false), s64(125));
  EXPECT_EQ(M64(0x346DC5D63886594BULL, 7, false), s64(625));
}

References s64().

Here is the call graph for this function:

TEST() [9/33]

v8::base::TEST	(	DivisionByConstant	,
		Unsigned32
	)

Definition at line 69 of file division-by-constant-unittest.cc.

                                     {
  EXPECT_EQ(M32(0x00000000U, 0, true), u32(1));
  for (unsigned k = 1; k <= 30; ++k) {
    EXPECT_EQ(M32(1U << (32 - k), 0, false), u32(1U << k));
  }
  EXPECT_EQ(M32(0xAAAAAAABU, 1, false), u32(3));
  EXPECT_EQ(M32(0xCCCCCCCDU, 2, false), u32(5));
  EXPECT_EQ(M32(0xAAAAAAABU, 2, false), u32(6));
  EXPECT_EQ(M32(0x24924925U, 3, true), u32(7));
  EXPECT_EQ(M32(0x38E38E39U, 1, false), u32(9));
  EXPECT_EQ(M32(0xCCCCCCCDU, 3, false), u32(10));
  EXPECT_EQ(M32(0xBA2E8BA3U, 3, false), u32(11));
  EXPECT_EQ(M32(0xAAAAAAABU, 3, false), u32(12));
  EXPECT_EQ(M32(0x51EB851FU, 3, false), u32(25));
  EXPECT_EQ(M32(0x10624DD3U, 3, false), u32(125));
  EXPECT_EQ(M32(0xD1B71759U, 9, false), u32(625));
}

References u32().

Here is the call graph for this function:

TEST() [10/33]

v8::base::TEST	(	DivisionByConstant	,
		Unsigned64
	)

Definition at line 113 of file division-by-constant-unittest.cc.

                                     {
  EXPECT_EQ(M64(0x0000000000000000ULL, 0, true), u64(1));
  for (unsigned k = 1; k <= 64 - 2; ++k) {
    EXPECT_EQ(M64(1ULL << (64 - k), 0, false), u64(1ULL << k));
  }
  EXPECT_EQ(M64(0xAAAAAAAAAAAAAAABULL, 1, false), u64(3));
  EXPECT_EQ(M64(0xCCCCCCCCCCCCCCCDULL, 2, false), u64(5));
  EXPECT_EQ(M64(0xAAAAAAAAAAAAAAABULL, 2, false), u64(6));
  EXPECT_EQ(M64(0x2492492492492493ULL, 3, true), u64(7));
  EXPECT_EQ(M64(0xE38E38E38E38E38FULL, 3, false), u64(9));
  EXPECT_EQ(M64(0xCCCCCCCCCCCCCCCDULL, 3, false), u64(10));
  EXPECT_EQ(M64(0x2E8BA2E8BA2E8BA3ULL, 1, false), u64(11));
  EXPECT_EQ(M64(0xAAAAAAAAAAAAAAABULL, 3, false), u64(12));
  EXPECT_EQ(M64(0x47AE147AE147AE15ULL, 5, true), u64(25));
  EXPECT_EQ(M64(0x0624DD2F1A9FBE77ULL, 7, true), u64(125));
  EXPECT_EQ(M64(0x346DC5D63886594BULL, 7, false), u64(625));
}

References u64().

Here is the call graph for this function:

TEST() [11/33]

v8::base::TEST	(	FlagsTest	,
		BasicOperations
	)

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

                                 {
  Flags1 a;
  EXPECT_EQ(kFlag1None, static_cast<int>(a));
  a |= kFlag1First;
  EXPECT_EQ(kFlag1First, static_cast<int>(a));
  a = a | kFlag1Second;
  EXPECT_EQ(kFlag1All, static_cast<int>(a));
  a &= kFlag1Second;
  EXPECT_EQ(kFlag1Second, static_cast<int>(a));
  a = kFlag1None & a;
  EXPECT_EQ(kFlag1None, static_cast<int>(a));
  a ^= (kFlag1All | kFlag1None);
  EXPECT_EQ(kFlag1All, static_cast<int>(a));
  Flags1 b = ~a;
  EXPECT_EQ(kFlag1All, static_cast<int>(a));
  EXPECT_EQ(~static_cast<int>(a), static_cast<int>(b));
  Flags1 c = a;
  EXPECT_EQ(a, c);
  EXPECT_NE(a, b);
  EXPECT_EQ(a, bar(a));
  EXPECT_EQ(a, bar(kFlag1All));
}

References v8::base::anonymous_namespace{flags-unittest.cc}::bar(), v8::base::anonymous_namespace{flags-unittest.cc}::kFlag1All, v8::base::anonymous_namespace{flags-unittest.cc}::kFlag1First, v8::base::anonymous_namespace{flags-unittest.cc}::kFlag1None, and v8::base::anonymous_namespace{flags-unittest.cc}::kFlag1Second.

Here is the call graph for this function:

TEST() [12/33]

v8::base::TEST	(	FlagsTest	,
		ClassScope
	)

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

                            {
  Foo::Enums enums;
  enums |= Foo::kEnum1;
  enums |= Foo::kEnum2;
  EXPECT_TRUE(enums & Foo::kEnum1);
  EXPECT_TRUE(enums & Foo::kEnum2);
}

TEST() [13/33]

v8::base::TEST	(	FlagsTest	,
		NamespaceScope
	)

Definition at line 74 of file flags-unittest.cc.

                                {
  foo::Options options;
  options ^= foo::kNoOptions;
  options |= foo::kOption1 | foo::kOption2;
  EXPECT_EQ(foo::kAllOptions, static_cast<int>(options));
}

References v8::base::anonymous_namespace{flags-unittest.cc}::foo::kAllOptions, v8::base::anonymous_namespace{flags-unittest.cc}::foo::kNoOptions, v8::base::anonymous_namespace{flags-unittest.cc}::foo::kOption1, and v8::base::anonymous_namespace{flags-unittest.cc}::foo::kOption2.

TEST() [14/33]

v8::base::TEST	(	Mutex	,
		LockGuardLazyMutex
	)

Definition at line 29 of file mutex-unittest.cc.

                                {
  LazyMutex lazy_mutex = LAZY_MUTEX_INITIALIZER;
  { LockGuard<Mutex> lock_guard(lazy_mutex.Pointer()); }
  { LockGuard<Mutex> lock_guard(lazy_mutex.Pointer()); }
}

References LAZY_MUTEX_INITIALIZER, and v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer().

Here is the call graph for this function:

TEST() [15/33]

v8::base::TEST	(	Mutex	,
		LockGuardLazyRecursiveMutex
	)

Definition at line 36 of file mutex-unittest.cc.

                                         {
  LazyRecursiveMutex lazy_recursive_mutex = LAZY_RECURSIVE_MUTEX_INITIALIZER;
  { LockGuard<RecursiveMutex> lock_guard(lazy_recursive_mutex.Pointer()); }
  {
    LockGuard<RecursiveMutex> lock_guard1(lazy_recursive_mutex.Pointer());
    LockGuard<RecursiveMutex> lock_guard2(lazy_recursive_mutex.Pointer());
  }
}

References LAZY_RECURSIVE_MUTEX_INITIALIZER, and v8::base::LazyInstanceImpl< T, AllocationTrait, CreateTrait, InitOnceTrait, DestroyTrait >::Pointer().

Here is the call graph for this function:

TEST() [16/33]

v8::base::TEST	(	Mutex	,
		LockGuardMutex
	)

Definition at line 12 of file mutex-unittest.cc.

                            {
  Mutex mutex;
  { LockGuard<Mutex> lock_guard(&mutex); }
  { LockGuard<Mutex> lock_guard(&mutex); }
}

TEST() [17/33]

v8::base::TEST	(	Mutex	,
		LockGuardRecursiveMutex
	)

Definition at line 19 of file mutex-unittest.cc.

                                     {
  RecursiveMutex recursive_mutex;
  { LockGuard<RecursiveMutex> lock_guard(&recursive_mutex); }
  {
    LockGuard<RecursiveMutex> lock_guard1(&recursive_mutex);
    LockGuard<RecursiveMutex> lock_guard2(&recursive_mutex);
  }
}

TEST() [18/33]

v8::base::TEST	(	Mutex	,
		MultipleMutexes
	)

Definition at line 46 of file mutex-unittest.cc.

                             {
  Mutex mutex1;
  Mutex mutex2;
  Mutex mutex3;
  // Order 1
  mutex1.Lock();
  mutex2.Lock();
  mutex3.Lock();
  mutex1.Unlock();
  mutex2.Unlock();
  mutex3.Unlock();
  // Order 2
  mutex1.Lock();
  mutex2.Lock();
  mutex3.Lock();
  mutex3.Unlock();
  mutex2.Unlock();
  mutex1.Unlock();
}

TEST() [19/33]

v8::base::TEST	(	Mutex	,
		MultipleRecursiveMutexes
	)

Definition at line 67 of file mutex-unittest.cc.

                                      {
  RecursiveMutex recursive_mutex1;
  RecursiveMutex recursive_mutex2;
  // Order 1
  recursive_mutex1.Lock();
  recursive_mutex2.Lock();
  EXPECT_TRUE(recursive_mutex1.TryLock());
  EXPECT_TRUE(recursive_mutex2.TryLock());
  recursive_mutex1.Unlock();
  recursive_mutex1.Unlock();
  recursive_mutex2.Unlock();
  recursive_mutex2.Unlock();
  // Order 2
  recursive_mutex1.Lock();
  EXPECT_TRUE(recursive_mutex1.TryLock());
  recursive_mutex2.Lock();
  EXPECT_TRUE(recursive_mutex2.TryLock());
  recursive_mutex2.Unlock();
  recursive_mutex1.Unlock();
  recursive_mutex2.Unlock();
  recursive_mutex1.Unlock();
}

TEST() [20/33]

v8::base::TEST	(	OS	,
		GetCurrentProcessId
	)

Definition at line 19 of file platform-unittest.cc.

                              {
#if V8_OS_POSIX
  EXPECT_EQ(static_cast<int>(getpid()), OS::GetCurrentProcessId());
#endif
 
#if V8_OS_WIN
  EXPECT_EQ(static_cast<int>(::GetCurrentProcessId()),
            OS::GetCurrentProcessId());
#endif
}

References v8::base::OS::GetCurrentProcessId().

Here is the call graph for this function:

TEST() [21/33]

v8::base::TEST	(	Semaphore	,
		ProducerConsumer
	)

Definition at line 93 of file semaphore-unittest.cc.

                                  {
  char buffer[kBufferSize];
  std::memset(buffer, 0, sizeof(buffer));
  Semaphore free_space(kBufferSize);
  Semaphore used_space(0);
  ProducerThread producer_thread(buffer, &free_space, &used_space);
  ConsumerThread consumer_thread(buffer, &free_space, &used_space);
  producer_thread.Start();
  consumer_thread.Start();
  producer_thread.Join();
  consumer_thread.Join();
}

References v8::base::anonymous_namespace{semaphore-unittest.cc}::kBufferSize.

TEST() [22/33]

v8::base::TEST	(	Semaphore	,
		WaitAndSignal
	)

Definition at line 107 of file semaphore-unittest.cc.

                               {
  Semaphore semaphore(0);
  WaitAndSignalThread t1(&semaphore);
  WaitAndSignalThread t2(&semaphore);
 
  t1.Start();
  t2.Start();
 
  // Make something available.
  semaphore.Signal();
 
  t1.Join();
  t2.Join();
 
  semaphore.Wait();
 
  EXPECT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1)));
}

TEST() [23/33]

v8::base::TEST	(	Semaphore	,
		WaitFor
	)

Definition at line 127 of file semaphore-unittest.cc.

                         {
  Semaphore semaphore(0);
 
  // Semaphore not signalled - timeout.
  ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(0)));
  ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(100)));
  ASSERT_FALSE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1000)));
 
  // Semaphore signalled - no timeout.
  semaphore.Signal();
  ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(0)));
  semaphore.Signal();
  ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(100)));
  semaphore.Signal();
  ASSERT_TRUE(semaphore.WaitFor(TimeDelta::FromMicroseconds(1000)));
}

TEST() [24/33]

v8::base::TEST	(	SysInfoTest	,
		AmountOfVirtualMemory
	)

Definition at line 27 of file sys-info-unittest.cc.

                                         {
  EXPECT_LE(0, SysInfo::AmountOfVirtualMemory());
}

TEST() [25/33]

v8::base::TEST	(	SysInfoTest	,
		DISABLE_ON_NACL(AmountOfPhysicalMemory)
	)

Definition at line 22 of file sys-info-unittest.cc.

                                                           {
  EXPECT_LT(0, SysInfo::AmountOfPhysicalMemory());
}

TEST() [26/33]

v8::base::TEST	(	SysInfoTest	,
		NumberOfProcessors
	)

Definition at line 17 of file sys-info-unittest.cc.

                                      {
  EXPECT_LT(0, SysInfo::NumberOfProcessors());
}

TEST() [27/33]

v8::base::TEST	(	Thread	,
		SelfJoin
	)

Definition at line 42 of file platform-unittest.cc.

                       {
  SelfJoinThread thread;
  thread.Start();
  thread.Join();
}

TEST() [28/33]

v8::base::TEST	(	Time	,
		JsTime
	)

Definition at line 55 of file time-unittest.cc.

                   {
  Time t = Time::FromJsTime(700000.3);
  EXPECT_DOUBLE_EQ(700000.3, t.ToJsTime());
}

TEST() [29/33]

v8::base::TEST	(	Time	,
		NowResolution
	)

Definition at line 145 of file time-unittest.cc.

                          {
  // We assume that Time::Now() has at least 16ms resolution.
  static const TimeDelta kTargetGranularity = TimeDelta::FromMilliseconds(16);
  ResolutionTest<Time>(&Time::Now, kTargetGranularity);
}

TEST() [30/33]

v8::base::TEST	(	TimeDelta	,
		FromAndIn
	)

Definition at line 24 of file time-unittest.cc.

                           {
  EXPECT_EQ(TimeDelta::FromDays(2), TimeDelta::FromHours(48));
  EXPECT_EQ(TimeDelta::FromHours(3), TimeDelta::FromMinutes(180));
  EXPECT_EQ(TimeDelta::FromMinutes(2), TimeDelta::FromSeconds(120));
  EXPECT_EQ(TimeDelta::FromSeconds(2), TimeDelta::FromMilliseconds(2000));
  EXPECT_EQ(TimeDelta::FromMilliseconds(2), TimeDelta::FromMicroseconds(2000));
  EXPECT_EQ(static_cast<int>(13), TimeDelta::FromDays(13).InDays());
  EXPECT_EQ(static_cast<int>(13), TimeDelta::FromHours(13).InHours());
  EXPECT_EQ(static_cast<int>(13), TimeDelta::FromMinutes(13).InMinutes());
  EXPECT_EQ(static_cast<int64_t>(13), TimeDelta::FromSeconds(13).InSeconds());
  EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromSeconds(13).InSecondsF());
  EXPECT_EQ(static_cast<int64_t>(13),
            TimeDelta::FromMilliseconds(13).InMilliseconds());
  EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromMilliseconds(13).InMillisecondsF());
  EXPECT_EQ(static_cast<int64_t>(13),
            TimeDelta::FromMicroseconds(13).InMicroseconds());
}

TEST() [31/33]

v8::base::TEST	(	TimeTicks	,
		HighResolutionNowResolution
	)

Definition at line 159 of file time-unittest.cc.

                                             {
  if (!TimeTicks::IsHighResolutionClockWorking()) return;
 
  // We assume that TimeTicks::HighResolutionNow() has sub-ms resolution.
  static const TimeDelta kTargetGranularity = TimeDelta::FromMilliseconds(1);
  ResolutionTest<TimeTicks>(&TimeTicks::HighResolutionNow, kTargetGranularity);
}

TEST() [32/33]

v8::base::TEST	(	TimeTicks	,
		IsMonotonic
	)

Definition at line 168 of file time-unittest.cc.

                             {
  TimeTicks previous_normal_ticks;
  TimeTicks previous_highres_ticks;
  ElapsedTimer timer;
  timer.Start();
  while (!timer.HasExpired(TimeDelta::FromMilliseconds(100))) {
    TimeTicks normal_ticks = TimeTicks::Now();
    TimeTicks highres_ticks = TimeTicks::HighResolutionNow();
    EXPECT_GE(normal_ticks, previous_normal_ticks);
    EXPECT_GE((normal_ticks - previous_normal_ticks).InMicroseconds(), 0);
    EXPECT_GE(highres_ticks, previous_highres_ticks);
    EXPECT_GE((highres_ticks - previous_highres_ticks).InMicroseconds(), 0);
    previous_normal_ticks = normal_ticks;
    previous_highres_ticks = highres_ticks;
  }
}

TEST() [33/33]

v8::base::TEST	(	TimeTicks	,
		NowResolution
	)

Definition at line 152 of file time-unittest.cc.

                               {
  // We assume that TimeTicks::Now() has at least 16ms resolution.
  static const TimeDelta kTargetGranularity = TimeDelta::FromMilliseconds(16);
  ResolutionTest<TimeTicks>(&TimeTicks::Now, kTargetGranularity);
}

TEST_F()

v8::base::TEST_F	(	ThreadLocalStorageTest	,
		DoTest
	)

Definition at line 103 of file platform-unittest.cc.

                                       {
  Run();
  Start();
  Join();
}

TEST_P() [1/3]

v8::base::TEST_P	(	RandomNumberGeneratorTest	,
		NextBooleanReturnsFalseOrTrue
	)

Definition at line 29 of file random-number-generator-unittest.cc.

                                                                 {
  RandomNumberGenerator rng(GetParam());
  for (int k = 0; k < kMaxRuns; ++k) {
    bool b = rng.NextBool();
    EXPECT_TRUE(b == false || b == true);
  }
}

References kMaxRuns.

TEST_P() [2/3]

v8::base::TEST_P	(	RandomNumberGeneratorTest	,
		NextDoubleReturnsValueBetween0And1
	)

Definition at line 38 of file random-number-generator-unittest.cc.

                                                                      {
  RandomNumberGenerator rng(GetParam());
  for (int k = 0; k < kMaxRuns; ++k) {
    double d = rng.NextDouble();
    EXPECT_LE(0.0, d);
    EXPECT_LT(d, 1.0);
  }
}

References kMaxRuns.

TEST_P() [3/3]

v8::base::TEST_P	(	RandomNumberGeneratorTest	,
		NextIntWithMaxValue
	)

Definition at line 19 of file random-number-generator-unittest.cc.

                                                       {
  RandomNumberGenerator rng(GetParam());
  for (int max = 1; max <= kMaxRuns; ++max) {
    int n = rng.NextInt(max);
    EXPECT_LE(0, n);
    EXPECT_LT(n, max);
  }
}

References kMaxRuns.

ThreadEntry() [1/2]

static void* v8::base::ThreadEntry ( void *  arg )

static

Definition at line 498 of file platform-posix.cc.

                                    {
  Thread* thread = reinterpret_cast<Thread*>(arg);
  // We take the lock here to make sure that pthread_create finished first since
  // we don't know which thread will run first (the original thread or the new
  // one).
  { LockGuard<Mutex> lock_guard(&thread->data()->thread_creation_mutex_); }
  SetThreadName(thread->name());
  DCHECK(thread->data()->thread_ != kNoThread);
  thread->NotifyStartedAndRun();
  return NULL;
}

References v8::base::Thread::data(), DCHECK, kNoThread, v8::base::Thread::name(), v8::base::Thread::NotifyStartedAndRun(), NULL, SetThreadName(), v8::base::Thread::PlatformData::thread_, and v8::base::Thread::PlatformData::thread_creation_mutex_.

Referenced by v8::base::Thread::Start().

Here is the call graph for this function:

Here is the caller graph for this function:

ThreadEntry() [2/2]

static unsigned int __stdcall v8::base::ThreadEntry ( void *  arg )

static

Definition at line 1314 of file platform-win32.cc.

                                                     {
  Thread* thread = reinterpret_cast<Thread*>(arg);
  thread->NotifyStartedAndRun();
  return 0;
}

References v8::base::Thread::NotifyStartedAndRun().

Here is the call graph for this function:

u32()

static M32 v8::base::u32 ( uint32_t  d )

static

Definition at line 40 of file division-by-constant-unittest.cc.

{ return UnsignedDivisionByConstant<uint32_t>(d); }

Referenced by TEST().

Here is the caller graph for this function:

u64()

static M64 v8::base::u64 ( uint64_t  d )

static

Definition at line 41 of file division-by-constant-unittest.cc.

{ return UnsignedDivisionByConstant<uint64_t>(d); }

Referenced by TEST().

Here is the caller graph for this function:

UnsignedDivisionByConstant() [1/3]

template<class T >

MagicNumbersForDivision< T > v8::base::UnsignedDivisionByConstant	(	T	d,
		unsigned	leading_zeros
	)

Definition at line 60 of file division-by-constant.cc.

                                                                              {
  STATIC_ASSERT(static_cast<T>(0) < static_cast<T>(-1));
  DCHECK(d != 0);
  const unsigned bits = static_cast<unsigned>(sizeof(T)) * 8;
  const T ones = ~static_cast<T>(0) >> leading_zeros;
  const T min = static_cast<T>(1) << (bits - 1);
  const T max = ~static_cast<T>(0) >> 1;
  const T nc = ones - (ones - d) % d;
  bool a = false;         // Init. "add" indicator.
  unsigned p = bits - 1;  // Init. p.
  T q1 = min / nc;        // Init. q1 = 2**p/nc
  T r1 = min - q1 * nc;   // Init. r1 = rem(2**p,nc)
  T q2 = max / d;         // Init. q2 = (2**p - 1)/d.
  T r2 = max - q2 * d;    // Init. r2 = rem(2**p - 1, d).
  T delta;
  do {
    p = p + 1;
    if (r1 >= nc - r1) {
      q1 = 2 * q1 + 1;
      r1 = 2 * r1 - nc;
    } else {
      q1 = 2 * q1;
      r1 = 2 * r1;
    }
    if (r2 + 1 >= d - r2) {
      if (q2 >= max) a = true;
      q2 = 2 * q2 + 1;
      r2 = 2 * r2 + 1 - d;
    } else {
      if (q2 >= min) a = true;
      q2 = 2 * q2;
      r2 = 2 * r2 + 1;
    }
    delta = d - 1 - r2;
  } while (p < bits * 2 && (q1 < delta || (q1 == delta && r1 == 0)));
  return {q2 + 1, p - bits, a};
}

References DCHECK, v8::internal::min(), v8::internal::q1, v8::internal::q2, v8::internal::r1, v8::internal::r2, STATIC_ASSERT, and T.

Here is the call graph for this function:

UnsignedDivisionByConstant() [2/3]

template MagicNumbersForDivision<uint32_t> v8::base::UnsignedDivisionByConstant	(	uint32_t	d,
		unsigned	leading_zeros
	)

UnsignedDivisionByConstant() [3/3]

template MagicNumbersForDivision<uint64_t> v8::base::UnsignedDivisionByConstant	(	uint64_t	d,
		unsigned	leading_zeros
	)

VPrintHelper()

static void v8::base::VPrintHelper ( FILE *  stream, const char *  format, va_list  args  )

static

Definition at line 561 of file platform-win32.cc.

                                                                         {
  if ((stream == stdout || stream == stderr) && !HasConsole()) {
    // It is important to use safe print here in order to avoid
    // overflowing the buffer. We might truncate the output, but this
    // does not crash.
    char buffer[4096];
    OS::VSNPrintF(buffer, sizeof(buffer), format, args);
    OutputDebugStringA(buffer);
  } else {
    vfprintf(stream, format, args);
  }
}

References HasConsole(), and v8::base::OS::VSNPrintF().

Here is the call graph for this function:

Variable Documentation

AtomicOps_Internalx86CPUFeatures

struct AtomicOps_x86CPUFeatureStruct v8::base::AtomicOps_Internalx86CPUFeatures

extern

entropy_mutex

LazyMutex v8::base::entropy_mutex = LAZY_MUTEX_INITIALIZER

static

Definition at line 19 of file random-number-generator.cc.

entropy_source

RandomNumberGenerator::EntropySource v8::base::entropy_source = NULL

static

Definition at line 20 of file random-number-generator.cc.

Referenced by v8::V8::SetEntropySource().

kernel_tick_clock

LazyStaticInstance<KernelTimestampClock, DefaultConstructTrait<KernelTimestampClock>, ThreadSafeInitOnceTrait>::type v8::base::kernel_tick_clock

static

Initial value:

=
    LAZY_STATIC_INSTANCE_INITIALIZER

Definition at line 637 of file time.cc.

kMaxRuns

const int v8::base::kMaxRuns = 12345

static

Definition at line 16 of file random-number-generator-unittest.cc.

Referenced by TEST_P().

kMmapFd [1/6]

const int v8::base::kMmapFd = -1

static

Definition at line 172 of file platform-freebsd.cc.

kMmapFd [2/6]

const int v8::base::kMmapFd = -1

static

Definition at line 296 of file platform-linux.cc.

kMmapFd [3/6]

const int v8::base::kMmapFd = VM_MAKE_TAG(255)

static

Definition at line 50 of file platform-macos.cc.

kMmapFd [4/6]

const int v8::base::kMmapFd = -1

static

Definition at line 203 of file platform-openbsd.cc.

kMmapFd [5/6]

const int v8::base::kMmapFd = -1

static

Definition at line 239 of file platform-qnx.cc.

kMmapFd [6/6]

const int v8::base::kMmapFd = -1

static

Definition at line 144 of file platform-solaris.cc.

kMmapFdOffset [1/6]

const int v8::base::kMmapFdOffset = 0

static

Definition at line 173 of file platform-freebsd.cc.

kMmapFdOffset [2/6]

const int v8::base::kMmapFdOffset = 0

static

Definition at line 297 of file platform-linux.cc.

kMmapFdOffset [3/6]

const off_t v8::base::kMmapFdOffset = 0

static

Definition at line 51 of file platform-macos.cc.

kMmapFdOffset [4/6]

const int v8::base::kMmapFdOffset = 0

static

Definition at line 204 of file platform-openbsd.cc.

kMmapFdOffset [5/6]

const int v8::base::kMmapFdOffset = 0

static

Definition at line 240 of file platform-qnx.cc.

kMmapFdOffset [6/6]

const int v8::base::kMmapFdOffset = 0

static

Definition at line 145 of file platform-solaris.cc.

kNoThread [1/2]

const pthread_t v8::base::kNoThread = (pthread_t) 0

static

Definition at line 43 of file platform-qnx.cc.

Referenced by v8::base::Thread::Start(), and ThreadEntry().

kNoThread [2/2]

const HANDLE v8::base::kNoThread = INVALID_HANDLE_VALUE

static

Definition at line 1308 of file platform-win32.cc.

output_mode

OutputMode v8::base::output_mode = UNKNOWN

static

Definition at line 539 of file platform-win32.cc.

Referenced by HasConsole().

platform_random_number_generator [1/2]

LazyInstance<RandomNumberGenerator>::type v8::base::platform_random_number_generator = LAZY_INSTANCE_INITIALIZER

static

Definition at line 135 of file platform-posix.cc.

Referenced by v8::base::OS::GetRandomMmapAddr(), and v8::base::OS::Initialize().

platform_random_number_generator [2/2]

LazyInstance<RandomNumberGenerator>::type v8::base::platform_random_number_generator = LAZY_INSTANCE_INITIALIZER

static

Definition at line 724 of file platform-win32.cc.