File: jsutil.h

package info (click to toggle)
thunderbird 1:60.8.0-1~deb9u1
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 2,339,208 kB
  • sloc: cpp: 5,456,704; ansic: 2,360,384; python: 596,095; asm: 340,963; java: 326,291; xml: 258,664; sh: 84,366; makefile: 23,702; perl: 17,317; objc: 3,768; yacc: 1,766; ada: 1,681; lex: 1,364; pascal: 1,264; cs: 879; exp: 527; php: 436; lisp: 258; ruby: 153; awk: 152; sed: 53; csh: 27
file content (387 lines) | stat: -rw-r--r-- 12,644 bytes parent folder | download | duplicates (8)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=8 sts=4 et sw=4 tw=99:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 * PR assertion checker.
 */

#ifndef jsutil_h
#define jsutil_h

#include "mozilla/Assertions.h"
#include "mozilla/Compiler.h"
#include "mozilla/GuardObjects.h"
#include "mozilla/HashFunctions.h"
#include "mozilla/MathAlgorithms.h"
#include "mozilla/PodOperations.h"

#include <limits.h>

#include "js/Initialization.h"
#include "js/Utility.h"
#include "js/Value.h"

#define JS_ALWAYS_TRUE(expr) MOZ_ALWAYS_TRUE(expr)
#define JS_ALWAYS_FALSE(expr) MOZ_ALWAYS_FALSE(expr)

#if defined(JS_DEBUG)
#define JS_DIAGNOSTICS_ASSERT(expr) MOZ_ASSERT(expr)
#elif defined(JS_CRASH_DIAGNOSTICS)
#define JS_DIAGNOSTICS_ASSERT(expr)         \
  do {                                      \
    if (MOZ_UNLIKELY(!(expr))) MOZ_CRASH(); \
  } while (0)
#else
#define JS_DIAGNOSTICS_ASSERT(expr) ((void)0)
#endif

static MOZ_ALWAYS_INLINE void* js_memcpy(void* dst_, const void* src_,
                                         size_t len) {
  char* dst = (char*)dst_;
  const char* src = (const char*)src_;
  MOZ_ASSERT_IF(dst >= src, (size_t)(dst - src) >= len);
  MOZ_ASSERT_IF(src >= dst, (size_t)(src - dst) >= len);

  return memcpy(dst, src, len);
}

