Reference.h

#ifndef ROSE_Partitioner2_Reference_H
#define ROSE_Partitioner2_Reference_H

#include <rosePublicConfig.h>
#ifdef ROSE_BUILD_BINARY_ANALYSIS_SUPPORT

#include <Partitioner2/BasicBlock.h>
#include <Partitioner2/Function.h>
#include <set>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

//                                      Reference

class Reference {
    Function::Ptr function_;
    BasicBlock::Ptr bblock_;
    SgAsmInstruction *insn_;
    Sawyer::Optional<rose_addr_t> address_;
public:
    enum Granularity {
        EMPTY,                                      
        ADDRESS,                                    
        INSTRUCTION,                                
        BASIC_BLOCK,                                
        FUNCTION                                    
    };

    explicit Reference(const Function::Ptr &function, const BasicBlock::Ptr &bblock=BasicBlock::Ptr(),
                       SgAsmInstruction *insn=NULL, const Sawyer::Optional<rose_addr_t> &address=Sawyer::Nothing())
        : function_(function), bblock_(bblock), insn_(insn), address_(address) {}


    explicit Reference(const BasicBlock::Ptr &bblock, SgAsmInstruction *insn=NULL,
                       const Sawyer::Optional<rose_addr_t> &address=Sawyer::Nothing())
        : bblock_(bblock), insn_(insn), address_(address) {}

    explicit Reference(SgAsmInstruction *insn, const Sawyer::Optional<rose_addr_t> &address=Sawyer::Nothing())
        : insn_(insn), address_(address) {}

    explicit Reference(rose_addr_t address)
        : insn_(NULL), address_(address) {}

    Reference()
        : insn_(NULL) {}
    Granularity granularity() const {
        if (address_)
            return ADDRESS;
        if (insn_)
            return INSTRUCTION;
        if (bblock_)
            return BASIC_BLOCK;
        if (function_)
            return FUNCTION;
        return EMPTY;
    }

    bool isEmpty() const {
        return granularity()==EMPTY;
    }

    bool hasFunction() const {
        return function_!=NULL;
    }

    Function::Ptr function() const {
        return function_;
    }

    bool hasBasicBlock() const {
        return bblock_!=NULL;
    }

    BasicBlock::Ptr basicBlock() const {
        return bblock_;
    }

    bool hasInstruction() const {
        return insn_ != NULL;
    }

    SgAsmInstruction* instruction() const {
        return insn_;
    }

    bool hasExplicitAddress() const {
        return address_;
    }

    rose_addr_t address() const;

    bool operator==(const Reference &other) const;

    bool operator<(const Reference &other) const;
};

typedef std::set<Reference> ReferenceSet;

typedef Sawyer::Container::Map<Reference, ReferenceSet> CrossReferences;

} // namespace
} // namespace
} // namespace

#endif
#endif