1 files changed, 62 insertions, 33 deletions
diff --git a/deps/v8/test/common/assembler-tester.h b/deps/v8/test/common/assembler-tester.h
index eca34c5521..5861acd71e 100644
--- a/deps/v8/test/common/assembler-tester.h
+++ b/deps/v8/test/common/assembler-tester.h
@@ -10,41 +10,70 @@
 namespace v8 {
 namespace internal {
 
-static inline uint8_t* AllocateAssemblerBuffer(
-    size_t* allocated,
-    size_t requested = v8::internal::AssemblerBase::kMinimalBufferSize,
-    void* address = nullptr) {
-  size_t page_size = v8::internal::AllocatePageSize();
-  size_t alloc_size = RoundUp(requested, page_size);
-  void* result = v8::internal::AllocatePages(
-      GetPlatformPageAllocator(), address, alloc_size, page_size,
-      v8::PageAllocator::kReadWriteExecute);
-  CHECK(result);
-  *allocated = alloc_size;
-  return static_cast<uint8_t*>(result);
-}
+class TestingAssemblerBuffer : public AssemblerBuffer {
+ public:
+  TestingAssemblerBuffer(size_t requested, void* address) {
+    size_t page_size = v8::internal::AllocatePageSize();
+    size_t alloc_size = RoundUp(requested, page_size);
+    CHECK_GE(kMaxInt, alloc_size);
+    size_ = static_cast<int>(alloc_size);
+    buffer_ = static_cast<byte*>(AllocatePages(GetPlatformPageAllocator(),
+                                               address, alloc_size, page_size,
+                                               v8::PageAllocator::kReadWrite));
+    CHECK_NOT_NULL(buffer_);
+  }
 
-static inline void MakeAssemblerBufferExecutable(uint8_t* buffer,
-                                                 size_t allocated) {
-  // Flush the instruction cache as part of making the buffer executable.
-  // Note: we do this before setting permissions to ReadExecute because on
-  // some older Arm64 kernels there is a bug which causes an access error on
-  // cache flush instructions to trigger access error on non-writable memory.
-  // See https://bugs.chromium.org/p/v8/issues/detail?id=8157
-  Assembler::FlushICache(buffer, allocated);
-
-  bool result =
-      v8::internal::SetPermissions(GetPlatformPageAllocator(), buffer,
-                                   allocated, v8::PageAllocator::kReadExecute);
-  CHECK(result);
-}
+  ~TestingAssemblerBuffer() {
+    CHECK(FreePages(GetPlatformPageAllocator(), buffer_, size_));
+  }
+
+  byte* start() const override { return buffer_; }
+
+  int size() const override { return size_; }
+
+  std::unique_ptr<AssemblerBuffer> Grow(int new_size) override {
+    FATAL("Cannot grow TestingAssemblerBuffer");
+  }
+
+  std::unique_ptr<AssemblerBuffer> CreateView() const {
+    return ExternalAssemblerBuffer(buffer_, size_);
+  }
 
-static inline void MakeAssemblerBufferWritable(uint8_t* buffer,
-                                               size_t allocated) {
-  bool result =
-      v8::internal::SetPermissions(GetPlatformPageAllocator(), buffer,
-                                   allocated, v8::PageAllocator::kReadWrite);
-  CHECK(result);
+  void MakeExecutable() {
+    // Flush the instruction cache as part of making the buffer executable.
+    // Note: we do this before setting permissions to ReadExecute because on
+    // some older ARM kernels there is a bug which causes an access error on
+    // cache flush instructions to trigger access error on non-writable memory.
+    // See https://bugs.chromium.org/p/v8/issues/detail?id=8157
+    Assembler::FlushICache(buffer_, size_);
+
+    bool result = SetPermissions(GetPlatformPageAllocator(), buffer_, size_,
+                                 v8::PageAllocator::kReadExecute);
+    CHECK(result);
+  }
+
+  void MakeWritable() {
+    bool result = SetPermissions(GetPlatformPageAllocator(), buffer_, size_,
+                                 v8::PageAllocator::kReadWrite);
+    CHECK(result);
+  }
+
+  // TODO(wasm): Only needed for the "test-jump-table-assembler.cc" tests.
+  void MakeWritableAndExecutable() {
+    bool result = SetPermissions(GetPlatformPageAllocator(), buffer_, size_,
+                                 v8::PageAllocator::kReadWriteExecute);
+    CHECK(result);
+  }
+
+ private:
+  byte* buffer_;
+  int size_;
+};
+
+static inline std::unique_ptr<TestingAssemblerBuffer> AllocateAssemblerBuffer(
+    size_t requested = v8::internal::AssemblerBase::kMinimalBufferSize,
+    void* address = nullptr) {
+  return base::make_unique<TestingAssemblerBuffer>(requested, address);
 }
 
 }  // namespace internal