StoragePool.h

#ifndef ROSE_BinaryAnalysis_CallingConvention_StoragePool_H
#define ROSE_BinaryAnalysis_CallingConvention_StoragePool_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
#include <Rose/BinaryAnalysis/CallingConvention/BasicTypes.h>
 
#include <Rose/BinaryAnalysis/Address.h>
#include <Rose/BinaryAnalysis/Alignment.h>
#include <Rose/BinaryAnalysis/ByteOrder.h>
#include <Rose/BinaryAnalysis/ConcreteLocation.h>
 
#include <string>
#include <vector>
 
class SgAsmType;
 
namespace Rose {
namespace BinaryAnalysis {
namespace CallingConvention {
 
 
class TypePredicate {
public:
    using Ptr = TypePredicatePtr;
    using ConstPtr = TypePredicateConstPtr;
public:
    virtual ~TypePredicate();
protected:
    TypePredicate();
 
public:
    virtual bool test(SgAsmType*) const = 0;
    bool operator()(SgAsmType*) const;
};
 
template<class F>
class TypePredicateFunctor: public TypePredicate {
    F f;
public:
    TypePredicateFunctor(F f)
        : f(f) {}
 
    bool test(SgAsmType *type) const override {
        return f(type);
    }
};
 
TypePredicate::Ptr isAnyType();
 
TypePredicate::Ptr isFpNotWiderThan(size_t nBits);
 
TypePredicate::Ptr isIntegerNotWiderThan(size_t nBits);
 
TypePredicate::Ptr isPointerNotWiderThan(size_t nBits);
 
TypePredicate::Ptr isNonFpNotWiderThan(size_t nBits);
 
 
class StoragePoolBase {
public:
    using Ptr = StoragePoolBasePtr;
    using ConstPtr = StoragePoolBaseConstPtr;
private:
    std::string name_;                                  // name for debugging
    TypePredicateConstPtr canStore_;                    // predicate for types that the locations can store
 
public:
    virtual ~StoragePoolBase();
protected:
    StoragePoolBase() = delete;
    StoragePoolBase(const std::string &name, const TypePredicateConstPtr&);
 
public:
    virtual Ptr copy() const = 0;
 
    virtual bool canStore(SgAsmType*) const;
 
    virtual void reset() = 0;
 
    virtual std::vector<ConcreteLocation> consume(SgAsmType*) = 0;
 
    virtual std::vector<ConcreteLocation> constantLocations() const;
};
 
 
class StoragePoolEnumerated: public StoragePoolBase {
public:
    using Ptr = StoragePoolEnumeratedPtr;
    using ConstPtr = StoragePoolEnumeratedConstPtr;
private:
    std::vector<ConcreteLocation> locations_;
    size_t current_ = 0;                                // points to the next available location in `locations_`
 
public:
    ~StoragePoolEnumerated();
protected:
    StoragePoolEnumerated() = delete;
    StoragePoolEnumerated(const std::string &name, const TypePredicateConstPtr&);
 
public:
    static Ptr instance(const std::string &name, const TypePredicateConstPtr&);
 
    void append(const ConcreteLocation&);
 
public:
    StoragePoolBasePtr copy() const override;
    std::vector<ConcreteLocation> constantLocations() const override;
    std::vector<ConcreteLocation> consume(SgAsmType*) override;
    void reset() override;
};
 
 
class StoragePoolStack: public StoragePoolBase {
public:
    using Ptr = StoragePoolStackPtr;
    using ConstPtr = StoragePoolStackConstPtr;
private:
    StackDirection stackDirection_ = StackDirection::GROWS_DOWN;
    size_t minimumValueSize_ = 1;
    Alignment valuePadding_;
    ByteOrder::Endianness valueJustification_ = ByteOrder::ORDER_LSB;
    Alignment alignment_;
    RegisterDescriptor baseRegister_;
    RegisterDictionaryPtr registerDictionary_;
 
    // Stack offsets are signed quantities measured from the perspective of the called function immediately after the "call"
    // instruction (whatever that might be for the architecture, such as `CALL` on x86). If the stack grows down then the storage
    // addresses are higher than the current stack pointer; or vice versa.
    int64_t initialOffset_ = 0;                         // offset from caller's SP to nearest storage location on the stack
    int64_t offset_ = 0;                                // adjusted by allocation: down if stack grows down, up if stack grows up
 
public:
    ~StoragePoolStack();
    StoragePoolStack() = delete;
    StoragePoolStack(const std::string &name, const TypePredicateConstPtr&,
                     const Rose::BinaryAnalysis::Architecture::BaseConstPtr&);
 
public:
    static Ptr instance(const std::string &name, const TypePredicateConstPtr&, const Architecture::BaseConstPtr&);
 
public:
    StackDirection stackDirection() const;
    void stackDirection(StackDirection);
    int64_t initialOffset() const;
    void initialOffset(int64_t);
    size_t minimumValueSize() const;
    void minimumValueSize(size_t m);
    const Alignment& valuePadding() const;
    void valuePadding(const Alignment&);
    ByteOrder::Endianness valueJustification() const;
    void valueJustification(ByteOrder::Endianness);
    const Alignment& alignment() const;
    void alignment(const Alignment&);
    RegisterDescriptor baseRegister() const;
    void baseRegister(RegisterDescriptor);
public:
    StoragePoolBasePtr copy() const override;
    std::vector<ConcreteLocation> consume(SgAsmType*) override;
    void reset() override;
};
 
 
class Allocator {
public:
    using Ptr = AllocatorPtr;
    using ConstPtr = AllocatorConstPtr;
private:
    std::vector<StoragePoolBaseConstPtr> initialPools_;
 
    // Initialized with copies of the `initialPools_` above when `reset` is called. That way, the methods that modify the state of
    // the pools (allocating space for arguments, etc) operate on copies without modifying the originals.
    std::vector<StoragePoolBasePtr> activePools_;
 
public:
    ~Allocator();
    Allocator();
 
public:
    static Ptr instance();
 
    void append(const StoragePoolBaseConstPtr&);
 
    void reset();
 
    std::vector<ConcreteLocation> allocate(SgAsmType*);
};
 
} // namespace
} // namespace
} // namespace
 
#endif
#endif