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>
#include <Rose/Progress.h>
 
class SgAsmInstructionList;
 
namespace Rose {
namespace BinaryAnalysis {
namespace ByteCode {
 
namespace P2 = Partitioner2;
 
using BasicBlockPtr = P2::BasicBlockPtr;
using PartitionerPtr = P2::PartitionerPtr;
using InstructionMap = std::map<Address, SgAsmInstruction*>;
 
// Forward references
class Class;
class Namespace;
class Container;
 
using ClassPtr = Sawyer::SharedPointer<Class>;
using NamespacePtr = Sawyer::SharedPointer<Namespace>;
using ContainerPtr = Sawyer::SharedPointer<Container>;
 
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:
    const std::string& name() const;
    Address address() const;
 
    void finalize();
 
    virtual bool returnsVoid() const;
    virtual bool isStatic() const = 0;
    virtual bool isSystemReserved(const std::string &name) const = 0;
 
    virtual const SgAsmInstructionList* instructions() const = 0;
    virtual void decode(const Disassembler::BasePtr&) const = 0;
 
    virtual std::string descriptor() const = 0;
 
    /* The method identity; class + name + descriptor */
    virtual std::string identity() const;
 
    /* Annotate the AST (.e.g., add comments to instructions) */
    virtual void annotate() = 0;
 
    /* Set of instruction branch targets */
    std::set<Address> targets() const;
 
    /* Accessors to the declaring class for this method */
    Class* declaringClass() const;
    void declaringClass(Class *declaringClass);
 
    /* Retrieve the instruction at the given address */
    SgAsmInstruction* instructionAt(Address va) const;
 
    // Methods associated with basic blocks (Rose::BinaryAnalysis::Partitioner2)
    //
    const std::vector<BasicBlockPtr>& blocks() const;
    void append(BasicBlockPtr bb);
 
    Method() = delete;
 
  protected:
    Method(std::string name, Address va);
 
  private:
    std::string name_;
 
  protected:
    Address address_ = 0;
 
  private:
    Class* class_ = nullptr; // non-owning pointer to the declaring class
    P2::FunctionPtr function_;
    std::vector<BasicBlockPtr> blocks_;
    InstructionMap instructionMap_;
};
 
class Interface: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Interface> {
  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>;
    using NamespacePtr = Sawyer::SharedPointer<Namespace>; // forward declaration
 
    virtual ~Class();
 
    // Dynamic pointer cast. No-op since this is the base class
    //  static Class promote(const Class&);
 
    const std::string& name() const;
    const std::string& baseClassName() const;
 
    Address address() const;
    NamespacePtr nameSpace() const;
 
    ByteCode::Method::Ptr findMethod(const std::string &name, const std::string &descriptor) const;
 
    virtual std::string qualifiedName() const;
    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;
 
    void finalize();
 
    virtual void partition(const PartitionerPtr &partitioner, std::map<std::string,Address> &discoveredFunctions,
                           const Progress::Ptr &progress = Progress::Ptr());
    virtual void digraph() const;
    virtual void dump() = 0;
 
    Class() = delete;
 
  private:
    std::string name_;
    Address address_ = 0; // Base virtual address assigned to this loaded class file
    NamespacePtr namespace_;
 
  protected:
    Class(std::string name, Address va, NamespacePtr ns);
 
    std::string baseClassName_;
 
    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>;
    using ContainerPtr = Sawyer::SharedPointer<Container>; // forward declaration
 
    virtual ~Namespace() = default;
 
    static Ptr instance(std::string name, ContainerPtr container);
 
    virtual std::string name() const;
    virtual void partition(const PartitionerPtr &partitioner,
                           std::map<std::string,Address> &discoveredFunctions);
 
    void append(Class::Ptr ptr);
 
    const std::vector<ByteCode::Class::Ptr>& classes() const;
 
  protected:
    Namespace() = delete;
    explicit Namespace(std::string name, ContainerPtr container);
 
    std::vector<ByteCode::Class::Ptr> classes_;
 
  private:
    std::string name_;
};
 
class Container: public Sawyer::SharedObject,
                 public Sawyer::SharedFromThis<Container> {
  public:
    using Ptr = Sawyer::SharedPointer<Container>;
 
    virtual ~Container() = default;
 
    /* A unique (per container) virtual address for system/library functions */
    static Address nextSystemReservedVa();
 
  public:
    virtual std::string name() const;
    virtual bool isSystemReserved(const std::string &name) const = 0;
    virtual void partition(const PartitionerPtr &partitioner);
 
    void append(Namespace::Ptr ptr);
 
    const std::vector<Namespace::Ptr>& namespaces() const;
 
  protected:
    Container() = delete;
    explicit Container(std::string name);
 
    std::vector<Namespace::Ptr> namespaces_;
 
  private:
    std::string name_;
    static Address nextSystemReservedVa_;
};
 
class ClassRepository: public Sawyer::SharedObject,
                        public Sawyer::SharedFromThis<ClassRepository> {
  public:
    using Ptr = Sawyer::SharedPointer<ClassRepository>;
 
    ClassRepository() = default;
    virtual ~ClassRepository() = default;
 
  public:
 
    static Ptr instance();
 
    bool insert(const Class::Ptr &cls);
 
    bool contains(const std::string &name) const;
 
    ByteCode::ClassPtr findClass(const std::string &name) const;
 
    bool isAssignableTo(const ClassPtr &source, const ClassPtr &target) const;
 
  private:
    std::map<std::string, ClassPtr> classes_;
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif