Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	util-inl.h	Lines:	230	251	91.6 %
Date:	2022-12-07 04:23:16	Branches:	90	133	67.7 %


// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef SRC_UTIL_INL_H_
#define SRC_UTIL_INL_H_

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#include <cmath>
#include <cstring>
#include <locale>
#include "util.h"

// These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
// To avoid warnings, undefine them before redefining them.
#ifdef BSWAP_2
# undef BSWAP_2
#endif
#ifdef BSWAP_4
# undef BSWAP_4
#endif
#ifdef BSWAP_8
# undef BSWAP_8
#endif

#if defined(_MSC_VER)
#include <intrin.h>
#define BSWAP_2(x) _byteswap_ushort(x)
#define BSWAP_4(x) _byteswap_ulong(x)
#define BSWAP_8(x) _byteswap_uint64(x)
#else
#define BSWAP_2(x) ((x) << 8) | ((x) >> 8)
#define BSWAP_4(x)                                                            \
  (((x) & 0xFF) << 24) |                                                      \
  (((x) & 0xFF00) << 8) |                                                     \
  (((x) >> 8) & 0xFF00) |                                                     \
  (((x) >> 24) & 0xFF)
#define BSWAP_8(x)                                                            \
  (((x) & 0xFF00000000000000ull) >> 56) |                                     \
  (((x) & 0x00FF000000000000ull) >> 40) |                                     \
  (((x) & 0x0000FF0000000000ull) >> 24) |                                     \
  (((x) & 0x000000FF00000000ull) >> 8) |                                      \
  (((x) & 0x00000000FF000000ull) << 8) |                                      \
  (((x) & 0x0000000000FF0000ull) << 24) |                                     \
  (((x) & 0x000000000000FF00ull) << 40) |                                     \
  (((x) & 0x00000000000000FFull) << 56)
#endif

#define CHAR_TEST(bits, name, expr)                                           \
  template <typename T>                                                       \
  bool name(const T ch) {                                                     \
    static_assert(sizeof(ch) >= (bits) / 8,                                   \
                  "Character must be wider than " #bits " bits");             \
    return (expr);                                                            \
  }

namespace node {

template <typename T>
ListNode<T>::ListNode() : prev_(this), next_(this) {}

template <typename T>
ListNode<T>::~ListNode() {
  Remove();
}

template <typename T>
void ListNode<T>::Remove() {
  prev_->next_ = next_;
  next_->prev_ = prev_;
  prev_ = this;
  next_ = this;
}

template <typename T>
bool ListNode<T>::IsEmpty() const {
  return prev_ == this;
}

template <typename T, ListNode<T> (T::*M)>
ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}

template <typename T, ListNode<T> (T::*M)>
T* ListHead<T, M>::Iterator::operator*() const {
  return ContainerOf(M, node_);
}

template <typename T, ListNode<T> (T::*M)>
const typename ListHead<T, M>::Iterator&
ListHead<T, M>::Iterator::operator++() {
  node_ = node_->next_;
  return *this;
}

template <typename T, ListNode<T> (T::*M)>
bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
  return node_ != that.node_;
}

template <typename T, ListNode<T> (T::*M)>
ListHead<T, M>::~ListHead() {
  while (IsEmpty() == false)
    head_.next_->Remove();
}

template <typename T, ListNode<T> (T::*M)>
void ListHead<T, M>::PushBack(T* element) {
  ListNode<T>* that = &(element->*M);
  head_.prev_->next_ = that;
  that->prev_ = head_.prev_;
  that->next_ = &head_;
  head_.prev_ = that;
}

template <typename T, ListNode<T> (T::*M)>
void ListHead<T, M>::PushFront(T* element) {
  ListNode<T>* that = &(element->*M);
  head_.next_->prev_ = that;
  that->prev_ = &head_;
  that->next_ = head_.next_;
  head_.next_ = that;
}

template <typename T, ListNode<T> (T::*M)>
bool ListHead<T, M>::IsEmpty() const {
  return head_.IsEmpty();
}

template <typename T, ListNode<T> (T::*M)>
T* ListHead<T, M>::PopFront() {
  if (IsEmpty())
    return nullptr;
  ListNode<T>* node = head_.next_;
  node->Remove();
  return ContainerOf(M, node);
}

template <typename T, ListNode<T> (T::*M)>
typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
  return Iterator(head_.next_);
}

template <typename T, ListNode<T> (T::*M)>
typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
  return Iterator(const_cast<ListNode<T>*>(&head_));
}

template <typename Inner, typename Outer>
constexpr uintptr_t OffsetOf(Inner Outer::*field) {
  return reinterpret_cast<uintptr_t>(&(static_cast<Outer*>(nullptr)->*field));
}

template <typename Inner, typename Outer>
ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
                                                   Inner* pointer)
    : pointer_(
        reinterpret_cast<Outer*>(
            reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}

template <typename Inner, typename Outer>
template <typename TypeName>
ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
  return static_cast<TypeName*>(pointer_);
}

template <typename Inner, typename Outer>
constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
                                                      Inner* pointer) {
  return ContainerOfHelper<Inner, Outer>(field, pointer);
}

inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
                                           const char* data,
                                           int length) {
  return v8::String::NewFromOneByte(isolate,
                                    reinterpret_cast<const uint8_t*>(data),
                                    v8::NewStringType::kNormal,
                                    length).ToLocalChecked();
}

inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
                                           const signed char* data,
                                           int length) {
  return v8::String::NewFromOneByte(isolate,
                                    reinterpret_cast<const uint8_t*>(data),
                                    v8::NewStringType::kNormal,
                                    length).ToLocalChecked();
}

inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
                                           const unsigned char* data,
                                           int length) {
  return v8::String::NewFromOneByte(
             isolate, data, v8::NewStringType::kNormal, length)
      .ToLocalChecked();
}

void SwapBytes16(char* data, size_t nbytes) {
  CHECK_EQ(nbytes % 2, 0);

#if defined(_MSC_VER)
  if (AlignUp(data, sizeof(uint16_t)) == data) {
    // MSVC has no strict aliasing, and is able to highly optimize this case.
    uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
    size_t len16 = nbytes / sizeof(*data16);
    for (size_t i = 0; i < len16; i++) {
      data16[i] = BSWAP_2(data16[i]);
    }
    return;
  }
#endif

  uint16_t temp;
  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
    memcpy(&temp, &data[i], sizeof(temp));
    temp = BSWAP_2(temp);
    memcpy(&data[i], &temp, sizeof(temp));
  }
}

void SwapBytes32(char* data, size_t nbytes) {
  CHECK_EQ(nbytes % 4, 0);

#if defined(_MSC_VER)
  // MSVC has no strict aliasing, and is able to highly optimize this case.
  if (AlignUp(data, sizeof(uint32_t)) == data) {
    uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
    size_t len32 = nbytes / sizeof(*data32);
    for (size_t i = 0; i < len32; i++) {
      data32[i] = BSWAP_4(data32[i]);
    }
    return;
  }
#endif

  uint32_t temp;
  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
    memcpy(&temp, &data[i], sizeof(temp));
    temp = BSWAP_4(temp);
    memcpy(&data[i], &temp, sizeof(temp));
  }
}

void SwapBytes64(char* data, size_t nbytes) {
  CHECK_EQ(nbytes % 8, 0);

#if defined(_MSC_VER)
  if (AlignUp(data, sizeof(uint64_t)) == data) {
    // MSVC has no strict aliasing, and is able to highly optimize this case.
    uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
    size_t len64 = nbytes / sizeof(*data64);
    for (size_t i = 0; i < len64; i++) {
      data64[i] = BSWAP_8(data64[i]);
    }
    return;
  }
#endif

  uint64_t temp;
  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
    memcpy(&temp, &data[i], sizeof(temp));
    temp = BSWAP_8(temp);
    memcpy(&data[i], &temp, sizeof(temp));
  }
}

char ToLower(char c) {
  return std::tolower(c, std::locale::classic());
}

std::string ToLower(const std::string& in) {
  std::string out(in.size(), 0);
  for (size_t i = 0; i < in.size(); ++i)
    out[i] = ToLower(in[i]);
  return out;
}

char ToUpper(char c) {
  return std::toupper(c, std::locale::classic());
}

std::string ToUpper(const std::string& in) {
  std::string out(in.size(), 0);
  for (size_t i = 0; i < in.size(); ++i)
    out[i] = ToUpper(in[i]);
  return out;
}

bool StringEqualNoCase(const char* a, const char* b) {
  while (ToLower(*a) == ToLower(*b++)) {
    if (*a++ == '\0')
      return true;
  }
  return false;
}

bool StringEqualNoCaseN(const char* a, const char* b, size_t length) {
  for (size_t i = 0; i < length; i++) {
    if (ToLower(a[i]) != ToLower(b[i]))
      return false;
    if (a[i] == '\0')
      return true;
  }
  return true;
}

template <typename T>
inline T MultiplyWithOverflowCheck(T a, T b) {
  auto ret = a * b;
  if (a != 0)
    CHECK_EQ(b, ret / a);

  return ret;
}

// These should be used in our code as opposed to the native
// versions as they abstract out some platform and or
// compiler version specific functionality.
// malloc(0) and realloc(ptr, 0) have implementation-defined behavior in
// that the standard allows them to either return a unique pointer or a
// nullptr for zero-sized allocation requests.  Normalize by always using
// a nullptr.
template <typename T>
T* UncheckedRealloc(T* pointer, size_t n) {
  size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);

  if (full_size == 0) {
    free(pointer);
    return nullptr;
  }

  void* allocated = realloc(pointer, full_size);

  if (UNLIKELY(allocated == nullptr)) {
    // Tell V8 that memory is low and retry.
    LowMemoryNotification();
    allocated = realloc(pointer, full_size);
  }

  return static_cast<T*>(allocated);
}

// As per spec realloc behaves like malloc if passed nullptr.
template <typename T>
inline T* UncheckedMalloc(size_t n) {
  return UncheckedRealloc<T>(nullptr, n);
}

template <typename T>
inline T* UncheckedCalloc(size_t n) {
  if (MultiplyWithOverflowCheck(sizeof(T), n) == 0) return nullptr;
  return static_cast<T*>(calloc(n, sizeof(T)));
}

