src/disassembler/llvm/LLVMDisassembler.cxx

   1 #include "disassembler/llvm/LLVMDisassembler.hxx"
   2 #include "disassembler/llvm/LLVMBasicBlock.hxx"
   3 #include "disassembler/llvm/LLVMFunction.hxx"
   4
   5 #include <stack>
   6 #include <algorithm>
   7
   8 using namespace llvm;
   9 using namespace llvm::object;
  10
  11 /*
  12  * TODO: fallback code falls die Datei kein ELF/PE/COFF/MacO/.. binary
  13  * ist sondern z.B. einfach nur Instruktionen oder ein Bootsektor oder
  14  * foo
  15  */
  16 LLVMDisassembler::LLVMDisassembler(const std::string& filename)
  17     : Disassembler(filename)
  18     , logger(log4cxx::Logger::getLogger("LLVMDisassembler"))
  19     , triple("unknown-unknown-unknown")
  20 {
  21     LOG4CXX_DEBUG(logger, "Handling file" << filename);
  22     auto result = createBinary(filename);
  23
  24     error_code ec;
  25     if ((ec = result.getError())) {
  26         LOG4CXX_ERROR(logger, "Failed to load Binary" << ec.message());
  27         binary = NULL;
  28         return;
  29     }
  30
  31     binary.reset(result.get());
  32
  33     o = dyn_cast<ObjectFile>(binary.get());
  34
  35     triple.setArch(Triple::ArchType(o->getArch()));
  36     std::string tripleName(triple.getTriple());
  37
  38     LOG4CXX_INFO(logger, "Architecture " << tripleName);
  39
  40
  41     std::string es;
  42     target = TargetRegistry::lookupTarget("", triple, es);
  43     if (!target) {
  44         LOG4CXX_ERROR(logger, es);
  45         return;
  46     }
  47
  48     LOG4CXX_INFO(logger, "Target " << target->getName());
  49
  50     MRI.reset(target->createMCRegInfo(tripleName));
  51     if (!MRI) {
  52         LOG4CXX_ERROR(logger, "no register info for target " << tripleName);
  53         return;
  54     }
  55
  56     // Set up disassembler.
  57     AsmInfo.reset(target->createMCAsmInfo(*MRI, tripleName));
  58     if (!AsmInfo) {
  59         LOG4CXX_ERROR(logger, "no assembly info for target " << tripleName);
  60         return;
  61     }
  62
  63     STI.reset(target->createMCSubtargetInfo(tripleName, "", ""));
  64     if (!STI) {
  65         LOG4CXX_ERROR(logger, "no subtarget info for target " << tripleName);
  66         return;
  67     }
  68
  69     MII.reset(target->createMCInstrInfo());
  70     if (!MII) {
  71         LOG4CXX_ERROR(logger, "no instruction info for target " << tripleName);
  72         return;
  73     }
  74
  75     DisAsm.reset(target->createMCDisassembler(*STI));
  76     if (!DisAsm) {
  77         LOG4CXX_ERROR(logger, "no disassembler for target " << tripleName);
  78         return;
  79     }
  80
  81     MOFI.reset(new MCObjectFileInfo);
  82     Ctx.reset(new MCContext(AsmInfo.get(), MRI.get(), MOFI.get()));
  83     RelInfo.reset(
  84         target->createMCRelocationInfo(tripleName, *Ctx.get()));
  85     if (RelInfo) {
  86         Symzer.reset(
  87             MCObjectSymbolizer::createObjectSymbolizer(*Ctx.get(), RelInfo, o));
  88         if (Symzer)
  89             DisAsm->setSymbolizer(Symzer);
  90     }
  91
  92     MIA.reset(target->createMCInstrAnalysis(MII.get()));
  93
  94     int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
  95     IP.reset(target->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *MII, *MRI, *STI));
  96     if (!IP) {
  97         LOG4CXX_ERROR(logger, "no instruction printer for target " << tripleName);
  98         return;
  99     }
 100
 101     IP->setPrintImmHex(llvm::HexStyle::C);
 102     IP->setPrintImmHex(true);
 103
 104     OwningPtr<MCObjectDisassembler> OD(
 105         new MCObjectDisassembler(*o, *DisAsm, *MIA));
 106     Mod.reset(OD->buildModule(false));
 107
 108     readSymbols();
 109     readSections();
 110     disassemble();
 111 }
 112
 113
 114 void LLVMDisassembler::disassemble() {
 115     std::stack<LLVMFunction*> remaining_functions;
 116     std::stack<LLVMBasicBlock*> remaining_blocks;
 117     SectionRef text_section = sections[".text"];
 118
 119         for (auto x = symbols.begin(); x != symbols.end(); ++x) {
 120                 uint64_t result;
 121                 bool contains;
 122                 SymbolRef::Type symbol_type;
 123
 124 /*
 125  * TODO: If we jump into some Basic Block we need to split it there into two
 126  */
 127
 128                 if (text_section.containsSymbol(x->second, contains) || !contains)
 129                         continue;
 130
 131                 if (x->second.getType(symbol_type)
 132                         || SymbolRef::ST_Function != symbol_type)
 133                         continue;
 134
 135                 if (!x->second.getAddress(result)) {
 136                         LLVMFunction * fun = new LLVMFunction(x->first, result);
 137                         remaining_functions.push(fun);
 138                         functions.insert(std::make_pair(result, fun));
 139                         LOG4CXX_DEBUG(logger, "Disasembling " << x->first);
 140                 }
 141         }
 142
 143     StringRef bytes;
 144     text_section.getContents(bytes);
 145     StringRefMemoryObject ref(bytes);
 146
 147     while (remaining_functions.size()) {
 148         LLVMFunction * current_function = remaining_functions.top();
 149         remaining_functions.pop();
 150
 151         LOG4CXX_DEBUG(logger, "Handling function " << current_function->getName());
 152
 153         // if ("_start" != current_function->getName())
 154         //  continue;
 155
 156                 LLVMBasicBlock * block = new LLVMBasicBlock(current_function->getStartAddress());
 157         remaining_blocks.push(block);
 158                 blocks.insert(std::make_pair(block->getStartAddress(), block));
 159
 160         while (remaining_blocks.size()) {
 161             LLVMBasicBlock * current_block = remaining_blocks.top();
 162             remaining_blocks.pop();
 163
 164             LOG4CXX_DEBUG(logger, "Handling Block starting at " << std::hex << current_block->getStartAddress());
 165
 166             uint64_t inst_size;
 167             uint64_t base_address;
 168             text_section.getAddress(base_address);
 169             uint64_t current_address = current_block->getStartAddress() - base_address;
 170             while(true) {
 171                 MCInst inst;
 172                 std::string buf;
 173                 llvm::raw_string_ostream s(buf);
 174
 175                 if(llvm::MCDisassembler::Success ==
 176                    DisAsm->getInstruction(inst, inst_size, ref, current_address, nulls(), nulls())) {
 177
 178                     uint8_t bytes[inst_size+2];
 179                     ref.readBytes(current_address, inst_size, bytes);
 180                     s << '\t';
 181                     for(uint8_t* cur = bytes; cur < bytes + inst_size; ++cur) {
 182                         s.write_hex(*cur);
 183                         s << ' ';
 184                     }
 185                     s << '\t';
 186
 187                     IP->printInst(&inst, s, "");
 188
 189                     LOG4CXX_DEBUG(logger, std::hex << current_address + base_address << s.str());
 190
 191                     uint64_t jmptarget;
 192                     if (MIA->evaluateBranch(inst, current_address, inst_size, jmptarget)) {
 193                                                 jmptarget += base_address;
 194                         if (!MIA->isIndirectBranch(inst)) {
 195                             if (MIA->isCall(inst)) {
 196                                                                 if (functions.find(jmptarget) == functions.end()) {
 197                                                                         std::stringstream s;
 198                                                                         s << "<Unnamed 0x" << std::hex << jmptarget << ">";
 199                                                                         LLVMFunction * fun = new LLVMFunction(s.str(), jmptarget);
 200                                                                         functions.insert(std::make_pair(jmptarget, fun));
 201                                                                         remaining_functions.push(fun);
 202                                                                 }
 203                             } else {
 204                                                                 if (blocks.find(jmptarget) == blocks.end()) {
 205                                                                         LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget);
 206                                                                         blocks.insert(std::make_pair(block->getStartAddress(), block));
 207                                                                         remaining_blocks.push(block);
 208                                                                 }
 209                                 if (MIA->isConditionalBranch(inst)) {
 210                                                                         jmptarget = base_address + current_address + inst_size;
 211                                                                         if (blocks.find(jmptarget) == blocks.end()) {
 212                                                                                 LLVMBasicBlock * block = new LLVMBasicBlock(jmptarget);
 213                                                                                 blocks.insert(std::make_pair(block->getStartAddress(), block));
 214                                                                                 remaining_blocks.push(new LLVMBasicBlock(jmptarget));
 215                                 }
 216                             }
 217                         }
 218                     }
 219                 } else {
 220                     inst_size = 0;
 221                 }
 222
 223
 224                 if (inst_size == 0 || MIA->isTerminator(inst) || MIA->isBranch(inst)) {
 225                     current_block->setEndAddress(current_address + base_address);
 226                     LOG4CXX_DEBUG(logger, "Finished Block at " << std::hex <<
 227                                                                   current_block->getEndAddress());
 228                                                                         }
 229                     break;
 230                 }
 231                 current_address += inst_size;
 232             }
 233         }
 234         LOG4CXX_DEBUG(logger, "Finished function " << current_function->getName());
 235     }
 236 }
 237
 238 void LLVMDisassembler::readSymbols() {
 239     error_code ec;
 240     symbol_iterator si(o->symbol_begin()), se(o->symbol_end());
 241     for (; si != se; ++si) {
 242         StringRef name;
 243         if ((ec = si->getName(name))) {
 244             LOG4CXX_ERROR(logger, ec.message());
 245             break;
 246         }
 247         LOG4CXX_DEBUG(logger, "Added symbol " << name.str());
 248         symbols.insert(make_pair(name.str(), *si));
 249     }
 250 }
 251
 252 void LLVMDisassembler::readSections() {
 253     error_code ec;
 254     section_iterator i(o->section_begin()), e(o->section_end());
 255     for (; i != e; ++i) {
 256         StringRef name;
 257         if ((ec = i->getName(name))) {
 258             LOG4CXX_ERROR(logger, ec.message());
 259             break;
 260         }
 261         LOG4CXX_DEBUG(logger, "Added section " << name.str());
 262         sections.insert(make_pair(name.str(), *i));
 263     }
 264
 265 }
 266
 267 void LLVMDisassembler::forEachFunction(std::function<void (uint64_t, Function*)> callback) {
 268         std::for_each(functions.begin(), functions.end(),
 269                                   [&](std::pair<uint64_t, LLVMFunction*> x) {
 270                                           callback(x.first, x.second);
 271                                   });
 272 }
 273
 274
 275
 276 void LLVMDisassembler::generateControlFlowGraph(uint64_t address) {
 277
 278 }