dart::Utils Class Reference

#include <utils.h>

Classes
class	BitsIterator
class	BitsRange

Public Types
typedef std::unique_ptr< char, decltype(std::free) * >	CStringUniquePtr

Static Public Member Functions
template<typename T >
static T	Minimum (T x, T y)
template<typename T >
static constexpr T	Maximum (T x, T y)
template<typename T >
static T	Abs (T x)
template<typename T >
static T	AbsWithSaturation (T x)
template<typename T >
static constexpr bool	IsPowerOfTwo (T x)
template<typename T >
static constexpr int	ShiftForPowerOfTwo (T x)
template<typename T >
static constexpr bool	IsAligned (T x, uintptr_t alignment, uintptr_t offset=0)
template<typename T >
static constexpr bool	IsAligned (T *x, uintptr_t alignment, uintptr_t offset=0)
template<typename T >
static constexpr T	RoundDown (T x, intptr_t alignment)
template<typename T >
static T *	RoundDown (T *x, intptr_t alignment)
template<typename T >
static constexpr T	RoundUp (T x, uintptr_t alignment, uintptr_t offset=0)
template<typename T >
static T *	RoundUp (T *x, uintptr_t alignment, uintptr_t offset=0)
static constexpr uintptr_t	RoundUpToPowerOfTwo (uintptr_t x)
static constexpr int	CountOneBits64 (uint64_t x)
static constexpr int	CountOneBits32 (uint32_t x)
static constexpr int	CountOneBitsWord (uword x)
static constexpr size_t	HighestBit (int64_t v)
static constexpr size_t	BitLength (int64_t value)
static int	CountLeadingZeros32 (uint32_t x)
static int	CountLeadingZeros64 (uint64_t x)
static int	CountLeadingZerosWord (uword x)
static int	CountTrailingZeros32 (uint32_t x)
static int	CountTrailingZeros64 (uint64_t x)
static int	CountTrailingZerosWord (uword x)
static uint64_t	ReverseBits64 (uint64_t x)
static uint32_t	ReverseBits32 (uint32_t x)
static uword	ReverseBitsWord (uword x)
static void	CalculateMagicAndShiftForDivRem (int64_t divisor, int64_t *magic, int64_t *shift)
static uint32_t	StringHash (const void *data, int length)
static uint32_t	WordHash (intptr_t key)
template<typename T >
static bool	IsInt (intptr_t N, T value)
template<typename T >
static bool	IsUint (intptr_t N, T value)
template<typename T >
static bool	MagnitudeIsUint (intptr_t N, T value)
static int32_t	Low16Bits (int32_t value)
static int32_t	High16Bits (int32_t value)
static int32_t	Low32Bits (int64_t value)
static int32_t	High32Bits (int64_t value)
static int64_t	LowHighTo64Bits (uint32_t low, int32_t high)
static constexpr bool	IsAlphaNumeric (uint32_t c)
static constexpr bool	IsDecimalDigit (uint32_t c)
static bool	IsHexDigit (char c)
static int	HexDigitToInt (char c)
static char	IntToHexDigit (int i)
static bool	RangeCheck (intptr_t offset, intptr_t count, intptr_t length)
static bool	WillAddOverflow (int64_t a, int64_t b)
static bool	WillSubOverflow (int64_t a, int64_t b)
template<typename T = int64_t>
static T	AddWithWrapAround (T a, T b)
template<typename T = int64_t>
static T	SubWithWrapAround (T a, T b)
template<typename T = int64_t>
static T	MulWithWrapAround (T a, T b)
template<typename T = int64_t>
static T	NegWithWrapAround (T a)
static int64_t	ShiftLeftWithTruncation (int64_t a, int64_t b)
template<typename T >
static T	RotateLeft (T value, uint8_t rotate)
template<typename T >
static T	RotateRight (T value, uint8_t rotate)
static float	DivideAllowZero (float a, float b)
static double	DivideAllowZero (double a, double b)
static uint16_t	HostToBigEndian16 (uint16_t host_value)
static uint32_t	HostToBigEndian32 (uint32_t host_value)
static uint64_t	HostToBigEndian64 (uint64_t host_value)
static uint16_t	HostToLittleEndian16 (uint16_t host_value)
static uint32_t	HostToLittleEndian32 (uint32_t host_value)
static uint64_t	HostToLittleEndian64 (uint64_t host_value)
static uint32_t	BigEndianToHost32 (uint32_t be_value)
static uint64_t	LittleEndianToHost64 (uint64_t le_value)
static bool	DoublesBitEqual (const double a, const double b)
template<typename T >
static T	SafeDoubleToInt (double v)
static bool	IsJavaScriptInt (int64_t value)
template<typename T = uword>
static constexpr T	NBitMask (size_t n)
template<typename T = uword>
static constexpr T	Bit (size_t n)
template<typename T >
static constexpr bool	TestBit (T mask, size_t position)
static char *	StrError (int err, char *buffer, size_t bufsize)
static char *	StrNDup (const char *s, intptr_t n)
static char *	StrDup (const char *s)
static intptr_t	StrNLen (const char *s, intptr_t n)
static bool	StrStartsWith (const char *s, const char *prefix)
static int	Close (int fildes)
static size_t	Read (int filedes, void *buf, size_t nbyte)
static int	Unlink (const char *path)
static int	SNPrint (char *str, size_t size, const char *format,...) PRINTF_ATTRIBUTE(3
static int static int	VSNPrint (char *str, size_t size, const char *format, va_list args)
static char *	SCreate (const char *format,...) PRINTF_ATTRIBUTE(1
static char static char *	VSCreate (const char *format, va_list args)
static CStringUniquePtr	CreateCStringUniquePtr (char *str)
static void *	LoadDynamicLibrary (const char *library_path, char **error=nullptr)
static void *	ResolveSymbolInDynamicLibrary (void *library_handle, const char *symbol, char **error=nullptr)
static void	UnloadDynamicLibrary (void *library_handle, char **error=nullptr)

Detailed Description

Definition at line 18 of file utils.h.

Member Typedef Documentation

CStringUniquePtr

typedef std::unique_ptr<char, decltype(std::free)*> dart::Utils::CStringUniquePtr

Definition at line 644 of file utils.h.

Member Function Documentation

Abs()

template<typename T >

static T dart::Utils::Abs ( T  x )

inlinestatic

Definition at line 34 of file utils.h.

                           {
    // Note: as a general rule, it is not OK to use STL in Dart VM.
    // However, std::numeric_limits<T>::min() and max() are harmless
    // and worthwhile exception from this rule.
    ASSERT(x != std::numeric_limits<T>::min());
    if (x < 0) return -x;
    return x;
  }

AbsWithSaturation()

template<typename T >

static T dart::Utils::AbsWithSaturation ( T  x )

inlinestatic

Definition at line 47 of file utils.h.

                                         {
    if (x < 0) {
      // Note: as a general rule, it is not OK to use STL in Dart VM.
      // However, std::numeric_limits<T>::min() and max() are harmless
      // and worthwhile exception from this rule.
      if (x == std::numeric_limits<T>::min()) {
        return std::numeric_limits<T>::max();
      }
      return -x;
    }
    return x;
  }

AddWithWrapAround()

template<typename T = int64_t>

static T dart::Utils::AddWithWrapAround ( T  a, T  b  )

inlinestatic

Definition at line 416 of file utils.h.

                                              {
    // Avoid undefined behavior by doing arithmetic in the unsigned type.
    using Unsigned = typename std::make_unsigned<T>::type;
    return static_cast<T>(static_cast<Unsigned>(a) + static_cast<Unsigned>(b));
  }

BigEndianToHost32()

static uint32_t dart::Utils::BigEndianToHost32 ( uint32_t  be_value )

inlinestatic

Definition at line 503 of file utils.h.

                                                              {
    return HostToBigEndian32(be_value);
  }

Bit()

template<typename T = uword>

static constexpr T dart::Utils::Bit ( size_t  n )

inlinestaticconstexpr

Definition at line 542 of file utils.h.

                                   {
    ASSERT(n < sizeof(T) * kBitsPerByte);
    T bit = 1;
    return bit << n;
  }

BitLength()

static constexpr size_t dart::Utils::BitLength ( int64_t  value )

inlinestaticconstexpr

Definition at line 198 of file utils.h.

                                                   {
    // Flip bits if negative (-1 becomes 0).
    value ^= value >> (8 * sizeof(value) - 1);
    return (value == 0) ? 0 : (Utils::HighestBit(value) + 1);
  }

CalculateMagicAndShiftForDivRem()

void dart::Utils::CalculateMagicAndShiftForDivRem ( int64_t  divisor, int64_t *  magic, int64_t *  shift  )

static

Definition at line 39 of file utils.cc.

                                                            {
  ASSERT(divisor <= -2 || divisor >= 2);
  /* The magic number M and shift S can be calculated in the following way:
   * Let nc be the most positive value of numerator(n) such that nc = kd - 1,
   * where divisor(d) >= 2.
   * Let nc be the most negative value of numerator(n) such that nc = kd + 1,
   * where divisor(d) <= -2.
   * Thus nc can be calculated like:
   * nc =  exp + exp       % d - 1, where d >= 2 and exp = 2^63.
   * nc = -exp + (exp + 1) % d,     where d >= 2 and exp = 2^63.
   *
   * So the shift p is the smallest p satisfying
   * 2^p > nc * (d - 2^p % d), where d >= 2
   * 2^p > nc * (d + 2^p % d), where d <= -2.
   *
   * The magic number M is calculated by
   * M = (2^p + d - 2^p % d) / d, where d >= 2
   * M = (2^p - d - 2^p % d) / d, where d <= -2.
   */
  int64_t p = 63;
  const uint64_t exp = 1LL << 63;
 
  // Initialize the computations.
  uint64_t abs_d = (divisor >= 0) ? divisor : -static_cast<uint64_t>(divisor);
  uint64_t sign_bit = static_cast<uint64_t>(divisor) >> 63;
  uint64_t tmp = exp + sign_bit;
  uint64_t abs_nc = tmp - 1 - (tmp % abs_d);
  uint64_t quotient1 = exp / abs_nc;
  uint64_t remainder1 = exp % abs_nc;
  uint64_t quotient2 = exp / abs_d;
  uint64_t remainder2 = exp % abs_d;
 
  // To avoid handling both positive and negative divisor,
  // "Hacker's Delight" introduces a method to handle these
  // two cases together to avoid duplication.
  uint64_t delta;
  do {
    p++;
    quotient1 = 2 * quotient1;
    remainder1 = 2 * remainder1;
    if (remainder1 >= abs_nc) {
      quotient1++;
      remainder1 = remainder1 - abs_nc;
    }
    quotient2 = 2 * quotient2;
    remainder2 = 2 * remainder2;
    if (remainder2 >= abs_d) {
      quotient2++;
      remainder2 = remainder2 - abs_d;
    }
    delta = abs_d - remainder2;
  } while (quotient1 < delta || (quotient1 == delta && remainder1 == 0));
 
  *magic = (divisor > 0) ? (quotient2 + 1) : (-quotient2 - 1);
  *shift = p - 64;
}

Close()

static int dart::Utils::Close ( int  fildes )

static

CountLeadingZeros32()

static int dart::Utils::CountLeadingZeros32 ( uint32_t  x )

inlinestatic

Definition at line 204 of file utils.h.

                                             {
#if defined(DART_HOST_OS_WINDOWS)
    unsigned long position;  // NOLINT
    return (_BitScanReverse(&position, x) == 0)
               ? 32
               : 31 - static_cast<int>(position);
#else
    return x == 0 ? 32 : __builtin_clz(x);
#endif
  }

CountLeadingZeros64()

static int dart::Utils::CountLeadingZeros64 ( uint64_t  x )

inlinestatic

Definition at line 214 of file utils.h.

                                             {
#if defined(DART_HOST_OS_WINDOWS)
#if defined(ARCH_IS_32_BIT)
    const uint32_t x_hi = static_cast<uint32_t>(x >> 32);
    if (x_hi != 0) {
      return CountLeadingZeros32(x_hi);
    }
    return 32 + CountLeadingZeros32(static_cast<uint32_t>(x));
#else
    unsigned long position;  // NOLINT
    return (_BitScanReverse64(&position, x) == 0)
               ? 64
               : 63 - static_cast<int>(position);
#endif
#else
    return x == 0 ? 64 : __builtin_clzll(x);
#endif
  }

CountLeadingZerosWord()

static int dart::Utils::CountLeadingZerosWord ( uword  x )

inlinestatic

Definition at line 232 of file utils.h.

                                            {
#ifdef ARCH_IS_64_BIT
    return CountLeadingZeros64(x);
#else
    return CountLeadingZeros32(x);
#endif
  }

CountOneBits32()

static constexpr int dart::Utils::CountOneBits32 ( uint32_t  x )

inlinestaticconstexpr

Definition at line 145 of file utils.h.

                                                  {
    // Apparently there are x64 chips without popcount.
#if __GNUC__ && !defined(HOST_ARCH_IA32) && !defined(HOST_ARCH_X64)
    return __builtin_popcount(x);
#else
    // Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
    // figure 5-2, page 66, where the function is called pop.
    x = x - ((x >> 1) & 0x55555555);
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x + (x >> 4)) & 0x0F0F0F0F;
    x = x + (x >> 8);
    x = x + (x >> 16);
    return static_cast<int>(x & 0x0000003F);
#endif
  }

CountOneBits64()

static constexpr int dart::Utils::CountOneBits64 ( uint64_t  x )

inlinestaticconstexpr

Definition at line 133 of file utils.h.

                                                  {
    // Apparently there are x64 chips without popcount.
#if __GNUC__ && !defined(HOST_ARCH_IA32) && !defined(HOST_ARCH_X64)
    return __builtin_popcountll(x);
#else
    x = x - ((x >> 1) & 0x5555555555555555);
    x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333);
    x = (((x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f) * 0x0101010101010101) >> 56;
    return x;
#endif
  }

CountOneBitsWord()

static constexpr int dart::Utils::CountOneBitsWord ( uword  x )

inlinestaticconstexpr

Definition at line 161 of file utils.h.

                                                 {
#ifdef ARCH_IS_64_BIT
    return CountOneBits64(x);
#else
    return CountOneBits32(x);
#endif
  }

CountTrailingZeros32()

static int dart::Utils::CountTrailingZeros32 ( uint32_t  x )

inlinestatic

Definition at line 240 of file utils.h.

                                              {
#if defined(DART_HOST_OS_WINDOWS)
    unsigned long position;  // NOLINT
    return (_BitScanForward(&position, x) == 0) ? 32
                                                : static_cast<int>(position);
#else
    return x == 0 ? 32 : __builtin_ctz(x);
#endif
  }

CountTrailingZeros64()

static int dart::Utils::CountTrailingZeros64 ( uint64_t  x )

inlinestatic

Definition at line 249 of file utils.h.

                                              {
#if defined(DART_HOST_OS_WINDOWS)
#if defined(ARCH_IS_32_BIT)
    const uint32_t x_lo = static_cast<uint32_t>(x);
    if (x_lo != 0) {
      return CountTrailingZeros32(x_lo);
    }
    return 32 + CountTrailingZeros32(static_cast<uint32_t>(x >> 32));
#else
    unsigned long position;  // NOLINT
    return (_BitScanForward64(&position, x) == 0) ? 64
                                                  : static_cast<int>(position);
#endif
#else
    return x == 0 ? 64 : __builtin_ctzll(x);
#endif
  }

CountTrailingZerosWord()

static int dart::Utils::CountTrailingZerosWord ( uword  x )

inlinestatic

Definition at line 266 of file utils.h.

                                             {
#ifdef ARCH_IS_64_BIT
    return CountTrailingZeros64(x);
#else
    return CountTrailingZeros32(x);
#endif
  }

CreateCStringUniquePtr()

Utils::CStringUniquePtr dart::Utils::CreateCStringUniquePtr ( char *  str )

static

Definition at line 257 of file utils.cc.

                                                             {
  return std::unique_ptr<char, decltype(std::free)*>{str, std::free};
}

DivideAllowZero() [1/2]

static double dart::Utils::DivideAllowZero ( double  a, double  b  )

inlinestatic

Definition at line 488 of file utils.h.

                                      {
    return a / b;
  }

DivideAllowZero() [2/2]

static float dart::Utils::DivideAllowZero ( float  a, float  b  )

inlinestatic

Definition at line 481 of file utils.h.

                                    {
    return a / b;
  }

DoublesBitEqual()

static bool dart::Utils::DoublesBitEqual ( const double  a, const double  b  )

inlinestatic

Definition at line 510 of file utils.h.

                                                              {
    return bit_cast<int64_t, double>(a) == bit_cast<int64_t, double>(b);
  }

HexDigitToInt()

static int dart::Utils::HexDigitToInt ( char  c )

inlinestatic

Definition at line 380 of file utils.h.

                                   {
    ASSERT(IsHexDigit(c));
    if (IsDecimalDigit(c)) return c - '0';
    if (('A' <= c) && (c <= 'F')) return 10 + (c - 'A');
    return 10 + (c - 'a');
  }

High16Bits()

static int32_t dart::Utils::High16Bits ( int32_t  value )

inlinestatic

Definition at line 350 of file utils.h.

                                                  {
    return static_cast<int32_t>(value >> 16);
  }

High32Bits()

static int32_t dart::Utils::High32Bits ( int64_t  value )

inlinestatic

Definition at line 358 of file utils.h.

                                                  {
    return static_cast<int32_t>(value >> 32);
  }

HighestBit()

static constexpr size_t dart::Utils::HighestBit ( int64_t  v )

inlinestaticconstexpr

Definition at line 170 of file utils.h.

                                                {
    uint64_t x = static_cast<uint64_t>((v > 0) ? v : -v);
    uint64_t t = 0;
    size_t r = 0;
    if ((t = x >> 32) != 0) {
      x = t;
      r += 32;
    }
    if ((t = x >> 16) != 0) {
      x = t;
      r += 16;
    }
    if ((t = x >> 8) != 0) {
      x = t;
      r += 8;
    }
    if ((t = x >> 4) != 0) {
      x = t;
      r += 4;
    }
    if ((t = x >> 2) != 0) {
      x = t;
      r += 2;
    }
    if (x > 1) r += 1;
    return r;
  }

HostToBigEndian16()

uint16_t dart::Utils::HostToBigEndian16 ( uint16_t  host_value )

inlinestatic

Definition at line 16 of file utils_android.h.

                                                       {
  return htobe16(value);
}

HostToBigEndian32()

uint32_t dart::Utils::HostToBigEndian32 ( uint32_t  host_value )

inlinestatic

Definition at line 20 of file utils_android.h.

                                                       {
  return htobe32(value);
}

HostToBigEndian64()

uint64_t dart::Utils::HostToBigEndian64 ( uint64_t  host_value )

inlinestatic

Definition at line 24 of file utils_android.h.

                                                       {
  return htobe64(value);
}

HostToLittleEndian16()

uint16_t dart::Utils::HostToLittleEndian16 ( uint16_t  host_value )

inlinestatic

Definition at line 28 of file utils_android.h.

                                                          {
  return htole16(value);
}

HostToLittleEndian32()

uint32_t dart::Utils::HostToLittleEndian32 ( uint32_t  host_value )

inlinestatic

Definition at line 32 of file utils_android.h.

                                                          {
  return htole32(value);
}

HostToLittleEndian64()

uint64_t dart::Utils::HostToLittleEndian64 ( uint64_t  host_value )

inlinestatic

Definition at line 36 of file utils_android.h.

                                                          {
  return htole64(value);
}

IntToHexDigit()

static char dart::Utils::IntToHexDigit ( int  i )

inlinestatic

Definition at line 387 of file utils.h.

                                   {
    ASSERT(0 <= i && i < 16);
    if (i < 10) return static_cast<char>('0' + i);
    return static_cast<char>('A' + (i - 10));
  }

IsAligned() [1/2]

template<typename T >

static constexpr bool dart::Utils::IsAligned ( T *  x, uintptr_t  alignment, uintptr_t  offset = 0  )

inlinestaticconstexpr

Definition at line 86 of file utils.h.

                                                        {
    return IsAligned(reinterpret_cast<uword>(x), alignment, offset);
  }

IsAligned() [2/2]

template<typename T >

static constexpr bool dart::Utils::IsAligned ( T  x, uintptr_t  alignment, uintptr_t  offset = 0  )

inlinestaticconstexpr

Definition at line 77 of file utils.h.

                                                        {
    ASSERT(IsPowerOfTwo(alignment));
    ASSERT(offset < alignment);
    return (x & (alignment - 1)) == offset;
  }

IsAlphaNumeric()

static constexpr bool dart::Utils::IsAlphaNumeric ( uint32_t  c )

inlinestaticconstexpr

Definition at line 366 of file utils.h.

                                                          {
    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') ||
           IsDecimalDigit(c);
  }

IsDecimalDigit()

static constexpr bool dart::Utils::IsDecimalDigit ( uint32_t  c )

inlinestaticconstexpr

Definition at line 371 of file utils.h.

                                                          {
    return ('0' <= c) && (c <= '9');
  }

IsHexDigit()

static bool dart::Utils::IsHexDigit ( char  c )

inlinestatic

Definition at line 375 of file utils.h.

                                 {
    return IsDecimalDigit(c) || (('A' <= c) && (c <= 'F')) ||
           (('a' <= c) && (c <= 'f'));
  }

IsInt()

template<typename T >

static bool dart::Utils::IsInt ( intptr_t  N, T  value  )

inlinestatic

Definition at line 298 of file utils.h.

                                                {
    ASSERT(N >= 1);
    constexpr intptr_t value_size_in_bits = kBitsPerByte * sizeof(T);
    if constexpr (std::is_signed<T>::value) {
      if (N >= value_size_in_bits) return true;  // Trivially fits.
      const T limit = static_cast<T>(1) << (N - 1);
      return (-limit <= value) && (value < limit);
    } else {
      if (N > value_size_in_bits) return true;  // Trivially fits.
      const T limit = static_cast<T>(1) << (N - 1);
      return value < limit;
    }
  }

IsJavaScriptInt()

static bool dart::Utils::IsJavaScriptInt ( int64_t  value )

inlinestatic

Definition at line 527 of file utils.h.

                                             {
    return ((-0x20000000000000LL <= value) && (value <= 0x20000000000000LL));
  }

IsPowerOfTwo()

template<typename T >

static constexpr bool dart::Utils::IsPowerOfTwo ( T  x )

inlinestaticconstexpr

Definition at line 61 of file utils.h.

                                          {
    return ((x & (x - 1)) == 0) && (x != 0);
  }

IsUint()

template<typename T >

static bool dart::Utils::IsUint ( intptr_t  N, T  value  )

inlinestatic

Definition at line 313 of file utils.h.

                                                 {
    ASSERT(N >= 1);
    constexpr intptr_t value_size_in_bits = kBitsPerByte * sizeof(T);
    if constexpr (std::is_signed<T>::value) {
      if (value < 0) return false;  // Not an unsigned value.
      if (N >= value_size_in_bits - 1) {
        return true;  // N can fit the magnitude bits.
      }
    } else {
      if (N >= value_size_in_bits) return true;  // Trivially fits.
    }
    const T limit = (static_cast<T>(1) << N) - 1;
    return value <= limit;
  }

LittleEndianToHost64()

static uint64_t dart::Utils::LittleEndianToHost64 ( uint64_t  le_value )

inlinestatic

Definition at line 506 of file utils.h.

                                                                 {
    return HostToLittleEndian64(le_value);
  }

LoadDynamicLibrary()

void * dart::Utils::LoadDynamicLibrary ( const char *  library_path, char **  error = nullptr  )

static

Definition at line 293 of file utils.cc.

                                                                      {
  void* handle = nullptr;
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
  handle = dlopen(library_path, RTLD_LAZY);
#elif defined(DART_HOST_OS_WINDOWS)
  SetLastError(0);  // Clear any errors.
 
  if (library_path == nullptr) {
    handle = GetModuleHandle(nullptr);
  } else {
    // Convert to wchar_t string.
    const int name_len = MultiByteToWideChar(
        CP_UTF8, /*dwFlags=*/0, library_path, /*cbMultiByte=*/-1, nullptr, 0);
    if (name_len != 0) {
      std::unique_ptr<wchar_t[]> name(new wchar_t[name_len]);
      const int written_len =
          MultiByteToWideChar(CP_UTF8, /*dwFlags=*/0, library_path,
                              /*cbMultiByte=*/-1, name.get(), name_len);
      RELEASE_ASSERT(written_len == name_len);
      handle = LoadLibraryW(name.get());
    }
  }
#endif
 
  if (handle == nullptr) {
    GetLastErrorAsString(error);
  }
 
  return handle;
}

Low16Bits()

static int32_t dart::Utils::Low16Bits ( int32_t  value )

inlinestatic

Definition at line 346 of file utils.h.

                                                 {
    return static_cast<int32_t>(value & 0xffff);
  }

Low32Bits()

static int32_t dart::Utils::Low32Bits ( int64_t  value )

inlinestatic

Definition at line 354 of file utils.h.

                                                 {
    return static_cast<int32_t>(value);
  }

LowHighTo64Bits()

static int64_t dart::Utils::LowHighTo64Bits ( uint32_t  low, int32_t  high  )

inlinestatic

Definition at line 362 of file utils.h.

                                                                    {
    return (static_cast<uint64_t>(high) << 32) | (low & 0x0ffffffffLL);
  }

MagnitudeIsUint()

template<typename T >

static bool dart::Utils::MagnitudeIsUint ( intptr_t  N, T  value  )

inlinestatic

Definition at line 337 of file utils.h.

                                                          {
    ASSERT(N >= 1);
    if constexpr (std::is_signed<T>::value) {
      using Unsigned = typename std::make_unsigned<T>::type;
      if (value < 0) return IsUint<Unsigned>(N, -value);
    }
    return IsUint(N, value);
  }

Maximum()

template<typename T >

static constexpr T dart::Utils::Maximum ( T  x, T  y  )

inlinestaticconstexpr

Definition at line 26 of file utils.h.

                                              {
    return x > y ? x : y;
  }

Minimum()

template<typename T >

static T dart::Utils::Minimum ( T  x, T  y  )

inlinestatic

Definition at line 21 of file utils.h.

                                    {
    return x < y ? x : y;
  }

MulWithWrapAround()

template<typename T = int64_t>

static T dart::Utils::MulWithWrapAround ( T  a, T  b  )

inlinestatic

Definition at line 434 of file utils.h.

                                              {
    // Avoid undefined behavior by doing arithmetic in the unsigned type.
    using Unsigned = typename std::make_unsigned<T>::type;
    return static_cast<T>(static_cast<Unsigned>(a) * static_cast<Unsigned>(b));
  }

NBitMask()

template<typename T = uword>

static constexpr T dart::Utils::NBitMask ( size_t  n )

inlinestaticconstexpr

Definition at line 533 of file utils.h.

                                        {
    using Unsigned = typename std::make_unsigned<T>::type;
    constexpr size_t kBitsPerT = sizeof(T) * kBitsPerByte;
    assert(n <= sizeof(T) * kBitsPerT);
    return static_cast<T>(n == kBitsPerT ? std::numeric_limits<Unsigned>::max()
                                         : (static_cast<Unsigned>(1) << n) - 1);
  }

NegWithWrapAround()

template<typename T = int64_t>

static T dart::Utils::NegWithWrapAround ( T  a )

inlinestatic

Definition at line 441 of file utils.h.

                                         {
    // Avoid undefined behavior by doing arithmetic in the unsigned type.
    using Unsigned = typename std::make_unsigned<T>::type;
    return static_cast<T>(-static_cast<Unsigned>(a));
  }

RangeCheck()

static bool dart::Utils::RangeCheck ( intptr_t  offset, intptr_t  count, intptr_t  length  )

inlinestatic

Definition at line 396 of file utils.h.

                                                 {
    return offset >= 0 && count >= 0 && length >= 0 &&
           count <= (length - offset);
  }

Read()

static size_t dart::Utils::Read ( int  filedes, void *  buf, size_t  nbyte  )

static

ResolveSymbolInDynamicLibrary()

void * dart::Utils::ResolveSymbolInDynamicLibrary ( void *  library_handle, const char *  symbol, char **  error = nullptr  )

static

Definition at line 326 of file utils.cc.

                                                         {
  void* result = nullptr;
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
  dlerror();  // Clear any errors.
  result = dlsym(library_handle, symbol);
  // Note: nullptr might be a valid return from dlsym. Must call dlerror
  // to differentiate.
  GetLastErrorAsString(error);
  return result;
#elif defined(DART_HOST_OS_WINDOWS)
  SetLastError(0);
  result = reinterpret_cast<void*>(
      GetProcAddress(reinterpret_cast<HMODULE>(library_handle), symbol));
#endif
 
  if (result == nullptr) {
    GetLastErrorAsString(error);
  }
 
  return result;
}

ReverseBits32()

uint32_t dart::Utils::ReverseBits32 ( uint32_t  x )

static

Definition at line 27 of file utils.cc.

                                        {
  x = ((x >> 16) & 0x0000ffff) | ((x & 0x0000ffff) << 16);
  x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
  x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
  x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
  x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
  return x;
}

ReverseBits64()

uint64_t dart::Utils::ReverseBits64 ( uint64_t  x )

static

Definition at line 17 of file utils.cc.

                                        {
  x = ((x >> 32) & 0x00000000ffffffff) | (x << 32);
  x = ((x >> 16) & 0x0000ffff0000ffff) | ((x & 0x0000ffff0000ffff) << 16);
  x = ((x >> 8) & 0x00ff00ff00ff00ff) | ((x & 0x00ff00ff00ff00ff) << 8);
  x = ((x >> 4) & 0x0f0f0f0f0f0f0f0f) | ((x & 0x0f0f0f0f0f0f0f0f) << 4);
  x = ((x >> 2) & 0x3333333333333333) | ((x & 0x3333333333333333) << 2);
  x = ((x >> 1) & 0x5555555555555555) | ((x & 0x5555555555555555) << 1);
  return x;
}

ReverseBitsWord()

static uword dart::Utils::ReverseBitsWord ( uword  x )

inlinestatic

Definition at line 277 of file utils.h.

                                        {
#ifdef ARCH_IS_64_BIT
    return ReverseBits64(x);
#else
    return ReverseBits32(x);
#endif
  }

RotateLeft()

template<typename T >

static T dart::Utils::RotateLeft ( T  value, uint8_t  rotate  )

inlinestatic

Definition at line 459 of file utils.h.

                                                      {
    const uint8_t width = sizeof(T) * kBitsPerByte;
    ASSERT(0 <= rotate);
    ASSERT(rotate <= width);
    using Unsigned = typename std::make_unsigned<T>::type;
    return (static_cast<Unsigned>(value) << rotate) |
           (static_cast<T>(value) >> ((width - rotate) & (width - 1)));
  }

RotateRight()

template<typename T >

static T dart::Utils::RotateRight ( T  value, uint8_t  rotate  )

inlinestatic

Definition at line 468 of file utils.h.

                                                       {
    const uint8_t width = sizeof(T) * kBitsPerByte;
    ASSERT(0 <= rotate);
    ASSERT(rotate <= width);
    using Unsigned = typename std::make_unsigned<T>::type;
    return (static_cast<T>(value) >> rotate) |
           (static_cast<Unsigned>(value) << ((width - rotate) & (width - 1)));
  }

RoundDown() [1/2]

template<typename T >

static T * dart::Utils::RoundDown ( T *  x, intptr_t  alignment  )

inlinestatic

Definition at line 99 of file utils.h.

                                                       {
    return reinterpret_cast<T*>(
        RoundDown(reinterpret_cast<uword>(x), alignment));
  }

RoundDown() [2/2]

template<typename T >

static constexpr T dart::Utils::RoundDown ( T  x, intptr_t  alignment  )

inlinestaticconstexpr

Definition at line 93 of file utils.h.

                                                               {
    ASSERT(IsPowerOfTwo(alignment));
    return (x & -alignment);
  }

RoundUp() [1/2]

template<typename T >

static T * dart::Utils::RoundUp ( T *  x, uintptr_t  alignment, uintptr_t  offset = 0  )

inlinestatic

Definition at line 113 of file utils.h.

                                                                            {
    return reinterpret_cast<T*>(
        RoundUp(reinterpret_cast<uword>(x), alignment, offset));
  }

RoundUp() [2/2]

template<typename T >

static constexpr T dart::Utils::RoundUp ( T  x, uintptr_t  alignment, uintptr_t  offset = 0  )

inlinestaticconstexpr

Definition at line 105 of file utils.h.

                                                          {
    ASSERT(offset < alignment);
    return RoundDown(x + alignment - 1 + offset, alignment) - offset;
  }

RoundUpToPowerOfTwo()

static constexpr uintptr_t dart::Utils::RoundUpToPowerOfTwo ( uintptr_t  x )

inlinestaticconstexpr

Definition at line 120 of file utils.h.

                                                              {
    x = x - 1;
    x = x | (x >> 1);
    x = x | (x >> 2);
    x = x | (x >> 4);
    x = x | (x >> 8);
    x = x | (x >> 16);
#if defined(ARCH_IS_64_BIT)
    x = x | (x >> 32);
#endif  // defined(ARCH_IS_64_BIT)
    return x + 1;
  }

SafeDoubleToInt()

template<typename T >

static T dart::Utils::SafeDoubleToInt ( double  v )

inlinestatic

Definition at line 518 of file utils.h.

                                     {
    const double min = static_cast<double>(std::numeric_limits<T>::min());
    const double max = static_cast<double>(std::numeric_limits<T>::max());
    return (min <= v && v <= max) ? static_cast<T>(v)
                                  : std::numeric_limits<T>::min();
  }

SCreate()

char * dart::Utils::SCreate ( const char *  format,   ...  )

static

Definition at line 231 of file utils.cc.

                                            {
  va_list args;
  va_start(args, format);
  char* buffer = VSCreate(format, args);
  va_end(args);
  return buffer;
}

ShiftForPowerOfTwo()

template<typename T >

static constexpr int dart::Utils::ShiftForPowerOfTwo ( T  x )

inlinestaticconstexpr

Definition at line 66 of file utils.h.

                                               {
    ASSERT(IsPowerOfTwo(x));
    int num_shifts = 0;
    while (x > 1) {
      num_shifts++;
      x = x >> 1;
    }
    return num_shifts;
  }

ShiftLeftWithTruncation()

static int64_t dart::Utils::ShiftLeftWithTruncation ( int64_t  a, int64_t  b  )

inlinestatic

Definition at line 449 of file utils.h.

                                                                      {
    ASSERT(b >= 0);
    if (b >= kBitsPerInt64) {
      return 0;
    }
    // Avoid undefined behavior by doing arithmetic in the unsigned type.
    return static_cast<int64_t>(static_cast<uint64_t>(a) << b);
  }

SNPrint()

static int dart::Utils::SNPrint ( char *  str, size_t  size, const char *  format,   ...  )

static

StrDup()

static char * dart::Utils::StrDup ( const char *  s )

static

StrError()

char * dart::Utils::StrError ( int  err, char *  buffer, size_t  bufsize  )

inlinestatic

Definition at line 40 of file utils_android.h.

                                                                  {
  if (strerror_r(err, buffer, bufsize) != 0) {
    snprintf(buffer, bufsize, "%s", "strerror_r failed");
  }
  return buffer;
}

StringHash()

uint32_t dart::Utils::StringHash ( const void *  data, int  length  )

static

Definition at line 114 of file utils.cc.

                                                       {
  int size = length;
  uint32_t hash = size;
 
  auto cursor = reinterpret_cast<const uint8_t*>(data);
 
  if (size >= kInt32Size) {
    const intptr_t misalignment =
        reinterpret_cast<intptr_t>(cursor) % kInt32Size;
    if (misalignment > 0) {
      // Stores 4-byte values starting from the start of the string to mimic
      // the algorithm on aligned data.
      uint32_t data_window = 0;
 
      // Shift sizes for adjusting the data window when adding the next aligned
      // piece of data.
      const uint32_t sr = misalignment * kBitsPerByte;
      const uint32_t sl = kBitsPerInt32 - sr;
 
      const intptr_t pre_alignment_length = kInt32Size - misalignment;
      switch (pre_alignment_length) {
        case 3:
          data_window |= cursor[2] << 16;
          FALL_THROUGH;
        case 2:
          data_window |= cursor[1] << 8;
          FALL_THROUGH;
        case 1:
          data_window |= cursor[0];
      }
      cursor += pre_alignment_length;
      size -= pre_alignment_length;
 
      // Mix four bytes at a time now that we're at an aligned spot.
      for (; size >= kInt32Size; cursor += kInt32Size, size -= kInt32Size) {
        uint32_t aligned_part = *reinterpret_cast<const uint32_t*>(cursor);
        data_window |= (aligned_part << sl);
        MIX(hash, data_window);
        data_window = aligned_part >> sr;
      }
 
      if (size >= misalignment) {
        // There's one more full window in the data. We'll let the normal tail
        // code handle any partial window.
        switch (misalignment) {
          case 3:
            data_window |= cursor[2] << (16 + sl);
            FALL_THROUGH;
          case 2:
            data_window |= cursor[1] << (8 + sl);
            FALL_THROUGH;
          case 1:
            data_window |= cursor[0] << sl;
        }
        MIX(hash, data_window);
        cursor += misalignment;
        size -= misalignment;
      } else {
        // This is a partial window, so just xor and multiply by M.
        switch (size) {
          case 2:
            data_window |= cursor[1] << (8 + sl);
            FALL_THROUGH;
          case 1:
            data_window |= cursor[0] << sl;
        }
        hash ^= data_window;
        hash *= kStringHashM;
        cursor += size;
        size = 0;
      }
    } else {
      // Mix four bytes at a time into the hash.
      for (; size >= kInt32Size; size -= kInt32Size, cursor += kInt32Size) {
        uint32_t part = *reinterpret_cast<const uint32_t*>(cursor);
        MIX(hash, part);
      }
    }
  }
 
  // Handle the last few bytes of the string if any.
  switch (size) {
    case 3:
      hash ^= cursor[2] << 16;
      FALL_THROUGH;
    case 2:
      hash ^= cursor[1] << 8;
      FALL_THROUGH;
    case 1:
      hash ^= cursor[0];
      hash *= kStringHashM;
  }
 
  // Do a few final mixes of the hash to ensure the last few bytes are
  // well-incorporated.
  hash ^= hash >> 13;
  hash *= kStringHashM;
  hash ^= hash >> 15;
  return hash;
}

StrNDup()

static char * dart::Utils::StrNDup ( const char *  s, intptr_t  n  )

static

StrNLen()

static intptr_t dart::Utils::StrNLen ( const char *  s, intptr_t  n  )

static

StrStartsWith()

static bool dart::Utils::StrStartsWith ( const char *  s, const char *  prefix  )

inlinestatic

Definition at line 612 of file utils.h.

                                                               {
    return strncmp(s, prefix, strlen(prefix)) == 0;
  }

SubWithWrapAround()

template<typename T = int64_t>

static T dart::Utils::SubWithWrapAround ( T  a, T  b  )

inlinestatic

Definition at line 425 of file utils.h.

                                              {
    // Avoid undefined behavior by doing arithmetic in the unsigned type.
    using Unsigned = typename std::make_unsigned<T>::type;
    return static_cast<T>(static_cast<Unsigned>(a) - static_cast<Unsigned>(b));
  }

TestBit()

template<typename T >

static constexpr bool dart::Utils::TestBit ( T  mask, size_t  position  )

inlinestaticconstexpr

Definition at line 549 of file utils.h.

                                                         {
    ASSERT(position < sizeof(T) * kBitsPerByte);
    return ((mask >> position) & 1) != 0;
  }

Unlink()

static int dart::Utils::Unlink ( const char *  path )

static

UnloadDynamicLibrary()

void dart::Utils::UnloadDynamicLibrary ( void *  library_handle, char **  error = nullptr  )

static

Definition at line 352 of file utils.cc.

                                                                   {
  bool ok = false;
 
#if defined(DART_HOST_OS_LINUX) || defined(DART_HOST_OS_MACOS) ||              \
    defined(DART_HOST_OS_ANDROID) || defined(DART_HOST_OS_FUCHSIA)
  ok = dlclose(library_handle) == 0;
#elif defined(DART_HOST_OS_WINDOWS)
  SetLastError(0);  // Clear any errors.
 
  ok = FreeLibrary(reinterpret_cast<HMODULE>(library_handle));
#endif
 
  if (!ok) {
    GetLastErrorAsString(error);
  }
}

VSCreate()

char * dart::Utils::VSCreate ( const char *  format, va_list  args  )

static

Definition at line 239 of file utils.cc.

                                                      {
  // Measure.
  va_list measure_args;
  va_copy(measure_args, args);
  intptr_t len = VSNPrint(nullptr, 0, format, measure_args);
  va_end(measure_args);
 
  char* buffer = reinterpret_cast<char*>(malloc(len + 1));
  ASSERT(buffer != nullptr);
 
  // Print.
  va_list print_args;
  va_copy(print_args, args);
  VSNPrint(buffer, len + 1, format, print_args);
  va_end(print_args);
  return buffer;
}

VSNPrint()

static int static int dart::Utils::VSNPrint ( char *  str, size_t  size, const char *  format, va_list  args  )

static

WillAddOverflow()

static bool dart::Utils::WillAddOverflow ( int64_t  a, int64_t  b  )

inlinestatic

Definition at line 403 of file utils.h.

                                                           {
    return ((b > 0) && (a > (kMaxInt64 - b))) ||
           ((b < 0) && (a < (kMinInt64 - b)));
  }

WillSubOverflow()

static bool dart::Utils::WillSubOverflow ( int64_t  a, int64_t  b  )

inlinestatic

Definition at line 408 of file utils.h.

                                                           {
    return ((b > 0) && (a < (kMinInt64 + b))) ||
           ((b < 0) && (a > (kMaxInt64 + b)));
  }

WordHash()

uint32_t dart::Utils::WordHash ( intptr_t  key )

static

Definition at line 217 of file utils.cc.

                                     {
  // TODO(iposva): Need to check hash spreading.
  // This example is from http://www.concentric.net/~Ttwang/tech/inthash.htm
  // via. http://web.archive.org/web/20071223173210/http://www.concentric.net/~Ttwang/tech/inthash.htm
  uword a = static_cast<uword>(key);
  a = (a + 0x7ed55d16) + (a << 12);
  a = (a ^ 0xc761c23c) ^ (a >> 19);
  a = (a + 0x165667b1) + (a << 5);
  a = (a + 0xd3a2646c) ^ (a << 9);
  a = (a + 0xfd7046c5) + (a << 3);
  a = (a ^ 0xb55a4f09) ^ (a >> 16);
  return static_cast<uint32_t>(a);
}

---

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

• third_party/dart-lang/sdk/runtime/platform/utils.h
• third_party/dart-lang/sdk/runtime/platform/utils.cc
• third_party/dart-lang/sdk/runtime/platform/utils_android.h
• third_party/dart-lang/sdk/runtime/platform/utils_fuchsia.h
• third_party/dart-lang/sdk/runtime/platform/utils_linux.h
• third_party/dart-lang/sdk/runtime/platform/utils_macos.h
• third_party/dart-lang/sdk/runtime/platform/utils_win.h