ObjectFiles was created twice, once to check the type it has and then
again to store and use it in the disassembler. We now create it only
once and store it with full type information for additional use
std::unique_ptr<Binary> o;
o.reset(createBinary(filename).get());
std::unique_ptr<Binary> o;
o.reset(createBinary(filename).get());
- const Binary * op = o.get();
+ Binary * op = o.release();
// ELFType<endian, maxalign, 64bit>
// ELFType<endian, maxalign, 64bit>
- if (const ELF32LEObjectFile * _ = dyn_cast<ELF32LEObjectFile>(op)) {
-#pragma unused(_)
- return new LLVMDisassembler<ELFType<support::little, 2, false>>(filename, manager);
+ if (ELF32LEObjectFile * object = dyn_cast<ELF32LEObjectFile>(op)) {
+ return new LLVMDisassembler<ELFType<support::little, 2, false>>(filename, manager, object);
- if (const ELF64LEObjectFile * _ = dyn_cast<ELF64LEObjectFile>(op)) {
-#pragma unused(_)
- return new LLVMDisassembler<ELFType<support::little, 2, true>>(filename, manager);
+ if (ELF64LEObjectFile * object = dyn_cast<ELF64LEObjectFile>(op)) {
+ return new LLVMDisassembler<ELFType<support::little, 2, true>>(filename, manager, object);
- if (const ELF32BEObjectFile * _ = dyn_cast<ELF32BEObjectFile>(op)) {
-#pragma unused(_)
- return new LLVMDisassembler<ELFType<support::big, 2, false>>(filename, manager);
+ if (ELF32BEObjectFile * object = dyn_cast<ELF32BEObjectFile>(op)) {
+ return new LLVMDisassembler<ELFType<support::big, 2, false>>(filename, manager, object);
- if (const ELF64BEObjectFile * _ = dyn_cast<ELF64BEObjectFile>(op)) {
-#pragma unused(_)
- return new LLVMDisassembler<ELFType<support::big, 2, true>>(filename, manager);
+ if (ELF64BEObjectFile * object = dyn_cast<ELF64BEObjectFile>(op)) {
+ return new LLVMDisassembler<ELFType<support::big, 2, true>>(filename, manager, object);
*/
template <typename ELFT>
LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
*/
template <typename ELFT>
LLVMDisassembler<ELFT>::LLVMDisassembler(const std::string& filename,
- InformationManager* manager)
+ InformationManager* manager,
+ ELFObjectFile<ELFT>* file)
: Disassembler(filename, manager)
, logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
, triple("unknown-unknown-unknown")
, manager(manager)
{
LOG4CXX_DEBUG(logger, "Handling file" << filename);
: Disassembler(filename, manager)
, logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
, triple("unknown-unknown-unknown")
, manager(manager)
{
LOG4CXX_DEBUG(logger, "Handling file" << filename);
- auto result = createBinary(filename);
- error_code ec;
- if ((ec = result.getError())) {
- LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
- binary = NULL;
- return;
- }
+ if (!file) {
+ auto result = createBinary(filename);
- binary.reset(result.get());
+ error_code ec;
+ if ((ec = result.getError())) {
+ LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
+ binary = NULL;
+ return;
+ }
- o = dyn_cast<ObjectFile>(binary.get());
+ binary.reset(result.get());
+
+ o = dyn_cast<ELFObjectFile<ELFT>>(binary.get());
+ } else {
+ o = file;
+ binary.reset(file);
+ }
triple.setArch(Triple::ArchType(o->getArch()));
std::string tripleName(triple.getTriple());
triple.setArch(Triple::ArchType(o->getArch()));
std::string tripleName(triple.getTriple());
class LLVMDisassembler
: public Disassembler {
public:
class LLVMDisassembler
: public Disassembler {
public:
- LLVMDisassembler(const std::string& filename, InformationManager* manager);
+ LLVMDisassembler(const std::string& filename, InformationManager* manager,
+ llvm::object::ELFObjectFile<ELFT>* file = NULL);
virtual ~LLVMDisassembler();
void start();
virtual ~LLVMDisassembler();
void start();
std::shared_ptr<llvm::object::Binary> binary;
const llvm::Target * target;
std::shared_ptr<llvm::object::Binary> binary;
const llvm::Target * target;
- llvm::object::ObjectFile * o;
+ llvm::object::ELFObjectFile<ELFT> * o;
std::unique_ptr<const llvm::MCRegisterInfo> MRI;
std::unique_ptr<const llvm::MCAsmInfo> AsmInfo;
std::unique_ptr<const llvm::MCRegisterInfo> MRI;
std::unique_ptr<const llvm::MCAsmInfo> AsmInfo;