Home | History | Annotate | Download | only in Disassembler 
      1 /*
      2  * Copyright 2011, The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *     http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include "Disassembler.h"
     18 
     19 #include "Config.h"
     20 
     21 #include "DebugHelper.h"
     22 #include "ExecutionEngine/Compiler.h"
     23 
     24 #include "llvm/MC/MCAsmInfo.h"
     25 #include "llvm/MC/MCDisassembler.h"
     26 #include "llvm/MC/MCInst.h"
     27 #include "llvm/MC/MCInstPrinter.h"
     28 
     29 #include "llvm/Support/MemoryObject.h"
     30 #include "llvm/Support/raw_ostream.h"
     31 
     32 #include "llvm/Target/TargetData.h"
     33 #include "llvm/Target/TargetMachine.h"
     34 #include "llvm/Target/TargetOptions.h"
     35 #include "llvm/Target/TargetRegistry.h"
     36 #include "llvm/Target/TargetSelect.h"
     37 
     38 #include "llvm/LLVMContext.h"
     39 
     40 #if USE_DISASSEMBLER
     41 
     42 namespace {
     43 
     44 class BufferMemoryObject : public llvm::MemoryObject {
     45 private:
     46   const uint8_t *mBytes;
     47   uint64_t mLength;
     48 
     49 public:
     50   BufferMemoryObject(const uint8_t *Bytes, uint64_t Length)
     51     : mBytes(Bytes), mLength(Length) {
     52   }
     53 
     54   virtual uint64_t getBase() const { return 0; }
     55   virtual uint64_t getExtent() const { return mLength; }
     56 
     57   virtual int readByte(uint64_t Addr, uint8_t *Byte) const {
     58     if (Addr > getExtent())
     59       return -1;
     60     *Byte = mBytes[Addr];
     61     return 0;
     62   }
     63 };
     64 
     65 } // namespace anonymous
     66 
     67 namespace bcc {
     68 
     69 void InitializeDisassembler() {
     70 #if defined(PROVIDE_ARM_CODEGEN)
     71   LLVMInitializeARMDisassembler();
     72 #endif
     73 
     74 #if defined(PROVIDE_X86_CODEGEN)
     75   LLVMInitializeX86Disassembler();
     76 #endif
     77 }
     78 
     79 void Disassemble(char const *OutputFileName,
     80                  llvm::Target const *Target,
     81                  llvm::TargetMachine *TM,
     82                  std::string const &Name,
     83                  unsigned char const *Func,
     84                  size_t FuncSize) {
     85 
     86   std::string ErrorInfo;
     87 
     88   // Open the disassembler output file
     89   llvm::raw_fd_ostream OS(OutputFileName, ErrorInfo,
     90                           llvm::raw_fd_ostream::F_Append);
     91 
     92   if (!ErrorInfo.empty()) {
     93     LOGE("Unable to open disassembler output file: %s\n", OutputFileName);
     94     return;
     95   }
     96 
     97   // Disassemble the given function
     98   OS << "Disassembled code: " << Name << "\n";
     99 
    100   const llvm::MCAsmInfo *AsmInfo;
    101   const llvm::MCDisassembler *Disassmbler;
    102   llvm::MCInstPrinter *IP;
    103 
    104   AsmInfo = Target->createMCAsmInfo(Compiler::getTargetTriple());
    105   Disassmbler = Target->createMCDisassembler();
    106   IP = Target->createMCInstPrinter(AsmInfo->getAssemblerDialect(),
    107                                    *AsmInfo);
    108 
    109   const BufferMemoryObject *BufferMObj = new BufferMemoryObject(Func, FuncSize);
    110 
    111   uint64_t Size;
    112   uint64_t Index;
    113 
    114   for (Index = 0; Index < FuncSize; Index += Size) {
    115     llvm::MCInst Inst;
    116 
    117     if (Disassmbler->getInstruction(Inst, Size, *BufferMObj, Index,
    118                                     /* REMOVED */ llvm::nulls())) {
    119       OS.indent(4);
    120       OS.write("0x", 2);
    121       OS.write_hex((uint32_t)Func + Index);
    122       OS.write(": 0x", 4);
    123       OS.write_hex(*(uint32_t *)(Func + Index));
    124       IP->printInst(&Inst, OS);
    125       OS << "\n";
    126     } else {
    127       if (Size == 0)
    128         Size = 1;  // skip illegible bytes
    129     }
    130   }
    131 
    132   OS << "\n";
    133 
    134   delete BufferMObj;
    135 
    136   delete AsmInfo;
    137   delete Disassmbler;
    138   delete IP;
    139 
    140   OS.close();
    141 }
    142 
    143 } // namespace bcc
    144 
    145 #endif // USE_DISASSEMBLER
    146