Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 205 insertions, 0 deletions

diff --git a/js/src/jit/ExecutableAllocator.h b/js/src/jit/ExecutableAllocator.h
new file mode 100644
index 0000000000..85c01562c3
--- /dev/null
+++ b/js/src/jit/ExecutableAllocator.h
@@ -0,0 +1,205 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: set ts=8 sts=2 et sw=2 tw=80:
+ *
+ * Copyright (C) 2008 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef jit_ExecutableAllocator_h
+#define jit_ExecutableAllocator_h
+
+#include "mozilla/EnumeratedArray.h"
+
+#include <limits>
+#include <stddef.h>  // for ptrdiff_t
+
+#include "jit/ProcessExecutableMemory.h"
+#include "js/AllocPolicy.h"
+#include "js/HashTable.h"
+#include "js/TypeDecls.h"
+#include "js/Vector.h"
+
+namespace JS {
+struct CodeSizes;
+}  // namespace JS
+
+namespace js {
+namespace jit {
+
+enum class CodeKind : uint8_t { Ion, Baseline, RegExp, Other, Count };
+
+class ExecutableAllocator;
+
+// These are reference-counted. A new one starts with a count of 1.
+class ExecutablePool {
+  friend class ExecutableAllocator;
+
+ private:
+  struct Allocation {
+    char* pages;
+    size_t size;
+  };
+
+  ExecutableAllocator* m_allocator;
+  char* m_freePtr;
+  char* m_end;
+  Allocation m_allocation;
+
+  // Reference count for automatic reclamation.
+  unsigned m_refCount : 31;
+
+  // Flag that can be used by algorithms operating on pools.
+  bool m_mark : 1;
+
+  // Number of bytes currently allocated for each CodeKind.
+  mozilla::EnumeratedArray<CodeKind, CodeKind::Count, size_t> m_codeBytes;
+
+ public:
+  void release(bool willDestroy = false);
+  void release(size_t n, CodeKind kind);
+
+  void addRef();
+
+  ExecutablePool(ExecutableAllocator* allocator, Allocation a)
+      : m_allocator(allocator),
+        m_freePtr(a.pages),
+        m_end(m_freePtr + a.size),
+        m_allocation(a),
+        m_refCount(1),
+        m_mark(false) {
+    for (size_t& count : m_codeBytes) {
+      count = 0;
+    }
+  }
+
+  ~ExecutablePool();
+
+  void mark() {
+    MOZ_ASSERT(!m_mark);
+    m_mark = true;
+  }
+  void unmark() {
+    MOZ_ASSERT(m_mark);
+    m_mark = false;
+  }
+  bool isMarked() const { return m_mark; }
+
+ private:
+  ExecutablePool(const ExecutablePool&) = delete;
+  void operator=(const ExecutablePool&) = delete;
+
+  void* alloc(size_t n, CodeKind kind);
+
+  size_t available() const;
+
+  // Returns the number of bytes that are currently in use (referenced by
+  // live JitCode objects).
+  size_t usedCodeBytes() const {
+    size_t res = 0;
+    for (size_t count : m_codeBytes) {
+      res += count;
+    }
+    return res;
+  }
+};
+
+struct JitPoisonRange {
+  jit::ExecutablePool* pool;
+  void* start;
+  size_t size;
+
+  JitPoisonRange(jit::ExecutablePool* pool, void* start, size_t size)
+      : pool(pool), start(start), size(size) {}
+};
+
+typedef Vector<JitPoisonRange, 0, SystemAllocPolicy> JitPoisonRangeVector;
+
+class ExecutableAllocator {
+ public:
+  ExecutableAllocator() = default;
+  ~ExecutableAllocator();
+
+  void purge();
+
+  // alloc() returns a pointer to some memory, and also (by reference) a
+  // pointer to reference-counted pool. The caller owns a reference to the
+  // pool; i.e. alloc() increments the count before returning the object.
+  void* alloc(JSContext* cx, size_t n, ExecutablePool** poolp, CodeKind type);
+
+  void releasePoolPages(ExecutablePool* pool);
+
+  void addSizeOfCode(JS::CodeSizes* sizes) const;
+
+ private:
+  static const size_t OVERSIZE_ALLOCATION = size_t(-1);
+
+  static size_t roundUpAllocationSize(size_t request, size_t granularity);
+
+  // On OOM, this will return an Allocation where pages is nullptr.
+  ExecutablePool::Allocation systemAlloc(size_t n);
+  static void systemRelease(const ExecutablePool::Allocation& alloc);
+
+  ExecutablePool* createPool(size_t n);
+  ExecutablePool* poolForSize(size_t n);
+
+  static void reprotectPool(JSRuntime* rt, ExecutablePool* pool,
+                            ProtectionSetting protection,
+                            MustFlushICache flushICache);
+
+ public:
+  [[nodiscard]] static bool makeWritable(void* start, size_t size) {
+    return ReprotectRegion(start, size, ProtectionSetting::Writable,
+                           MustFlushICache::No);
+  }
+
+  [[nodiscard]] static bool makeExecutableAndFlushICache(void* start,
+                                                         size_t size) {
+    return ReprotectRegion(start, size, ProtectionSetting::Executable,
+                           MustFlushICache::Yes);
+  }
+
+  static void poisonCode(JSRuntime* rt, JitPoisonRangeVector& ranges);
+
+ private:
+  ExecutableAllocator(const ExecutableAllocator&) = delete;
+  void operator=(const ExecutableAllocator&) = delete;
+
+  // These are strong references;  they keep pools alive.
+  static const size_t maxSmallPools = 4;
+  typedef js::Vector<ExecutablePool*, maxSmallPools, js::SystemAllocPolicy>
+      SmallExecPoolVector;
+  SmallExecPoolVector m_smallPools;
+
+  // All live pools are recorded here, just for stats purposes.  These are
+  // weak references;  they don't keep pools alive.  When a pool is destroyed
+  // its reference is removed from m_pools.
+  typedef js::HashSet<ExecutablePool*, js::DefaultHasher<ExecutablePool*>,
+                      js::SystemAllocPolicy>
+      ExecPoolHashSet;
+  ExecPoolHashSet m_pools;  // All pools, just for stats purposes.
+};
+
+}  // namespace jit
+}  // namespace js
+
+#endif /* jit_ExecutableAllocator_h */