template <typename T>
inline T* Realloc(T* pointer, size_t n) {
  T* ret = UncheckedRealloc(pointer, n);
  CHECK_IMPLIES(n > 0, ret != nullptr);
  return ret;
}

template <typename T>
inline T* Malloc(size_t n) {
  T* ret = UncheckedMalloc<T>(n);
  CHECK_IMPLIES(n > 0, ret != nullptr);
  return ret;
}

template <typename T>
inline T* Calloc(size_t n) {
  T* ret = UncheckedCalloc<T>(n);
  CHECK_IMPLIES(n > 0, ret != nullptr);
  return ret;
}

// Shortcuts for char*.
inline char* Malloc(size_t n) { return Malloc<char>(n); }
inline char* Calloc(size_t n) { return Calloc<char>(n); }
inline char* UncheckedMalloc(size_t n) { return UncheckedMalloc<char>(n); }
inline char* UncheckedCalloc(size_t n) { return UncheckedCalloc<char>(n); }

// This is a helper in the .cc file so including util-inl.h doesn't include more
// headers than we really need to.
void ThrowErrStringTooLong(v8::Isolate* isolate);

v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                    std::string_view str,
                                    v8::Isolate* isolate) {
  if (isolate == nullptr) isolate = context->GetIsolate();
  if (UNLIKELY(str.size() >= static_cast<size_t>(v8::String::kMaxLength))) {
    // V8 only has a TODO comment about adding an exception when the maximum
    // string size is exceeded.
    ThrowErrStringTooLong(isolate);
    return v8::MaybeLocal<v8::Value>();
  }

  return v8::String::NewFromUtf8(
             isolate, str.data(), v8::NewStringType::kNormal, str.size())
      .FromMaybe(v8::Local<v8::String>());
}

template <typename T>
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                    const std::vector<T>& vec,
                                    v8::Isolate* isolate) {
  if (isolate == nullptr) isolate = context->GetIsolate();
  v8::EscapableHandleScope handle_scope(isolate);

  MaybeStackBuffer<v8::Local<v8::Value>, 128> arr(vec.size());
  arr.SetLength(vec.size());
  for (size_t i = 0; i < vec.size(); ++i) {
    if (!ToV8Value(context, vec[i], isolate).ToLocal(&arr[i]))
      return v8::MaybeLocal<v8::Value>();
  }

  return handle_scope.Escape(v8::Array::New(isolate, arr.out(), arr.length()));
}

template <typename T>
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                    const std::set<T>& set,
                                    v8::Isolate* isolate) {
  if (isolate == nullptr) isolate = context->GetIsolate();
  v8::Local<v8::Set> set_js = v8::Set::New(isolate);
  v8::HandleScope handle_scope(isolate);

  for (const T& entry : set) {
    v8::Local<v8::Value> value;
    if (!ToV8Value(context, entry, isolate).ToLocal(&value))
      return {};
    if (set_js->Add(context, value).IsEmpty())
      return {};
  }

  return set_js;
}

template <typename T, typename U>
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                    const std::unordered_map<T, U>& map,
                                    v8::Isolate* isolate) {
  if (isolate == nullptr) isolate = context->GetIsolate();
  v8::EscapableHandleScope handle_scope(isolate);

  v8::Local<v8::Map> ret = v8::Map::New(isolate);
  for (const auto& item : map) {
    v8::Local<v8::Value> first, second;
    if (!ToV8Value(context, item.first, isolate).ToLocal(&first) ||
        !ToV8Value(context, item.second, isolate).ToLocal(&second) ||
        ret->Set(context, first, second).IsEmpty()) {
      return v8::MaybeLocal<v8::Value>();
    }
  }

  return handle_scope.Escape(ret);
}

template <typename T, typename >
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                    const T& number,
                                    v8::Isolate* isolate) {
  if (isolate == nullptr) isolate = context->GetIsolate();

  using Limits = std::numeric_limits<T>;
  // Choose Uint32, Int32, or Double depending on range checks.
  // These checks should all collapse at compile time.
  if (static_cast<uint32_t>(Limits::max()) <=
          std::numeric_limits<uint32_t>::max() &&
      static_cast<uint32_t>(Limits::min()) >=
          std::numeric_limits<uint32_t>::min() && Limits::is_exact) {
    return v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(number));
  }

  if (static_cast<int32_t>(Limits::max()) <=
          std::numeric_limits<int32_t>::max() &&
      static_cast<int32_t>(Limits::min()) >=
          std::numeric_limits<int32_t>::min() && Limits::is_exact) {
    return v8::Integer::New(isolate, static_cast<int32_t>(number));
  }

  return v8::Number::New(isolate, static_cast<double>(number));
}

SlicedArguments::SlicedArguments(
    const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
  const size_t length = static_cast<size_t>(args.Length());
  if (start >= length) return;
  const size_t size = length - start;

  AllocateSufficientStorage(size);
  for (size_t i = 0; i < size; ++i)
    (*this)[i] = args[i + start];
}

template <typename T, size_t S>
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
    v8::Local<v8::Value> value) {
  DCHECK(value->IsArrayBufferView() || value->IsSharedArrayBuffer() ||
         value->IsArrayBuffer());
  ReadValue(value);
}

template <typename T, size_t S>
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
    v8::Local<v8::Object> value) {
  CHECK(value->IsArrayBufferView());
  Read(value.As<v8::ArrayBufferView>());
}

template <typename T, size_t S>
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
    v8::Local<v8::ArrayBufferView> abv) {
  Read(abv);
}

template <typename T, size_t S>
void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
  static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
  length_ = abv->ByteLength();
  if (length_ > sizeof(stack_storage_) || abv->HasBuffer()) {
    data_ = static_cast<T*>(abv->Buffer()->Data()) + abv->ByteOffset();
  } else {
    abv->CopyContents(stack_storage_, sizeof(stack_storage_));
    data_ = stack_storage_;
  }
}

template <typename T, size_t S>
void ArrayBufferViewContents<T, S>::ReadValue(v8::Local<v8::Value> buf) {
  static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
  DCHECK(buf->IsArrayBufferView() || buf->IsSharedArrayBuffer() ||
         buf->IsArrayBuffer());

  if (buf->IsArrayBufferView()) {
    Read(buf.As<v8::ArrayBufferView>());
  } else if (buf->IsArrayBuffer()) {
    auto ab = buf.As<v8::ArrayBuffer>();
    length_ = ab->ByteLength();
    data_ = static_cast<T*>(ab->Data());
  } else {
    CHECK(buf->IsSharedArrayBuffer());
    auto sab = buf.As<v8::SharedArrayBuffer>();
    length_ = sab->ByteLength();
    data_ = static_cast<T*>(sab->Data());
  }
}

// ECMA262 20.1.2.5
inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
  if (!v->IsNumber()) return false;
  double v_d = v.As<v8::Number>()->Value();
  if (std::isnan(v_d)) return false;
  if (std::isinf(v_d)) return false;
  if (std::trunc(v_d) != v_d) return false;  // not int
  if (std::abs(v_d) <= static_cast<double>(kMaxSafeJsInteger)) return true;
  return false;
}

constexpr size_t FastStringKey::HashImpl(const char* str) {
  // Low-quality hash (djb2), but just fine for current use cases.
  size_t h = 5381;
  while (*str != '\0') {
    h = h * 33 + *(str++);  // NOLINT(readability/pointer_notation)
  }
  return h;
}

constexpr size_t FastStringKey::Hash::operator()(
    const FastStringKey& key) const {
  return key.cached_hash_;
}

constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
  const char* p1 = name_;
  const char* p2 = other.name_;
  if (p1 == p2) return true;
  do {
    if (*(p1++) != *(p2++)) return false;
  } while (*p1 != '\0');
  return *p2 == '\0';
}

constexpr FastStringKey::FastStringKey(const char* name)
  : name_(name), cached_hash_(HashImpl(name)) {}

constexpr const char* FastStringKey::c_str() const {
  return name_;
}

}  // namespace node

#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#endif  // SRC_UTIL_INL_H_


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			// Copyright Joyent, Inc. and other Node contributors.
2			//
3			// Permission is hereby granted, free of charge, to any person obtaining a
4			// copy of this software and associated documentation files (the
5			// "Software"), to deal in the Software without restriction, including
6			// without limitation the rights to use, copy, modify, merge, publish,
7			// distribute, sublicense, and/or sell copies of the Software, and to permit
8			// persons to whom the Software is furnished to do so, subject to the
9			// following conditions:
10			//
11			// The above copyright notice and this permission notice shall be included
12			// in all copies or substantial portions of the Software.
13			//
14			// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15			// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16			// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
17			// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
18			// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
19			// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
20			// USE OR OTHER DEALINGS IN THE SOFTWARE.
21
22			#ifndef SRC_UTIL_INL_H_
23			#define SRC_UTIL_INL_H_
24
25			#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
26
27			#include <cmath>
28			#include <cstring>
29			#include <locale>
30			#include "util.h"
31
32			// These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
33			// To avoid warnings, undefine them before redefining them.
34			#ifdef BSWAP_2
35			# undef BSWAP_2
36			#endif
37			#ifdef BSWAP_4
38			# undef BSWAP_4
39			#endif
40			#ifdef BSWAP_8
41			# undef BSWAP_8
42			#endif
43
44			#if defined(_MSC_VER)
45			#include <intrin.h>
46			#define BSWAP_2(x) _byteswap_ushort(x)
47			#define BSWAP_4(x) _byteswap_ulong(x)
48			#define BSWAP_8(x) _byteswap_uint64(x)
49			#else
50			#define BSWAP_2(x) ((x) << 8) \| ((x) >> 8)
51			#define BSWAP_4(x) \
52			(((x) & 0xFF) << 24) \| \
53			(((x) & 0xFF00) << 8) \| \
54			(((x) >> 8) & 0xFF00) \| \
55			(((x) >> 24) & 0xFF)
56			#define BSWAP_8(x) \
57			(((x) & 0xFF00000000000000ull) >> 56) \| \
58			(((x) & 0x00FF000000000000ull) >> 40) \| \
59			(((x) & 0x0000FF0000000000ull) >> 24) \| \
60			(((x) & 0x000000FF00000000ull) >> 8) \| \
61			(((x) & 0x00000000FF000000ull) << 8) \| \
62			(((x) & 0x0000000000FF0000ull) << 24) \| \
63			(((x) & 0x000000000000FF00ull) << 40) \| \
64			(((x) & 0x00000000000000FFull) << 56)
65			#endif
66
67			#define CHAR_TEST(bits, name, expr) \
68			template <typename T> \
69			bool name(const T ch) { \
70			static_assert(sizeof(ch) >= (bits) / 8, \
71			"Character must be wider than " #bits " bits"); \
72			return (expr); \
73			}
74
75			namespace node {
76
77			template <typename T>
78		212514	ListNode<T>::ListNode() : prev_(this), next_(this) {}
79
80			template <typename T>
81		208388	ListNode<T>::~ListNode() {
82		208388	Remove();
83		208388	}
84
85			template <typename T>
86		325462	void ListNode<T>::Remove() {
87		325462	prev_->next_ = next_;
88		325462	next_->prev_ = prev_;
89		325462	prev_ = this;
90		325462	next_ = this;
91		325462	}
92
93			template <typename T>
94		71633	bool ListNode<T>::IsEmpty() const {
95		71633	return prev_ == this;
96			}
97
98			template <typename T, ListNode<T> (T::*M)>
99		91784	ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}
100
101			template <typename T, ListNode<T> (T::*M)>
102		10029	T* ListHead<T, M>::Iterator::operator*() const {
103		10029	return ContainerOf(M, node_);
104			}
105
106			template <typename T, ListNode<T> (T::*M)>
107			const typename ListHead<T, M>::Iterator&
108		10029	ListHead<T, M>::Iterator::operator++() {
109		10029	node_ = node_->next_;
110		10029	return *this;
111			}
112
113			template <typename T, ListNode<T> (T::*M)>
114		55919	bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
115		55919	return node_ != that.node_;
116			}
117
118			template <typename T, ListNode<T> (T::*M)>
119		22941	ListHead<T, M>::~ListHead() {
120	✗✓	22941	while (IsEmpty() == false)
121			head_.next_->Remove();
122		22941	}
123
124			template <typename T, ListNode<T> (T::*M)>
125		137920	void ListHead<T, M>::PushBack(T* element) {
126		137920	ListNode<T>* that = &(element->*M);
127		137920	head_.prev_->next_ = that;
128		137920	that->prev_ = head_.prev_;
129		137920	that->next_ = &head_;
130		137920	head_.prev_ = that;
131		137920	}
132
133			template <typename T, ListNode<T> (T::*M)>
134			void ListHead<T, M>::PushFront(T* element) {
135			ListNode<T>* that = &(element->*M);
136			head_.next_->prev_ = that;
137			that->prev_ = &head_;
138			that->next_ = head_.next_;
139			head_.next_ = that;
140			}
141
142			template <typename T, ListNode<T> (T::*M)>
143		71629	bool ListHead<T, M>::IsEmpty() const {
144		71629	return head_.IsEmpty();
145			}
146
147			template <typename T, ListNode<T> (T::*M)>
148		2	T* ListHead<T, M>::PopFront() {
149	✗✓	2	if (IsEmpty())
150			return nullptr;
151		2	ListNode<T>* node = head_.next_;
152		2	node->Remove();
153		2	return ContainerOf(M, node);
154			}
155
156			template <typename T, ListNode<T> (T::*M)>
157		45890	typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
158		45890	return Iterator(head_.next_);
159			}
160
161			template <typename T, ListNode<T> (T::*M)>
162		45894	typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
163		45894	return Iterator(const_cast<ListNode<T>*>(&head_));
164			}
165
166			template <typename Inner, typename Outer>
167		2384075	constexpr uintptr_t OffsetOf(Inner Outer::*field) {
168		2384075	return reinterpret_cast<uintptr_t>(&(static_cast<Outer>(nullptr)->field));
169			}
170
171			template <typename Inner, typename Outer>
172		2315711	ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
173			Inner* pointer)
174			: pointer_(
175			reinterpret_cast<Outer*>(
176		2315711	reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}
177
178			template <typename Inner, typename Outer>
179			template <typename TypeName>
180		2315711	ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
181		2315711	return static_cast<TypeName*>(pointer_);
182			}
183
184			template <typename Inner, typename Outer>
185		2308217	constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
186			Inner* pointer) {
187		2308217	return ContainerOfHelper<Inner, Outer>(field, pointer);
188			}
189
190		4257758	inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
191			const char* data,
192			int length) {
193		4257758	return v8::String::NewFromOneByte(isolate,
194			reinterpret_cast<const uint8_t*>(data),
195			v8::NewStringType::kNormal,
196		4257758	length).ToLocalChecked();
197			}
198
199			inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
200			const signed char* data,
201			int length) {
202			return v8::String::NewFromOneByte(isolate,
203			reinterpret_cast<const uint8_t*>(data),
204			v8::NewStringType::kNormal,
205			length).ToLocalChecked();
206			}
207
208		1352	inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
209			const unsigned char* data,
210			int length) {
211		1352	return v8::String::NewFromOneByte(
212		1352	isolate, data, v8::NewStringType::kNormal, length)
213		1352	.ToLocalChecked();
214			}
215
216		2	void SwapBytes16(char* data, size_t nbytes) {
217	✗✓	2	CHECK_EQ(nbytes % 2, 0);
218
219			#if defined(_MSC_VER)
220			if (AlignUp(data, sizeof(uint16_t)) == data) {
221			// MSVC has no strict aliasing, and is able to highly optimize this case.
222			uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
223			size_t len16 = nbytes / sizeof(*data16);
224			for (size_t i = 0; i < len16; i++) {
225			data16[i] = BSWAP_2(data16[i]);
226			}
227			return;
228			}
229			#endif
230
231			uint16_t temp;
232	✓✓	1537	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
233		1535	memcpy(&temp, &data[i], sizeof(temp));
234		1535	temp = BSWAP_2(temp);
235		1535	memcpy(&data[i], &temp, sizeof(temp));
236			}
237		2	}
238
239		2	void SwapBytes32(char* data, size_t nbytes) {
240	✗✓	2	CHECK_EQ(nbytes % 4, 0);
241
242			#if defined(_MSC_VER)
243			// MSVC has no strict aliasing, and is able to highly optimize this case.
244			if (AlignUp(data, sizeof(uint32_t)) == data) {
245			uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
246			size_t len32 = nbytes / sizeof(*data32);
247			for (size_t i = 0; i < len32; i++) {
248			data32[i] = BSWAP_4(data32[i]);
249			}
250			return;
251			}
252			#endif
253
254			uint32_t temp;
255	✓✓	769	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
256		767	memcpy(&temp, &data[i], sizeof(temp));
257		767	temp = BSWAP_4(temp);
258		767	memcpy(&data[i], &temp, sizeof(temp));
259			}
260		2	}
261
262		2	void SwapBytes64(char* data, size_t nbytes) {
263	✗✓	2	CHECK_EQ(nbytes % 8, 0);
264
265			#if defined(_MSC_VER)
266			if (AlignUp(data, sizeof(uint64_t)) == data) {
267			// MSVC has no strict aliasing, and is able to highly optimize this case.
268			uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
269			size_t len64 = nbytes / sizeof(*data64);
270			for (size_t i = 0; i < len64; i++) {
271			data64[i] = BSWAP_8(data64[i]);
272			}
273			return;
274			}
275			#endif
276
277			uint64_t temp;
278	✓✓	513	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
279		511	memcpy(&temp, &data[i], sizeof(temp));
280		511	temp = BSWAP_8(temp);
281		511	memcpy(&data[i], &temp, sizeof(temp));
282			}
283		2	}
284
285		55847	char ToLower(char c) {
286		55847	return std::tolower(c, std::locale::classic());
287			}
288
289		4011	std::string ToLower(const std::string& in) {
290		4011	std::string out(in.size(), 0);
291	✓✓	52199	for (size_t i = 0; i < in.size(); ++i)
292		48188	out[i] = ToLower(in[i]);
293		4011	return out;
294			}
295
296		13758	char ToUpper(char c) {
297		13758	return std::toupper(c, std::locale::classic());
298			}
299
300		2	std::string ToUpper(const std::string& in) {
301		2	std::string out(in.size(), 0);
302	✓✓	5	for (size_t i = 0; i < in.size(); ++i)
303		3	out[i] = ToUpper(in[i]);
304		2	return out;
305			}
306
307		1345	bool StringEqualNoCase(const char* a, const char* b) {
308	✓✓	1345	while (ToLower(a) == ToLower(b++)) {
309	✓✓	1221	if (*a++ == '\0')
310		108	return true;
311			}
312		124	return false;
313			}
314
315		665	bool StringEqualNoCaseN(const char* a, const char* b, size_t length) {
316	✓✓	2689	for (size_t i = 0; i < length; i++) {
317	✓✓	2483	if (ToLower(a[i]) != ToLower(b[i]))
318		458	return false;
319	✓✓	2025	if (a[i] == '\0')
320		1	return true;
321			}
322		206	return true;
323			}
324
325			template <typename T>
326		468896	inline T MultiplyWithOverflowCheck(T a, T b) {
327		468896	auto ret = a * b;
328	✓✓	468896	if (a != 0)
329	✗✓	468894	CHECK_EQ(b, ret / a);
330
331		468896	return ret;
332			}
333
334			// These should be used in our code as opposed to the native
335			// versions as they abstract out some platform and or
336			// compiler version specific functionality.
337			// malloc(0) and realloc(ptr, 0) have implementation-defined behavior in
338			// that the standard allows them to either return a unique pointer or a
339			// nullptr for zero-sized allocation requests. Normalize by always using
340			// a nullptr.
341			template <typename T>
342		778522	T* UncheckedRealloc(T* pointer, size_t n) {
343		778522	size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);
344
345	✓✓	778522	if (full_size == 0) {
346		211210	free(pointer);
347		211210	return nullptr;
348			}
349
350		567312	void* allocated = realloc(pointer, full_size);
351
352	✗✓	567312	if (UNLIKELY(allocated == nullptr)) {
353			// Tell V8 that memory is low and retry.
354			LowMemoryNotification();
355			allocated = realloc(pointer, full_size);
356			}
357
358		567312	return static_cast<T*>(allocated);
359			}
360
361			// As per spec realloc behaves like malloc if passed nullptr.
362			template <typename T>
363		44642	inline T* UncheckedMalloc(size_t n) {
364		44642	return UncheckedRealloc<T>(nullptr, n);
365			}
366
367			template <typename T>
368		54	inline T* UncheckedCalloc(size_t n) {
369	✓✓	54	if (MultiplyWithOverflowCheck(sizeof(T), n) == 0) return nullptr;
370		29	return static_cast<T*>(calloc(n, sizeof(T)));
371			}
372
373			template <typename T>
374		156169	inline T* Realloc(T* pointer, size_t n) {
375		156169	T* ret = UncheckedRealloc(pointer, n);
376	✓✗✗✓	156169	CHECK_IMPLIES(n > 0, ret != nullptr);
377		156169	return ret;
378			}
379
380			template <typename T>
381		2104	inline T* Malloc(size_t n) {
382		2104	T* ret = UncheckedMalloc<T>(n);
383	✓✓✗✓	2104	CHECK_IMPLIES(n > 0, ret != nullptr);
384		2104	return ret;
385			}
386
387			template <typename T>
388		50	inline T* Calloc(size_t n) {
389		50	T* ret = UncheckedCalloc<T>(n);
390	✓✓✗✓	50	CHECK_IMPLIES(n > 0, ret != nullptr);
391		50	return ret;
392			}
393
394			// Shortcuts for char*.
395		4	inline char* Malloc(size_t n) { return Malloc<char>(n); }
396		2	inline char* Calloc(size_t n) { return Calloc<char>(n); }
397		21243	inline char* UncheckedMalloc(size_t n) { return UncheckedMalloc<char>(n); }
398		2	inline char* UncheckedCalloc(size_t n) { return UncheckedCalloc<char>(n); }
399
400			// This is a helper in the .cc file so including util-inl.h doesn't include more
401			// headers than we really need to.
402			void ThrowErrStringTooLong(v8::Isolate* isolate);
403
404		3582829	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
405			std::string_view str,
406			v8::Isolate* isolate) {
407	✓✓	5862427	if (isolate == nullptr) isolate = context->GetIsolate();
408	✗✓	3582829	if (UNLIKELY(str.size() >= static_cast<size_t>(v8::String::kMaxLength))) {
409			// V8 only has a TODO comment about adding an exception when the maximum
410			// string size is exceeded.
411			ThrowErrStringTooLong(isolate);
412			return v8::MaybeLocal<v8::Value>();
413			}
414
415		3582829	return v8::String::NewFromUtf8(
416		3582829	isolate, str.data(), v8::NewStringType::kNormal, str.size())
417		3582829	.FromMaybe(v8::Local<v8::String>());
418			}
419
420			template <typename T>
421		310782	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
422			const std::vector<T>& vec,
423			v8::Isolate* isolate) {
424	✓✓	466794	if (isolate == nullptr) isolate = context->GetIsolate();
425		310782	v8::EscapableHandleScope handle_scope(isolate);
426
427		621564	MaybeStackBuffer<v8::Local<v8::Value>, 128> arr(vec.size());
428		310782	arr.SetLength(vec.size());
429	✓✓	1458766	for (size_t i = 0; i < vec.size(); ++i) {
430	✗✓✓	2295968	if (!ToV8Value(context, vec[i], isolate).ToLocal(&arr[i]))
431			return v8::MaybeLocal<v8::Value>();
432			}
433
434		621564	return handle_scope.Escape(v8::Array::New(isolate, arr.out(), arr.length()));
435			}
436
437			template <typename T>
438		4	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
439			const std::set<T>& set,
440			v8::Isolate* isolate) {
441	✓✗	8	if (isolate == nullptr) isolate = context->GetIsolate();
442		4	v8::Local<v8::Set> set_js = v8::Set::New(isolate);
443		8	v8::HandleScope handle_scope(isolate);
444
445	✓✓	483	for (const T& entry : set) {
446			v8::Local<v8::Value> value;
447	✗✓	958	if (!ToV8Value(context, entry, isolate).ToLocal(&value))
448			return {};
449	✗✓	958	if (set_js->Add(context, value).IsEmpty())
450			return {};
451			}
452
453		4	return set_js;
454			}
455
456			template <typename T, typename U>
457		7035	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
458			const std::unordered_map<T, U>& map,
459			v8::Isolate* isolate) {
460	✓✗	14070	if (isolate == nullptr) isolate = context->GetIsolate();
461		7035	v8::EscapableHandleScope handle_scope(isolate);
462
463		7035	v8::Local<v8::Map> ret = v8::Map::New(isolate);
464	✓✓	161805	for (const auto& item : map) {
465			v8::Local<v8::Value> first, second;
466		154770	if (!ToV8Value(context, item.first, isolate).ToLocal(&first) \|\|
467	✓✗✓✗	464310	!ToV8Value(context, item.second, isolate).ToLocal(&second) \|\|
468	✗✓✗✓	464310	ret->Set(context, first, second).IsEmpty()) {
469			return v8::MaybeLocal<v8::Value>();
470			}
471			}
472
473		7035	return handle_scope.Escape(ret);
474			}
475
476			template <typename T, typename >
477		2	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
478			const T& number,
479			v8::Isolate* isolate) {
480	✗✓	2	if (isolate == nullptr) isolate = context->GetIsolate();
481
482			using Limits = std::numeric_limits<T>;
483			// Choose Uint32, Int32, or Double depending on range checks.
484			// These checks should all collapse at compile time.
485		2	if (static_cast<uint32_t>(Limits::max()) <=
486	✓✗	4	std::numeric_limits<uint32_t>::max() &&
487		2	static_cast<uint32_t>(Limits::min()) >=
488	✓✗✓✗	6	std::numeric_limits<uint32_t>::min() && Limits::is_exact) {
489		4	return v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(number));
490			}
491
492			if (static_cast<int32_t>(Limits::max()) <=
493			std::numeric_limits<int32_t>::max() &&
494			static_cast<int32_t>(Limits::min()) >=
495			std::numeric_limits<int32_t>::min() && Limits::is_exact) {
496			return v8::Integer::New(isolate, static_cast<int32_t>(number));
497			}
498
499			return v8::Number::New(isolate, static_cast<double>(number));
500			}
501
502		74340	SlicedArguments::SlicedArguments(
503		74340	const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
504		74340	const size_t length = static_cast<size_t>(args.Length());
505	✓✓	74340	if (start >= length) return;
506		74322	const size_t size = length - start;
507
508		74322	AllocateSufficientStorage(size);
509	✓✓	161247	for (size_t i = 0; i < size; ++i)
510	✓✗	173850	(*this)[i] = args[i + start];
511			}
512
513			template <typename T, size_t S>
514		17554	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
515		17554	v8::Local<v8::Value> value) {
516			DCHECK(value->IsArrayBufferView() \|\| value->IsSharedArrayBuffer() \|\|
517			value->IsArrayBuffer());
518		17554	ReadValue(value);
519		17554	}
520
521			template <typename T, size_t S>
522		137494	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
523		137494	v8::Local<v8::Object> value) {
524	✗✓	137494	CHECK(value->IsArrayBufferView());
525		137494	Read(value.As<v8::ArrayBufferView>());
526		137494	}
527
528			template <typename T, size_t S>
529		27039	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
530		27039	v8::Local<v8::ArrayBufferView> abv) {
531		27039	Read(abv);
532		27039	}
533
534			template <typename T, size_t S>
535		181927	void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
536			static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
537		181927	length_ = abv->ByteLength();
538	✓✓✓✓ ✓✓	269296	if (length_ > sizeof(stack_storage_) \|\| abv->HasBuffer()) {
539		542487	data_ = static_cast<T*>(abv->Buffer()->Data()) + abv->ByteOffset();
540			} else {
541		1098	abv->CopyContents(stack_storage_, sizeof(stack_storage_));
542		1098	data_ = stack_storage_;
543			}
544		181927	}
545
546			template <typename T, size_t S>
547		17554	void ArrayBufferViewContents<T, S>::ReadValue(v8::Local<v8::Value> buf) {
548			static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
549			DCHECK(buf->IsArrayBufferView() \|\| buf->IsSharedArrayBuffer() \|\|
550			buf->IsArrayBuffer());
551
552	✓✓	17554	if (buf->IsArrayBufferView()) {
553		17258	Read(buf.As<v8::ArrayBufferView>());
554	✓✓	296	} else if (buf->IsArrayBuffer()) {
555		293	auto ab = buf.As<v8::ArrayBuffer>();
556		293	length_ = ab->ByteLength();
557		293	data_ = static_cast<T*>(ab->Data());
558			} else {
559	✗✓	3	CHECK(buf->IsSharedArrayBuffer());
560		3	auto sab = buf.As<v8::SharedArrayBuffer>();
561		3	length_ = sab->ByteLength();
562		3	data_ = static_cast<T*>(sab->Data());
563			}
564		17554	}
565
566			// ECMA262 20.1.2.5
567		766208	inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
568	✓✓	766208	if (!v->IsNumber()) return false;
569		533634	double v_d = v.As<v8::Number>()->Value();
570	✗✓	533634	if (std::isnan(v_d)) return false;
571	✗✓	533634	if (std::isinf(v_d)) return false;
572	✗✓	533634	if (std::trunc(v_d) != v_d) return false; // not int
573	✓✗	533634	if (std::abs(v_d) <= static_cast<double>(kMaxSafeJsInteger)) return true;
574			return false;
575			}
576
577			constexpr size_t FastStringKey::HashImpl(const char* str) {
578			// Low-quality hash (djb2), but just fine for current use cases.
579			size_t h = 5381;
580			while (*str != '\0') {
581			h = h * 33 + *(str++); // NOLINT(readability/pointer_notation)
582			}
583			return h;
584			}
585
586		1064615	constexpr size_t FastStringKey::Hash::operator()(
587			const FastStringKey& key) const {
588		1064615	return key.cached_hash_;
589			}
590
591		1037691	constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
592		1037691	const char* p1 = name_;
593		1037691	const char* p2 = other.name_;
594	✓✗	1037691	if (p1 == p2) return true;
595			do {
596			if ((p1++) != (p2++)) return false;
597			} while (*p1 != '\0');
598			return *p2 == '\0';
599			}
600
601			constexpr FastStringKey::FastStringKey(const char* name)
602			: name_(name), cached_hash_(HashImpl(name)) {}
603
604		22580	constexpr const char* FastStringKey::c_str() const {
605		22580	return name_;
606			}
607
608			} // namespace node
609
610			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
611
612			#endif // SRC_UTIL_INL_H_