tor-browser

MozCachingDecoder.h (6591B)

---

#ifndef VIXL_A64_MOZ_CACHING_DECODER_A64_H_
#define VIXL_A64_MOZ_CACHING_DECODER_A64_H_

#include "mozilla/HashTable.h"

#include "jit/arm64/vixl/Decoder-vixl.h"
#include "js/AllocPolicy.h"

#ifdef DEBUG
#define JS_CACHE_SIMULATOR_ARM64 1
#endif

#ifdef JS_CACHE_SIMULATOR_ARM64
namespace vixl {

// This enumeration list the different kind of instructions which can be
// decoded. These kind correspond to the set of visitor defined by the default
// Decoder.
enum class InstDecodedKind : uint8_t {
 NotDecodedYet,
#define DECLARE(E) E,
 VISITOR_LIST(DECLARE)
#undef DECLARE
};

// A SinglePageDecodeCache is used to store the decoded kind of all instructions
// in an executable page of code. Each time an instruction is decoded, its
// decoded kind is recorded in this structure. The previous instruction value is
// also recorded in this structure when using a debug build.
//
// The next time the same offset is visited, the instruction would be decoded
// using the previously recorded decode kind. It is also compared against the
// previously recorded bits of the instruction to check for potential missing
// cache invalidations, in debug builds.
//
// This structure stores the equivalent of a single page of code to have better
// memory locality when using the simulator. As opposed to having a hash-table
// for all instructions. However a hash-table is used by the CachingDecoder to
// map the prefixes of page addresses to these SinglePageDecodeCaches.
class SinglePageDecodeCache {
public:
 static const uintptr_t PageSize = 1 << 12;
 static const uintptr_t PageMask = PageSize - 1;
 static const uintptr_t InstSize = vixl::kInstructionSize;
 static const uintptr_t InstMask = InstSize - 1;
 static const uintptr_t InstPerPage = PageSize / InstSize;

 SinglePageDecodeCache(const Instruction* inst)
   : pageStart_(PageStart(inst))
 {
   memset(&decodeCache_, int(InstDecodedKind::NotDecodedYet), sizeof(decodeCache_));
 }
 // Compute the start address of the page which contains this instruction.
 static uintptr_t PageStart(const Instruction* inst) {
   return uintptr_t(inst) & ~PageMask;
 }
 // Returns whether the instruction decoded kind is stored in this
 // SinglePageDecodeCache.
 bool contains(const Instruction* inst) {
   return pageStart_ == PageStart(inst);
 }
 void clearDecode(const Instruction* inst) {
   uintptr_t offset = (uintptr_t(inst) & PageMask) / InstSize;
   decodeCache_[offset] = InstDecodedKind::NotDecodedYet;
 }
 InstDecodedKind* decodePtr(const Instruction* inst) {
   uintptr_t offset = (uintptr_t(inst) & PageMask) / InstSize;
   uint32_t instValue = *reinterpret_cast<const uint32_t*>(inst);
   instCache_[offset] = instValue;
   return &decodeCache_[offset];
 }
 InstDecodedKind decode(const Instruction* inst) const {
   uintptr_t offset = (uintptr_t(inst) & PageMask) / InstSize;
   InstDecodedKind val = decodeCache_[offset];
   uint32_t instValue = *reinterpret_cast<const uint32_t*>(inst);
   MOZ_ASSERT_IF(val != InstDecodedKind::NotDecodedYet,
                 instCache_[offset] == instValue);
   return val;
 }

private:
 // Record the address at which the corresponding code page starts.
 const uintptr_t pageStart_;

 // Cache what instruction got decoded previously, in order to assert if we see
 // any stale instructions after.
 uint32_t instCache_[InstPerPage];

 // Cache the decoding of the instruction such that we can skip the decoding
 // part.
 InstDecodedKind decodeCache_[InstPerPage];
};

// A DecoderVisitor which will record which visitor function should be called
// the next time we want to decode the same instruction.
class CachingDecoderVisitor : public DecoderVisitor {
public:
 CachingDecoderVisitor() = default;
 virtual ~CachingDecoderVisitor() {}

#define DECLARE(A) virtual void Visit##A(const Instruction* instr) { \
   if (last_) { \
     MOZ_ASSERT(*last_ == InstDecodedKind::NotDecodedYet); \
     *last_ = InstDecodedKind::A; \
     last_ = nullptr; \
   } \
 };

 VISITOR_LIST(DECLARE)
#undef DECLARE

 void setDecodePtr(InstDecodedKind* ptr) {
   last_ = ptr;
 }

private:
 InstDecodedKind* last_;
};

// The Caching decoder works by extending the default vixl Decoder class. It
// extends it by overloading the Decode function.
//
// The overloaded Decode function checks whether the instruction given as
// argument got decoded before or since it got invalidated. If it was not
// previously decoded, the value of the instruction is recorded as well as the
// kind of instruction. Otherwise, the value of the instruction is checked
// against the previously recorded value and the instruction kind is used to
// skip the decoding visitor and resume the execution of instruction.
//
// The caching decoder stores the equivalent of a page of executable code in a
// hash-table. Each SinglePageDecodeCache stores an array of decoded kind as
// well as the value of the previously decoded instruction.
//
// When testing if an instruction was decoded before, we check if the address of
// the instruction is contained in the last SinglePageDecodeCache. If it is not,
// then the hash-table entry is queried and created if necessary, and the last
// SinglePageDecodeCache is updated. Then, the last SinglePageDecodeCache
// necessary contains the decoded kind of the instruction given as argument.
//
// The caching decoder add an extra function for flushing the cache, which is in
// charge of clearing the decoded kind of instruction in the range of addresses
// given as argument. This is indirectly called by
// CPU::EnsureIAndDCacheCoherency.
class CachingDecoder : public Decoder {
 using ICacheMap = mozilla::HashMap<uintptr_t, SinglePageDecodeCache*>;
public:
 CachingDecoder()
     : lastPage_(nullptr)
 {
   PrependVisitor(&cachingDecoder_);
 }
 ~CachingDecoder() {
   RemoveVisitor(&cachingDecoder_);
 }

 void Decode(const Instruction* instr);
 void Decode(Instruction* instr) {
   Decode(const_cast<const Instruction*>(instr));
 }

 void FlushICache(void* start, size_t size);

private:
 // Record the type of the decoded instruction, to avoid decoding it a second
 // time the next time we execute it.
 CachingDecoderVisitor cachingDecoder_;

 // Store the mapping of Instruction pointer to the corresponding
 // SinglePageDecodeCache.
 ICacheMap iCache_;

 // Record the last SinglePageDecodeCache seen, such that we can quickly access
 // it for the next instruction.
 SinglePageDecodeCache* lastPage_;
};

}
#endif // !JS_CACHE_SIMULATOR_ARM64
#endif // !VIXL_A64_MOZ_CACHING_DECODER_A64_H_