BinaryAnalysis/ByteCode/Analysis.h

#ifndef ROSE_BinaryAnalysis_ByteCode_Analysis_H
#define ROSE_BinaryAnalysis_ByteCode_Analysis_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Disassembler/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
 
// For operators
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
 
class SgAsmInstructionList;
 
namespace P2 = Rose::BinaryAnalysis::Partitioner2;
namespace BS = Rose::BinaryAnalysis::InstructionSemantics::BaseSemantics;
 
namespace Rose {
namespace BinaryAnalysis {
namespace ByteCode {
 
using BasicBlockPtr = P2::BasicBlockPtr;
using PartitionerPtr = P2::PartitionerPtr;
 
// Forward references
class Class;
class Namespace;
 
using NamespacePtr = Sawyer::SharedPointer<Namespace>;
 
class Code: public Sawyer::SharedObject,
            public Sawyer::SharedFromThis<Code> {
  public:
    using Ptr = Sawyer::SharedPointer<Code>;
 
    virtual ~Code();
 
public:
    virtual const uint8_t* bytes() const = 0;
    virtual size_t size() const = 0;
    virtual Address offset() const = 0;
 
protected:
    Code();
};
 
class Field: public Sawyer::SharedObject,
             public Sawyer::SharedFromThis<Field> {
  public:
    using Ptr = Sawyer::SharedPointer<Field>;
 
    virtual ~Field();
 
public:
    virtual std::string name() const = 0;
 
protected:
    Field();
};
 
class Method: public Sawyer::SharedObject,
              public Sawyer::SharedFromThis<Method> {
  public:
    using Ptr = Sawyer::SharedPointer<Method>;
 
    virtual ~Method();
 
public:
    virtual std::string name() const = 0;
    virtual bool isSystemReserved(const std::string &name) const = 0;
 
    virtual const Code & code() const = 0;
    virtual const SgAsmInstructionList* instructions() const = 0;
    virtual void decode(const Disassembler::BasePtr&) const = 0;
 
    /* Annotate the AST (.e.g., add comments to instructions) */
    virtual void annotate() = 0;
 
    /* Set of instruction branch targets */
    std::set<Address> targets() const;
 
    // Methods associated with basic blocks (Rose::BinaryAnalysis::Partitioner2)
    //
    const std::vector<BasicBlockPtr>& blocks() const;
    void append(BasicBlockPtr bb);
 
    Method() = delete;
 
protected:
    Method(Address);
    Address classAddr_;
    P2::FunctionPtr function_;
    std::vector<BasicBlockPtr> blocks_;
};
 
class Interface: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Class> {
  public:
    using Ptr = Sawyer::SharedPointer<Interface>;
 
    virtual ~Interface();
 
    virtual std::string name() const = 0;
 
  protected:
    Interface();
};
 
class Attribute: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Attribute> {
public:
    using Ptr = Sawyer::SharedPointer<Attribute>;
 
    virtual ~Attribute();
 
    virtual std::string name() const = 0;
 
  protected:
    Attribute();
};
 
class Class: public Sawyer::SharedObject,
             public Sawyer::SharedFromThis<Class> {
  public:
    using Ptr = Sawyer::SharedPointer<Class>;
 
    virtual ~Class();
 
    // Dynamic pointer cast. No-op since this is the base class
    //  static Class promote(const Class&);
 
    virtual std::string name() const = 0;
    virtual std::string super_name() const = 0;
    virtual std::string typeSeparator() const = 0;
 
    virtual const std::vector<std::string>& strings();
 
    const std::vector<Field::Ptr>& fields() const;
    const std::vector<Method::Ptr>& methods() const;
    const std::vector<Attribute::Ptr>& attributes() const;
    const std::vector<Interface::Ptr>& interfaces() const;
 
    virtual void partition(const PartitionerPtr &partitioner, BS::RiscOperatorsPtr &ops,
                           std::map<std::string,Address> &discoveredFunctions) const;
 
    virtual void digraph() const;
    virtual void dump() = 0;
 
    Address address() const;
 
    Class() = delete;
 
  protected:
    Address address_;
    NamespacePtr namespace_;
    Class(NamespacePtr ns, Address va);
 
    std::vector<Field::Ptr> fields_;
    std::vector<Method::Ptr> methods_;
    std::vector<Attribute::Ptr> attributes_;
    std::vector<Interface::Ptr> interfaces_;
    std::vector<std::string> strings_;
};
 
class Namespace: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Namespace> {
  public:
    using Ptr = Sawyer::SharedPointer<Namespace>;
 
    virtual ~Namespace();
 
    static Ptr instance();
 
    virtual std::string name() const;
    virtual void partition(const PartitionerPtr &partitioner, BS::RiscOperatorsPtr &ops,
                           std::map<std::string,Address> &discoveredFunctions) const;
 
    void append(Class::Ptr ptr);
 
    const std::vector<ByteCode::Class::Ptr>& classes() const;
 
  protected:
    Namespace();
    std::vector<ByteCode::Class::Ptr> classes_;
};
 
class Container: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Container> {
  public:
    using Ptr = Sawyer::SharedPointer<Container>;
 
    virtual ~Container();
 
    /* A unique (per container) virtual address for system/library functions */
    static Address nextSystemReservedVa();
 
  public:
    virtual std::string name() const = 0;
    virtual bool isSystemReserved(const std::string &name) const = 0;
    virtual void partition(const PartitionerPtr &partitioner, BS::RiscOperatorsPtr &ops) const;
 
    const std::vector<Namespace::Ptr>& namespaces() const;
 
  protected:
    Container();
    std::vector<Namespace::Ptr> namespaces_;
 
  private:
    static Address nextSystemReservedVa_;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif