AstHash.h

#ifndef ROSE_BinaryAnalysis_AstHash_H
#define ROSE_BinaryAnalysis_AstHash_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/MemoryMap.h>
#include <Rose/BinaryAnalysis/Partitioner2/BasicBlock.h>
#include "Combinatorics.h"
 
namespace Rose {
namespace BinaryAnalysis {
 
     class AstHash: public AstSimpleProcessing
        {
          public:
            // @brief Constructor just initializes output buffer  
        AstHash(boost::shared_ptr<Rose::Combinatorics::Hasher> in_hasher, bool includeConstants = false, bool includeAddresses = false) : 
                hasher_(in_hasher), includeConstants(includeConstants), includeAddresses(includeAddresses){}
               
            // @brief Generates the hash. Called by traverse
            void visit(SgNode* n);
            
            // @brief For the Partitioner Interface, traverses a basic block
            void appendBasicBlock(Rose::BinaryAnalysis::Partitioner2::BasicBlockPtr bb );
 
            // @brief Gets the Rose::Combinatorics::Hasher
            const boost::shared_ptr<Rose::Combinatorics::Hasher> hasher() const { return hasher_; }; 
 
        private:
            // @brief The reference used to the output data buffer,
            // get the opcodes
            boost::shared_ptr<Rose::Combinatorics::Hasher> hasher_;
 
            // @brief Include constant values in the hash, usually
            // false to avoid linking changing pointers, and therefore
            // the signature
            bool includeConstants;
 
            // @brief Include instruction addresses in the hash, usually
            // false to avoid different memory map changing the signature
            bool includeAddresses;
 
        };
     class AstHash: public AstSimpleProcessing {…};
 
} // namespace
} // namespace
 
#endif
#endif