namespace js {

// An internal version of JS_IsInitialized() that returns whether SpiderMonkey
// is currently initialized or is in the process of being initialized.
inline bool IsInitialized() {
  using namespace JS::detail;
  return libraryInitState == InitState::Initializing ||
         libraryInitState == InitState::Running;
}

template <class T>
static inline void Reverse(T* beg, T* end) {
  while (beg != end) {
    if (--end == beg) return;
    T tmp = *beg;
    *beg = *end;
    *end = tmp;
    ++beg;
  }
}

template <class T, class Pred>
static inline T* RemoveIf(T* begin, T* end, Pred pred) {
  T* result = begin;
  for (T* p = begin; p != end; p++) {
    if (!pred(*p)) *result++ = *p;
  }
  return result;
}

template <class Container, class Pred>
static inline size_t EraseIf(Container& c, Pred pred) {
  auto newEnd = RemoveIf(c.begin(), c.end(), pred);
  size_t removed = c.end() - newEnd;
  c.shrinkBy(removed);
  return removed;
}

template <class T>
static inline T* Find(T* beg, T* end, const T& v) {
  for (T* p = beg; p != end; ++p) {
    if (*p == v) return p;
  }
  return end;
}

template <class Container>
static inline typename Container::ElementType* Find(
    Container& c, const typename Container::ElementType& v) {
  return Find(c.begin(), c.end(), v);
}

template <typename InputIterT, typename CallableT>
void ForEach(InputIterT begin, InputIterT end, CallableT f) {
  for (; begin != end; ++begin) f(*begin);
}

template <class Container1, class Container2>
static inline bool EqualContainers(const Container1& lhs,
                                   const Container2& rhs) {
  if (lhs.length() != rhs.length()) return false;
  for (size_t i = 0, n = lhs.length(); i < n; i++) {
    if (lhs[i] != rhs[i]) return false;
  }
  return true;
}

template <class Container>
static inline HashNumber AddContainerToHash(const Container& c,
                                            HashNumber hn = 0) {
  for (size_t i = 0; i < c.length(); i++)
    hn = mozilla::AddToHash(hn, HashNumber(c[i]));
  return hn;
}

template <class T>
static inline T Min(T t1, T t2) {
  return t1 < t2 ? t1 : t2;
}

template <class T>
static inline T Max(T t1, T t2) {
  return t1 > t2 ? t1 : t2;
}

template <typename T>
class MOZ_RAII AutoScopedAssign {
 public:
  AutoScopedAssign(T* addr, const T& value MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
      : addr_(addr), old(*addr_) {
    MOZ_GUARD_OBJECT_NOTIFIER_INIT;
    *addr_ = value;
  }

  ~AutoScopedAssign() { *addr_ = old; }

 private:
  MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
  T* addr_;
  T old;
};

template <typename T, typename U>
static inline U ComputeByteAlignment(T bytes, U alignment) {
  static_assert(mozilla::IsUnsigned<U>::value,
                "alignment amount must be unsigned");

  MOZ_ASSERT(mozilla::IsPowerOfTwo(alignment));
  return (alignment - (bytes % alignment)) % alignment;
}

template <typename T, typename U>
static inline T AlignBytes(T bytes, U alignment) {
  static_assert(mozilla::IsUnsigned<U>::value,
                "alignment amount must be unsigned");

  return bytes + ComputeByteAlignment(bytes, alignment);
}

/*****************************************************************************/

/* A bit array is an array of bits represented by an array of words (size_t). */

static const size_t BitArrayElementBits = sizeof(size_t) * CHAR_BIT;

static inline unsigned NumWordsForBitArrayOfLength(size_t length) {
  return (length + (BitArrayElementBits - 1)) / BitArrayElementBits;
}

static inline unsigned BitArrayIndexToWordIndex(size_t length,
                                                size_t bitIndex) {
  unsigned wordIndex = bitIndex / BitArrayElementBits;
  MOZ_ASSERT(wordIndex < length);
  return wordIndex;
}

static inline size_t BitArrayIndexToWordMask(size_t i) {
  return size_t(1) << (i % BitArrayElementBits);
}

static inline bool IsBitArrayElementSet(const size_t* array, size_t length,
                                        size_t i) {
  return array[BitArrayIndexToWordIndex(length, i)] &
         BitArrayIndexToWordMask(i);
}

static inline bool IsAnyBitArrayElementSet(const size_t* array, size_t length) {
  unsigned numWords = NumWordsForBitArrayOfLength(length);
  for (unsigned i = 0; i < numWords; ++i) {
    if (array[i]) return true;
  }
  return false;
}

static inline void SetBitArrayElement(size_t* array, size_t length, size_t i) {
  array[BitArrayIndexToWordIndex(length, i)] |= BitArrayIndexToWordMask(i);
}

static inline void ClearBitArrayElement(size_t* array, size_t length,
                                        size_t i) {
  array[BitArrayIndexToWordIndex(length, i)] &= ~BitArrayIndexToWordMask(i);
}

static inline void ClearAllBitArrayElements(size_t* array, size_t length) {
  for (unsigned i = 0; i < length; ++i) array[i] = 0;
}

} /* namespace js */

namespace mozilla {

/**
 * Set the first |aNElem| T elements in |aDst| to |aSrc|.
 */
template <typename T>
static MOZ_ALWAYS_INLINE void PodSet(T* aDst, const T& aSrc, size_t aNElem) {
  for (const T* dstend = aDst + aNElem; aDst < dstend; ++aDst) *aDst = aSrc;
}

} /* namespace mozilla */

/*
 * Patterns used by SpiderMonkey to overwrite unused memory. If you are
 * accessing an object with one of these pattern, you probably have a dangling
 * pointer. These values should be odd, see the comment in IsThingPoisoned.
 *
 * Note: new patterns should also be added to the array in IsThingPoisoned!
 */
#define JS_FRESH_NURSERY_PATTERN 0x2F
#define JS_SWEPT_NURSERY_PATTERN 0x2B
#define JS_ALLOCATED_NURSERY_PATTERN 0x2D
#define JS_FRESH_TENURED_PATTERN 0x4F
#define JS_MOVED_TENURED_PATTERN 0x49
#define JS_SWEPT_TENURED_PATTERN 0x4B
#define JS_ALLOCATED_TENURED_PATTERN 0x4D
#define JS_FREED_HEAP_PTR_PATTERN 0x6B

/*
 * Ensure JS_SWEPT_CODE_PATTERN is a byte pattern that will crash immediately
 * when executed, so either an undefined instruction or an instruction that's
 * illegal in user mode.
 */
#if defined(JS_CODEGEN_X86) || defined(JS_CODEGEN_X64) || \
    defined(JS_CODEGEN_NONE)
#define JS_SWEPT_CODE_PATTERN 0xED  // IN instruction, crashes in user mode.
#elif defined(JS_CODEGEN_ARM) || defined(JS_CODEGEN_ARM64)
#define JS_SWEPT_CODE_PATTERN 0xA3  // undefined instruction
#elif defined(JS_CODEGEN_MIPS32) || defined(JS_CODEGEN_MIPS64)
#define JS_SWEPT_CODE_PATTERN 0x01  // undefined instruction
#else
#error "JS_SWEPT_CODE_PATTERN not defined for this platform"
#endif

static inline void* Poison(void* ptr, uint8_t value, size_t num) {
  static bool disablePoison = bool(getenv("JSGC_DISABLE_POISONING"));
  if (disablePoison) return ptr;

    // Without a valid Value tag, a poisoned Value may look like a valid
    // floating point number. To ensure that we crash more readily when
    // observing a poisoned Value, we make the poison an invalid ObjectValue.
    // Unfortunately, this adds about 2% more overhead, so we can only enable
    // it in debug.
#if defined(DEBUG)
  uintptr_t poison;
  memset(&poison, value, sizeof(poison));
#if defined(JS_PUNBOX64)
  poison = poison & ((uintptr_t(1) << JSVAL_TAG_SHIFT) - 1);
#endif
  JS::Value v = js::PoisonedObjectValue(poison);

  size_t value_count = num / sizeof(v);
  size_t byte_count = num % sizeof(v);
  mozilla::PodSet(reinterpret_cast<JS::Value*>(ptr), v, value_count);
  if (byte_count) {
    uint8_t* bytes = static_cast<uint8_t*>(ptr);
    uint8_t* end = bytes + num;
    mozilla::PodSet(end - byte_count, value, byte_count);
  }
#else   // !DEBUG
  memset(ptr, value, num);
#endif  // !DEBUG
  return ptr;
}

/* Crash diagnostics by default in debug and on nightly channel. */
#if (defined(DEBUG) || defined(NIGHTLY_BUILD)) && !defined(MOZ_ASAN)
#define JS_CRASH_DIAGNOSTICS 1
#endif

/* Enable poisoning in crash-diagnostics and zeal builds. */
#if defined(JS_CRASH_DIAGNOSTICS) || defined(JS_GC_ZEAL)
#define JS_POISON(p, val, size) Poison(p, val, size)
#define JS_GC_POISONING 1
#else
#define JS_POISON(p, val, size) ((void)0)
#endif

/* Enable even more poisoning in purely debug builds. */
#if defined(DEBUG)
#define JS_EXTRA_POISON(p, val, size) Poison(p, val, size)
#else
#define JS_EXTRA_POISON(p, val, size) ((void)0)
#endif

/* Basic stats */
#ifdef DEBUG
#define JS_BASIC_STATS 1
#endif
#ifdef JS_BASIC_STATS
#include <stdio.h>
typedef struct JSBasicStats {
  uint32_t num;
  uint32_t max;
  double sum;
  double sqsum;
  uint32_t logscale; /* logarithmic scale: 0 (linear), 2, 10 */
  uint32_t hist[11];
} JSBasicStats;
#define JS_INIT_STATIC_BASIC_STATS                     \
  {                                                    \
    0, 0, 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } \
  }
