assembler-tester.h 2.81 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2018 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_TEST_COMMON_ASSEMBLER_TESTER_H_
#define V8_TEST_COMMON_ASSEMBLER_TESTER_H_

8 9
#include <memory>

10 11
#include "src/codegen/assembler.h"
#include "src/codegen/code-desc.h"
12 13 14 15

namespace v8 {
namespace internal {

16 17 18 19 20 21 22 23 24 25 26 27
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_);
  }
28

29 30 31
  ~TestingAssemblerBuffer() {
    CHECK(FreePages(GetPlatformPageAllocator(), buffer_, size_));
  }
32

33
  byte* start() const override { return buffer_; }
34

35 36 37 38 39 40 41 42 43
  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_);
  }
44

45 46 47 48 49 50
  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
51
    FlushInstructionCache(buffer_, size_);
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

    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(
77
    size_t requested = v8::internal::AssemblerBase::kDefaultBufferSize,
78
    void* address = nullptr) {
79
  return std::make_unique<TestingAssemblerBuffer>(requested, address);
80 81 82 83 84 85
}

}  // namespace internal
}  // namespace v8

#endif  // V8_TEST_COMMON_ASSEMBLER_TESTER_H_