Source code

Revision control

Copy as Markdown

Other Tools

#include "mozilla/HashTable.h"
#include "jit/arm64/vixl/Decoder-vixl.h"
#include "js/AllocPolicy.h"
#ifdef DEBUG
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 {
#define DECLARE(E) E,
#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 {
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;
// 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 {
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; \
} \
#undef DECLARE
void setDecodePtr(InstDecodedKind* ptr) {
last_ = ptr;
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*>;
: lastPage_(nullptr)
~CachingDecoder() {
void Decode(const Instruction* instr);
void Decode(Instruction* instr) {
Decode(const_cast<const Instruction*>(instr));
void FlushICache(void* start, size_t size);
// 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_;