Architecture/Base.h

#ifndef ROSE_BinaryAnalysis_Architecture_Base_H
#define ROSE_BinaryAnalysis_Architecture_Base_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Alignment.h>
#include <Rose/BinaryAnalysis/Architecture/BasicTypes.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/BaseSemantics/BasicTypes.h>
#include <Rose/BinaryAnalysis/Unparser/Base.h>
 
#include <Sawyer/Interval.h>
#include <Sawyer/Optional.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Architecture {
 
class Base: public std::enable_shared_from_this<Base> {
public:
    using Ptr = BasePtr;
 
    using ConstPtr = BaseConstPtr;
 
private:
    std::string name_;                                  // name of architecture
    Sawyer::Optional<size_t> registrationId_;           // registration identification number
    size_t bytesPerWord_ = 0;
    ByteOrder::Endianness byteOrder_ = ByteOrder::ORDER_UNSPECIFIED;
 
protected:
    Sawyer::Cached<RegisterDictionaryPtr> registerDictionary_;
    Sawyer::Cached<RegisterDictionaryPtr> interruptDictionary_;
    Sawyer::Cached<CallingConvention::Dictionary> callingConventions_;
    Sawyer::Cached<Unparser::Base::Ptr> insnToString_, insnToStringNoAddr_;
 
protected:
    Base(const std::string &name, size_t bytesPerWord, ByteOrder::Endianness byteOrder);
    virtual ~Base();
 
    // Properties
public:
    const std::string& name() const;
 
    const Sawyer::Optional<size_t>& registrationId() const;
    void registrationId(const Sawyer::Optional<size_t>&);
    size_t bytesPerWord() const;
    size_t bitsPerWord() const;
    ByteOrder::Endianness byteOrder() const;
 
    virtual RegisterDictionaryPtr registerDictionary() const = 0;
 
    virtual RegisterDictionaryPtr interruptDictionary() const;
 
    virtual const CallingConvention::Dictionary& callingConventions() const;
 
    // Lookup functions
public:
    virtual bool matchesName(const std::string&) const;
 
    virtual bool matchesHeader(SgAsmGenericHeader*) const;
 
    // Factories
public:
    virtual Disassembler::BasePtr newInstructionDecoder() const = 0;
 
    virtual Unparser::BasePtr newUnparser() const = 0;
    virtual Unparser::BasePtr newInstructionUnparser() const;
    virtual InstructionSemantics::BaseSemantics::DispatcherPtr
    newInstructionDispatcher(const InstructionSemantics::BaseSemantics::RiscOperatorsPtr&) const;
 
    // Instruction characteristics
public:
    virtual Sawyer::Container::Interval<size_t> bytesPerInstruction() const = 0;
 
    virtual Alignment instructionAlignment() const = 0;
 
    bool instructionsCanOverlap() const;
 
    virtual std::string toString(const SgAsmInstruction*) const;
    virtual std::string toStringNoAddr(const SgAsmInstruction*) const;
    virtual std::string toString(const SgAsmExpression*) const;
 
    virtual std::string instructionMnemonic(const SgAsmInstruction*) const = 0;
 
    virtual std::string instructionDescription(const SgAsmInstruction*) const;
 
    virtual bool isUnknown(const SgAsmInstruction*) const = 0;
 
    virtual bool isControlTransfer(const SgAsmInstruction*) const;
 
    virtual bool terminatesBasicBlock(SgAsmInstruction*) const = 0;
 
    virtual bool isFunctionCallFast(const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret) const;
    virtual bool isFunctionCallSlow(const std::vector<SgAsmInstruction*>&, rose_addr_t *target, rose_addr_t *ret) const;
    virtual bool isFunctionReturnFast(const std::vector<SgAsmInstruction*>&) const;
    virtual bool isFunctionReturnSlow(const std::vector<SgAsmInstruction*>&) const;
    virtual Sawyer::Optional<rose_addr_t> branchTarget(SgAsmInstruction*) const;
 
    virtual AddressSet getSuccessors(SgAsmInstruction*, bool &complete) const;
 
    AddressSet getSuccessors(const std::vector<SgAsmInstruction*> &basicBlock, bool &complete) const;
    virtual AddressSet getSuccessors(const std::vector<SgAsmInstruction*> &basicBlock, bool &complete,
                                     const MemoryMapPtr &initial_memory) const;
    // Architecture-specific stuff for a partitioning engine.
public:
    virtual std::vector<Partitioner2::FunctionPrologueMatcherPtr>
    functionPrologueMatchers(const Partitioner2::EnginePtr&) const;
 
    virtual std::vector<Partitioner2::BasicBlockCallbackPtr>
    basicBlockCreationHooks(const Partitioner2::EnginePtr&) const;
 
    // Miscellaneous
protected:
    Ptr ptr();
    ConstPtr constPtr() const;
 
    // Safely obtain a pointer to an unparser that's suitable for unparsing an instruction or expression.
    virtual Unparser::BasePtr insnUnparser() const;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif