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-09-06 22:14:11 Branches: 114 186 61.3 %

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
132194
ListNode<T>::ListNode() : prev_(this), next_(this) {}
70
71
template <typename T>
72
130791
ListNode<T>::~ListNode() {
73
130791
  Remove();
74
130794
}
75
76
template <typename T>
77
183289
void ListNode<T>::Remove() {
78
183289
  prev_->next_ = next_;
79
183289
  next_->prev_ = prev_;
80
183289
  prev_ = this;
81
183289
  next_ = this;
82
183289
}
83
84
template <typename T>
85
27269
bool ListNode<T>::IsEmpty() const {
86
27269
  return prev_ == this;
87
}
88
89
template <typename T, ListNode<T> (T::*M)>
90
35095
ListHead<T, M>::Iterator::Iterator(ListNode<T>* node) : node_(node) {}
91
92
template <typename T, ListNode<T> (T::*M)>
93
2475
T* ListHead<T, M>::Iterator::operator*() const {
94
2475
  return ContainerOf(M, node_);
95
}
96
97
template <typename T, ListNode<T> (T::*M)>
98
const typename ListHead<T, M>::Iterator&
99
2478
ListHead<T, M>::Iterator::operator++() {
100
2478
  node_ = node_->next_;
101
2478
  return *this;
102
}
103
104
template <typename T, ListNode<T> (T::*M)>
105
20026
bool ListHead<T, M>::Iterator::operator!=(const Iterator& that) const {
106
20026
  return node_ != that.node_;
107
}
108
109
template <typename T, ListNode<T> (T::*M)>
110
8777
ListHead<T, M>::~ListHead() {
111

8777
  while (IsEmpty() == false)
112
    head_.next_->Remove();
113
8775
}
114
115
template <typename T, ListNode<T> (T::*M)>
116
124087
void ListHead<T, M>::PushBack(T* element) {
117
124087
  ListNode<T>* that = &(element->*M);
118
124087
  head_.prev_->next_ = that;
119
124087
  that->prev_ = head_.prev_;
120
124087
  that->next_ = &head_;
121
124087
  head_.prev_ = that;
122
124087
}
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
27263
bool ListHead<T, M>::IsEmpty() const {
135
27263
  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
17546
typename ListHead<T, M>::Iterator ListHead<T, M>::begin() const {
149
17546
  return Iterator(head_.next_);
150
}
151
152
template <typename T, ListNode<T> (T::*M)>
153
17548
typename ListHead<T, M>::Iterator ListHead<T, M>::end() const {
154
17548
  return Iterator(const_cast<ListNode<T>*>(&head_));
155
}
156
157
template <typename Inner, typename Outer>
158
2157900
constexpr uintptr_t OffsetOf(Inner Outer::*field) {
159
2157900
  return reinterpret_cast<uintptr_t>(&(static_cast<Outer*>(nullptr)->*field));
160
}
161
162
template <typename Inner, typename Outer>
163
2108653
ContainerOfHelper<Inner, Outer>::ContainerOfHelper(Inner Outer::*field,
164
                                                   Inner* pointer)
165
    : pointer_(
166
        reinterpret_cast<Outer*>(
167
2108653
            reinterpret_cast<uintptr_t>(pointer) - OffsetOf(field))) {}
168
169
template <typename Inner, typename Outer>
170
template <typename TypeName>
171
2108832
ContainerOfHelper<Inner, Outer>::operator TypeName*() const {
172
2108832
  return static_cast<TypeName*>(pointer_);
173
}
174
175
template <typename Inner, typename Outer>
176
2108704
constexpr ContainerOfHelper<Inner, Outer> ContainerOf(Inner Outer::*field,
177
                                                      Inner* pointer) {
178
2108704
  return ContainerOfHelper<Inner, Outer>(field, pointer);
179
}
180
181
3412668
inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
182
                                           const char* data,
183
                                           int length) {
184
6825393
  return v8::String::NewFromOneByte(isolate,
185
                                    reinterpret_cast<const uint8_t*>(data),
186
                                    v8::NewStringType::kNormal,
187
3412725
                                    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
97
inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
200
                                           const unsigned char* data,
201
                                           int length) {
202
194
  return v8::String::NewFromOneByte(
203
             isolate, data, v8::NewStringType::kNormal, length)
204
97
      .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
45952
char ToLower(char c) {
277

45952
  return c >= 'A' && c <= 'Z' ? c + ('a' - 'A') : c;
278
}
279
280
3336
std::string ToLower(const std::string& in) {
281
3336
  std::string out(in.size(), 0);
282
42279
  for (size_t i = 0; i < in.size(); ++i)
283
38943
    out[i] = ToLower(in[i]);
284
3336
  return out;
285
}
286
287
12730
char ToUpper(char c) {
288

12730
  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
1179
bool StringEqualNoCase(const char* a, const char* b) {
299
2177
  while (ToLower(*a) == ToLower(*b++)) {
300
1092
    if (*a++ == '\0')
301
94
      return true;
302
  }
303
87
  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
2486491
inline T MultiplyWithOverflowCheck(T a, T b) {
318
2486491
  auto ret = a * b;
319
2486491
  if (a != 0)
320
2486490
    CHECK_EQ(b, ret / a);
321
322
2486491
  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
2078196
T* UncheckedRealloc(T* pointer, size_t n) {
334
2078196
  size_t full_size = MultiplyWithOverflowCheck(sizeof(T), n);
335
336


2078196
  if (full_size == 0) {
337
102876
    free(pointer);
338
102876
    return nullptr;
339
  }
340
341
1975320
  void* allocated = realloc(pointer, full_size);
342
343


1975320
  if (UNLIKELY(allocated == nullptr)) {
344
    // Tell V8 that memory is low and retry.
345
    LowMemoryNotification();
346
    allocated = realloc(pointer, full_size);
347
  }
348
349
1975320
  return static_cast<T*>(allocated);
350
}
351
352
// As per spec realloc behaves like malloc if passed nullptr.
353
template <typename T>
354
1193666
inline T* UncheckedMalloc(size_t n) {
355


1193666
  if (n == 0) n = 1;
356
1193666
  return UncheckedRealloc<T>(nullptr, n);
357
}
358
359
template <typename T>
360
28778
inline T* UncheckedCalloc(size_t n) {
361
28778
  if (n == 0) n = 1;
362
28778
  MultiplyWithOverflowCheck(sizeof(T), n);
363
28778
  return static_cast<T*>(calloc(n, sizeof(T)));
364
}
365
366
template <typename T>
367
362848
inline T* Realloc(T* pointer, size_t n) {
368
362848
  T* ret = UncheckedRealloc(pointer, n);
369




362848
  CHECK_IMPLIES(n > 0, ret != nullptr);
370
362848
  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
53
inline T* Calloc(size_t n) {
382
53
  T* ret = UncheckedCalloc<T>(n);
383

53
  CHECK_IMPLIES(n > 0, ret != nullptr);
384
53
  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
1193603
inline char* UncheckedMalloc(size_t n) { return UncheckedMalloc<char>(n); }
391
28723
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
2595617
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
398
                                    const std::string& str,
399
                                    v8::Isolate* isolate) {
400
3869038
  if (isolate == nullptr) isolate = context->GetIsolate();
401
2595617
  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
5191236
  return v8::String::NewFromUtf8(
409
2595618
             isolate, str.data(), v8::NewStringType::kNormal, str.size())
410
5191236
      .FromMaybe(v8::Local<v8::String>());
411
}
412
413
template <typename T>
414
242693
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
415
                                    const std::vector<T>& vec,
416
                                    v8::Isolate* isolate) {
417
388846
  if (isolate == nullptr) isolate = context->GetIsolate();
418
242694
  v8::EscapableHandleScope handle_scope(isolate);
419
420
485388
  MaybeStackBuffer<v8::Local<v8::Value>, 128> arr(vec.size());
421
242693
  arr.SetLength(vec.size());
422
1468354
  for (size_t i = 0; i < vec.size(); ++i) {
423
2451320
    if (!ToV8Value(context, vec[i], isolate).ToLocal(&arr[i]))
424
      return v8::MaybeLocal<v8::Value>();
425
  }
426
427
485388
  return handle_scope.Escape(v8::Array::New(isolate, arr.out(), arr.length()));
428
}
429
430
template <typename T, typename U>
431
4827
v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
432
                                    const std::unordered_map<T, U>& map,
433
                                    v8::Isolate* isolate) {
434
9654
  if (isolate == nullptr) isolate = context->GetIsolate();
435
4827
  v8::EscapableHandleScope handle_scope(isolate);
436
437
4827
  v8::Local<v8::Map> ret = v8::Map::New(isolate);
438
101367
  for (const auto& item : map) {
439
    v8::Local<v8::Value> first, second;
440

482700
    if (!ToV8Value(context, item.first, isolate).ToLocal(&first) ||
441

386160
        !ToV8Value(context, item.second, isolate).ToLocal(&second) ||
442
289620
        ret->Set(context, first, second).IsEmpty()) {
443
      return v8::MaybeLocal<v8::Value>();
444
    }
445
  }
446
447
4827
  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
40547
SlicedArguments::SlicedArguments(
477
40547
    const v8::FunctionCallbackInfo<v8::Value>& args, size_t start) {
478
40547
  const size_t length = static_cast<size_t>(args.Length());
479
40547
  if (start >= length) return;
480
40521
  const size_t size = length - start;
481
482
40521
  AllocateSufficientStorage(size);
483
92416
  for (size_t i = 0; i < size; ++i)
484
103790
    (*this)[i] = args[i + start];
485
}
486
487
template <typename T, size_t S>
488
26046
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
489
26046
    v8::Local<v8::Value> value) {
490

26046
  CHECK(value->IsArrayBufferView());
491
26046
  Read(value.As<v8::ArrayBufferView>());
492
26046
}
493
494
template <typename T, size_t S>
495
448224
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
496
448224
    v8::Local<v8::Object> value) {
497
448224
  CHECK(value->IsArrayBufferView());
498
448224
  Read(value.As<v8::ArrayBufferView>());
499
448224
}
500
501
template <typename T, size_t S>
502
124648
ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
503
124648
    v8::Local<v8::ArrayBufferView> abv) {
504
124648
  Read(abv);
505
124648
}
506
507
template <typename T, size_t S>
508
600104
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
600104
  length_ = abv->ByteLength();
511



1137855
  if (length_ > sizeof(stack_storage_) || abv->HasBuffer()) {
512
1775628
    data_ = static_cast<T*>(abv->Buffer()->GetBackingStore()->Data()) +
513
591876
        abv->ByteOffset();
514
  } else {
515
16456
    abv->CopyContents(stack_storage_, sizeof(stack_storage_));
516
8228
    data_ = stack_storage_;
517
  }
518
600104
}
519
520
// ECMA262 20.1.2.5
521
218388
inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
522
218388
  if (!v->IsNumber()) return false;
523
324302
  double v_d = v.As<v8::Number>()->Value();
524

162151
  if (std::isnan(v_d)) return false;
525
162151
  if (std::isinf(v_d)) return false;
526
162151
  if (std::trunc(v_d) != v_d) return false;  // not int
527
162151
  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
548251
constexpr size_t FastStringKey::Hash::operator()(
541
    const FastStringKey& key) const {
542
548251
  return key.cached_hash_;
543
}
544
545
541933
constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
546
541933
  const char* p1 = name_;
547
541933
  const char* p2 = other.name_;
548
541933
  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_