github_mirrors/vectorscan
3
0
Fork 1
mirror of https://github.com/VectorCamp/vectorscan.git synced 2025-06-28 16:41:01 +03:00
Code Issues Packages Projects Releases Wiki Activity
vectorscan/src/rose/rose_build_instructions.h

2252 lines
80 KiB
C++
Raw Blame History

/*
* Copyright (c) 2017-2019, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 THE COPYRIGHT OWNER 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.
*/
/** \file
* \brief Concrete classes for interpreter instructions.
*
* Note: this header should only be included in files which need to deal with
* the details of actual instructions. It is expected that most will only
* require access to the RoseInstruction API exposed in rose_build_program.h
*/
#ifndef ROSE_BUILD_INSTRUCTIONS_H
#define ROSE_BUILD_INSTRUCTIONS_H
#include "rose_build_lookaround.h"
#include "rose_build_program.h"
#include "util/hash.h"
#include "util/verify_types.h"
namespace ue2 {
/**
* \brief Abstract base class representing a single Rose instruction.
*/
class RoseInstruction {
public:
virtual ~RoseInstruction();
/** \brief Opcode used for the instruction in the bytecode. */
virtual RoseInstructionCode code() const = 0;
/**
* \brief Simple hash used for program equivalence.
*
* Note that pointers (jumps, for example) should not be used when
* calculating the hash: they will be converted to instruction offsets when
* compared later.
*/
virtual size_t hash() const = 0;
/** \brief Length of the bytecode instruction in bytes. */
virtual size_t byte_length() const = 0;
using OffsetMap = std::unordered_map<const RoseInstruction *, u32>;
/**
* \brief Writes a concrete implementation of this instruction.
*
* Other data that this instruction depends on is written directly into the
* blob, while the instruction structure itself (of size given by
* the byte_length() function) is written to dest.
*/
virtual void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const = 0;
/**
* \brief Update a target pointer.
*
* If this instruction contains any reference to the old target, replace it
* with the new one.
*/
virtual void update_target(const RoseInstruction *old_target,
const RoseInstruction *new_target) = 0;
/**
* \brief True if these instructions are equivalent within their own
* programs.
*
* Checks that any pointers to other instructions point to the same
* offsets.
*/
bool equiv(const RoseInstruction &other, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return equiv_impl(other, offsets, other_offsets);
}
private:
virtual bool equiv_impl(const RoseInstruction &other,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const = 0;
};
/**
* \brief Templated implementation class to handle boring boilerplate code.
*/
template<RoseInstructionCode Opcode, class ImplType, class RoseInstrType>
class RoseInstrBase : public RoseInstruction {
protected:
static constexpr RoseInstructionCode opcode = Opcode;
using impl_type = ImplType;
public:
RoseInstructionCode code() const override { return opcode; }
size_t byte_length() const override {
return sizeof(impl_type);
}
/**
* Note: this implementation simply zeroes the destination region and
* writes in the correct opcode. This is sufficient for trivial
* instructions, but instructions with data members will want to override
* it.
*/
void write(void *dest, RoseEngineBlob &,
const RoseInstruction::OffsetMap &) const override {
assert(dest != nullptr);
assert(ISALIGNED_N(dest, ROSE_INSTR_MIN_ALIGN));
impl_type *inst = static_cast<impl_type *>(dest);
memset(inst, 0, sizeof(impl_type));
inst->code = verify_u8(opcode);
}
private:
bool equiv_impl(const RoseInstruction &other, const OffsetMap &offsets,
const OffsetMap &other_offsets) const override {
const auto *ri_that = dynamic_cast<const RoseInstrType *>(&other);
if (!ri_that) {
return false;
}
const auto *ri_this = dynamic_cast<const RoseInstrType *>(this);
assert(ri_this);
return ri_this->equiv_to(*ri_that, offsets, other_offsets);
}
};
template<RoseInstructionCode Opcode, class ImplType, class RoseInstrType>
constexpr RoseInstructionCode
RoseInstrBase<Opcode, ImplType, RoseInstrType>::opcode;
/**
* \brief Refinement of RoseInstrBase to use for instructions that have
* just a single target member, called "target".
*/
template<RoseInstructionCode Opcode, class ImplType, class RoseInstrType>
class RoseInstrBaseOneTarget
: public RoseInstrBase<Opcode, ImplType, RoseInstrType> {
public:
void update_target(const RoseInstruction *old_target,
const RoseInstruction *new_target) override {
RoseInstrType *ri = dynamic_cast<RoseInstrType *>(this);
assert(ri);
if (ri->target == old_target) {
ri->target = new_target;
}
}
};
/**
* \brief Refinement of RoseInstrBase to use for instructions that have no
* targets.
*/
template<RoseInstructionCode Opcode, class ImplType, class RoseInstrType>
class RoseInstrBaseNoTargets
: public RoseInstrBase<Opcode, ImplType, RoseInstrType> {
public:
void update_target(const RoseInstruction *,
const RoseInstruction *) override {}
};
/**
* \brief Refinement of RoseInstrBaseNoTargets to use for instructions that
* have no members at all, just an opcode.
*/
template<RoseInstructionCode Opcode, class ImplType, class RoseInstrType>
class RoseInstrBaseTrivial
: public RoseInstrBaseNoTargets<Opcode, ImplType, RoseInstrType> {
public:
virtual bool operator==(const RoseInstrType &) const { return true; }
size_t hash() const override {
return hash_all(Opcode);
}
bool equiv_to(const RoseInstrType &, const RoseInstruction::OffsetMap &,
const RoseInstruction::OffsetMap &) const {
return true;
}
};
////
//// Concrete implementation classes start here.
////
class RoseInstrAnchoredDelay
: public RoseInstrBaseOneTarget<ROSE_INSTR_ANCHORED_DELAY,
ROSE_STRUCT_ANCHORED_DELAY,
RoseInstrAnchoredDelay> {
public:
rose_group groups;
u32 anch_id;
const RoseInstruction *target;
RoseInstrAnchoredDelay(rose_group groups_in, u32 anch_id_in,
const RoseInstruction *target_in)
: groups(groups_in), anch_id(anch_id_in), target(target_in) {}
bool operator==(const RoseInstrAnchoredDelay &ri) const {
return groups == ri.groups && anch_id == ri.anch_id
&& target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, groups, anch_id);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrAnchoredDelay &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return groups == ri.groups && anch_id == ri.anch_id
&& offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckLitEarly
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_LIT_EARLY,
ROSE_STRUCT_CHECK_LIT_EARLY,
RoseInstrCheckLitEarly> {
public:
u32 min_offset;
const RoseInstruction *target;
RoseInstrCheckLitEarly(u32 min_offset_in, const RoseInstruction *target_in)
: min_offset(min_offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckLitEarly &ri) const {
return min_offset == ri.min_offset && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, min_offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckLitEarly &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return min_offset == ri.min_offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckGroups
: public RoseInstrBaseNoTargets<ROSE_INSTR_CHECK_GROUPS,
ROSE_STRUCT_CHECK_GROUPS,
RoseInstrCheckGroups> {
public:
rose_group groups;
explicit RoseInstrCheckGroups(rose_group groups_in) : groups(groups_in) {}
bool operator==(const RoseInstrCheckGroups &ri) const {
return groups == ri.groups;
}
size_t hash() const override {
return hash_all(opcode, groups);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckGroups &ri, const OffsetMap &,
const OffsetMap &) const {
return groups == ri.groups;
}
};
class RoseInstrCheckOnlyEod
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_ONLY_EOD,
ROSE_STRUCT_CHECK_ONLY_EOD,
RoseInstrCheckOnlyEod> {
public:
const RoseInstruction *target;
explicit RoseInstrCheckOnlyEod(const RoseInstruction *target_in)
: target(target_in) {}
bool operator==(const RoseInstrCheckOnlyEod &ri) const {
return target == ri.target;
}
size_t hash() const override {
return hash_all(opcode);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckOnlyEod &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckBounds
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_BOUNDS,
ROSE_STRUCT_CHECK_BOUNDS,
RoseInstrCheckBounds> {
public:
u64a min_bound;
u64a max_bound;
const RoseInstruction *target;
RoseInstrCheckBounds(u64a min, u64a max, const RoseInstruction *target_in)
: min_bound(min), max_bound(max), target(target_in) {}
bool operator==(const RoseInstrCheckBounds &ri) const {
return min_bound == ri.min_bound && max_bound == ri.max_bound &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, min_bound, max_bound);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckBounds &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return min_bound == ri.min_bound && max_bound == ri.max_bound &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckNotHandled
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_NOT_HANDLED,
ROSE_STRUCT_CHECK_NOT_HANDLED,
RoseInstrCheckNotHandled> {
public:
u32 key;
const RoseInstruction *target;
RoseInstrCheckNotHandled(u32 key_in, const RoseInstruction *target_in)
: key(key_in), target(target_in) {}
bool operator==(const RoseInstrCheckNotHandled &ri) const {
return key == ri.key && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, key);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckNotHandled &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return key == ri.key &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckSingleLookaround
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_SINGLE_LOOKAROUND,
ROSE_STRUCT_CHECK_SINGLE_LOOKAROUND,
RoseInstrCheckSingleLookaround> {
public:
s8 offset;
CharReach reach;
const RoseInstruction *target;
RoseInstrCheckSingleLookaround(s8 offset_in, CharReach reach_in,
const RoseInstruction *target_in)
: offset(offset_in), reach(std::move(reach_in)), target(target_in) {}
bool operator==(const RoseInstrCheckSingleLookaround &ri) const {
return offset == ri.offset && reach == ri.reach && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, offset, reach);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckSingleLookaround &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return offset == ri.offset && reach == ri.reach &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckLookaround
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_LOOKAROUND,
ROSE_STRUCT_CHECK_LOOKAROUND,
RoseInstrCheckLookaround> {
public:
std::vector<LookEntry> look;
const RoseInstruction *target;
RoseInstrCheckLookaround(std::vector<LookEntry> look_in,
const RoseInstruction *target_in)
: look(std::move(look_in)), target(target_in) {}
bool operator==(const RoseInstrCheckLookaround &ri) const {
return look == ri.look && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, look);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckLookaround &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return look == ri.look
&& offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMask
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MASK,
ROSE_STRUCT_CHECK_MASK,
RoseInstrCheckMask> {
public:
u64a and_mask;
u64a cmp_mask;
u64a neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckMask(u64a and_mask_in, u64a cmp_mask_in, u64a neg_mask_in,
s32 offset_in, const RoseInstruction *target_in)
: and_mask(and_mask_in), cmp_mask(cmp_mask_in), neg_mask(neg_mask_in),
offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckMask &ri) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, and_mask, cmp_mask, neg_mask, offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMask &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMask32
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MASK_32,
ROSE_STRUCT_CHECK_MASK_32,
RoseInstrCheckMask32> {
public:
std::array<u8, 32> and_mask;
std::array<u8, 32> cmp_mask;
u32 neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckMask32(std::array<u8, 32> and_mask_in,
std::array<u8, 32> cmp_mask_in, u32 neg_mask_in,
s32 offset_in, const RoseInstruction *target_in)
: and_mask(std::move(and_mask_in)), cmp_mask(std::move(cmp_mask_in)),
neg_mask(neg_mask_in), offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckMask32 &ri) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, and_mask, cmp_mask, neg_mask, offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMask32 &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckByte
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_BYTE,
ROSE_STRUCT_CHECK_BYTE,
RoseInstrCheckByte> {
public:
u8 and_mask;
u8 cmp_mask;
u8 negation;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckByte(u8 and_mask_in, u8 cmp_mask_in, u8 negation_in,
s32 offset_in, const RoseInstruction *target_in)
: and_mask(and_mask_in), cmp_mask(cmp_mask_in), negation(negation_in),
offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckByte &ri) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
negation == ri.negation && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, and_mask, cmp_mask, negation, offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckByte &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask &&
negation == ri.negation && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckShufti16x8
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_SHUFTI_16x8,
ROSE_STRUCT_CHECK_SHUFTI_16x8,
RoseInstrCheckShufti16x8> {
public:
std::array<u8, 32> nib_mask;
std::array<u8, 16> bucket_select_mask;
u32 neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckShufti16x8(std::array<u8, 32> nib_mask_in,
std::array<u8, 16> bucket_select_mask_in,
u32 neg_mask_in, s32 offset_in,
const RoseInstruction *target_in)
: nib_mask(std::move(nib_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
neg_mask(neg_mask_in), offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckShufti16x8 &ri) const {
return nib_mask == ri.nib_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, nib_mask, bucket_select_mask, neg_mask, offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckShufti16x8 &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return nib_mask == ri.nib_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckShufti32x8
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_SHUFTI_32x8,
ROSE_STRUCT_CHECK_SHUFTI_32x8,
RoseInstrCheckShufti32x8> {
public:
std::array<u8, 16> hi_mask;
std::array<u8, 16> lo_mask;
std::array<u8, 32> bucket_select_mask;
u32 neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckShufti32x8(std::array<u8, 16> hi_mask_in,
std::array<u8, 16> lo_mask_in,
std::array<u8, 32> bucket_select_mask_in,
u32 neg_mask_in, s32 offset_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
neg_mask(neg_mask_in), offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckShufti32x8 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask, neg_mask,
offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckShufti32x8 &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckShufti16x16
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_SHUFTI_16x16,
ROSE_STRUCT_CHECK_SHUFTI_16x16,
RoseInstrCheckShufti16x16> {
public:
std::array<u8, 32> hi_mask;
std::array<u8, 32> lo_mask;
std::array<u8, 32> bucket_select_mask;
u32 neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckShufti16x16(std::array<u8, 32> hi_mask_in,
std::array<u8, 32> lo_mask_in,
std::array<u8, 32> bucket_select_mask_in,
u32 neg_mask_in, s32 offset_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
neg_mask(neg_mask_in), offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckShufti16x16 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask, neg_mask,
offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckShufti16x16 &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckShufti32x16
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_SHUFTI_32x16,
ROSE_STRUCT_CHECK_SHUFTI_32x16,
RoseInstrCheckShufti32x16> {
public:
std::array<u8, 32> hi_mask;
std::array<u8, 32> lo_mask;
std::array<u8, 32> bucket_select_mask_hi;
std::array<u8, 32> bucket_select_mask_lo;
u32 neg_mask;
s32 offset;
const RoseInstruction *target;
RoseInstrCheckShufti32x16(std::array<u8, 32> hi_mask_in,
std::array<u8, 32> lo_mask_in,
std::array<u8, 32> bucket_select_mask_hi_in,
std::array<u8, 32> bucket_select_mask_lo_in,
u32 neg_mask_in, s32 offset_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask_hi(std::move(bucket_select_mask_hi_in)),
bucket_select_mask_lo(std::move(bucket_select_mask_lo_in)),
neg_mask(neg_mask_in), offset(offset_in), target(target_in) {}
bool operator==(const RoseInstrCheckShufti32x16 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask_hi == ri.bucket_select_mask_hi &&
bucket_select_mask_lo == ri.bucket_select_mask_lo &&
neg_mask == ri.neg_mask && offset == ri.offset &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask_hi,
bucket_select_mask_lo, neg_mask, offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckShufti32x16 &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask_hi == ri.bucket_select_mask_hi &&
bucket_select_mask_lo == ri.bucket_select_mask_lo &&
neg_mask == ri.neg_mask && offset == ri.offset &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckInfix
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_INFIX,
ROSE_STRUCT_CHECK_INFIX,
RoseInstrCheckInfix> {
public:
u32 queue;
u32 lag;
ReportID report;
const RoseInstruction *target;
RoseInstrCheckInfix(u32 queue_in, u32 lag_in, ReportID report_in,
const RoseInstruction *target_in)
: queue(queue_in), lag(lag_in), report(report_in), target(target_in) {}
bool operator==(const RoseInstrCheckInfix &ri) const {
return queue == ri.queue && lag == ri.lag && report == ri.report &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, queue, lag, report);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckInfix &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return queue == ri.queue && lag == ri.lag && report == ri.report &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckPrefix
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_PREFIX,
ROSE_STRUCT_CHECK_PREFIX,
RoseInstrCheckPrefix> {
public:
u32 queue;
u32 lag;
ReportID report;
const RoseInstruction *target;
RoseInstrCheckPrefix(u32 queue_in, u32 lag_in, ReportID report_in,
const RoseInstruction *target_in)
: queue(queue_in), lag(lag_in), report(report_in), target(target_in) {}
bool operator==(const RoseInstrCheckPrefix &ri) const {
return queue == ri.queue && lag == ri.lag && report == ri.report &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, queue, lag, report);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckPrefix &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return queue == ri.queue && lag == ri.lag && report == ri.report &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrPushDelayed
: public RoseInstrBaseNoTargets<ROSE_INSTR_PUSH_DELAYED,
ROSE_STRUCT_PUSH_DELAYED,
RoseInstrPushDelayed> {
public:
u8 delay;
u32 index;
RoseInstrPushDelayed(u8 delay_in, u32 index_in)
: delay(delay_in), index(index_in) {}
bool operator==(const RoseInstrPushDelayed &ri) const {
return delay == ri.delay && index == ri.index;
}
size_t hash() const override {
return hash_all(opcode, delay, index);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrPushDelayed &ri, const OffsetMap &,
const OffsetMap &) const {
return delay == ri.delay && index == ri.index;
}
};
class RoseInstrCatchUp
: public RoseInstrBaseTrivial<ROSE_INSTR_CATCH_UP, ROSE_STRUCT_CATCH_UP,
RoseInstrCatchUp> {
public:
~RoseInstrCatchUp() override;
};
class RoseInstrCatchUpMpv
: public RoseInstrBaseTrivial<ROSE_INSTR_CATCH_UP_MPV,
ROSE_STRUCT_CATCH_UP_MPV,
RoseInstrCatchUpMpv> {
public:
~RoseInstrCatchUpMpv() override;
};
class RoseInstrSomAdjust
: public RoseInstrBaseNoTargets<ROSE_INSTR_SOM_ADJUST,
ROSE_STRUCT_SOM_ADJUST,
RoseInstrSomAdjust> {
public:
u32 distance;
explicit RoseInstrSomAdjust(u32 distance_in) : distance(distance_in) {}
bool operator==(const RoseInstrSomAdjust &ri) const {
return distance == ri.distance;
}
size_t hash() const override {
return hash_all(opcode, distance);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSomAdjust &ri, const OffsetMap &,
const OffsetMap &) const {
return distance == ri.distance;
}
};
class RoseInstrSomLeftfix
: public RoseInstrBaseNoTargets<ROSE_INSTR_SOM_LEFTFIX,
ROSE_STRUCT_SOM_LEFTFIX,
RoseInstrSomLeftfix> {
public:
u32 queue;
u32 lag;
RoseInstrSomLeftfix(u32 queue_in, u32 lag_in)
: queue(queue_in), lag(lag_in) {}
bool operator==(const RoseInstrSomLeftfix &ri) const {
return queue == ri.queue && lag == ri.lag;
}
size_t hash() const override {
return hash_all(opcode, queue, lag);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSomLeftfix &ri, const OffsetMap &,
const OffsetMap &) const {
return queue == ri.queue && lag == ri.lag;
}
};
class RoseInstrSomFromReport
: public RoseInstrBaseNoTargets<ROSE_INSTR_SOM_FROM_REPORT,
ROSE_STRUCT_SOM_FROM_REPORT,
RoseInstrSomFromReport> {
public:
som_operation som;
RoseInstrSomFromReport() {
std::memset(&som, 0, sizeof(som));
}
bool operator==(const RoseInstrSomFromReport &ri) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
size_t hash() const override {
return hash_all(opcode, som.type, som.onmatch);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSomFromReport &ri, const OffsetMap &,
const OffsetMap &) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
};
class RoseInstrSomZero
: public RoseInstrBaseTrivial<ROSE_INSTR_SOM_ZERO, ROSE_STRUCT_SOM_ZERO,
RoseInstrSomZero> {
public:
~RoseInstrSomZero() override;
};
class RoseInstrTriggerInfix
: public RoseInstrBaseNoTargets<ROSE_INSTR_TRIGGER_INFIX,
ROSE_STRUCT_TRIGGER_INFIX,
RoseInstrTriggerInfix> {
public:
u8 cancel;
u32 queue;
u32 event;
RoseInstrTriggerInfix(u8 cancel_in, u32 queue_in, u32 event_in)
: cancel(cancel_in), queue(queue_in), event(event_in) {}
bool operator==(const RoseInstrTriggerInfix &ri) const {
return cancel == ri.cancel && queue == ri.queue && event == ri.event;
}
size_t hash() const override {
return hash_all(opcode, cancel, queue, event);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrTriggerInfix &ri, const OffsetMap &,
const OffsetMap &) const {
return cancel == ri.cancel && queue == ri.queue && event == ri.event;
}
};
class RoseInstrTriggerSuffix
: public RoseInstrBaseNoTargets<ROSE_INSTR_TRIGGER_SUFFIX,
ROSE_STRUCT_TRIGGER_SUFFIX,
RoseInstrTriggerSuffix> {
public:
u32 queue;
u32 event;
RoseInstrTriggerSuffix(u32 queue_in, u32 event_in)
: queue(queue_in), event(event_in) {}
bool operator==(const RoseInstrTriggerSuffix &ri) const {
return queue == ri.queue && event == ri.event;
}
size_t hash() const override {
return hash_all(opcode, queue, event);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrTriggerSuffix &ri, const OffsetMap &,
const OffsetMap &) const {
return queue == ri.queue && event == ri.event;
}
};
class RoseInstrDedupe
: public RoseInstrBaseOneTarget<ROSE_INSTR_DEDUPE, ROSE_STRUCT_DEDUPE,
RoseInstrDedupe> {
public:
u8 quash_som;
u32 dkey;
s32 offset_adjust;
const RoseInstruction *target;
RoseInstrDedupe(u8 quash_som_in, u32 dkey_in, s32 offset_adjust_in,
const RoseInstruction *target_in)
: quash_som(quash_som_in), dkey(dkey_in),
offset_adjust(offset_adjust_in), target(target_in) {}
bool operator==(const RoseInstrDedupe &ri) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
offset_adjust == ri.offset_adjust && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, quash_som, dkey, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrDedupe &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
offset_adjust == ri.offset_adjust &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrDedupeSom
: public RoseInstrBaseOneTarget<ROSE_INSTR_DEDUPE_SOM,
ROSE_STRUCT_DEDUPE_SOM,
RoseInstrDedupeSom> {
public:
u8 quash_som;
u32 dkey;
s32 offset_adjust;
const RoseInstruction *target;
RoseInstrDedupeSom(u8 quash_som_in, u32 dkey_in, s32 offset_adjust_in,
const RoseInstruction *target_in)
: quash_som(quash_som_in), dkey(dkey_in),
offset_adjust(offset_adjust_in), target(target_in) {}
bool operator==(const RoseInstrDedupeSom &ri) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
offset_adjust == ri.offset_adjust && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, quash_som, dkey, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrDedupeSom &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
offset_adjust == ri.offset_adjust &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrReportChain
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_CHAIN,
ROSE_STRUCT_REPORT_CHAIN,
RoseInstrReportChain> {
public:
u32 event;
u64a top_squash_distance;
RoseInstrReportChain(u32 event_in, u32 top_squash_distance_in)
: event(event_in), top_squash_distance(top_squash_distance_in) {}
bool operator==(const RoseInstrReportChain &ri) const {
return event == ri.event &&
top_squash_distance == ri.top_squash_distance;
}
size_t hash() const override {
return hash_all(opcode, event, top_squash_distance);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportChain &ri, const OffsetMap &,
const OffsetMap &) const {
return event == ri.event &&
top_squash_distance == ri.top_squash_distance;
}
};
class RoseInstrReportSomInt
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_SOM_INT,
ROSE_STRUCT_REPORT_SOM_INT,
RoseInstrReportSomInt> {
public:
som_operation som;
RoseInstrReportSomInt() {
std::memset(&som, 0, sizeof(som));
}
bool operator==(const RoseInstrReportSomInt &ri) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
size_t hash() const override {
return hash_all(opcode, som.type, som.onmatch);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportSomInt &ri, const OffsetMap &,
const OffsetMap &) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
};
class RoseInstrReportSomAware
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_SOM_AWARE,
ROSE_STRUCT_REPORT_SOM_AWARE,
RoseInstrReportSomAware> {
public:
som_operation som;
RoseInstrReportSomAware() {
std::memset(&som, 0, sizeof(som));
}
bool operator==(const RoseInstrReportSomAware &ri) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
size_t hash() const override {
return hash_all(opcode, som.type, som.onmatch);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportSomAware &ri, const OffsetMap &,
const OffsetMap &) const {
return std::memcmp(&som, &ri.som, sizeof(som)) == 0;
}
};
class RoseInstrReport
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT, ROSE_STRUCT_REPORT,
RoseInstrReport> {
public:
ReportID onmatch;
s32 offset_adjust;
RoseInstrReport(ReportID onmatch_in, s32 offset_adjust_in)
: onmatch(onmatch_in), offset_adjust(offset_adjust_in) {}
bool operator==(const RoseInstrReport &ri) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
size_t hash() const override {
return hash_all(opcode, onmatch, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReport &ri, const OffsetMap &,
const OffsetMap &) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
};
class RoseInstrReportExhaust
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_EXHAUST,
ROSE_STRUCT_REPORT_EXHAUST,
RoseInstrReportExhaust> {
public:
ReportID onmatch;
s32 offset_adjust;
u32 ekey;
RoseInstrReportExhaust(ReportID onmatch_in, s32 offset_adjust_in,
u32 ekey_in)
: onmatch(onmatch_in), offset_adjust(offset_adjust_in), ekey(ekey_in) {}
bool operator==(const RoseInstrReportExhaust &ri) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
ekey == ri.ekey;
}
size_t hash() const override {
return hash_all(opcode, onmatch, offset_adjust, ekey);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportExhaust &ri, const OffsetMap &,
const OffsetMap &) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
ekey == ri.ekey;
}
};
class RoseInstrReportSom
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_SOM,
ROSE_STRUCT_REPORT_SOM,
RoseInstrReportSom> {
public:
ReportID onmatch;
s32 offset_adjust;
RoseInstrReportSom(ReportID onmatch_in, s32 offset_adjust_in)
: onmatch(onmatch_in), offset_adjust(offset_adjust_in) {}
bool operator==(const RoseInstrReportSom &ri) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
size_t hash() const override {
return hash_all(opcode, onmatch, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportSom &ri, const OffsetMap &,
const OffsetMap &) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
};
class RoseInstrReportSomExhaust
: public RoseInstrBaseNoTargets<ROSE_INSTR_REPORT_SOM_EXHAUST,
ROSE_STRUCT_REPORT_SOM_EXHAUST,
RoseInstrReportSomExhaust> {
public:
ReportID onmatch;
s32 offset_adjust;
u32 ekey;
RoseInstrReportSomExhaust(ReportID onmatch_in, s32 offset_adjust_in,
u32 ekey_in)
: onmatch(onmatch_in), offset_adjust(offset_adjust_in), ekey(ekey_in) {}
bool operator==(const RoseInstrReportSomExhaust &ri) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
ekey == ri.ekey;
}
size_t hash() const override {
return hash_all(opcode, onmatch, offset_adjust, ekey);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrReportSomExhaust &ri, const OffsetMap &,
const OffsetMap &) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
ekey == ri.ekey;
}
};
class RoseInstrDedupeAndReport
: public RoseInstrBaseOneTarget<ROSE_INSTR_DEDUPE_AND_REPORT,
ROSE_STRUCT_DEDUPE_AND_REPORT,
RoseInstrDedupeAndReport> {
public:
u8 quash_som;
u32 dkey;
ReportID onmatch;
s32 offset_adjust;
const RoseInstruction *target;
RoseInstrDedupeAndReport(u8 quash_som_in, u32 dkey_in, ReportID onmatch_in,
s32 offset_adjust_in,
const RoseInstruction *target_in)
: quash_som(quash_som_in), dkey(dkey_in), onmatch(onmatch_in),
offset_adjust(offset_adjust_in), target(target_in) {}
bool operator==(const RoseInstrDedupeAndReport &ri) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, quash_som, dkey, onmatch, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrDedupeAndReport &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return quash_som == ri.quash_som && dkey == ri.dkey &&
onmatch == ri.onmatch && offset_adjust == ri.offset_adjust &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrFinalReport
: public RoseInstrBaseNoTargets<ROSE_INSTR_FINAL_REPORT,
ROSE_STRUCT_FINAL_REPORT,
RoseInstrFinalReport> {
public:
ReportID onmatch;
s32 offset_adjust;
RoseInstrFinalReport(ReportID onmatch_in, s32 offset_adjust_in)
: onmatch(onmatch_in), offset_adjust(offset_adjust_in) {}
bool operator==(const RoseInstrFinalReport &ri) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
size_t hash() const override {
return hash_all(opcode, onmatch, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrFinalReport &ri, const OffsetMap &,
const OffsetMap &) const {
return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust;
}
};
class RoseInstrCheckExhausted
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_EXHAUSTED,
ROSE_STRUCT_CHECK_EXHAUSTED,
RoseInstrCheckExhausted> {
public:
u32 ekey;
const RoseInstruction *target;
RoseInstrCheckExhausted(u32 ekey_in, const RoseInstruction *target_in)
: ekey(ekey_in), target(target_in) {}
bool operator==(const RoseInstrCheckExhausted &ri) const {
return ekey == ri.ekey && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, ekey);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckExhausted &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return ekey == ri.ekey &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMinLength
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MIN_LENGTH,
ROSE_STRUCT_CHECK_MIN_LENGTH,
RoseInstrCheckMinLength> {
public:
s32 end_adj;
u64a min_length;
const RoseInstruction *target;
RoseInstrCheckMinLength(s32 end_adj_in, u64a min_length_in,
const RoseInstruction *target_in)
: end_adj(end_adj_in), min_length(min_length_in), target(target_in) {}
bool operator==(const RoseInstrCheckMinLength &ri) const {
return end_adj == ri.end_adj && min_length == ri.min_length &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, end_adj, min_length);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMinLength &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return end_adj == ri.end_adj && min_length == ri.min_length &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrSetState
: public RoseInstrBaseNoTargets<ROSE_INSTR_SET_STATE, ROSE_STRUCT_SET_STATE,
RoseInstrSetState> {
public:
u32 index;
explicit RoseInstrSetState(u32 index_in) : index(index_in) {}
bool operator==(const RoseInstrSetState &ri) const {
return index == ri.index;
}
size_t hash() const override {
return hash_all(opcode, index);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSetState &ri, const OffsetMap &,
const OffsetMap &) const {
return index == ri.index;
}
};
class RoseInstrSetGroups
: public RoseInstrBaseNoTargets<ROSE_INSTR_SET_GROUPS,
ROSE_STRUCT_SET_GROUPS,
RoseInstrSetGroups> {
public:
rose_group groups;
explicit RoseInstrSetGroups(rose_group groups_in) : groups(groups_in) {}
bool operator==(const RoseInstrSetGroups &ri) const {
return groups == ri.groups;
}
size_t hash() const override {
return hash_all(opcode, groups);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSetGroups &ri, const OffsetMap &,
const OffsetMap &) const {
return groups == ri.groups;
}
};
class RoseInstrSquashGroups
: public RoseInstrBaseNoTargets<ROSE_INSTR_SQUASH_GROUPS,
ROSE_STRUCT_SQUASH_GROUPS,
RoseInstrSquashGroups> {
public:
rose_group groups;
explicit RoseInstrSquashGroups(rose_group groups_in) : groups(groups_in) {}
bool operator==(const RoseInstrSquashGroups &ri) const {
return groups == ri.groups;
}
size_t hash() const override {
return hash_all(opcode, groups);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSquashGroups &ri, const OffsetMap &,
const OffsetMap &) const {
return groups == ri.groups;
}
};
class RoseInstrCheckState
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_STATE,
ROSE_STRUCT_CHECK_STATE,
RoseInstrCheckState> {
public:
u32 index;
const RoseInstruction *target;
RoseInstrCheckState(u32 index_in, const RoseInstruction *target_in)
: index(index_in), target(target_in) {}
bool operator==(const RoseInstrCheckState &ri) const {
return index == ri.index && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, index);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckState &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return index == ri.index &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrSparseIterBegin
: public RoseInstrBase<ROSE_INSTR_SPARSE_ITER_BEGIN,
ROSE_STRUCT_SPARSE_ITER_BEGIN,
RoseInstrSparseIterBegin> {
public:
u32 num_keys; // total number of multibit keys
std::vector<std::pair<u32, const RoseInstruction *>> jump_table;
const RoseInstruction *target;
RoseInstrSparseIterBegin(u32 num_keys_in,
const RoseInstruction *target_in)
: num_keys(num_keys_in), target(target_in) {}
bool operator==(const RoseInstrSparseIterBegin &ri) const {
return num_keys == ri.num_keys && jump_table == ri.jump_table &&
target == ri.target;
}
size_t hash() const override {
size_t v = hash_all(opcode, num_keys);
for (const u32 &key : jump_table | boost::adaptors::map_keys) {
hash_combine(v, key);
}
return v;
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
void update_target(const RoseInstruction *old_target,
const RoseInstruction *new_target) override {
if (target == old_target) {
target = new_target;
}
for (auto &jump : jump_table) {
if (jump.second == old_target) {
jump.second = new_target;
}
}
}
bool equiv_to(const RoseInstrSparseIterBegin &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
if (iter_offset != ri.iter_offset ||
offsets.at(target) != other_offsets.at(ri.target)) {
return false;
}
if (jump_table.size() != ri.jump_table.size()) {
return false;
}
auto it1 = jump_table.begin(), it2 = ri.jump_table.begin();
for (; it1 != jump_table.end(); ++it1, ++it2) {
if (it1->first != it2->first) {
return false;
}
if (offsets.at(it1->second) != other_offsets.at(it2->second)) {
return false;
}
}
return true;
}
private:
friend class RoseInstrSparseIterNext;
// These variables allow us to use the same multibit iterator and jump
// table in subsequent SPARSE_ITER_NEXT write() operations.
mutable bool is_written = false;
mutable u32 iter_offset = 0;
mutable u32 jump_table_offset = 0;
};
class RoseInstrSparseIterNext
: public RoseInstrBase<ROSE_INSTR_SPARSE_ITER_NEXT,
ROSE_STRUCT_SPARSE_ITER_NEXT,
RoseInstrSparseIterNext> {
public:
u32 state;
const RoseInstrSparseIterBegin *begin;
const RoseInstruction *target;
RoseInstrSparseIterNext(u32 state_in,
const RoseInstrSparseIterBegin *begin_in,
const RoseInstruction *target_in)
: state(state_in), begin(begin_in), target(target_in) {}
bool operator==(const RoseInstrSparseIterNext &ri) const {
return state == ri.state && begin == ri.begin && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, state);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
void update_target(const RoseInstruction *old_target,
const RoseInstruction *new_target) override {
if (target == old_target) {
target = new_target;
}
if (begin == old_target) {
assert(new_target->code() == ROSE_INSTR_SPARSE_ITER_BEGIN);
begin = static_cast<const RoseInstrSparseIterBegin *>(new_target);
}
}
bool equiv_to(const RoseInstrSparseIterNext &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return state == ri.state &&
offsets.at(begin) == other_offsets.at(ri.begin) &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrSparseIterAny
: public RoseInstrBaseOneTarget<ROSE_INSTR_SPARSE_ITER_ANY,
ROSE_STRUCT_SPARSE_ITER_ANY,
RoseInstrSparseIterAny> {
public:
u32 num_keys; // total number of multibit keys
std::vector<u32> keys;
const RoseInstruction *target;
RoseInstrSparseIterAny(u32 num_keys_in, std::vector<u32> keys_in,
const RoseInstruction *target_in)
: num_keys(num_keys_in), keys(std::move(keys_in)), target(target_in) {}
bool operator==(const RoseInstrSparseIterAny &ri) const {
return num_keys == ri.num_keys && keys == ri.keys &&
target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, num_keys, keys);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSparseIterAny &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return num_keys == ri.num_keys && keys == ri.keys &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrEnginesEod
: public RoseInstrBaseNoTargets<ROSE_INSTR_ENGINES_EOD,
ROSE_STRUCT_ENGINES_EOD,
RoseInstrEnginesEod> {
public:
u32 iter_offset;
explicit RoseInstrEnginesEod(u32 iter_in) : iter_offset(iter_in) {}
bool operator==(const RoseInstrEnginesEod &ri) const {
return iter_offset == ri.iter_offset;
}
size_t hash() const override {
return hash_all(opcode, iter_offset);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrEnginesEod &ri, const OffsetMap &,
const OffsetMap &) const {
return iter_offset == ri.iter_offset;
}
};
class RoseInstrSuffixesEod
: public RoseInstrBaseTrivial<ROSE_INSTR_SUFFIXES_EOD,
ROSE_STRUCT_SUFFIXES_EOD,
RoseInstrSuffixesEod> {
public:
~RoseInstrSuffixesEod() override;
};
class RoseInstrMatcherEod : public RoseInstrBaseTrivial<ROSE_INSTR_MATCHER_EOD,
ROSE_STRUCT_MATCHER_EOD,
RoseInstrMatcherEod> {
public:
~RoseInstrMatcherEod() override;
};
class RoseInstrCheckLongLit
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_LONG_LIT,
ROSE_STRUCT_CHECK_LONG_LIT,
RoseInstrCheckLongLit> {
public:
std::string literal;
const RoseInstruction *target;
RoseInstrCheckLongLit(std::string literal_in,
const RoseInstruction *target_in)
: literal(std::move(literal_in)), target(target_in) {}
bool operator==(const RoseInstrCheckLongLit &ri) const {
return literal == ri.literal && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, literal);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckLongLit &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return literal == ri.literal &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckLongLitNocase
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_LONG_LIT_NOCASE,
ROSE_STRUCT_CHECK_LONG_LIT_NOCASE,
RoseInstrCheckLongLitNocase> {
public:
std::string literal;
const RoseInstruction *target;
RoseInstrCheckLongLitNocase(std::string literal_in,
const RoseInstruction *target_in)
: literal(std::move(literal_in)), target(target_in) {
upperString(literal);
}
bool operator==(const RoseInstrCheckLongLitNocase &ri) const {
return literal == ri.literal && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, literal);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckLongLitNocase &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return literal == ri.literal &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMedLit
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MED_LIT,
ROSE_STRUCT_CHECK_MED_LIT,
RoseInstrCheckMedLit> {
public:
std::string literal;
const RoseInstruction *target;
explicit RoseInstrCheckMedLit(std::string literal_in,
const RoseInstruction *target_in)
: literal(std::move(literal_in)), target(target_in) {}
bool operator==(const RoseInstrCheckMedLit &ri) const {
return literal == ri.literal && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, literal);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMedLit &ri, const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return literal == ri.literal &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMedLitNocase
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MED_LIT_NOCASE,
ROSE_STRUCT_CHECK_MED_LIT_NOCASE,
RoseInstrCheckMedLitNocase> {
public:
std::string literal;
const RoseInstruction *target;
explicit RoseInstrCheckMedLitNocase(std::string literal_in,
const RoseInstruction *target_in)
: literal(std::move(literal_in)), target(target_in) {
upperString(literal);
}
bool operator==(const RoseInstrCheckMedLitNocase &ri) const {
return literal == ri.literal && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, literal);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMedLitNocase &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return literal == ri.literal &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrClearWorkDone
: public RoseInstrBaseTrivial<ROSE_INSTR_CLEAR_WORK_DONE,
ROSE_STRUCT_CLEAR_WORK_DONE,
RoseInstrClearWorkDone> {
public:
~RoseInstrClearWorkDone() override;
};
class RoseInstrMultipathLookaround
: public RoseInstrBaseOneTarget<ROSE_INSTR_MULTIPATH_LOOKAROUND,
ROSE_STRUCT_MULTIPATH_LOOKAROUND,
RoseInstrMultipathLookaround> {
public:
std::vector<std::vector<LookEntry>> multi_look;
s32 last_start;
std::array<u8, 16> start_mask;
const RoseInstruction *target;
RoseInstrMultipathLookaround(std::vector<std::vector<LookEntry>> ml,
s32 last_start_in,
std::array<u8, 16> start_mask_in,
const RoseInstruction *target_in)
: multi_look(std::move(ml)), last_start(last_start_in),
start_mask(std::move(start_mask_in)), target(target_in) {}
bool operator==(const RoseInstrMultipathLookaround &ri) const {
return multi_look == ri.multi_look && last_start == ri.last_start
&& start_mask == ri.start_mask && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, multi_look, last_start, start_mask);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrMultipathLookaround &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return multi_look == ri.multi_look && last_start == ri.last_start
&& start_mask == ri.start_mask
&& offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMultipathShufti16x8
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_16x8,
ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_16x8,
RoseInstrCheckMultipathShufti16x8> {
public:
std::array<u8, 32> nib_mask;
std::array<u8, 64> bucket_select_mask;
std::array<u8, 64> data_select_mask;
u16 hi_bits_mask;
u16 lo_bits_mask;
u16 neg_mask;
s32 base_offset;
s32 last_start;
const RoseInstruction *target;
RoseInstrCheckMultipathShufti16x8(std::array<u8, 32> nib_mask_in,
std::array<u8, 64> bucket_select_mask_in,
std::array<u8, 64> data_select_mask_in,
u16 hi_bits_mask_in, u16 lo_bits_mask_in,
u16 neg_mask_in, s32 base_offset_in,
s32 last_start_in,
const RoseInstruction *target_in)
: nib_mask(std::move(nib_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
data_select_mask(std::move(data_select_mask_in)),
hi_bits_mask(hi_bits_mask_in), lo_bits_mask(lo_bits_mask_in),
neg_mask(neg_mask_in), base_offset(base_offset_in),
last_start(last_start_in), target(target_in) {}
bool operator==(const RoseInstrCheckMultipathShufti16x8 &ri) const {
return nib_mask == ri.nib_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask &&
neg_mask == ri.neg_mask && base_offset == ri.base_offset &&
last_start == ri.last_start && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, nib_mask, bucket_select_mask, data_select_mask,
hi_bits_mask, lo_bits_mask, neg_mask, base_offset,
last_start);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMultipathShufti16x8 &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return nib_mask == ri.nib_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask && neg_mask == ri.neg_mask &&
base_offset == ri.base_offset && last_start == ri.last_start &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMultipathShufti32x8
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_32x8,
ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_32x8,
RoseInstrCheckMultipathShufti32x8> {
public:
std::array<u8, 32> hi_mask;
std::array<u8, 32> lo_mask;
std::array<u8, 64> bucket_select_mask;
std::array<u8, 64> data_select_mask;
u32 hi_bits_mask;
u32 lo_bits_mask;
u32 neg_mask;
s32 base_offset;
s32 last_start;
const RoseInstruction *target;
RoseInstrCheckMultipathShufti32x8(std::array<u8, 32> hi_mask_in,
std::array<u8, 32> lo_mask_in,
std::array<u8, 64> bucket_select_mask_in,
std::array<u8, 64> data_select_mask_in,
u32 hi_bits_mask_in, u32 lo_bits_mask_in,
u32 neg_mask_in, s32 base_offset_in,
s32 last_start_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
data_select_mask(std::move(data_select_mask_in)),
hi_bits_mask(hi_bits_mask_in), lo_bits_mask(lo_bits_mask_in),
neg_mask(neg_mask_in), base_offset(base_offset_in),
last_start(last_start_in), target(target_in) {}
bool operator==(const RoseInstrCheckMultipathShufti32x8 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask &&
neg_mask == ri.neg_mask && base_offset == ri.base_offset &&
last_start == ri.last_start && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask,
data_select_mask, hi_bits_mask, lo_bits_mask, neg_mask,
base_offset, last_start);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMultipathShufti32x8 &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask && neg_mask == ri.neg_mask &&
base_offset == ri.base_offset && last_start == ri.last_start &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMultipathShufti32x16
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_32x16,
ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_32x16,
RoseInstrCheckMultipathShufti32x16> {
public:
std::array<u8, 32> hi_mask;
std::array<u8, 32> lo_mask;
std::array<u8, 64> bucket_select_mask_hi;
std::array<u8, 64> bucket_select_mask_lo;
std::array<u8, 64> data_select_mask;
u32 hi_bits_mask;
u32 lo_bits_mask;
u32 neg_mask;
s32 base_offset;
s32 last_start;
const RoseInstruction *target;
RoseInstrCheckMultipathShufti32x16(std::array<u8, 32> hi_mask_in,
std::array<u8, 32> lo_mask_in,
std::array<u8, 64> bucket_select_mask_hi_in,
std::array<u8, 64> bucket_select_mask_lo_in,
std::array<u8, 64> data_select_mask_in,
u32 hi_bits_mask_in, u32 lo_bits_mask_in,
u32 neg_mask_in, s32 base_offset_in,
s32 last_start_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask_hi(std::move(bucket_select_mask_hi_in)),
bucket_select_mask_lo(std::move(bucket_select_mask_lo_in)),
data_select_mask(std::move(data_select_mask_in)),
hi_bits_mask(hi_bits_mask_in), lo_bits_mask(lo_bits_mask_in),
neg_mask(neg_mask_in), base_offset(base_offset_in),
last_start(last_start_in), target(target_in) {}
bool operator==(const RoseInstrCheckMultipathShufti32x16 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask_hi == ri.bucket_select_mask_hi &&
bucket_select_mask_lo == ri.bucket_select_mask_lo &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask &&
neg_mask == ri.neg_mask && base_offset == ri.base_offset &&
last_start == ri.last_start && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask_hi,
bucket_select_mask_lo, data_select_mask, hi_bits_mask,
lo_bits_mask, neg_mask, base_offset, last_start);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMultipathShufti32x16 &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask_hi == ri.bucket_select_mask_hi &&
bucket_select_mask_lo == ri.bucket_select_mask_lo &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask && neg_mask == ri.neg_mask &&
base_offset == ri.base_offset && last_start == ri.last_start &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrCheckMultipathShufti64
: public RoseInstrBaseOneTarget<ROSE_INSTR_CHECK_MULTIPATH_SHUFTI_64,
ROSE_STRUCT_CHECK_MULTIPATH_SHUFTI_64,
RoseInstrCheckMultipathShufti64> {
public:
std::array<u8, 32> hi_mask;
std::array<u8, 32> lo_mask;
std::array<u8, 64> bucket_select_mask;
std::array<u8, 64> data_select_mask;
u64a hi_bits_mask;
u64a lo_bits_mask;
u64a neg_mask;
s32 base_offset;
s32 last_start;
const RoseInstruction *target;
RoseInstrCheckMultipathShufti64(std::array<u8, 32> hi_mask_in,
std::array<u8, 32> lo_mask_in,
std::array<u8, 64> bucket_select_mask_in,
std::array<u8, 64> data_select_mask_in,
u64a hi_bits_mask_in, u64a lo_bits_mask_in,
u64a neg_mask_in, s32 base_offset_in,
s32 last_start_in,
const RoseInstruction *target_in)
: hi_mask(std::move(hi_mask_in)), lo_mask(std::move(lo_mask_in)),
bucket_select_mask(std::move(bucket_select_mask_in)),
data_select_mask(std::move(data_select_mask_in)),
hi_bits_mask(hi_bits_mask_in), lo_bits_mask(lo_bits_mask_in),
neg_mask(neg_mask_in), base_offset(base_offset_in),
last_start(last_start_in), target(target_in) {}
bool operator==(const RoseInstrCheckMultipathShufti64 &ri) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask &&
neg_mask == ri.neg_mask && base_offset == ri.base_offset &&
last_start == ri.last_start && target == ri.target;
}
size_t hash() const override {
return hash_all(opcode, hi_mask, lo_mask, bucket_select_mask,
data_select_mask, hi_bits_mask, lo_bits_mask, neg_mask,
base_offset, last_start);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrCheckMultipathShufti64 &ri,
const OffsetMap &offsets,
const OffsetMap &other_offsets) const {
return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask &&
bucket_select_mask == ri.bucket_select_mask &&
data_select_mask == ri.data_select_mask &&
hi_bits_mask == ri.hi_bits_mask &&
lo_bits_mask == ri.lo_bits_mask && neg_mask == ri.neg_mask &&
base_offset == ri.base_offset && last_start == ri.last_start &&
offsets.at(target) == other_offsets.at(ri.target);
}
};
class RoseInstrIncludedJump
: public RoseInstrBaseNoTargets<ROSE_INSTR_INCLUDED_JUMP,
ROSE_STRUCT_INCLUDED_JUMP,
RoseInstrIncludedJump> {
public:
u32 child_offset;
u8 squash;
RoseInstrIncludedJump(u32 child_offset_in, u8 squash_in)
: child_offset(child_offset_in), squash(squash_in) {}
bool operator==(const RoseInstrIncludedJump &ri) const {
return child_offset == ri.child_offset && squash == ri.squash;
}
size_t hash() const override {
return hash_all(static_cast<int>(opcode), child_offset, squash);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrIncludedJump &ri, const OffsetMap &,
const OffsetMap &) const {
return child_offset == ri.child_offset && squash == ri.squash;
}
};
class RoseInstrSetLogical
: public RoseInstrBaseNoTargets<ROSE_INSTR_SET_LOGICAL,
ROSE_STRUCT_SET_LOGICAL,
RoseInstrSetLogical> {
public:
u32 lkey;
s32 offset_adjust;
RoseInstrSetLogical(u32 lkey_in, s32 offset_adjust_in)
: lkey(lkey_in), offset_adjust(offset_adjust_in) {}
bool operator==(const RoseInstrSetLogical &ri) const {
return lkey == ri.lkey && offset_adjust == ri.offset_adjust;
}
size_t hash() const override {
return hash_all(opcode, lkey, offset_adjust);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSetLogical &ri, const OffsetMap &,
const OffsetMap &) const {
return lkey == ri.lkey && offset_adjust == ri.offset_adjust;
}
};
class RoseInstrSetCombination
: public RoseInstrBaseNoTargets<ROSE_INSTR_SET_COMBINATION,
ROSE_STRUCT_SET_COMBINATION,
RoseInstrSetCombination> {
public:
u32 ckey;
RoseInstrSetCombination(u32 ckey_in) : ckey(ckey_in) {}
bool operator==(const RoseInstrSetCombination &ri) const {
return ckey == ri.ckey;
}
size_t hash() const override {
return hash_all(opcode, ckey);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSetCombination &ri, const OffsetMap &,
const OffsetMap &) const {
return ckey == ri.ckey;
}
};
class RoseInstrFlushCombination
: public RoseInstrBaseTrivial<ROSE_INSTR_FLUSH_COMBINATION,
ROSE_STRUCT_FLUSH_COMBINATION,
RoseInstrFlushCombination> {
public:
~RoseInstrFlushCombination() override;
};
class RoseInstrLastFlushCombination
: public RoseInstrBaseTrivial<ROSE_INSTR_LAST_FLUSH_COMBINATION,
ROSE_STRUCT_LAST_FLUSH_COMBINATION,
RoseInstrLastFlushCombination> {
public:
~RoseInstrLastFlushCombination() override;
};
class RoseInstrSetExhaust
: public RoseInstrBaseNoTargets<ROSE_INSTR_SET_EXHAUST,
ROSE_STRUCT_SET_EXHAUST,
RoseInstrSetExhaust> {
public:
u32 ekey;
RoseInstrSetExhaust(u32 ekey_in) : ekey(ekey_in) {}
bool operator==(const RoseInstrSetExhaust &ri) const {
return ekey == ri.ekey;
}
size_t hash() const override {
return hash_all(opcode, ekey);
}
void write(void *dest, RoseEngineBlob &blob,
const OffsetMap &offset_map) const override;
bool equiv_to(const RoseInstrSetExhaust &ri, const OffsetMap &,
const OffsetMap &) const {
return ekey == ri.ekey;
}
};
class RoseInstrEnd
: public RoseInstrBaseTrivial<ROSE_INSTR_END, ROSE_STRUCT_END,
RoseInstrEnd> {
public:
~RoseInstrEnd() override;
};
}
#endif
Reference in New Issue View Git Blame Copy Permalink