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
42namespace {
43
44class BufferMemoryObject : public llvm::MemoryObject {
45private:
46  const uint8_t *mBytes;
47  uint64_t mLength;
48
49public:
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
67namespace bcc {
68
69void InitializeDisassembler() {
70#if defined(PROVIDE_ARM_CODEGEN)
71  LLVMInitializeARMDisassembler();
72#endif
73
74#if defined(PROVIDE_X86_CODEGEN)
75  LLVMInitializeX86Disassembler();
76#endif
77}
78
79void 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