GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: util-inl.h Lines: 230 251 91.6 %
Date: 2022-11-10 04:21:28 Branches: 90 133 67.7 %

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
211977
ListNode<T>::ListNode() : prev_(this), next_(this) {}
79
80
template <typename T>
81
207934
ListNode<T>::~ListNode() {
82
207934
  Remove();
83
207934
}
84
85
template <typename T>
86
324436
void ListNode<T>::Remove() {
87
324436
  prev_->next_ = next_;
88
324436
  next_->prev_ = prev_;
89
324436
  prev_ = this;
90
324436
  next_ = this;
91
324436
}
92
93
template <typename T>
94
71073
bool ListNode<T>::IsEmpty() const {
95
71073
  return prev_ == this;
96
}
97
98
template <typename T, ListNode<T> (T::*M)>
99
91076
ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}
100
101
template <typename T, ListNode<T> (T::*M)>
102
9885
T* ListHead<T, M>::Iterator::operator*() const {
103
9885
  return ContainerOf(M, node_);
104
}
105
106
template <typename T, ListNode<T> (T::*M)>
107
const typename ListHead<T, M>::Iterator&
108
9885
ListHead<T, M>::Iterator::operator++() {
109
9885
  node_ = node_->next_;
110
9885
  return *this;
111
}
112
113
template <typename T, ListNode<T> (T::*M)>
114
55421
bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
115
55421
  return node_ != that.node_;
116
}
117
118
template <typename T, ListNode<T> (T::*M)>
119
22761
ListHead<T, M>::~ListHead() {
120
22761
  while (IsEmpty() == false)
121
    head_.next_->Remove();
122
22761
}
123
124
template <typename T, ListNode<T> (T::*M)>
125
137798
void ListHead<T, M>::PushBack(T* element) {
126
137798
  ListNode<T>* that = &(element->*M);
127
137798
  head_.prev_->next_ = that;
128
137798
  that->prev_ = head_.prev_;
129
137798
  that->next_ = &head_;
130
137798
  head_.prev_ = that;
131
137798
}
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
71069
bool ListHead<T, M>::IsEmpty() const {
144
71069
  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
45536
typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
158
45536
  return Iterator(head_.next_);
159
}
160
161
template <typename T, ListNode<T> (T::*M)>
162
45540
typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
163
45540
  return Iterator(const_cast<ListNode<T>*>(&head_));
164
}
165
166
template <typename Inner, typename Outer>
167
2360655
constexpr uintptr_t OffsetOf(Inner Outer::*field) {
168
2360655
  return reinterpret_cast<uintptr_t>(&(static_cast<Outer*>(nullptr)->*field));
169
}
170
171
template <typename Inner, typename Outer>
172
2292747
ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
173
                                                   Inner* pointer)
174
    : pointer_(
175
        reinterpret_cast<Outer*>(
176
2292747
            reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}
177
178
template <typename Inner, typename Outer>
179
template <typename TypeName>
180
2292747
ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
181
2292747
  return static_cast<TypeName*>(pointer_);
182
}
183
184
template <typename Inner, typename Outer>
185
2285259
constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
186
                                                      Inner* pointer) {
187
2285259
  return ContainerOfHelper<Inner, Outer>(field, pointer);
188
}
189
190
4187198
inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
191
                                           const char* data,
192
                                           int length) {
193
4187198
  return v8::String::NewFromOneByte(isolate,
194
                                    reinterpret_cast<const uint8_t*>(data),
195
                                    v8::NewStringType::kNormal,
196
4187198
                                    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
13362
char ToUpper(char c) {
297
13362
  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
463535
inline T MultiplyWithOverflowCheck(T a, T b) {
327
463535
  auto ret = a * b;
328
463535
  if (a != 0)
329
463533
    CHECK_EQ(b, ret / a);
330
331
463535
  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
770629
T* UncheckedRealloc(T* pointer, size_t n) {
343
770629
  size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);
344
345
770629
  if (full_size == 0) {
346
211222
    free(pointer);
347
211222
    return nullptr;
348
  }
349
350
559407
  void* allocated = realloc(pointer, full_size);
351
352
559407
  if (UNLIKELY(allocated == nullptr)) {
353
    // Tell V8 that memory is low and retry.
354
    LowMemoryNotification();
355
    allocated = realloc(pointer, full_size);
356
  }
357
358
559407
  return static_cast<T*>(allocated);
359
}
360
361
// As per spec realloc behaves like malloc if passed nullptr.
362
template <typename T>
363
42640
inline T* UncheckedMalloc(size_t n) {
364
42640
  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
153542
inline T* Realloc(T* pointer, size_t n) {
375
153542
  T* ret = UncheckedRealloc(pointer, n);
376

153542
  CHECK_IMPLIES(n > 0, ret != nullptr);
377
153542
  return ret;
378
}
379
380
template <typename T>
381
2066
inline T* Malloc(size_t n) {
382
2066
  T* ret = UncheckedMalloc<T>(n);
383

2066
  CHECK_IMPLIES(n > 0, ret != nullptr);
384
2066
  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
20261
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
3541882
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
405
                                    std::string_view str,
406
                                    v8::Isolate* isolate) {
407
5797133
  if (isolate == nullptr) isolate = context->GetIsolate();
408
3541882
  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
3541882
  return v8::String::NewFromUtf8(
416
3541882
             isolate, str.data(), v8::NewStringType::kNormal, str.size())
417
3541882
      .FromMaybe(v8::Local<v8::String>());
418
}
419
420
template <typename T>
421
309309
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
422
                                    const std::vector<T>& vec,
423
                                    v8::Isolate* isolate) {
424
464530
  if (isolate == nullptr) isolate = context->GetIsolate();
425
309309
  v8::EscapableHandleScope handle_scope(isolate);
426
427
618618
  MaybeStackBuffer<v8::Local<v8::Value>, 128> arr(vec.size());
428
309309
  arr.SetLength(vec.size());
429
1441382
  for (size_t i = 0; i < vec.size(); ++i) {
430
2264146
    if (!ToV8Value(context, vec[i], isolate).ToLocal(&arr[i]))
431
      return v8::MaybeLocal<v8::Value>();
432
  }
433
434
618618
  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
476
  for (const T& entry : set) {
446
    v8::Local<v8::Value> value;
447
944
    if (!ToV8Value(context, entry, isolate).ToLocal(&value))
448
      return {};
449
944
    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
7004
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
458
                                    const std::unordered_map<T, U>& map,
459
                                    v8::Isolate* isolate) {
460
14008
  if (isolate == nullptr) isolate = context->GetIsolate();
461
7004
  v8::EscapableHandleScope handle_scope(isolate);
462
463
7004
  v8::Local<v8::Map> ret = v8::Map::New(isolate);
464
161092
  for (const auto& item : map) {
465
    v8::Local<v8::Value> first, second;
466
154088
    if (!ToV8Value(context, item.first, isolate).ToLocal(&first) ||
467

462264
        !ToV8Value(context, item.second, isolate).ToLocal(&second) ||
468

462264
        ret->Set(context, first, second).IsEmpty()) {
469
      return v8::MaybeLocal<v8::Value>();
470
    }
471
  }
472
473
7004
  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
72363
SlicedArguments::SlicedArguments(
503
72363
    const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
504
72363
  const size_t length = static_cast<size_t>(args.Length());
505
72363
  if (start >= length) return;
506
72345
  const size_t size = length - start;
507
508
72345
  AllocateSufficientStorage(size);
509
157283
  for (size_t i = 0; i < size; ++i)
510
169876
    (*this)[i] = args[i + start];
511
}
512
513
template <typename T, size_t S>
514
17569
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
515
17569
    v8::Local<v8::Value> value) {
516
  DCHECK(value->IsArrayBufferView() || value->IsSharedArrayBuffer() ||
517
         value->IsArrayBuffer());
518
17569
  ReadValue(value);
519
17569
}
520
521
template <typename T, size_t S>
522
136750
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
523
136750
    v8::Local<v8::Object> value) {
524
136750
  CHECK(value->IsArrayBufferView());
525
136750
  Read(value.As<v8::ArrayBufferView>());
526
136750
}
527
528
template <typename T, size_t S>
529
26318
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
530
26318
    v8::Local<v8::ArrayBufferView> abv) {
531
26318
  Read(abv);
532
26318
}
533
534
template <typename T, size_t S>
535
180498
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
180498
  length_ = abv->ByteLength();
538

266807
  if (length_ > sizeof(stack_storage_) || abv->HasBuffer()) {
539
538215
    data_ = static_cast<T*>(abv->Buffer()->Data()) + abv->ByteOffset();
540
  } else {
541
1093
    abv->CopyContents(stack_storage_, sizeof(stack_storage_));
542
1093
    data_ = stack_storage_;
543
  }
544
180498
}
545
546
template <typename T, size_t S>
547
17569
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
17569
  if (buf->IsArrayBufferView()) {
553
17294
    Read(buf.As<v8::ArrayBufferView>());
554
275
  } else if (buf->IsArrayBuffer()) {
555
272
    auto ab = buf.As<v8::ArrayBuffer>();
556
272
    length_ = ab->ByteLength();
557
272
    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
17569
}
565
566
// ECMA262 20.1.2.5
567
757540
inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
568
757540
  if (!v->IsNumber()) return false;
569
530171
  double v_d = v.As<v8::Number>()->Value();
570
530171
  if (std::isnan(v_d)) return false;
571
530171
  if (std::isinf(v_d)) return false;
572
530171
  if (std::trunc(v_d) != v_d) return false;  // not int
573
530171
  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
1054538
constexpr size_t FastStringKey::Hash::operator()(
587
    const FastStringKey& key) const {
588
1054538
  return key.cached_hash_;
589
}
590
591
1027821
constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
592
1027821
  const char* p1 = name_;
593
1027821
  const char* p2 = other.name_;
594
1027821
  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
22428
constexpr const char* FastStringKey::c_str() const {
605
22428
  return name_;
606
}
607
608
}  // namespace node
609
610
#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
611
612
#endif  // SRC_UTIL_INL_H_