ModulesElf.h

#ifndef ROSE_BinaryAnalysis_Partitioner2_ModulesElf_H
#define ROSE_BinaryAnalysis_Partitioner2_ModulesElf_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/Partitioner2/BasicTypes.h>
#include <Rose/BinaryAnalysis/Partitioner2/Function.h>
#include <Rose/BinaryAnalysis/Partitioner2/Modules.h>
 
#include <boost/filesystem.hpp>
 
namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {
 
namespace ModulesElf {
 
std::vector<FunctionPtr> findErrorHandlingFunctions(SgAsmElfFileHeader*);
std::vector<FunctionPtr> findErrorHandlingFunctions(SgAsmInterpretation*);
size_t findErrorHandlingFunctions(SgAsmElfFileHeader*, std::vector<FunctionPtr>&);
std::vector<FunctionPtr> findPltFunctions(const PartitionerPtr&, SgAsmElfFileHeader*);
std::vector<FunctionPtr> findPltFunctions(const PartitionerPtr&, SgAsmInterpretation*);
size_t findPltFunctions(const PartitionerPtr&, SgAsmElfFileHeader*, std::vector<FunctionPtr>&);
struct PltInfo {
    SgAsmGenericSection *section;
    size_t firstOffset;                                 
    size_t entrySize;                                   
    PltInfo()
        : section(NULL), firstOffset(0), entrySize(0) {}
};
 
PltInfo findPlt(const PartitionerConstPtr&, SgAsmGenericSection*, SgAsmElfFileHeader*);
 
std::vector<SgAsmElfSection*> findSectionsByName(SgAsmInterpretation*, const std::string&);
 
bool isImport(const PartitionerConstPtr&, const FunctionPtr&);
 
bool isLinkedImport(const PartitionerConstPtr&, const FunctionPtr&);
 
bool isUnlinkedImport(const PartitionerConstPtr&, const FunctionPtr&);
 
bool isObjectFile(const boost::filesystem::path&);
 
bool isStaticArchive(const boost::filesystem::path&);
 
namespace FixUndefinedSymbols {
enum Boolean {
    NO,                                                 
    YES                                                 
};
} // namespace
 
bool tryLink(const std::string &command, const boost::filesystem::path &outputName,
             std::vector<boost::filesystem::path> inputNames, Sawyer::Message::Stream &errors,
             FixUndefinedSymbols::Boolean fixUndefinedSymbols = FixUndefinedSymbols::YES);
 
std::vector<boost::filesystem::path>
extractStaticArchive(const boost::filesystem::path &directory, const boost::filesystem::path &archive);
 
struct PltEntryMatcher: public InstructionMatcher {
    // These data members are generally optional, and filled in as they're matched.
    rose_addr_t gotVa_ = 0;                             // address of global offset table
    rose_addr_t gotEntryVa_ = 0;                        // address through which an indirect branch branches
    size_t gotEntryNBytes_ = 0;                         // size of the global offset table entry in bytes
    rose_addr_t gotEntry_ = 0;                          // address read from the GOT if the address is mapped (or zero)
    size_t nBytesMatched_ = 0;                          // number of bytes matched for PLT entry
    rose_addr_t functionNumber_ = 0;                    // function number argument for the dynamic linker (usually a push)
    rose_addr_t pltEntryAlignment_ = 1;                 // must PLT entries be aligned, and by how much?
 
public:
    explicit PltEntryMatcher(rose_addr_t gotVa)
        : gotVa_(gotVa) {}
    static Ptr instance(rose_addr_t gotVa) {
        return Ptr(new PltEntryMatcher(gotVa));
    }
    virtual bool match(const PartitionerConstPtr&, rose_addr_t anchor);
 
    rose_addr_t gotVa() const { return gotVa_; }
 
    size_t nBytesMatched() const { return nBytesMatched_; }
 
    rose_addr_t pltEntryAlignment() const { return pltEntryAlignment_; }
 
    rose_addr_t gotEntryVa() const { return gotEntryVa_; }
 
    size_t gotEntryNBytes() const { return gotEntryNBytes_; }
    
    rose_addr_t gotEntry() const { return gotEntry_; }
 
private:
    SgAsmInstruction* matchNop(const PartitionerConstPtr&, rose_addr_t va);
    SgAsmInstruction* matchPush(const PartitionerConstPtr&, rose_addr_t var, rose_addr_t &n /*out*/);
    SgAsmInstruction* matchDirectJump(const PartitionerConstPtr&, rose_addr_t va);
    SgAsmInstruction* matchIndirectJump(const PartitionerConstPtr&, rose_addr_t va,
                                        rose_addr_t &indirectVa /*out*/, size_t &indirectNBytes /*out*/);
    SgAsmInstruction* matchIndirectJumpEbx(const PartitionerConstPtr&, rose_addr_t va,
                                           rose_addr_t &offsetFromEbx /*out*/, size_t &indirectNBytes /*out*/);
    SgAsmInstruction* matchAarch64Adrp(const PartitionerConstPtr&, rose_addr_t va, rose_addr_t &value /*out*/);
    SgAsmInstruction* matchAarch64Ldr(const PartitionerConstPtr&, rose_addr_t va, rose_addr_t &indirectVa /*in,out*/,
                                      rose_addr_t &indirectNBytes /*out*/);
    SgAsmInstruction* matchAarch64Add(const PartitionerConstPtr&, rose_addr_t va);
    SgAsmInstruction* matchAarch64Br(const PartitionerConstPtr&, rose_addr_t va);
    SgAsmInstruction* matchAarch32CopyPcToIp(const PartitionerConstPtr&, rose_addr_t va, uint32_t &result);
    SgAsmInstruction* matchAarch32AddConstToIp(const PartitionerConstPtr&, rose_addr_t va, uint32_t &addend);
    SgAsmInstruction* matchAarch32IndirectBranch(const PartitionerConstPtr&, rose_addr_t va, uint32_t &addend);
};
 
void buildMayReturnLists(const PartitionerPtr&);
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif