1060 lines
37 KiB
C++
1060 lines
37 KiB
C++
#ifndef PROCESSORS_H
|
|
#define PROCESSORS_H
|
|
|
|
#include "osutils.h"
|
|
|
|
class CommandLink;
|
|
class Buffer;
|
|
class CommandBlock;
|
|
class IVirtualMachine;
|
|
class SignatureList;
|
|
class ICommand;
|
|
class IFunction;
|
|
class Folder;
|
|
class MemoryManager;
|
|
class CommandInfoList;
|
|
class FunctionInfoList;
|
|
class FunctionInfo;
|
|
|
|
enum OperandType : uint16_t {
|
|
otNone = 0x0000,
|
|
otValue = 0x0001,
|
|
otRegistr = 0x0002,
|
|
otMemory = 0x0004,
|
|
otSegmentRegistr = 0x0008,
|
|
otControlRegistr = 0x0010,
|
|
otDebugRegistr = 0x0020,
|
|
otFPURegistr = 0x0040,
|
|
otHiPartRegistr = 0x0080,
|
|
otBaseRegistr = 0x0100,
|
|
otMMXRegistr = 0x0200,
|
|
otXMMRegistr = 0x0400,
|
|
// otAbsolute = 0x0800,
|
|
};
|
|
|
|
enum CommandOption {
|
|
roInverseFlag = 0x0001,
|
|
roLockPrefix = 0x0002,
|
|
roFar = 0x0004,
|
|
roVexPrefix = 0x0008,
|
|
roBreaked = 0x0010,
|
|
roClearOriginalCode = 0x0020,
|
|
roNeedCompile = 0x0040,
|
|
roCreateNewBlock = 0x0080,
|
|
roFillNop = 0x0100,
|
|
roInternal = 0x0200,
|
|
roNoNative = 0x0400,
|
|
roNoSaveFlags = 0x0800,
|
|
roWritable = 0x1000,
|
|
roUseAsJmp = 0x2000,
|
|
roNoProgress = 0x4000,
|
|
roExternal = 0x8000,
|
|
roNeedCRC = 0x10000,
|
|
roInvalidOpcode = 0x20000,
|
|
roDataSegment = 0x40000,
|
|
roImportSegment = 0x80000,
|
|
};
|
|
|
|
enum VMRegistr {
|
|
regEFX = 16,
|
|
regETX,
|
|
regERX,
|
|
regEIX,
|
|
regEmpty,
|
|
regExtended = 0x80
|
|
};
|
|
|
|
typedef uint32_t CommandType;
|
|
|
|
enum LinkType {
|
|
ltNone,
|
|
ltSEHBlock,
|
|
ltFinallyBlock,
|
|
ltDualSEHBlock,
|
|
ltFilterSEHBlock,
|
|
ltJmp,
|
|
ltJmpWithFlag,
|
|
ltJmpWithFlagNSFS,
|
|
ltJmpWithFlagNSNA,
|
|
ltJmpWithFlagNSNS,
|
|
ltCall,
|
|
ltCase,
|
|
ltSwitch,
|
|
ltNative,
|
|
ltOffset,
|
|
ltGateOffset,
|
|
ltExtSEHBlock,
|
|
ltMemSEHBlock,
|
|
ltExtSEHHandler,
|
|
ltVBMemSEHBlock,
|
|
ltDelta
|
|
};
|
|
|
|
enum SectionOption {
|
|
rtNone = 0x0000,
|
|
rtLinkedToInt = 0x0001,
|
|
rtLinkedToExt = 0x0002,
|
|
rtLinkedFrom = 0x0004,
|
|
rtLinkedNext = 0x0008,
|
|
rtBeginSection = 0x0010,
|
|
rtEndSection = 0x0020,
|
|
rtCloseSection = 0x0040,
|
|
rtNoInverseResult = 0x0080,
|
|
rtInverseResult = 0x0100,
|
|
rtNoSaveFlags = 0x0200,
|
|
rtInverseWrite = 0x0400,
|
|
rtLinkedFromOtherType = 0x0800,
|
|
rtBackwardDirection = 0x1000
|
|
};
|
|
|
|
class IVMCommand: public IObject
|
|
{
|
|
public:
|
|
virtual void WriteToFile(IArchitecture &file) = 0;
|
|
virtual void Compile() = 0;
|
|
virtual size_t dump_size() const = 0;
|
|
virtual void set_address(uint64_t address) = 0;
|
|
virtual uint64_t address() const = 0;
|
|
virtual ICommand *owner() const = 0;
|
|
virtual bool is_end() const = 0;
|
|
};
|
|
|
|
enum VMCommandOption {
|
|
voNone = 0x0000,
|
|
voLinkCommand = 0x0001,
|
|
voFixup = 0x0002,
|
|
voSectionCommand = 0x0004,
|
|
voInverseValue = 0x0008,
|
|
voUseBeginSectionCryptor = 0x0010,
|
|
voUseEndSectionCryptor = 0x0020,
|
|
voBeginOffset = 0x0040,
|
|
voEndOffset = 0x0080,
|
|
voInitOffset = 0x0100,
|
|
voNoCRC = 0x0200,
|
|
voNoCryptValue = 0x0400
|
|
};
|
|
|
|
class BaseVMCommand: public IVMCommand
|
|
{
|
|
public:
|
|
explicit BaseVMCommand(ICommand *owner);
|
|
~BaseVMCommand();
|
|
virtual ICommand *owner() const { return owner_; }
|
|
void set_owner(ICommand *owner) { owner_ = owner; }
|
|
private:
|
|
ICommand *owner_;
|
|
};
|
|
|
|
enum CommentType : uint8_t {
|
|
ttUnknown,
|
|
ttNone,
|
|
ttJmp,
|
|
ttFunction,
|
|
ttImport,
|
|
ttString,
|
|
ttVariable,
|
|
ttComment,
|
|
ttExport,
|
|
ttMarker
|
|
};
|
|
|
|
struct CommentInfo {
|
|
std::string value;
|
|
CommentType type;
|
|
CommentInfo() : type(ttUnknown) {}
|
|
CommentInfo(CommentType type_, const std::string &value_) : type(type_), value(value_) {}
|
|
std::string display_value() const
|
|
{
|
|
std::string res;
|
|
if (value.empty())
|
|
return std::string();
|
|
return (value[0] < 5) ? value[0] + DisplayString(value.substr(1)) : DisplayString(value);
|
|
}
|
|
};
|
|
|
|
class AddressRange;
|
|
class ISEHandler;
|
|
struct CompileContext;
|
|
|
|
class ICommand: public ObjectList<IVMCommand>
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint64_t next_address() const = 0;
|
|
virtual CommandType type() const = 0;
|
|
virtual std::string text() const = 0;
|
|
virtual CommentInfo comment() = 0;
|
|
virtual void set_comment(const CommentInfo &value) = 0;
|
|
virtual uint32_t options() const = 0;
|
|
virtual CommandLink *link() const = 0;
|
|
virtual void set_link(CommandLink *link) = 0;
|
|
virtual uint8_t dump(size_t index) const = 0;
|
|
virtual size_t dump_size() const = 0;
|
|
virtual std::string dump_str() const = 0;
|
|
virtual size_t original_dump_size() const = 0;
|
|
virtual size_t vm_dump_size() const = 0;
|
|
virtual void clear() = 0;
|
|
virtual void CompileToNative() = 0;
|
|
virtual void CompileLink(const CompileContext &ctx) = 0;
|
|
virtual void PrepareLink(const CompileContext &ctx) = 0;
|
|
virtual void CompileInfo() = 0;
|
|
virtual void set_operand_value(size_t operand_index, uint64_t value) = 0;
|
|
virtual void set_link_value(size_t link_index, uint64_t value) = 0;
|
|
virtual void set_jmp_value(size_t link_index, uint64_t value) = 0;
|
|
virtual void set_address(uint64_t address) = 0;
|
|
virtual uint64_t vm_address() const = 0;
|
|
virtual uint64_t ext_vm_address() const = 0;
|
|
virtual void set_vm_address(uint64_t address) = 0;
|
|
virtual void WriteToFile(IArchitecture &file) = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file) = 0;
|
|
virtual size_t alignment() const = 0;
|
|
virtual CommandBlock *block() const = 0;
|
|
virtual void set_block(CommandBlock *block) = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IFunction *owner() const = 0;
|
|
virtual ICommand *Clone(IFunction *owner) const = 0;
|
|
virtual CommandLink *AddLink(int operand_index, LinkType type, ICommand *to_command) = 0;
|
|
virtual CommandLink *AddLink(int operand_index, LinkType type, uint64_t to_address = 0) = 0;
|
|
virtual void include_section_option(SectionOption option) = 0;
|
|
virtual uint32_t section_options() const = 0;
|
|
virtual ISEHandler *seh_handler() const = 0;
|
|
virtual AddressRange *address_range() const = 0;
|
|
virtual void set_address_range(AddressRange *address_range) = 0;
|
|
virtual bool Merge(ICommand *command) = 0;
|
|
virtual bool is_data() const = 0;
|
|
virtual bool is_end() const = 0;
|
|
virtual void include_option(CommandOption value) = 0;
|
|
virtual void exclude_option(CommandOption value) = 0;
|
|
virtual std::string display_address() const = 0;
|
|
virtual void set_tag(uint8_t tag) = 0;
|
|
virtual uint8_t tag() const = 0;
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const ICommand &obj) const
|
|
{
|
|
if (address() < obj.address())
|
|
return -1;
|
|
if (address() > obj.address())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const = 0;
|
|
#endif
|
|
};
|
|
|
|
enum AccessType : uint8_t {
|
|
atRead,
|
|
atWrite
|
|
};
|
|
|
|
class CommandInfo : public IObject
|
|
{
|
|
public:
|
|
explicit CommandInfo(CommandInfoList *owner, AccessType type, uint8_t value, OperandType operand_type, OperandSize size);
|
|
~CommandInfo();
|
|
AccessType type() const { return type_; }
|
|
OperandType operand_type() const { return operand_type_; }
|
|
uint8_t value() const { return value_; }
|
|
OperandSize size() const { return size_; }
|
|
void set_size(OperandSize size) { size_ = size; }
|
|
private:
|
|
CommandInfoList *owner_;
|
|
OperandType operand_type_;
|
|
AccessType type_;
|
|
uint8_t value_;
|
|
OperandSize size_;
|
|
};
|
|
|
|
class CommandInfoList: public ObjectList<CommandInfo>
|
|
{
|
|
public:
|
|
explicit CommandInfoList();
|
|
virtual void Add(AccessType access_type, uint8_t value, OperandType operand_type, OperandSize size);
|
|
void set_need_flags(uint16_t flags) { need_flags_ = flags; }
|
|
void set_change_flags(uint16_t flags) { change_flags_ = flags; }
|
|
CommandInfo *GetInfo(AccessType type, OperandType operand_type, uint8_t value) const;
|
|
CommandInfo *GetInfo(AccessType type, OperandType operand_type) const;
|
|
CommandInfo *GetInfo(OperandType operand_type) const;
|
|
uint16_t need_flags() const { return need_flags_; }
|
|
uint16_t change_flags() const { return change_flags_; }
|
|
virtual void clear();
|
|
private:
|
|
uint16_t need_flags_;
|
|
uint16_t change_flags_;
|
|
};
|
|
|
|
class BaseCommand: public ICommand
|
|
{
|
|
public:
|
|
explicit BaseCommand(IFunction *owner);
|
|
explicit BaseCommand(IFunction *owner, const std::string &value);
|
|
explicit BaseCommand(IFunction *owner, const os::unicode_string &value);
|
|
explicit BaseCommand(IFunction *owner, const Data &value);
|
|
explicit BaseCommand(IFunction *owner, const BaseCommand &src);
|
|
~BaseCommand();
|
|
virtual uint64_t next_address() const { return address() + dump_size(); }
|
|
virtual uint8_t dump(size_t index) const { return dump_[index]; }
|
|
uint64_t dump_value(size_t pos, OperandSize size) const;
|
|
Data &raw_dump(void) { return dump_; };
|
|
virtual size_t dump_size() const { return dump_.size(); }
|
|
virtual std::string dump_str() const;
|
|
virtual size_t vm_dump_size() const;
|
|
virtual void clear();
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void WriteToFile(IArchitecture &file);
|
|
virtual CommandLink *link() const { return link_; }
|
|
virtual void set_link(CommandLink *link) { link_ = link; }
|
|
virtual CommandBlock *block() const { return block_; }
|
|
virtual void set_block(CommandBlock *block) { block_ = block; }
|
|
virtual IFunction *owner() const { return owner_; }
|
|
virtual CommandLink *AddLink(int operand_index, LinkType type, ICommand *to_command);
|
|
virtual CommandLink *AddLink(int operand_index, LinkType type, uint64_t to_address = 0);
|
|
virtual uint64_t vm_address() const { return vm_address_; }
|
|
virtual uint64_t ext_vm_address() const { return vm_address_; }
|
|
virtual void set_vm_address(uint64_t address);
|
|
bool CompareDump(const uint8_t *buffer, size_t size) const;
|
|
void set_dump(const void *buffer, size_t size);
|
|
virtual ISEHandler *seh_handler() const { return NULL; }
|
|
virtual CommentInfo comment() { return comment_; }
|
|
virtual void set_comment(const CommentInfo &comment) { comment_ = comment; }
|
|
virtual AddressRange *address_range() const { return address_range_; }
|
|
virtual void set_address_range(AddressRange *address_range) { address_range_ = address_range; }
|
|
virtual void CompileInfo();
|
|
virtual size_t alignment() const { return alignment_; }
|
|
void set_alignment(size_t alignment) { alignment_ = alignment; }
|
|
virtual uint32_t options() const { return options_; }
|
|
virtual void include_option(CommandOption value) { options_ |= value; }
|
|
virtual void exclude_option(CommandOption value) { options_ &= ~value; }
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const { return true; }
|
|
#endif
|
|
virtual void set_tag(uint8_t tag) { tag_ = tag; }
|
|
virtual uint8_t tag() const { return tag_; }
|
|
protected:
|
|
void Read(IArchitecture &file, size_t len);
|
|
uint8_t ReadByte(IArchitecture &file);
|
|
uint16_t ReadWord(IArchitecture &file);
|
|
uint32_t ReadDWord(IArchitecture &file);
|
|
uint64_t ReadQWord(IArchitecture &file);
|
|
|
|
void PushByte(uint8_t value);
|
|
void PushWord(uint16_t value);
|
|
void PushDWord(uint32_t value);
|
|
void PushQWord(uint64_t value);
|
|
void InsertByte(size_t position, uint8_t value);
|
|
void WriteDWord(size_t position, uint32_t value);
|
|
std::string comment_text() const { return comment_.value; }
|
|
private:
|
|
Data dump_;
|
|
IFunction *owner_;
|
|
CommandLink *link_;
|
|
CommandBlock *block_;
|
|
uint64_t vm_address_;
|
|
AddressRange *address_range_;
|
|
CommentInfo comment_;
|
|
size_t alignment_;
|
|
uint32_t options_;
|
|
uint8_t tag_;
|
|
};
|
|
|
|
class InternalLinkList;
|
|
|
|
enum InternalLinkType {
|
|
vlNone,
|
|
vlCRCTableAddress,
|
|
vlCRCTableCount,
|
|
vlCRCValue
|
|
};
|
|
|
|
class InternalLink : public IObject
|
|
{
|
|
public:
|
|
InternalLink(InternalLinkList *owner, InternalLinkType type, IVMCommand *from_command, IObject *to_command);
|
|
~InternalLink();
|
|
InternalLinkType type() const { return type_; }
|
|
IVMCommand *from_command() const { return from_command_; }
|
|
IObject *to_command() const { return to_command_; }
|
|
private:
|
|
InternalLinkList *owner_;
|
|
InternalLinkType type_;
|
|
IVMCommand *from_command_;
|
|
IObject *to_command_;
|
|
};
|
|
|
|
class InternalLinkList : public ObjectList<InternalLink>
|
|
{
|
|
public:
|
|
InternalLink *Add(InternalLinkType type, IVMCommand *from_command, IObject *to_command);
|
|
};
|
|
|
|
enum CryptCommandType : uint8_t {
|
|
ccAdd,
|
|
ccSub,
|
|
ccXor,
|
|
ccInc,
|
|
ccDec,
|
|
ccBswap,
|
|
ccRol,
|
|
ccRor,
|
|
ccNot,
|
|
ccNeg,
|
|
ccUnknown
|
|
};
|
|
|
|
class ValueCryptor;
|
|
|
|
class ValueCommand: public IObject
|
|
{
|
|
public:
|
|
explicit ValueCommand(ValueCryptor *owner, OperandSize size, CryptCommandType type, uint64_t value);
|
|
explicit ValueCommand(ValueCryptor *owner, const ValueCommand &src);
|
|
~ValueCommand();
|
|
ValueCommand *Clone(ValueCryptor *owner) const;
|
|
CryptCommandType type(bool is_decrypt = false) const;
|
|
uint64_t Encrypt(uint64_t value);
|
|
uint64_t Decrypt(uint64_t value);
|
|
uint64_t value() const { return value_; }
|
|
OperandSize size() const { return size_; }
|
|
private:
|
|
uint64_t value_;
|
|
ValueCryptor *owner_;
|
|
uint64_t Calc(uint64_t value, bool is_decrypt);
|
|
CryptCommandType type_;
|
|
OperandSize size_;
|
|
};
|
|
|
|
class ValueCryptor : public ObjectList<ValueCommand>
|
|
{
|
|
public:
|
|
ValueCryptor();
|
|
ValueCryptor(const ValueCryptor &src);
|
|
ValueCryptor *Clone() const;
|
|
virtual void Init(OperandSize size);
|
|
uint64_t Encrypt(uint64_t value);
|
|
uint64_t Decrypt(uint64_t value);
|
|
OperandSize size() const { return size_; }
|
|
void set_size(OperandSize size) { size_ = size; }
|
|
void Add(CryptCommandType command, uint64_t value);
|
|
private:
|
|
OperandSize size_;
|
|
// no assignment op
|
|
ValueCryptor &operator =(const ValueCryptor &);
|
|
};
|
|
|
|
class OpcodeCryptor : public ValueCryptor
|
|
{
|
|
public:
|
|
OpcodeCryptor();
|
|
virtual void Init(OperandSize size);
|
|
uint64_t EncryptOpcode(uint64_t value1, uint64_t value2);
|
|
uint64_t DecryptOpcode(uint64_t value1, uint64_t value2);
|
|
CryptCommandType type() const { return type_; }
|
|
private:
|
|
uint64_t Calc(uint64_t value1, uint64_t value2, bool is_decrypt);
|
|
CryptCommandType type_;
|
|
};
|
|
|
|
class CommandLinkList;
|
|
class FunctionInfo;
|
|
|
|
class CommandLink: public IObject
|
|
{
|
|
public:
|
|
explicit CommandLink(CommandLinkList *owner, ICommand *from_command, int operand_index, LinkType type, uint64_t to_address);
|
|
explicit CommandLink(CommandLinkList *owner, ICommand *from_command, int operand_index, LinkType type, ICommand *to_command);
|
|
explicit CommandLink(CommandLinkList *owner, const CommandLink &src);
|
|
virtual ~CommandLink();
|
|
CommandLink *Clone(CommandLinkList *owner) const;
|
|
ICommand *from_command() const { return from_command_; }
|
|
ICommand *parent_command() const { return parent_command_; }
|
|
ICommand *to_command() const { return to_command_; }
|
|
ICommand *next_command() const { return next_command_; }
|
|
uint64_t to_address() const { return to_address_; }
|
|
LinkType type() const { return type_; }
|
|
bool parsed() const { return parsed_; }
|
|
int operand_index() const { return operand_index_; }
|
|
void set_operand_index(int value) { operand_index_ = value; }
|
|
void set_parsed(bool parsed) { parsed_ = parsed; }
|
|
void set_type(LinkType type) { type_ = type; }
|
|
void set_parent_command(ICommand *parent_command) { parent_command_ = parent_command; }
|
|
void set_from_command(ICommand *command);
|
|
void set_to_command(ICommand *command) { to_command_ = command; }
|
|
void set_next_command(ICommand *command) { next_command_ = command; }
|
|
void set_sub_value(uint64_t value) { sub_value_ = value; }
|
|
uint64_t sub_value() const { return sub_value_; }
|
|
ICommand *gate_command(size_t index) const { return gate_commands_[index]; }
|
|
void Rebase(uint64_t delta_base);
|
|
void AddGateCommand(ICommand *command) { gate_commands_.push_back(command); }
|
|
uint64_t Encrypt(uint64_t value) const;
|
|
ValueCryptor *cryptor() const { return cryptor_; }
|
|
void set_cryptor(ValueCryptor *cryptor);
|
|
FunctionInfo *base_function_info() const { return base_function_info_; }
|
|
void set_base_function_info(FunctionInfo *base_function_info) { base_function_info_ = base_function_info; }
|
|
void set_is_inverse(bool is_inverse) { is_inverse_ = is_inverse; }
|
|
private:
|
|
CommandLinkList *owner_;
|
|
bool parsed_;
|
|
ICommand *from_command_;
|
|
ICommand *parent_command_;
|
|
ICommand *to_command_;
|
|
ICommand *next_command_;
|
|
LinkType type_;
|
|
uint64_t to_address_;
|
|
int operand_index_;
|
|
uint64_t sub_value_;
|
|
std::vector<ICommand *> gate_commands_;
|
|
ValueCryptor *cryptor_;
|
|
FunctionInfo *base_function_info_;
|
|
bool is_inverse_;
|
|
|
|
// no copy ctr or assignment op
|
|
CommandLink(const CommandLink &);
|
|
CommandLink &operator =(const CommandLink &);
|
|
};
|
|
|
|
class CommandLinkList : public ObjectList<CommandLink>
|
|
{
|
|
public:
|
|
explicit CommandLinkList();
|
|
explicit CommandLinkList(const CommandLinkList &src);
|
|
virtual CommandLinkList *Clone() const;
|
|
CommandLink *Add(ICommand *from_command, int operand_index, LinkType type, uint64_t to_address = 0);
|
|
CommandLink *Add(ICommand *from_command, int operand_index, LinkType type, ICommand *to_command);
|
|
CommandLink *GetLinkByToAddress(LinkType type, uint64_t to_address);
|
|
void Rebase(uint64_t delta_base);
|
|
private:
|
|
// no assignment op
|
|
CommandLinkList &operator =(const CommandLinkList &);
|
|
};
|
|
|
|
class ExtCommandList;
|
|
|
|
class ExtCommand: public IObject
|
|
{
|
|
public:
|
|
explicit ExtCommand(ExtCommandList *owner, uint64_t address, ICommand *command, bool use_call);
|
|
explicit ExtCommand(ExtCommandList *owner, const ExtCommand &src);
|
|
virtual ~ExtCommand();
|
|
virtual ExtCommand *Clone(ExtCommandList *owner) const;
|
|
|
|
using IObject::CompareWith;
|
|
int CompareWith(const ExtCommand &obj) const;
|
|
uint64_t address() const { return address_; }
|
|
ICommand *command() const { return command_; }
|
|
bool use_call() const { return use_call_; }
|
|
void set_command(ICommand *command) { command_ = command; }
|
|
ExtCommandList *owner() const { return owner_; }
|
|
private:
|
|
ExtCommandList *owner_;
|
|
uint64_t address_;
|
|
ICommand *command_;
|
|
bool use_call_;
|
|
};
|
|
|
|
class ExtCommandList : public ObjectList<ExtCommand>
|
|
{
|
|
public:
|
|
explicit ExtCommandList(IFunction *owner);
|
|
explicit ExtCommandList(IFunction *owner, const ExtCommandList &src);
|
|
virtual ExtCommandList *Clone(IFunction *owner) const;
|
|
ExtCommand *Add(uint64_t address);
|
|
ExtCommand *Add(uint64_t address, ICommand *command, bool use_call = false);
|
|
ExtCommand *GetCommandByAddress(uint64_t address) const;
|
|
virtual void AddObject(ExtCommand *ext_command);
|
|
virtual void RemoveObject(ExtCommand *ext_command);
|
|
IFunction *owner() const { return owner_; }
|
|
private:
|
|
IFunction *owner_;
|
|
};
|
|
|
|
class CommandBlockList;
|
|
|
|
class CommandBlock: public AddressableObject
|
|
{
|
|
public:
|
|
explicit CommandBlock(CommandBlockList *owner, uint32_t type, size_t start_index);
|
|
explicit CommandBlock(CommandBlockList *owner, const CommandBlock &src);
|
|
~CommandBlock();
|
|
CommandBlock *Clone(CommandBlockList *owner);
|
|
size_t start_index() const { return start_index_; }
|
|
size_t end_index() const { return end_index_; }
|
|
uint32_t type() const { return type_; }
|
|
void set_start_index(size_t start_index) { start_index_ = start_index; }
|
|
void set_end_index(size_t end_index) { end_index_ = end_index; }
|
|
void Compile(MemoryManager &manager);
|
|
void CompileLinks(const CompileContext &ctx);
|
|
void CompileInfo();
|
|
size_t WriteToFile(IArchitecture &file);
|
|
uint8_t GetRegistr(OperandSize size, uint8_t registr, bool is_write);
|
|
void AddCorrectCommand(IVMCommand *command) { correct_command_list_.push_back(command); }
|
|
std::vector<IVMCommand *> correct_command_list() const { return correct_command_list_; }
|
|
IFunction *function() const;
|
|
IVirtualMachine *virtual_machine() const { return virtual_machine_; }
|
|
void set_virtual_machine(IVirtualMachine *value) { virtual_machine_ = value; }
|
|
size_t sort_index() const { return sort_index_; }
|
|
void set_sort_index(size_t sort_index) { sort_index_ = sort_index; }
|
|
CommandBlockList *owner() { return owner_; };
|
|
private:
|
|
CommandBlockList *owner_;
|
|
uint32_t type_;
|
|
size_t start_index_;
|
|
size_t end_index_;
|
|
uint8_t registr_indexes_[24];
|
|
size_t registr_count_;
|
|
std::vector<IVMCommand *> correct_command_list_;
|
|
IVirtualMachine *virtual_machine_;
|
|
size_t sort_index_;
|
|
};
|
|
|
|
class CommandBlockList : public ObjectList<CommandBlock>
|
|
{
|
|
public:
|
|
explicit CommandBlockList(IFunction *owner);
|
|
explicit CommandBlockList(IFunction *owner, const CommandBlockList &src);
|
|
CommandBlockList *Clone(IFunction *owner) const;
|
|
CommandBlock *Add(uint32_t memory_type, size_t start_index);
|
|
void CompileBlocks(MemoryManager &manager);
|
|
void CompileLinks(const CompileContext &ctx);
|
|
void CompileInfo();
|
|
size_t WriteToFile(IArchitecture &file);
|
|
IFunction *owner() const { return owner_; }
|
|
private:
|
|
IFunction *owner_;
|
|
};
|
|
|
|
enum EntryType : uint8_t {
|
|
etDefault,
|
|
etRandomAddress,
|
|
etNone
|
|
};
|
|
|
|
enum CompilationOption {
|
|
coLockToKey = 0x2000
|
|
};
|
|
|
|
enum FunctionTag {
|
|
ftNone,
|
|
ftLicensing,
|
|
ftBundler,
|
|
ftRegistry,
|
|
ftResources,
|
|
ftLoader,
|
|
ftProcessor
|
|
};
|
|
|
|
enum CommandTag {
|
|
cmdtNone,
|
|
cmdtMutant
|
|
};
|
|
|
|
class AddressRange : public IObject
|
|
{
|
|
public:
|
|
explicit AddressRange(FunctionInfo *owner, uint64_t begin, uint64_t end, ICommand *begin_entry, ICommand *end_entry, ICommand *size_entry);
|
|
explicit AddressRange(FunctionInfo *owner, const AddressRange &src);
|
|
~AddressRange();
|
|
uint64_t begin() const { return begin_; }
|
|
uint64_t end() const { return end_; }
|
|
uint64_t original_begin() const { return original_begin_ ? original_begin_ : begin_; }
|
|
uint64_t original_end() const { return original_end_ ? original_end_ : end_; }
|
|
ICommand *begin_entry() const { return begin_entry_; }
|
|
ICommand *end_entry() const { return end_entry_; }
|
|
ICommand *size_entry() const { return size_entry_; }
|
|
void set_begin_entry(ICommand *begin_entry) { begin_entry_ = begin_entry; }
|
|
void set_end_entry(ICommand *end_entry) { end_entry_ = end_entry; }
|
|
void set_size_entry(ICommand *size_entry) { size_entry_ = size_entry; }
|
|
AddressRange *Clone(FunctionInfo *owner) const;
|
|
void Add(uint64_t address, size_t size);
|
|
void Prepare();
|
|
void Rebase(uint64_t delta_base);
|
|
FunctionInfo *owner() const { return owner_; }
|
|
void set_begin(uint64_t value) { begin_ = value; }
|
|
void set_end(uint64_t value) { end_ = value; }
|
|
FunctionInfo *link_info() const { return link_info_; }
|
|
void set_link_info(FunctionInfo *info) { link_info_ = info; }
|
|
void AddLink(AddressRange *link) { link_list_.push_back(link); }
|
|
private:
|
|
FunctionInfo *owner_;
|
|
uint64_t begin_;
|
|
uint64_t end_;
|
|
uint64_t original_begin_;
|
|
uint64_t original_end_;
|
|
ICommand *begin_entry_;
|
|
ICommand *end_entry_;
|
|
ICommand *size_entry_;
|
|
FunctionInfo *link_info_;
|
|
std::vector<AddressRange *> link_list_;
|
|
};
|
|
|
|
enum AddressBaseType {
|
|
btValue,
|
|
btImageBase,
|
|
btFunctionBegin
|
|
};
|
|
|
|
class FunctionInfo : public ObjectList<AddressRange>
|
|
{
|
|
public:
|
|
explicit FunctionInfo();
|
|
explicit FunctionInfo(FunctionInfoList *owner, uint64_t begin, uint64_t end, AddressBaseType base_type, uint64_t base_value, size_t prolog_size,
|
|
uint8_t frame_registr, IRuntimeFunction *source, ICommand *entry);
|
|
explicit FunctionInfo(FunctionInfoList *owner, const FunctionInfo &src);
|
|
~FunctionInfo();
|
|
AddressRange *Add(uint64_t begin, uint64_t end, ICommand *begin_entry, ICommand *end_entry, ICommand *size_entry);
|
|
AddressRange *GetRangeByAddress(uint64_t address) const;
|
|
uint64_t begin() const { return begin_; }
|
|
uint64_t end() const { return end_; }
|
|
size_t prolog_size() const { return prolog_size_; }
|
|
AddressBaseType base_type() const { return base_type_; }
|
|
uint64_t base_value() const { return base_value_; }
|
|
ICommand *entry() const { return entry_; }
|
|
void set_entry(ICommand *entry) { entry_ = entry; }
|
|
ICommand *data_entry() const { return data_entry_; }
|
|
void set_data_entry(ICommand *data_entry) { data_entry_ = data_entry; }
|
|
FunctionInfo *Clone(FunctionInfoList *owner) const;
|
|
void Prepare();
|
|
void Compile();
|
|
void WriteToFile(IArchitecture &file);
|
|
void Rebase(uint64_t delta_base);
|
|
uint8_t frame_registr() const { return frame_registr_; }
|
|
IRuntimeFunction *source() const { return source_; }
|
|
void set_source(IRuntimeFunction *source) { source_ = source; }
|
|
std::vector<ICommand *> *unwind_opcodes() { return &unwind_opcodes_; }
|
|
void set_unwind_opcodes(const std::vector<ICommand *> &unwind_opcodes) { unwind_opcodes_ = unwind_opcodes; }
|
|
private:
|
|
FunctionInfoList *owner_;
|
|
uint64_t begin_;
|
|
uint64_t end_;
|
|
size_t prolog_size_;
|
|
ICommand *entry_;
|
|
ICommand *data_entry_;
|
|
uint8_t frame_registr_;
|
|
AddressBaseType base_type_;
|
|
uint64_t base_value_;
|
|
IRuntimeFunction *source_;
|
|
std::vector<ICommand *> unwind_opcodes_;
|
|
};
|
|
|
|
class FunctionInfoList : public ObjectList<FunctionInfo>
|
|
{
|
|
public:
|
|
explicit FunctionInfoList();
|
|
explicit FunctionInfoList(const FunctionInfoList &src);
|
|
FunctionInfoList *Clone() const;
|
|
FunctionInfo *GetItemByAddress(uint64_t address) const;
|
|
AddressRange *GetRangeByAddress(uint64_t address) const;
|
|
FunctionInfo *Add(uint64_t begin, uint64_t end, AddressBaseType base_type, uint64_t base_value, size_t prolog_size, uint8_t frame_registr,
|
|
IRuntimeFunction *source, ICommand *entry);
|
|
void Prepare();
|
|
void Compile();
|
|
void WriteToFile(IArchitecture &file);
|
|
void Rebase(uint64_t delta_base);
|
|
private:
|
|
// no assignment op
|
|
FunctionInfoList &operator =(const FunctionInfoList &);
|
|
};
|
|
|
|
class IFunctionList;
|
|
|
|
class IFunction : public ObjectList<ICommand>
|
|
{
|
|
public:
|
|
virtual uint64_t address() const = 0;
|
|
virtual uint64_t break_address() const = 0;
|
|
virtual ObjectType type() const = 0;
|
|
virtual EntryType entry_type() const = 0;
|
|
virtual ICommand *entry() const = 0;
|
|
virtual std::string name() const = 0;
|
|
virtual std::string display_name() const = 0;
|
|
virtual FunctionName full_name() const = 0;
|
|
virtual OperandSize cpu_address_size() const = 0;
|
|
virtual CommandLinkList *link_list() const = 0;
|
|
virtual ExtCommandList *ext_command_list() const = 0;
|
|
virtual CommandBlockList *block_list() const = 0;
|
|
virtual bool need_compile() const = 0;
|
|
virtual CompilationType compilation_type() const = 0;
|
|
virtual CompilationType default_compilation_type() const = 0;
|
|
virtual uint32_t compilation_options() const = 0;
|
|
virtual Folder *folder() const = 0;
|
|
virtual void set_break_address(uint64_t break_address) = 0;
|
|
virtual bool is_breaked_address(uint64_t address) const = 0;
|
|
virtual void set_compilation_type(CompilationType compilation_type) = 0;
|
|
virtual void set_compilation_options(uint32_t compilation_options) = 0;
|
|
virtual void set_need_compile(bool need_compile) = 0;
|
|
virtual void set_folder(Folder *folder) = 0;
|
|
virtual void set_tag(uint8_t tag) = 0;
|
|
virtual bool from_runtime() const = 0;
|
|
virtual void set_from_runtime(bool from_runtime) = 0;
|
|
virtual IFunction *Clone(IFunctionList *owner) const = 0;
|
|
virtual size_t ReadFromFile(IArchitecture &file, uint64_t address) = 0;
|
|
virtual size_t WriteToFile(IArchitecture &file) = 0;
|
|
virtual bool Init(const CompileContext &ctx) = 0;
|
|
virtual bool Prepare(const CompileContext &ctx) = 0;
|
|
virtual bool PrepareExtCommands(const CompileContext &ctx) = 0;
|
|
virtual bool PrepareLinks(const CompileContext &ctx) = 0;
|
|
virtual bool Compile(const CompileContext &ctx) = 0;
|
|
virtual void AfterCompile(const CompileContext &ctx) = 0;
|
|
virtual void CompileLinks(const CompileContext &ctx) = 0;
|
|
virtual void CompileInfo(const CompileContext &ctx) = 0;
|
|
virtual ICommand *GetCommandByAddress(uint64_t address) const = 0;
|
|
virtual ICommand *GetCommandByNearAddress(uint64_t address) const = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file) = 0;
|
|
virtual uint8_t tag() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual uint32_t memory_type() const = 0;
|
|
virtual void set_memory_type(uint32_t memory_type) = 0;
|
|
virtual ICommand *ParseCommand(IArchitecture &file, uint64_t address, bool dump_mode = false) = 0;
|
|
virtual IFunctionList *owner() const = 0;
|
|
virtual IFunction *parent() const = 0;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const = 0;
|
|
virtual CommandBlock *AddBlock(size_t start_index, bool is_executable = false) = 0;
|
|
virtual ICommand *AddCommand(const Data &value) = 0;
|
|
virtual ICommand *AddCommand(OperandSize value_size, uint64_t value) = 0;
|
|
virtual std::string display_address(const std::string &arch_name) const = 0;
|
|
virtual Data hash() const = 0;
|
|
virtual FunctionInfoList *function_info_list() const = 0;
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const = 0;
|
|
#endif
|
|
protected:
|
|
virtual ICommand *CreateCommand() = 0;
|
|
};
|
|
|
|
struct CommandBlockListCompareHelper {
|
|
bool operator () (const CommandBlock *block1, const CommandBlock *block2) const;
|
|
};
|
|
|
|
class BaseFunction : public IFunction
|
|
{
|
|
public:
|
|
explicit BaseFunction(IFunctionList *owner, const FunctionName &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder);
|
|
explicit BaseFunction(IFunctionList *owner, OperandSize cpu_address_size, IFunction *parent);
|
|
explicit BaseFunction(IFunctionList *owner, const BaseFunction &source);
|
|
virtual ~BaseFunction();
|
|
virtual void RemoveObject(ICommand *obj);
|
|
virtual void clear();
|
|
virtual uint64_t address() const { return address_; }
|
|
virtual ObjectType type() const { return type_; }
|
|
virtual EntryType entry_type() const { return entry_type_; }
|
|
virtual void set_entry_type(EntryType entry_type) { entry_type_ = entry_type; }
|
|
virtual ICommand *entry() const { return entry_; }
|
|
virtual std::string name() const { return name_.name(); }
|
|
virtual std::string display_name() const { return name_.display_name(); }
|
|
virtual FunctionName full_name() const { return name_; }
|
|
virtual OperandSize cpu_address_size() const { return cpu_address_size_; }
|
|
virtual CommandLinkList *link_list() const { return link_list_; }
|
|
virtual ExtCommandList *ext_command_list() const { return ext_command_list_; }
|
|
virtual CommandBlockList *block_list() const { return block_list_; }
|
|
virtual bool need_compile() const { return need_compile_; }
|
|
virtual CompilationType compilation_type() const { return (default_compilation_type_ == ctNone) ? compilation_type_ : default_compilation_type_; }
|
|
virtual CompilationType default_compilation_type() const { return default_compilation_type_; }
|
|
virtual uint32_t compilation_options() const { return compilation_options_ | (internal_lock_to_key_ ? coLockToKey : 0); }
|
|
virtual Folder *folder() const { return folder_; }
|
|
virtual uint32_t memory_type() const { return memory_type_; }
|
|
virtual void set_memory_type(uint32_t memory_type) { memory_type_ = memory_type; }
|
|
virtual uint8_t tag() const { return tag_; }
|
|
virtual void set_compilation_type(CompilationType compilation_type);
|
|
virtual void set_compilation_options(uint32_t compilation_options);
|
|
virtual void set_need_compile(bool need_compile);
|
|
virtual void set_folder(Folder *folder);
|
|
virtual void set_tag(uint8_t tag) { tag_ = tag; }
|
|
virtual bool from_runtime() const { return from_runtime_; }
|
|
virtual void set_from_runtime(bool from_runtime) { from_runtime_ = from_runtime; }
|
|
virtual size_t ReadFromFile(IArchitecture &file, uint64_t address);
|
|
virtual size_t WriteToFile(IArchitecture &file);
|
|
virtual ICommand *GetCommandByAddress(uint64_t address) const;
|
|
virtual ICommand *GetCommandByNearAddress(uint64_t address) const;
|
|
virtual bool Init(const CompileContext &ctx);
|
|
virtual bool Prepare(const CompileContext &ctx);
|
|
virtual bool PrepareExtCommands(const CompileContext &ctx);
|
|
virtual bool PrepareLinks(const CompileContext &ctx);
|
|
virtual bool Compile(const CompileContext &ctx);
|
|
virtual void AfterCompile(const CompileContext &ctx);
|
|
virtual void CompileLinks(const CompileContext &ctx);
|
|
virtual void CompileInfo(const CompileContext &ctx);
|
|
void AddWatermark(Watermark *watermark, int copy_count);
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void Rebase(uint64_t delta_base);
|
|
bool FreeByManager(const CompileContext &ctx);
|
|
virtual IFunctionList *owner() const { return owner_; }
|
|
virtual uint64_t break_address() const { return break_address_; }
|
|
virtual void set_break_address(uint64_t break_address);
|
|
virtual bool is_breaked_address(uint64_t address) const { return break_address_ ? address >= break_address_ : false; }
|
|
virtual IFunction *parent() const { return parent_; }
|
|
virtual CommandBlock *AddBlock(size_t start_index, bool is_executable = false);
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
virtual FunctionInfo *range_list() const { return range_list_; }
|
|
virtual FunctionInfoList *function_info_list() const { return function_info_list_; }
|
|
virtual std::string display_address(const std::string &arch_name) const;
|
|
virtual Data hash() const;
|
|
virtual IVirtualMachine *virtual_machine(IVirtualMachineList *virtual_machine_list, ICommand *command) const;
|
|
virtual void AddObject(ICommand *command);
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const;
|
|
#endif
|
|
protected:
|
|
virtual ICommand *ParseString(IArchitecture & /*file*/, uint64_t /*address*/, size_t /*len*/) { return NULL; }
|
|
virtual void ParseBeginCommands(IArchitecture & /*file*/) { return; }
|
|
virtual void ParseEndCommands(IArchitecture & /*file*/) { return; }
|
|
void set_entry(ICommand *entry) { entry_ = entry; }
|
|
ICommand *GetCommandByLowerAddress(uint64_t address) const;
|
|
ICommand *GetCommandByUpperAddress(uint64_t address) const;
|
|
virtual uint64_t GetNextAddress(IArchitecture &file);
|
|
virtual IFunction *CreateFunction(IFunction *parent = NULL) = 0;
|
|
void ClearItems();
|
|
private:
|
|
typedef std::map<uint64_t, ICommand *> map_command_list_t;
|
|
|
|
map_command_list_t map_;
|
|
FunctionName name_;
|
|
IFunction *parent_;
|
|
|
|
uint64_t address_;
|
|
uint64_t break_address_;
|
|
|
|
IFunctionList *owner_;
|
|
CommandLinkList *link_list_;
|
|
ExtCommandList *ext_command_list_;
|
|
CommandBlockList *block_list_;
|
|
Folder *folder_;
|
|
ICommand *entry_;
|
|
FunctionInfo *range_list_;
|
|
FunctionInfoList *function_info_list_;
|
|
|
|
uint32_t compilation_options_;
|
|
uint32_t memory_type_;
|
|
|
|
ObjectType type_;
|
|
OperandSize cpu_address_size_;
|
|
CompilationType compilation_type_;
|
|
CompilationType default_compilation_type_;
|
|
uint8_t tag_;
|
|
EntryType entry_type_;
|
|
bool from_runtime_;
|
|
bool internal_lock_to_key_;
|
|
bool need_compile_;
|
|
|
|
// no copy ctr or assignment op
|
|
BaseFunction(const BaseFunction &);
|
|
BaseFunction &operator =(const BaseFunction &);
|
|
};
|
|
|
|
class Signature: public IObject
|
|
{
|
|
public:
|
|
explicit Signature(SignatureList *owner, const std::string &value, uint32_t tag);
|
|
~Signature();
|
|
size_t size() const { return dump_.size(); }
|
|
uint8_t dump(size_t index) const { return dump_[index]; }
|
|
uint32_t tag() const { return tag_; }
|
|
void InitSearch() { pos_.clear(); }
|
|
bool SearchByte(uint8_t value);
|
|
private:
|
|
void Init();
|
|
|
|
SignatureList *owner_;
|
|
std::string value_;
|
|
std::vector<uint8_t> dump_;
|
|
std::vector<uint8_t> mask_;
|
|
std::vector<size_t> pos_;
|
|
uint32_t tag_;
|
|
};
|
|
|
|
class SignatureList: public ObjectList<Signature>
|
|
{
|
|
public:
|
|
explicit SignatureList();
|
|
Signature *Add(const std::string &value, uint32_t tag = 0);
|
|
void InitSearch();
|
|
};
|
|
|
|
class IFunctionList : public ObjectList<IFunction>
|
|
{
|
|
public:
|
|
virtual IFunction *Add(const std::string &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder) = 0;
|
|
virtual IFunction *GetFunctionByAddress(uint64_t address) const = 0;
|
|
virtual IFunction *GetFunctionByName(const std::string &name) const = 0;
|
|
virtual IFunction *GetUnknownByName(const std::string &name) const = 0;
|
|
virtual ICommand *GetCommandByAddress(uint64_t address, bool need_compile) const = 0;
|
|
virtual ICommand *GetCommandByNearAddress(uint64_t address, bool need_compile) const = 0;
|
|
virtual IFunction *AddUnknown(const std::string &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder) = 0;
|
|
virtual IFunction *AddByAddress(uint64_t address, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder) = 0;
|
|
virtual IFunctionList *Clone(IArchitecture *owner) const = 0;
|
|
virtual bool Prepare(const CompileContext &ctx) = 0;
|
|
virtual bool Compile(const CompileContext &ctx) = 0;
|
|
virtual void CompileLinks(const CompileContext &ctx) = 0;
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file) = 0;
|
|
virtual IFunction *crc_table() const = 0;
|
|
virtual ValueCryptor *crc_cryptor() const = 0;
|
|
virtual void Rebase(uint64_t delta_base) = 0;
|
|
virtual IFunction *CreateFunction(OperandSize cpu_address_size = osDefault) = 0;
|
|
virtual IArchitecture *owner() const = 0;
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const = 0;
|
|
virtual bool GetRuntimeOptions() const = 0;
|
|
virtual std::vector<IFunction *> processor_list() const = 0;
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const = 0;
|
|
#endif
|
|
};
|
|
|
|
class BaseFunctionList : public IFunctionList
|
|
{
|
|
public:
|
|
explicit BaseFunctionList(IArchitecture *owner);
|
|
explicit BaseFunctionList(IArchitecture *owner, const BaseFunctionList &src);
|
|
virtual IFunction *GetFunctionByAddress(uint64_t address) const;
|
|
virtual IFunction *GetFunctionByName(const std::string &name) const;
|
|
virtual IFunction *GetUnknownByName(const std::string &name) const;
|
|
virtual ICommand *GetCommandByAddress(uint64_t address, bool need_compile) const;
|
|
virtual ICommand *GetCommandByNearAddress(uint64_t address, bool need_compile) const;
|
|
virtual IFunction *AddUnknown(const std::string &name, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder);
|
|
virtual IFunction *AddByAddress(uint64_t address, CompilationType compilation_type, uint32_t compilation_options, bool need_compile, Folder *folder);
|
|
virtual bool Prepare(const CompileContext &ctx);
|
|
virtual bool Compile(const CompileContext &ctx);
|
|
virtual void CompileLinks(const CompileContext &ctx);
|
|
virtual void CompileInfo(const CompileContext &ctx);
|
|
virtual void ReadFromBuffer(Buffer &buffer, IArchitecture &file);
|
|
virtual void Rebase(uint64_t delta_base);
|
|
virtual IArchitecture *owner() const { return owner_; }
|
|
virtual void RemoveObject(IFunction *func);
|
|
virtual void Notify(MessageType type, IObject *sender, const std::string &message = "") const;
|
|
virtual std::vector<IFunction *> processor_list() const;
|
|
#ifdef CHECKED
|
|
virtual bool check_hash() const;
|
|
#endif
|
|
private:
|
|
IArchitecture *owner_;
|
|
};
|
|
|
|
typedef std::vector<uint8_t> ByteList;
|
|
|
|
class IVirtualMachine : public IObject
|
|
{
|
|
public:
|
|
virtual uint8_t id() const = 0;
|
|
virtual ByteList *registr_order() = 0;
|
|
virtual bool backward_direction() const = 0;
|
|
virtual IFunction *processor() const = 0;
|
|
};
|
|
|
|
class IVirtualMachineList : public ObjectList<IVirtualMachine>
|
|
{
|
|
public:
|
|
virtual IVirtualMachineList *Clone() const = 0;
|
|
virtual void Prepare(const CompileContext &ctx) = 0;
|
|
};
|
|
|
|
class BaseVirtualMachine : public IVirtualMachine
|
|
{
|
|
public:
|
|
BaseVirtualMachine(IVirtualMachineList *owner, uint8_t id);
|
|
~BaseVirtualMachine();
|
|
virtual uint8_t id() const { return id_; }
|
|
private:
|
|
IVirtualMachineList *owner_;
|
|
uint8_t id_;
|
|
};
|
|
|
|
#endif
|