#define JS_BASIC_STATS_INIT(bs) memset((bs), 0, sizeof(JSBasicStats))
#define JS_BASIC_STATS_ACCUM(bs, val) JS_BasicStatsAccum(bs, val)
#define JS_MeanAndStdDevBS(bs, sigma) \
  JS_MeanAndStdDev((bs)->num, (bs)->sum, (bs)->sqsum, sigma)
extern void JS_BasicStatsAccum(JSBasicStats* bs, uint32_t val);
extern double JS_MeanAndStdDev(uint32_t num, double sum, double sqsum,
                               double* sigma);
extern void JS_DumpBasicStats(JSBasicStats* bs, const char* title, FILE* fp);
extern void JS_DumpHistogram(JSBasicStats* bs, FILE* fp);
#else
#define JS_BASIC_STATS_ACCUM(bs, val)
#endif

/* A jsbitmap_t is a long integer that can be used for bitmaps. */
typedef size_t jsbitmap;
#define JS_BITMAP_NBITS (sizeof(jsbitmap) * CHAR_BIT)
#define JS_TEST_BIT(_map, _bit)       \
  ((_map)[(_bit) / JS_BITMAP_NBITS] & \
   (jsbitmap(1) << ((_bit) % JS_BITMAP_NBITS)))
#define JS_SET_BIT(_map, _bit)         \
  ((_map)[(_bit) / JS_BITMAP_NBITS] |= \
   (jsbitmap(1) << ((_bit) % JS_BITMAP_NBITS)))
#define JS_CLEAR_BIT(_map, _bit)       \
  ((_map)[(_bit) / JS_BITMAP_NBITS] &= \
   ~(jsbitmap(1) << ((_bit) % JS_BITMAP_NBITS)))

/* Wrapper for various macros to stop warnings coming from their expansions. */
#if defined(__clang__)
#define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr)                                \
  JS_BEGIN_MACRO                                                             \
    _Pragma("clang diagnostic push") /* If these _Pragmas cause warnings for \
                                        you, try disabling ccache. */        \
        _Pragma("clang diagnostic ignored \"-Wunused-value\"") {             \
      expr;                                                                  \
    }                                                                        \
    _Pragma("clang diagnostic pop")                                          \
  JS_END_MACRO
#elif MOZ_IS_GCC

#define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr)                                 \
  JS_BEGIN_MACRO                                                              \
    _Pragma("GCC diagnostic push")                                            \
        _Pragma("GCC diagnostic ignored \"-Wunused-but-set-variable\"") expr; \
    _Pragma("GCC diagnostic pop")                                             \
  JS_END_MACRO
#endif

#if !defined(JS_SILENCE_UNUSED_VALUE_IN_EXPR)
#define JS_SILENCE_UNUSED_VALUE_IN_EXPR(expr) \
  JS_BEGIN_MACRO                              \
    expr;                                     \
  JS_END_MACRO
#endif

#endif /* jsutil_h */