FunctionInfo.h

#ifndef FUNCTION_INFO_H
#define FUNCTION_INFO_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include <Rose/BinaryAnalysis/AstHash.h>
#include "Combinatorics.h"
#include <Rose/BinaryAnalysis/Partitioner2/Partitioner.h>
#include <Rose/BinaryAnalysis/Partitioner2/Function.h>
namespace LibraryIdentification
{
    class FunctionInfo
    {
    public:
    FunctionInfo(const std::string& ifuncName, const std::string& ifuncHash, const std::string& ilibHash) :
        funcName(ifuncName), funcHash(ifuncHash), libHash(ilibHash), binaryFunction() {};
        
    FunctionInfo(const Rose::BinaryAnalysis::Partitioner2::Partitioner& partitioner, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function, const std::string& ilibHash) :
        funcName(function->name()),  libHash(ilibHash), binaryFunction(function)
        {
             initializeHash(partitioner, function);
        }


    FunctionInfo(const Rose::BinaryAnalysis::Partitioner2::Partitioner& partitioner, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function) :
        funcName(function->name()),  libHash(), binaryFunction(function)
        {
             initializeHash(partitioner, function);
        }
        
    FunctionInfo(const Rose::BinaryAnalysis::Partitioner2::Partitioner& partitioner, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function, LibraryInfo& libInfo) :
        funcName(function->name()),  libHash(libInfo.libHash), binaryFunction(function)
        {
             initializeHash(partitioner, function);
        }

    FunctionInfo(const std::string& ifuncHash) :
        funcName(""), funcHash(ifuncHash), libHash(""), binaryFunction() {};

    FunctionInfo(const std::string& ifuncHash, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function) :
        funcHash(ifuncHash), libHash(""), binaryFunction(function) {
            if(function != 0) {
                funcName = function->name();    
            }
        }; 

        friend bool operator<(const FunctionInfo& lhs, const FunctionInfo& rhs) 
        {
            return lhs.funcHash < rhs.funcHash;
        }

        bool operator==(const FunctionInfo& rhs) 
        {
            if(funcName == rhs.funcName &&
               funcHash == rhs.funcHash &&
               libHash == rhs.libHash) 
                {
                    return true;
                }
            return false;
            
        }
        


        //@brief The name of the function
        std::string funcName;

        //@brief A hash that should uniquely identify the function
        std::string funcHash;

        //@brief A hash that should uniquely identify the library the
        //function belongs to.  It should already be in the database.
        std::string libHash;

        //@brief A pointer to the binary version of this function IF
        //IT'S AVAILIBLE.  THIS IS LIKELY TO BE NULL
        Rose::BinaryAnalysis::Partitioner2::Function::Ptr binaryFunction;
        
        static std::string getHash(const Rose::BinaryAnalysis::Partitioner2::Partitioner& partitioner, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function) 
        {
            boost::shared_ptr<Rose::Combinatorics::Hasher> hasher = Rose::Combinatorics::Hasher::HasherFactory::Instance().createHasher("SHA256");
            Rose::BinaryAnalysis::AstHash astHash(hasher);            

            const std::set<rose_addr_t>& basicBlocks = function->basicBlockAddresses();
            
            for(std::set<rose_addr_t>::const_iterator bbIt = basicBlocks.begin(); bbIt != basicBlocks.end(); ++bbIt) 
                {
                    Rose::BinaryAnalysis::Partitioner2::BasicBlock::Ptr bb = partitioner.basicBlockExists(*bbIt);
                    ROSE_ASSERT(bb != NULL);
                    astHash.appendBasicBlock(bb);
                    
                }

            return hasher->toString();
        }
        

    private:
        void initializeHash(const Rose::BinaryAnalysis::Partitioner2::Partitioner& partitioner, Rose::BinaryAnalysis::Partitioner2::Function::Ptr function) 
        {   //Ordered set, so it should always be the same order...
            funcHash = getHash(partitioner, function);
            
        }

    };
    
}

#endif
#endif