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) {}
};
struct PltInfo {…};
 
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                                                 
};
enum Boolean {…};
} // namespace
namespace FixUndefinedSymbols {…}
 
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.
    Address gotVa_ = 0;                                 // address of global offset table
    Address gotEntryVa_ = 0;                            // address through which an indirect branch branches
    size_t gotEntryNBytes_ = 0;                         // size of the global offset table entry in bytes
    Address 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
    Address functionNumber_ = 0;                        // function number argument for the dynamic linker (usually a push)
    Address pltEntryAlignment_ = 1;                     // must PLT entries be aligned, and by how much?
 
public:
    explicit PltEntryMatcher(Address gotVa)
        : gotVa_(gotVa) {}
    static Ptr instance(Address gotVa) {
        return Ptr(new PltEntryMatcher(gotVa));
    }
    virtual bool match(const PartitionerConstPtr&, Address anchor);
 
    Address gotVa() const { return gotVa_; }
 
    size_t nBytesMatched() const { return nBytesMatched_; }
 
    Address pltEntryAlignment() const { return pltEntryAlignment_; }
 
    Address gotEntryVa() const { return gotEntryVa_; }
 
    size_t gotEntryNBytes() const { return gotEntryNBytes_; }
    
    Address gotEntry() const { return gotEntry_; }
 
private:
    SgAsmInstruction* matchNop(const PartitionerConstPtr&, Address va);
    SgAsmInstruction* matchPush(const PartitionerConstPtr&, Address var, Address &n /*out*/);
    SgAsmInstruction* matchDirectJump(const PartitionerConstPtr&, Address va);
    SgAsmInstruction* matchIndirectJump(const PartitionerConstPtr&, Address va, Address &indirectVa /*out*/,
                                        size_t &indirectNBytes /*out*/);
    SgAsmInstruction* matchIndirectJumpEbx(const PartitionerConstPtr&, Address va, Address &offsetFromEbx /*out*/,
                                           size_t &indirectNBytes /*out*/);
    SgAsmInstruction* matchAarch64Adrp(const PartitionerConstPtr&, Address va, Address &value /*out*/);
    SgAsmInstruction* matchAarch64Ldr(const PartitionerConstPtr&, Address va, Address &indirectVa /*in,out*/,
                                      Address &indirectNBytes /*out*/);
    SgAsmInstruction* matchAarch64Add(const PartitionerConstPtr&, Address va);
    SgAsmInstruction* matchAarch64Br(const PartitionerConstPtr&, Address va);
    SgAsmInstruction* matchAarch32CopyPcToIp(const PartitionerConstPtr&, Address va, uint32_t &result);
    SgAsmInstruction* matchAarch32AddConstToIp(const PartitionerConstPtr&, Address va, uint32_t &addend);
    SgAsmInstruction* matchAarch32IndirectBranch(const PartitionerConstPtr&, Address va, uint32_t &addend);
};
struct PltEntryMatcher: public InstructionMatcher {…};
 
void buildMayReturnLists(const PartitionerPtr&);
 
} // namespace
namespace ModulesElf {…}
} // namespace
} // namespace
} // namespace
 
#endif
#endif