v8::base::OS Class Reference

#include <platform.h>

Collaboration diagram for v8::base::OS:

Classes
class	MemoryMappedFile
struct	SharedLibraryAddress
struct	StackFrame

Static Public Member Functions
static void	Initialize (int64_t random_seed, bool hard_abort, const char *const gc_fake_mmap)
static int	GetUserTime (uint32_t *secs, uint32_t *usecs)
static double	TimeCurrentMillis ()
static TimezoneCache *	CreateTimezoneCache ()
static void	DisposeTimezoneCache (TimezoneCache *cache)
static void	ClearTimezoneCache (TimezoneCache *cache)
static const char *	LocalTimezone (double time, TimezoneCache *cache)
static double	LocalTimeOffset (TimezoneCache *cache)
static double	DaylightSavingsOffset (double time, TimezoneCache *cache)
static int	GetLastError ()
static FILE *	FOpen (const char *path, const char *mode)
static bool	Remove (const char *path)
static FILE *	OpenTemporaryFile ()
static void	Print (const char *format,...)
static void	VPrint (const char *format, va_list args)
static void	FPrint (FILE *out, const char *format,...)
static void	VFPrint (FILE *out, const char *format, va_list args)
static void	PrintError (const char *format,...)
static void	VPrintError (const char *format, va_list args)
static void *	Allocate (const size_t requested, size_t *allocated, bool is_executable)
static void	Free (void *address, const size_t size)
static intptr_t	CommitPageSize ()
static void	ProtectCode (void *address, const size_t size)
static void	Guard (void *address, const size_t size)
static void *	GetRandomMmapAddr ()
static size_t	AllocateAlignment ()
static void	Sleep (const int milliseconds)
static void	Abort ()
static void	DebugBreak ()
static int	SNPrintF (char *str, int length, const char *format,...)
static int	VSNPrintF (char *str, int length, const char *format, va_list args)
static char *	StrChr (char *str, int c)
static void	StrNCpy (char *dest, int length, const char *src, size_t n)
static std::vector< SharedLibraryAddress >	GetSharedLibraryAddresses ()
static void	SignalCodeMovingGC ()
static double	nan_value ()
static bool	ArmUsingHardFloat ()
static int	ActivationFrameAlignment ()
static int	GetCurrentProcessId ()
static int	GetCurrentThreadId ()

Static Public Attributes
static const char *const	LogFileOpenMode = "w"
static const int	kStackWalkError = -1
static const int	kStackWalkMaxNameLen = 256
static const int	kStackWalkMaxTextLen = 256

Private Member Functions
	DISALLOW_IMPLICIT_CONSTRUCTORS (OS)

Static Private Attributes
static const int	msPerSecond = 1000

Detailed Description

Definition at line 142 of file platform.h.

Member Function Documentation

Abort()

void v8::base::OS::Abort ( )

static

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

               {
  if (g_hard_abort) {
    V8_IMMEDIATE_CRASH();
  }
  // Redirect to std abort to signal abnormal program termination.
  abort();
}

References v8::base::anonymous_namespace{platform-posix.cc}::g_hard_abort, and V8_IMMEDIATE_CRASH.

Referenced by v8::internal::Isolate::DoThrow(), v8::Utils::ReportApiFailure(), v8::internal::RUNTIME_FUNCTION(), v8::internal::Isolate::StackTraceString(), and V8_Fatal().

Here is the caller graph for this function:

ActivationFrameAlignment()

int v8::base::OS::ActivationFrameAlignment ( )

static

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

                                 {
#if V8_TARGET_ARCH_ARM
  // On EABI ARM targets this is required for fp correctness in the
  // runtime system.
  return 8;
#elif V8_TARGET_ARCH_MIPS
  return 8;
#else
  // Otherwise we just assume 16 byte alignment, i.e.:
  // - With gcc 4.4 the tree vectorization optimizer can generate code
  //   that requires 16 byte alignment such as movdqa on x86.
  // - Mac OS X and Solaris (64-bit) activation frames must be 16 byte-aligned;
  //   see "Mac OS X ABI Function Call Guide"
  return 16;
#endif
}

Allocate()

void * v8::base::OS::Allocate ( const size_t  requested, size_t *  allocated, bool  is_executable  )

static

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

                                       {
  const size_t msize = RoundUp(requested, sysconf(_SC_PAGESIZE));
  int prot = PROT_READ | PROT_WRITE | (is_executable ? PROT_EXEC : 0);
  void* mbase = mmap(NULL, msize, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
  if (mbase == MAP_FAILED) return NULL;
  *allocated = msize;
  return mbase;
}

References NULL, and RoundUp().

Here is the call graph for this function:

AllocateAlignment()

size_t v8::base::OS::AllocateAlignment ( )

static

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

                             {
  return static_cast<size_t>(sysconf(_SC_PAGESIZE));
}

Referenced by v8::internal::SemiSpace::GrowTo(), v8::internal::SemiSpace::ShrinkTo(), and v8::base::VirtualMemory::VirtualMemory().

Here is the caller graph for this function:

ArmUsingHardFloat()

static bool v8::base::OS::ArmUsingHardFloat ( )

static

Referenced by v8::internal::MacroAssembler::use_eabi_hardfloat().

Here is the caller graph for this function:

ClearTimezoneCache()

void v8::base::OS::ClearTimezoneCache ( TimezoneCache *  cache )

static

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

                                                {
  DCHECK(cache == NULL);
}

References DCHECK, and NULL.

Referenced by v8::internal::DateCache::ResetDateCache().

Here is the caller graph for this function:

CommitPageSize()

intptr_t v8::base::OS::CommitPageSize ( )

static

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

                            {
  static intptr_t page_size = getpagesize();
  return page_size;
}

Referenced by v8::internal::MemoryAllocator::AllocateChunk(), v8::internal::AllocateCodeChunk(), v8::internal::MemoryAllocator::CodePageAreaEndOffset(), v8::internal::MemoryAllocator::CodePageGuardSize(), v8::internal::MemoryAllocator::CodePageGuardStartOffset(), v8::internal::MemoryChunk::CommitArea(), v8::internal::Deoptimizer::GetMaxDeoptTableSize(), v8::base::VirtualMemory::Guard(), and v8::internal::StoreBuffer::SetUp().

Here is the caller graph for this function:

CreateTimezoneCache()

TimezoneCache * v8::base::OS::CreateTimezoneCache ( )

static

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

                                       {
  return NULL;
}

References NULL.

DaylightSavingsOffset()

double v8::base::OS::DaylightSavingsOffset ( double  time, TimezoneCache *  cache  )

static

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

                                                            {
  if (std::isnan(time)) return nan_value();
  time_t tv = static_cast<time_t>(std::floor(time/msPerSecond));
  struct tm* t = localtime(&tv);
  if (NULL == t) return nan_value();
  return t->tm_isdst > 0 ? 3600 * msPerSecond : 0;
}

References msPerSecond, nan_value(), and NULL.

Referenced by v8::internal::DateCache::GetDaylightSavingsOffsetFromOS().

Here is the call graph for this function:

Here is the caller graph for this function:

DebugBreak()

void v8::base::OS::DebugBreak ( )

static

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

                    {
#if V8_HOST_ARCH_ARM
  asm("bkpt 0");
#elif V8_HOST_ARCH_ARM64
  asm("brk 0");
#elif V8_HOST_ARCH_MIPS
  asm("break");
#elif V8_HOST_ARCH_MIPS64
  asm("break");
#elif V8_HOST_ARCH_IA32
#if V8_OS_NACL
  asm("hlt");
#else
  asm("int $3");
#endif  // V8_OS_NACL
#elif V8_HOST_ARCH_X64
  asm("int $3");
#else
#error Unsupported host architecture.
#endif
}

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::base::OS::DISALLOW_IMPLICIT_CONSTRUCTORS ( OS  )

private

DisposeTimezoneCache()

void v8::base::OS::DisposeTimezoneCache ( TimezoneCache *  cache )

static

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

                                                  {
  DCHECK(cache == NULL);
}

References DCHECK, and NULL.

Referenced by v8::internal::DateCache::~DateCache().

Here is the caller graph for this function:

FOpen()

FILE * v8::base::OS::FOpen ( const char *  path, const char *  mode  )

static

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

                                                  {
  FILE* file = fopen(path, mode);
  if (file == NULL) return NULL;
  struct stat file_stat;
  if (fstat(fileno(file), &file_stat) != 0) return NULL;
  bool is_regular_file = ((file_stat.st_mode & S_IFREG) != 0);
  if (is_regular_file) return file;
  fclose(file);
  return NULL;
}

References file(), mode(), and NULL.

Referenced by v8::internal::AppendChars(), SnapshotWriter::GetFileDescriptorOrDie(), v8::internal::LowLevelLogger::LowLevelLogger(), main(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::OpenFile(), v8::internal::Log::OpenFile(), v8::internal::PerfBasicLogger::PerfBasicLogger(), v8::internal::ReadCharsFromFile(), v8::internal::compiler::Pipeline::VerifyAndPrintGraph(), and v8::internal::WriteChars().

Here is the call graph for this function:

Here is the caller graph for this function:

FPrint()

void v8::base::OS::FPrint ( FILE *  out, const char *  format,   ...  )

static

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

                                                  {
  va_list args;
  va_start(args, format);
  VFPrint(out, format, args);
  va_end(args);
}

References VFPrint().

Referenced by v8::internal::PerfBasicLogger::LogRecordedBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

Free()

void v8::base::OS::Free ( void *  address, const size_t  size  )

static

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

                                              {
  // TODO(1240712): munmap has a return value which is ignored here.
  int result = munmap(address, size);
  USE(result);
  DCHECK(result == 0);
}

References DCHECK, size, and USE().

Here is the call graph for this function:

GetCurrentProcessId()

int v8::base::OS::GetCurrentProcessId ( )

static

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

                            {
  return static_cast<int>(getpid());
}

Referenced by v8::internal::FINAL< kOperandKind, kNumCachedOperands >::CodeTracer(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::HTracer(), v8::base::LoadSymbols(), v8::internal::PerfBasicLogger::PerfBasicLogger(), v8::internal::PrepareLogFileName(), v8::internal::PrintPID(), and v8::base::TEST().

Here is the caller graph for this function:

GetCurrentThreadId()

int v8::base::OS::GetCurrentThreadId ( )

static

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

                           {
#if defined(ANDROID)
  return static_cast<int>(syscall(__NR_gettid));
#elif defined(SYS_gettid)
  return static_cast<int>(syscall(SYS_gettid));
#else
  // PNaCL doesn't have a way to get an integral thread ID, but it doesn't
  // really matter, because we only need it in PerfJitLogger::LogRecordedBuffer.
  return 0;
#endif
}

GetLastError()

int v8::base::OS::GetLastError ( )

static

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

                     {
  return errno;
}

Referenced by v8::base::LoadSymbols(), and v8::internal::Heap::RecordStats().

Here is the caller graph for this function:

GetRandomMmapAddr()

void * v8::base::OS::GetRandomMmapAddr ( )

static

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

                            {
#if V8_OS_NACL
  // TODO(bradchen): restore randomization once Native Client gets
  // smarter about using mmap address hints.
  // See http://code.google.com/p/nativeclient/issues/3341
  return NULL;
#endif
#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
    defined(THREAD_SANITIZER)
  // Dynamic tools do not support custom mmap addresses.
  return NULL;
#endif
  uintptr_t raw_addr;
  platform_random_number_generator.Pointer()->NextBytes(&raw_addr,
                                                        sizeof(raw_addr));
#if V8_TARGET_ARCH_X64
  // Currently available CPUs have 48 bits of virtual addressing.  Truncate
  // the hint address to 46 bits to give the kernel a fighting chance of
  // fulfilling our placement request.
  raw_addr &= V8_UINT64_C(0x3ffffffff000);
#else
  raw_addr &= 0x3ffff000;
 
# ifdef __sun
  // For our Solaris/illumos mmap hint, we pick a random address in the bottom
  // half of the top half of the address space (that is, the third quarter).
  // Because we do not MAP_FIXED, this will be treated only as a hint -- the
  // system will not fail to mmap() because something else happens to already
  // be mapped at our random address. We deliberately set the hint high enough
  // to get well above the system's break (that is, the heap); Solaris and
  // illumos will try the hint and if that fails allocate as if there were
  // no hint at all. The high hint prevents the break from getting hemmed in
  // at low values, ceding half of the address space to the system heap.
  raw_addr += 0x80000000;
# else
  // The range 0x20000000 - 0x60000000 is relatively unpopulated across a
  // variety of ASLR modes (PAE kernel, NX compat mode, etc) and on macos
  // 10.6 and 10.7.
  raw_addr += 0x20000000;
# endif
#endif
  return reinterpret_cast<void*>(raw_addr);
}

References NULL, v8::base::platform_random_number_generator, and V8_UINT64_C.

Referenced by v8::base::RandomizedVirtualAlloc().

Here is the caller graph for this function:

GetSharedLibraryAddresses()

std::vector< OS::SharedLibraryAddress > v8::base::OS::GetSharedLibraryAddresses ( )

static

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

                                                                {
  std::vector<SharedLibraryAddresses> result;
  // This function assumes that the layout of the file is as follows:
  // hex_start_addr-hex_end_addr rwxp <unused data> [binary_file_name]
  // If we encounter an unexpected situation we abort scanning further entries.
  FILE* fp = fopen("/proc/self/maps", "r");
  if (fp == NULL) return result;
 
  // Allocate enough room to be able to store a full file name.
  const int kLibNameLen = FILENAME_MAX + 1;
  char* lib_name = reinterpret_cast<char*>(malloc(kLibNameLen));
 
  // This loop will terminate once the scanning hits an EOF.
  while (true) {
    uintptr_t start, end;
    char attr_r, attr_w, attr_x, attr_p;
    // Parse the addresses and permission bits at the beginning of the line.
    if (fscanf(fp, "%" V8PRIxPTR "-%" V8PRIxPTR, &start, &end) != 2) break;
    if (fscanf(fp, " %c%c%c%c", &attr_r, &attr_w, &attr_x, &attr_p) != 4) break;
 
    int c;
    if (attr_r == 'r' && attr_w != 'w' && attr_x == 'x') {
      // Found a read-only executable entry. Skip characters until we reach
      // the beginning of the filename or the end of the line.
      do {
        c = getc(fp);
      } while ((c != EOF) && (c != '\n') && (c != '/'));
      if (c == EOF) break;  // EOF: Was unexpected, just exit.
 
      // Process the filename if found.
      if (c == '/') {
        ungetc(c, fp);  // Push the '/' back into the stream to be read below.
 
        // Read to the end of the line. Exit if the read fails.
        if (fgets(lib_name, kLibNameLen, fp) == NULL) break;
 
        // Drop the newline character read by fgets. We do not need to check
        // for a zero-length string because we know that we at least read the
        // '/' character.
        lib_name[strlen(lib_name) - 1] = '\0';
      } else {
        // No library name found, just record the raw address range.
        snprintf(lib_name, kLibNameLen,
                 "%08" V8PRIxPTR "-%08" V8PRIxPTR, start, end);
      }
      result.push_back(SharedLibraryAddress(lib_name, start, end));
    } else {
      // Entry not describing executable data. Skip to end of line to set up
      // reading the next entry.
      do {
        c = getc(fp);
      } while ((c != EOF) && (c != '\n'));
      if (c == EOF) break;
    }
  }
  free(lib_name);
  fclose(fp);
  return result;
}

References v8::internal::fp, NULL, and V8PRIxPTR.

Referenced by v8::internal::Profiler::Engage().

Here is the caller graph for this function:

GetUserTime()

int v8::base::OS::GetUserTime ( uint32_t *  secs, uint32_t *  usecs  )

static

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

                                                    {
#if V8_OS_NACL
  // Optionally used in Logger::ResourceEvent.
  return -1;
#else
  struct rusage usage;
 
  if (getrusage(RUSAGE_SELF, &usage) < 0) return -1;
  *secs = usage.ru_utime.tv_sec;
  *usecs = usage.ru_utime.tv_usec;
  return 0;
#endif
}

Referenced by v8::internal::Logger::ResourceEvent().

Here is the caller graph for this function:

Guard()

void v8::base::OS::Guard ( void *  address, const size_t  size  )

static

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

                                               {
#if V8_OS_CYGWIN
  DWORD oldprotect;
  VirtualProtect(address, size, PAGE_NOACCESS, &oldprotect);
#else
  mprotect(address, size, PROT_NONE);
#endif
}

References v8::base::DWORD(), and size.

Here is the call graph for this function:

Initialize()

void v8::base::OS::Initialize ( int64_t  random_seed, bool  hard_abort, const char *const  gc_fake_mmap  )

static

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

                                                    {
  if (random_seed) {
    platform_random_number_generator.Pointer()->SetSeed(random_seed);
  }
  g_hard_abort = hard_abort;
  g_gc_fake_mmap = gc_fake_mmap;
}

References v8::base::anonymous_namespace{platform-posix.cc}::g_gc_fake_mmap, v8::base::anonymous_namespace{platform-posix.cc}::g_hard_abort, and v8::base::platform_random_number_generator.

Referenced by v8::internal::V8::InitializeOncePerProcessImpl().

Here is the caller graph for this function:

LocalTimeOffset()

double v8::base::OS::LocalTimeOffset ( TimezoneCache *  cache )

static

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

                                               {
  // On Cygwin, struct tm does not contain a tm_gmtoff field.
  time_t utc = time(NULL);
  DCHECK(utc != -1);
  struct tm* loc = localtime(&utc);
  DCHECK(loc != NULL);
  // time - localtime includes any daylight savings offset, so subtract it.
  return static_cast<double>((mktime(loc) - utc) * msPerSecond -
                             (loc->tm_isdst > 0 ? 3600 * msPerSecond : 0));
}

References DCHECK, msPerSecond, and NULL.

Referenced by v8::internal::DateCache::GetLocalOffsetFromOS().

Here is the caller graph for this function:

LocalTimezone()

const char * v8::base::OS::LocalTimezone ( double  time, TimezoneCache *  cache  )

static

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

                                                               {
  if (std::isnan(time)) return "";
  time_t tv = static_cast<time_t>(std::floor(time/msPerSecond));
  struct tm* t = localtime(&tv);
  if (NULL == t) return "";
  return tzname[0];  // The location of the timezone string on Cygwin.
}

References msPerSecond, and NULL.

Referenced by v8::internal::DateCache::LocalTimezone().

Here is the caller graph for this function:

nan_value()

double v8::base::OS::nan_value ( )

static

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

                     {
  // NAN from math.h is defined in C99 and not in POSIX.
  return NAN;
}

Referenced by v8::internal::HOptimizedGraphBuilder::BuildStringCharCodeAt(), v8::internal::FixedDoubleArray::canonical_not_the_hole_nan_as_double(), v8::internal::Heap::CreateInitialObjects(), DaylightSavingsOffset(), v8::internal::TypeImpl< Config >::BitsetType::Min(), v8::internal::compiler::JSGraph::NaNConstant(), v8::Date::New(), v8::Number::New(), v8::Value::NumberValue(), v8::internal::power_double_double(), v8::internal::RUNTIME_FUNCTION(), v8::internal::ExternalFloat32Array::SetValue(), v8::internal::ExternalFloat64Array::SetValue(), and v8::internal::compiler::TEST_F().

Here is the caller graph for this function:

OpenTemporaryFile()

FILE * v8::base::OS::OpenTemporaryFile ( )

static

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

                            {
  return tmpfile();
}

Referenced by v8::internal::Log::OpenTemporaryFile().

Here is the caller graph for this function:

Print()

void v8::base::OS::Print ( const char *  format,   ...  )

static

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

                                      {
  va_list args;
  va_start(args, format);
  VPrint(format, args);
  va_end(args);
}

References VPrint().

Referenced by v8::internal::CodeMap::CodeTreePrinter::Call(), v8::internal::BoundsCheckBbData::CoverCheck(), v8::base::LoadSymbols(), v8::internal::HBoundsCheckEliminationPhase::PreProcessBlock(), v8::internal::CpuProfile::Print(), v8::internal::AllocationTraceTree::Print(), v8::internal::ProfileNode::Print(), v8::internal::AllocationTraceNode::Print(), v8::internal::PrintPID(), and v8::internal::BoundsCheckBbData::TightenCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

PrintError()

void v8::base::OS::PrintError ( const char *  format,   ...  )

static

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

                                           {
  va_list args;
  va_start(args, format);
  VPrintError(format, args);
  va_end(args);
}

References VPrintError().

Referenced by v8::internal::AppendChars(), v8::internal::Isolate::DoThrow(), v8::base::DumpBacktrace(), v8::internal::Isolate::PrintStack(), v8::internal::ReadCharsFromFile(), v8::Utils::ReportApiFailure(), v8::internal::RUNTIME_FUNCTION(), v8::internal::Isolate::StackTraceString(), V8_Fatal(), and v8::internal::WriteChars().

Here is the call graph for this function:

Here is the caller graph for this function:

ProtectCode()

void v8::base::OS::ProtectCode ( void *  address, const size_t  size  )

static

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

                                                     {
#if V8_OS_CYGWIN
  DWORD old_protect;
  VirtualProtect(address, size, PAGE_EXECUTE_READ, &old_protect);
#elif V8_OS_NACL
  // The Native Client port of V8 uses an interpreter, so
  // code pages don't need PROT_EXEC.
  mprotect(address, size, PROT_READ);
#else
  mprotect(address, size, PROT_READ | PROT_EXEC);
#endif
}

References v8::base::DWORD(), and size.

Here is the call graph for this function:

Remove()

bool v8::base::OS::Remove ( const char *  path )

static

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

                                {
  return (remove(path) == 0);
}

SignalCodeMovingGC()

void v8::base::OS::SignalCodeMovingGC ( )

static

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

                            {
  // Nothing to do on Cygwin.
}

Referenced by v8::internal::Logger::CodeMovingGCEvent().

Here is the caller graph for this function:

Sleep()

void v8::base::OS::Sleep ( const int  milliseconds )

static

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

                               {
  useconds_t ms = static_cast<useconds_t>(milliseconds);
  usleep(1000 * ms);
}

Referenced by v8::internal::OptimizingCompilerThread::Run(), v8::internal::SamplerThread::Run(), and v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

SNPrintF()

int v8::base::OS::SNPrintF ( char *  str, int  length, const char *  format,   ...  )

static

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

                                                               {
  va_list args;
  va_start(args, format);
  int result = VSNPrintF(str, length, format, args);
  va_end(args);
  return result;
}

References VSNPrintF().

Referenced by v8::base::TimezoneCache::InitializeIfNeeded().

Here is the call graph for this function:

Here is the caller graph for this function:

StrChr()

char * v8::base::OS::StrChr ( char *  str, int  c  )

static

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

                                 {
  return strchr(str, c);
}

StrNCpy()

void v8::base::OS::StrNCpy ( char *  dest, int  length, const char *  src, size_t  n  )

static

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

                                                                  {
  strncpy(dest, src, n);
}

Referenced by v8::internal::StrNCpy().

Here is the caller graph for this function:

TimeCurrentMillis()

double v8::base::OS::TimeCurrentMillis ( )

static

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

                             {
  return Time::Now().ToJsTime();
}

Referenced by v8::internal::Logger::DebugEvent(), v8::internal::GCTracer::GCTracer(), v8::internal::Logger::HeapSampleBeginEvent(), v8::internal::IncrementalMarking::Hurry(), v8::internal::Isolate::Init(), v8::internal::MarkCompactCollector::MarkLiveObjects(), v8::internal::PrepareLogFileName(), v8::internal::Logger::ResourceEvent(), v8::internal::RUNTIME_FUNCTION(), v8::internal::GCTracer::Scope::Scope(), v8::internal::GCTracer::Start(), v8::internal::IncrementalMarking::Step(), v8::internal::GCTracer::Stop(), v8::internal::MarkCompactCollector::SweepSpaces(), v8::internal::Isolate::time_millis_since_init(), and v8::internal::GCTracer::Scope::~Scope().

Here is the caller graph for this function:

VFPrint()

void v8::base::OS::VFPrint ( FILE *  out, const char *  format, va_list  args  )

static

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

                                                            {
#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
  __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
#else
  vfprintf(out, format, args);
#endif
}

Referenced by FPrint(), and v8::internal::PrintF().

Here is the caller graph for this function:

VPrint()

void v8::base::OS::VPrint ( const char *  format, va_list  args  )

static

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

                                                {
#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
  __android_log_vprint(ANDROID_LOG_INFO, LOG_TAG, format, args);
#else
  vprintf(format, args);
#endif
}

Referenced by Print(), v8::internal::PrintF(), v8::internal::PrintPID(), v8::internal::compiler::Trace(), v8::internal::TraceGVN(), and v8::internal::HRangeAnalysisPhase::TraceRange().

Here is the caller graph for this function:

VPrintError()

void v8::base::OS::VPrintError ( const char *  format, va_list  args  )

static

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

                                                     {
#if defined(ANDROID) && !defined(V8_ANDROID_LOG_STDOUT)
  __android_log_vprint(ANDROID_LOG_ERROR, LOG_TAG, format, args);
#else
  vfprintf(stderr, format, args);
#endif
}

Referenced by PrintError(), and V8_Fatal().

Here is the caller graph for this function:

VSNPrintF()

int v8::base::OS::VSNPrintF ( char *  str, int  length, const char *  format, va_list  args  )

static

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

                                {
  int n = vsnprintf(str, length, format, args);
  if (n < 0 || n >= length) {
    // If the length is zero, the assignment fails.
    if (length > 0)
      str[length - 1] = '\0';
    return -1;
  } else {
    return n;
  }
}

Referenced by SNPrintF(), v8::base::VPrintHelper(), and v8::internal::VSNPrintF().

Here is the caller graph for this function:

Member Data Documentation

kStackWalkError

const int v8::base::OS::kStackWalkError = -1

static

Definition at line 239 of file platform.h.

kStackWalkMaxNameLen

const int v8::base::OS::kStackWalkMaxNameLen = 256

static

Definition at line 240 of file platform.h.

Referenced by v8::base::LoadSymbols().

kStackWalkMaxTextLen

const int v8::base::OS::kStackWalkMaxTextLen = 256

static

Definition at line 241 of file platform.h.

LogFileOpenMode

const char *const v8::base::OS::LogFileOpenMode = "w"

static

Definition at line 187 of file platform.h.

Referenced by v8::internal::LowLevelLogger::LowLevelLogger(), v8::internal::Log::OpenFile(), and v8::internal::PerfBasicLogger::PerfBasicLogger().

msPerSecond

const int v8::base::OS::msPerSecond = 1000

staticprivate

Definition at line 303 of file platform.h.

Referenced by DaylightSavingsOffset(), LocalTimeOffset(), and LocalTimezone().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/base/platform/platform.h
• /mnt/V8SourceCode/src/base/platform/platform-cygwin.cc
• /mnt/V8SourceCode/src/base/platform/platform-freebsd.cc
• /mnt/V8SourceCode/src/base/platform/platform-linux.cc
• /mnt/V8SourceCode/src/base/platform/platform-macos.cc
• /mnt/V8SourceCode/src/base/platform/platform-openbsd.cc
• /mnt/V8SourceCode/src/base/platform/platform-posix.cc
• /mnt/V8SourceCode/src/base/platform/platform-qnx.cc
• /mnt/V8SourceCode/src/base/platform/platform-solaris.cc
• /mnt/V8SourceCode/src/base/platform/platform-win32.cc