Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/util-inl.h	Lines:	211	230	91.7 %
Date:	2020-12-12 04:11:07	Branches:	115	190	60.5 %


// 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 "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

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 c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
}

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 c >= 'a' && c <= 'z' ? (c - 'a') + 'A' : c;
}

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) {
  if (n == 0) n = 1;
  return UncheckedRealloc<T>(nullptr, n);
}

template <typename T>
inline T* UncheckedCalloc(size_t n) {
  if (n == 0) n = 1;
  MultiplyWithOverflowCheck(sizeof(T), n);
  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,
                                    const std::string& 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, 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) {
  CHECK(value->IsArrayBufferView());
  Read(value.As<v8::ArrayBufferView>());
}

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()->GetBackingStore()->Data()) +
        abv->ByteOffset();
  } else {
    abv->CopyContents(stack_storage_, sizeof(stack_storage_));
    data_ = stack_storage_;
  }
}

// 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 3.4)

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 "util.h"
30
31			// These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
32			// To avoid warnings, undefine them before redefining them.
33			#ifdef BSWAP_2
34			# undef BSWAP_2
35			#endif
36			#ifdef BSWAP_4
37			# undef BSWAP_4
38			#endif
39			#ifdef BSWAP_8
40			# undef BSWAP_8
41			#endif
42
43			#if defined(_MSC_VER)
44			#include <intrin.h>
45			#define BSWAP_2(x) _byteswap_ushort(x)
46			#define BSWAP_4(x) _byteswap_ulong(x)
47			#define BSWAP_8(x) _byteswap_uint64(x)
48			#else
49			#define BSWAP_2(x) ((x) << 8) \| ((x) >> 8)
50			#define BSWAP_4(x) \
51			(((x) & 0xFF) << 24) \| \
52			(((x) & 0xFF00) << 8) \| \
53			(((x) >> 8) & 0xFF00) \| \
54			(((x) >> 24) & 0xFF)
55			#define BSWAP_8(x) \
56			(((x) & 0xFF00000000000000ull) >> 56) \| \
57			(((x) & 0x00FF000000000000ull) >> 40) \| \
58			(((x) & 0x0000FF0000000000ull) >> 24) \| \
59			(((x) & 0x000000FF00000000ull) >> 8) \| \
60			(((x) & 0x00000000FF000000ull) << 8) \| \
61			(((x) & 0x0000000000FF0000ull) << 24) \| \
62			(((x) & 0x000000000000FF00ull) << 40) \| \
63			(((x) & 0x00000000000000FFull) << 56)
64			#endif
65
66			namespace node {
67
68			template <typename T>
69		134442	ListNode<T>::ListNode() : prev_(this), next_(this) {}
70
71			template <typename T>
72		133101	ListNode<T>::~ListNode() {
73		133101	Remove();
74		133101	}
75
76			template <typename T>
77		186831	void ListNode<T>::Remove() {
78		186831	prev_->next_ = next_;
79		186831	next_->prev_ = prev_;
80		186831	prev_ = this;
81		186831	next_ = this;
82		186831	}
83
84			template <typename T>
85		28418	bool ListNode<T>::IsEmpty() const {
86		28418	return prev_ == this;
87			}
88
89			template <typename T, ListNode<T> (T::*M)>
90		36613	ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}
91
92			template <typename T, ListNode<T> (T::*M)>
93		2446	T* ListHead<T, M>::Iterator::operator*() const {
94		2446	return ContainerOf(M, node_);
95			}
96
97			template <typename T, ListNode<T> (T::*M)>
98			const typename ListHead<T, M>::Iterator&
99		2447	ListHead<T, M>::Iterator::operator++() {
100		2447	node_ = node_->next_;
101		2447	return *this;
102			}
103
104			template <typename T, ListNode<T> (T::*M)>
105		20751	bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
106		20751	return node_ != that.node_;
107			}
108
109			template <typename T, ListNode<T> (T::*M)>
110		9157	ListHead<T, M>::~ListHead() {
111	✗✓✗✓	9157	while (IsEmpty() == false)
112			head_.next_->Remove();
113		9157	}
114
115			template <typename T, ListNode<T> (T::*M)>
116		126043	void ListHead<T, M>::PushBack(T* element) {
117		126043	ListNode<T>* that = &(element->*M);
118		126043	head_.prev_->next_ = that;
119		126043	that->prev_ = head_.prev_;
120		126043	that->next_ = &head_;
121		126043	head_.prev_ = that;
122		126043	}
123
124			template <typename T, ListNode<T> (T::*M)>
125			void ListHead<T, M>::PushFront(T* element) {
126			ListNode<T>* that = &(element->*M);
127			head_.next_->prev_ = that;
128			that->prev_ = &head_;
129			that->next_ = head_.next_;
130			head_.next_ = that;
131			}
132
133			template <typename T, ListNode<T> (T::*M)>
134		28414	bool ListHead<T, M>::IsEmpty() const {
135		28414	return head_.IsEmpty();
136			}
137
138			template <typename T, ListNode<T> (T::*M)>
139		2	T* ListHead<T, M>::PopFront() {
140	✗✓	2	if (IsEmpty())
141			return nullptr;
142		2	ListNode<T>* node = head_.next_;
143		2	node->Remove();
144		2	return ContainerOf(M, node);
145			}
146
147			template <typename T, ListNode<T> (T::*M)>
148		18304	typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
149		18304	return Iterator(head_.next_);
150			}
151
152			template <typename T, ListNode<T> (T::*M)>
153		18309	typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
154		18309	return Iterator(const_cast<ListNode<T>*>(&head_));
155			}
156
157			template <typename Inner, typename Outer>
158		2697076	constexpr uintptr_t OffsetOf(Inner Outer::*field) {
159		2697076	return reinterpret_cast<uintptr_t>(&(static_cast<Outer>(nullptr)->field));
160			}
161
162			template <typename Inner, typename Outer>
163		2645638	ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
164			Inner* pointer)
165			: pointer_(
166			reinterpret_cast<Outer*>(
167		2645638	reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}
168
169			template <typename Inner, typename Outer>
170			template <typename TypeName>
171		2645762	ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
172		2645762	return static_cast<TypeName*>(pointer_);
173			}
174
175			template <typename Inner, typename Outer>
176		2645759	constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
177			Inner* pointer) {
178		2645759	return ContainerOfHelper<Inner, Outer>(field, pointer);
179			}
180
181		3276271	inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
182			const char* data,
183			int length) {
184		6552643	return v8::String::NewFromOneByte(isolate,
185			reinterpret_cast<const uint8_t*>(data),
186			v8::NewStringType::kNormal,
187		3276372	length).ToLocalChecked();
188			}
189
190			inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
191			const signed char* data,
192			int length) {
193			return v8::String::NewFromOneByte(isolate,
194			reinterpret_cast<const uint8_t*>(data),
195			v8::NewStringType::kNormal,
196			length).ToLocalChecked();
197			}
198
199		111	inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
200			const unsigned char* data,
201			int length) {
202		222	return v8::String::NewFromOneByte(
203			isolate, data, v8::NewStringType::kNormal, length)
204		111	.ToLocalChecked();
205			}
206
207		2	void SwapBytes16(char* data, size_t nbytes) {
208	✗✓	2	CHECK_EQ(nbytes % 2, 0);
209
210			#if defined(_MSC_VER)
211			if (AlignUp(data, sizeof(uint16_t)) == data) {
212			// MSVC has no strict aliasing, and is able to highly optimize this case.
213			uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
214			size_t len16 = nbytes / sizeof(*data16);
215			for (size_t i = 0; i < len16; i++) {
216			data16[i] = BSWAP_2(data16[i]);
217			}
218			return;
219			}
220			#endif
221
222			uint16_t temp;
223	✓✓	1537	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
224		1535	memcpy(&temp, &data[i], sizeof(temp));
225		1535	temp = BSWAP_2(temp);
226		1535	memcpy(&data[i], &temp, sizeof(temp));
227			}
228		2	}
229
230		2	void SwapBytes32(char* data, size_t nbytes) {
231	✗✓	2	CHECK_EQ(nbytes % 4, 0);
232
233			#if defined(_MSC_VER)
234			// MSVC has no strict aliasing, and is able to highly optimize this case.
235			if (AlignUp(data, sizeof(uint32_t)) == data) {
236			uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
237			size_t len32 = nbytes / sizeof(*data32);
238			for (size_t i = 0; i < len32; i++) {
239			data32[i] = BSWAP_4(data32[i]);
240			}
241			return;
242			}
243			#endif
244
245			uint32_t temp;
246	✓✓	769	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
247		767	memcpy(&temp, &data[i], sizeof(temp));
248		767	temp = BSWAP_4(temp);
249		767	memcpy(&data[i], &temp, sizeof(temp));
250			}
251		2	}
252
253		2	void SwapBytes64(char* data, size_t nbytes) {
254	✗✓	2	CHECK_EQ(nbytes % 8, 0);
255
256			#if defined(_MSC_VER)
257			if (AlignUp(data, sizeof(uint64_t)) == data) {
258			// MSVC has no strict aliasing, and is able to highly optimize this case.
259			uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
260			size_t len64 = nbytes / sizeof(*data64);
261			for (size_t i = 0; i < len64; i++) {
262			data64[i] = BSWAP_8(data64[i]);
263			}
264			return;
265			}
266			#endif
267
268			uint64_t temp;
269	✓✓	513	for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
270		511	memcpy(&temp, &data[i], sizeof(temp));
271		511	temp = BSWAP_8(temp);
272		511	memcpy(&data[i], &temp, sizeof(temp));
273			}
274		2	}
275
276		57490	char ToLower(char c) {
277	✓✓✓✓	57490	return c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
278			}
279
280		4257	std::string ToLower(const std::string& in) {
281		4257	std::string out(in.size(), 0);
282	✓✓	54680	for (size_t i = 0; i < in.size(); ++i)
283		50423	out[i] = ToLower(in[i]);
284		4257	return out;
285			}
286
287		12746	char ToUpper(char c) {
288	✓✓✓✗	12746	return c >= 'a' && c <= 'z' ? (c - 'a') + 'A' : c;
289			}
290
291		2	std::string ToUpper(const std::string& in) {
292		2	std::string out(in.size(), 0);
293	✓✓	5	for (size_t i = 0; i < in.size(); ++i)
294		3	out[i] = ToUpper(in[i]);
295		2	return out;
296			}
297
298		1208	bool StringEqualNoCase(const char* a, const char* b) {
299	✓✓	2230	while (ToLower(a) == ToLower(b++)) {
300	✓✓	1117	if (*a++ == '\0')
301		95	return true;
302			}
303		91	return false;
304			}
305
306		609	bool StringEqualNoCaseN(const char* a, const char* b, size_t length) {
307	✓✓	2505	for (size_t i = 0; i < length; i++) {
308	✓✓	2324	if (ToLower(a[i]) != ToLower(b[i]))
309		427	return false;
310	✓✓	1897	if (a[i] == '\0')
311		1	return true;
312			}
313		181	return true;
314			}
315
316			template <typename T>
317		1203194	inline T MultiplyWithOverflowCheck(T a, T b) {
318		1203194	auto ret = a * b;
319	✓✓	1203194	if (a != 0)
320	✗✓	1203192	CHECK_EQ(b, ret / a);
321
322		1203194	return ret;
323			}
324
325			// These should be used in our code as opposed to the native
326			// versions as they abstract out some platform and or
327			// compiler version specific functionality.
328			// malloc(0) and realloc(ptr, 0) have implementation-defined behavior in
329			// that the standard allows them to either return a unique pointer or a
330			// nullptr for zero-sized allocation requests. Normalize by always using
331			// a nullptr.
332			template <typename T>
333		1130236	T* UncheckedRealloc(T* pointer, size_t n) {
334		1130236	size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);
335
336	✓✓✗✓ ✗✓✗✗ ✗✗	1130237	if (full_size == 0) {
337		102882	free(pointer);
338		102882	return nullptr;
339			}
340
341		1027355	void* allocated = realloc(pointer, full_size);
342
343	✗✓✗✓ ✗✓✗✗ ✗✗	1027355	if (UNLIKELY(allocated == nullptr)) {
344			// Tell V8 that memory is low and retry.
345			LowMemoryNotification();
346			allocated = realloc(pointer, full_size);
347			}
348
349		1027355	return static_cast<T*>(allocated);
350			}
351
352			// As per spec realloc behaves like malloc if passed nullptr.
353			template <typename T>
354		503086	inline T* UncheckedMalloc(size_t n) {
355	✓✓✗✓ ✗✓✗✗	503086	if (n == 0) n = 1;
356		503086	return UncheckedRealloc<T>(nullptr, n);
357			}
358
359			template <typename T>
360		32411	inline T* UncheckedCalloc(size_t n) {
361	✓✓	32411	if (n == 0) n = 1;
362		32411	MultiplyWithOverflowCheck(sizeof(T), n);
363		32411	return static_cast<T*>(calloc(n, sizeof(T)));
364			}
365
366			template <typename T>
367		113779	inline T* Realloc(T* pointer, size_t n) {
368		113779	T* ret = UncheckedRealloc(pointer, n);
369	✓✗✗✓ ✓✗✗✓ ✓✗✗✓ ✗✗✗✗	113779	CHECK_IMPLIES(n > 0, ret != nullptr);
370		113779	return ret;
371			}
372
373			template <typename T>
374		35	inline T* Malloc(size_t n) {
375		35	T* ret = UncheckedMalloc<T>(n);
376	✓✓✗✓ ✓✗✗✓ ✓✗✗✓ ✓✓✗✓	35	CHECK_IMPLIES(n > 0, ret != nullptr);
377		35	return ret;
378			}
379
380			template <typename T>
381		54	inline T* Calloc(size_t n) {
382		54	T* ret = UncheckedCalloc<T>(n);
383	✓✓✗✓	54	CHECK_IMPLIES(n > 0, ret != nullptr);
384		54	return ret;
385			}
386
387			// Shortcuts for char*.
388		4	inline char* Malloc(size_t n) { return Malloc<char>(n); }
389		2	inline char* Calloc(size_t n) { return Calloc<char>(n); }
390		503023	inline char* UncheckedMalloc(size_t n) { return UncheckedMalloc<char>(n); }
391		32355	inline char* UncheckedCalloc(size_t n) { return UncheckedCalloc<char>(n); }
392
393			// This is a helper in the .cc file so including util-inl.h doesn't include more
394			// headers than we really need to.
395			void ThrowErrStringTooLong(v8::Isolate* isolate);
396
397		2565681	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
398			const std::string& str,
399			v8::Isolate* isolate) {
400	✓✓	3913817	if (isolate == nullptr) isolate = context->GetIsolate();
401	✗✓	2565682	if (UNLIKELY(str.size() >= static_cast<size_t>(v8::String::kMaxLength))) {
402			// V8 only has a TODO comment about adding an exception when the maximum
403			// string size is exceeded.
404			ThrowErrStringTooLong(isolate);
405			return v8::MaybeLocal<v8::Value>();
406			}
407
408		5131371	return v8::String::NewFromUtf8(
409		2565671	isolate, str.data(), v8::NewStringType::kNormal, str.size())
410		5131408	.FromMaybe(v8::Local<v8::String>());
411			}
412
413			template <typename T>
414		246967	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
415			const std::vector<T>& vec,
416			v8::Isolate* isolate) {
417	✓✓	388577	if (isolate == nullptr) isolate = context->GetIsolate();
418		246967	v8::EscapableHandleScope handle_scope(isolate);
419
420		493935	MaybeStackBuffer<v8::Local<v8::Value>, 128> arr(vec.size());
421		246968	arr.SetLength(vec.size());
422	✓✓	1359212	for (size_t i = 0; i < vec.size(); ++i) {
423	✗✓	2224487	if (!ToV8Value(context, vec[i], isolate).ToLocal(&arr[i]))
424			return v8::MaybeLocal<v8::Value>();
425			}
426
427		493936	return handle_scope.Escape(v8::Array::New(isolate, arr.out(), arr.length()));
428			}
429
430			template <typename T, typename U>
431		5017	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
432			const std::unordered_map<T, U>& map,
433			v8::Isolate* isolate) {
434	✓✗	10034	if (isolate == nullptr) isolate = context->GetIsolate();
435		5017	v8::EscapableHandleScope handle_scope(isolate);
436
437		5017	v8::Local<v8::Map> ret = v8::Map::New(isolate);
438	✓✓	110374	for (const auto& item : map) {
439			v8::Local<v8::Value> first, second;
440	✓✗✗✓	526785	if (!ToV8Value(context, item.first, isolate).ToLocal(&first) \|\|
441	✓✗✗✓	421428	!ToV8Value(context, item.second, isolate).ToLocal(&second) \|\|
442		316071	ret->Set(context, first, second).IsEmpty()) {
443			return v8::MaybeLocal<v8::Value>();
444			}
445			}
446
447		5017	return handle_scope.Escape(ret);
448			}
449
450			template <typename T, typename >
451		2	v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
452			const T& number,
453			v8::Isolate* isolate) {
454	✗✓	2	if (isolate == nullptr) isolate = context->GetIsolate();
455
456			using Limits = std::numeric_limits<T>;
457			// Choose Uint32, Int32, or Double depending on range checks.
458			// These checks should all collapse at compile time.
459	✓✗	4	if (static_cast<uint32_t>(Limits::max()) <=
460	✓✗	4	std::numeric_limits<uint32_t>::max() &&
461		2	static_cast<uint32_t>(Limits::min()) >=
462	✓✗	6	std::numeric_limits<uint32_t>::min() && Limits::is_exact) {
463		4	return v8::Integer::NewFromUnsigned(isolate, static_cast<uint32_t>(number));
464			}
465
466			if (static_cast<int32_t>(Limits::max()) <=
467			std::numeric_limits<int32_t>::max() &&
468			static_cast<int32_t>(Limits::min()) >=
469			std::numeric_limits<int32_t>::min() && Limits::is_exact) {
470			return v8::Integer::New(isolate, static_cast<int32_t>(number));
471			}
472
473			return v8::Number::New(isolate, static_cast<double>(number));
474			}
475
476		17473	SlicedArguments::SlicedArguments(
477		17473	const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
478		17473	const size_t length = static_cast<size_t>(args.Length());
479	✓✓	17473	if (start >= length) return;
480		17449	const size_t size = length - start;
481
482		17449	AllocateSufficientStorage(size);
483	✓✓	46302	for (size_t i = 0; i < size; ++i)
484		57706	(*this)[i] = args[i + start];
485			}
486
487			template <typename T, size_t S>
488		14659	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
489		14659	v8::Local<v8::Value> value) {
490	✗✓✗✗	14659	CHECK(value->IsArrayBufferView());
491		14659	Read(value.As<v8::ArrayBufferView>());
492		14659	}
493
494			template <typename T, size_t S>
495		102377	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
496		102377	v8::Local<v8::Object> value) {
497	✗✓	102377	CHECK(value->IsArrayBufferView());
498		102377	Read(value.As<v8::ArrayBufferView>());
499		102377	}
500
501			template <typename T, size_t S>
502		26587	ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
503		26587	v8::Local<v8::ArrayBufferView> abv) {
504		26587	Read(abv);
505		26587	}
506
507			template <typename T, size_t S>
508		143630	void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
509			static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
510		143630	length_ = abv->ByteLength();
511	✓✓✓✓ ✓✓✓✗ ✓✗✓✗ ✓✓✓✓ ✓✓	220367	if (length_ > sizeof(stack_storage_) \|\| abv->HasBuffer()) {
512		428631	data_ = static_cast<T*>(abv->Buffer()->GetBackingStore()->Data()) +
513		142877	abv->ByteOffset();
514			} else {
515		1506	abv->CopyContents(stack_storage_, sizeof(stack_storage_));
516		753	data_ = stack_storage_;
517			}
518		143630	}
519
520			// ECMA262 20.1.2.5
521		283694	inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
522	✓✓	283694	if (!v->IsNumber()) return false;
523		307672	double v_d = v.As<v8::Number>()->Value();
524	✗✓	153836	if (std::isnan(v_d)) return false;
525	✗✓	153836	if (std::isinf(v_d)) return false;
526	✗✓	153836	if (std::trunc(v_d) != v_d) return false; // not int
527	✓✗	153836	if (std::abs(v_d) <= static_cast<double>(kMaxSafeJsInteger)) return true;
528			return false;
529			}
530
531			constexpr size_t FastStringKey::HashImpl(const char* str) {
532			// Low-quality hash (djb2), but just fine for current use cases.
533			size_t h = 5381;
534			while (*str != '\0') {
535			h = h * 33 + *(str++); // NOLINT(readability/pointer_notation)
536			}
537			return h;
538			}
539
540		676468	constexpr size_t FastStringKey::Hash::operator()(
541			const FastStringKey& key) const {
542		676468	return key.cached_hash_;
543			}
544
545		669836	constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
546		669836	const char* p1 = name_;
547		669836	const char* p2 = other.name_;
548	✓✗	669836	if (p1 == p2) return true;
549			do {
550			if ((p1++) != (p2++)) return false;
551			} while (*p1 != '\0');
552			return *p2 == '\0';
553			}
554
555			constexpr FastStringKey::FastStringKey(const char* name)
556			: name_(name), cached_hash_(HashImpl(name)) {}
557
558			constexpr const char* FastStringKey::c_str() const {
559			return name_;
560			}
561
562			} // namespace node
563
564			#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
565
566			#endif // SRC_UTIL_INL_H_