blob: 2458af478fd94d40f519f2397055e554a3f5c579 [file] [log] [blame]
Michael J. Spencer92e1deb2011-01-20 06:39:06 +00001//===-- llvm-objdump.cpp - Object file dumping utility for llvm -----------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This program is a utility that works like binutils "objdump", that is, it
11// dumps out a plethora of information about an object file depending on the
12// flags.
13//
14//===----------------------------------------------------------------------===//
15
Benjamin Kramer685a2502011-07-20 19:37:35 +000016#include "MCFunction.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000017#include "llvm/Object/ObjectFile.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000018#include "llvm/ADT/OwningPtr.h"
19#include "llvm/ADT/Triple.h"
Benjamin Kramer739b65b2011-07-15 18:39:24 +000020#include "llvm/ADT/STLExtras.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000021#include "llvm/MC/MCAsmInfo.h"
22#include "llvm/MC/MCDisassembler.h"
23#include "llvm/MC/MCInst.h"
24#include "llvm/MC/MCInstPrinter.h"
Benjamin Kramer685a2502011-07-20 19:37:35 +000025#include "llvm/MC/MCInstrDesc.h"
26#include "llvm/MC/MCInstrInfo.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000027#include "llvm/Support/CommandLine.h"
28#include "llvm/Support/Debug.h"
29#include "llvm/Support/Format.h"
Benjamin Kramer853b0fd2011-07-25 23:04:36 +000030#include "llvm/Support/GraphWriter.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000031#include "llvm/Support/Host.h"
32#include "llvm/Support/ManagedStatic.h"
33#include "llvm/Support/MemoryBuffer.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000034#include "llvm/Support/MemoryObject.h"
35#include "llvm/Support/PrettyStackTrace.h"
36#include "llvm/Support/Signals.h"
37#include "llvm/Support/SourceMgr.h"
38#include "llvm/Support/raw_ostream.h"
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000039#include "llvm/Support/system_error.h"
40#include "llvm/Target/TargetRegistry.h"
41#include "llvm/Target/TargetSelect.h"
42#include <algorithm>
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000043#include <cstring>
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000044using namespace llvm;
45using namespace object;
46
47namespace {
48 cl::list<std::string>
49 InputFilenames(cl::Positional, cl::desc("<input object files>"),
50 cl::ZeroOrMore);
51
52 cl::opt<bool>
53 Disassemble("disassemble",
54 cl::desc("Display assembler mnemonics for the machine instructions"));
55 cl::alias
56 Disassembled("d", cl::desc("Alias for --disassemble"),
57 cl::aliasopt(Disassemble));
58
Benjamin Kramer685a2502011-07-20 19:37:35 +000059 cl::opt<bool>
60 CFG("cfg", cl::desc("Create a CFG for every symbol in the object file and"
61 "write it to a graphviz file"));
62
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000063 cl::opt<std::string>
64 TripleName("triple", cl::desc("Target triple to disassemble for, "
65 "see -version for available targets"));
66
67 cl::opt<std::string>
68 ArchName("arch", cl::desc("Target arch to disassemble for, "
69 "see -version for available targets"));
70
71 StringRef ToolName;
Michael J. Spencer25b15772011-06-25 17:55:23 +000072
73 bool error(error_code ec) {
74 if (!ec) return false;
75
76 outs() << ToolName << ": error reading file: " << ec.message() << ".\n";
77 outs().flush();
78 return true;
79 }
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000080}
81
82static const Target *GetTarget(const ObjectFile *Obj = NULL) {
83 // Figure out the target triple.
84 llvm::Triple TT("unknown-unknown-unknown");
Michael J. Spencerd11699d2011-01-20 07:22:04 +000085 if (TripleName.empty()) {
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000086 if (Obj)
87 TT.setArch(Triple::ArchType(Obj->getArch()));
Michael J. Spencerd11699d2011-01-20 07:22:04 +000088 } else
Michael J. Spencer92e1deb2011-01-20 06:39:06 +000089 TT.setTriple(Triple::normalize(TripleName));
90
91 if (!ArchName.empty())
92 TT.setArchName(ArchName);
93
94 TripleName = TT.str();
95
96 // Get the target specific parser.
97 std::string Error;
98 const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
99 if (TheTarget)
100 return TheTarget;
101
102 errs() << ToolName << ": error: unable to get target for '" << TripleName
103 << "', see --version and --triple.\n";
104 return 0;
105}
106
107namespace {
108class StringRefMemoryObject : public MemoryObject {
109private:
110 StringRef Bytes;
111public:
112 StringRefMemoryObject(StringRef bytes) : Bytes(bytes) {}
113
114 uint64_t getBase() const { return 0; }
115 uint64_t getExtent() const { return Bytes.size(); }
116
117 int readByte(uint64_t Addr, uint8_t *Byte) const {
Benjamin Kramer14c92462011-07-19 22:59:25 +0000118 if (Addr >= getExtent())
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000119 return -1;
120 *Byte = Bytes[Addr];
121 return 0;
122 }
123};
124}
125
126static void DumpBytes(StringRef bytes) {
127 static char hex_rep[] = "0123456789abcdef";
128 // FIXME: The real way to do this is to figure out the longest instruction
129 // and align to that size before printing. I'll fix this when I get
130 // around to outputting relocations.
131 // 15 is the longest x86 instruction
132 // 3 is for the hex rep of a byte + a space.
133 // 1 is for the null terminator.
134 enum { OutputSize = (15 * 3) + 1 };
135 char output[OutputSize];
136
137 assert(bytes.size() <= 15
138 && "DumpBytes only supports instructions of up to 15 bytes");
139 memset(output, ' ', sizeof(output));
140 unsigned index = 0;
141 for (StringRef::iterator i = bytes.begin(),
142 e = bytes.end(); i != e; ++i) {
143 output[index] = hex_rep[(*i & 0xF0) >> 4];
144 output[index + 1] = hex_rep[*i & 0xF];
145 index += 3;
146 }
147
148 output[sizeof(output) - 1] = 0;
149 outs() << output;
150}
151
152static void DisassembleInput(const StringRef &Filename) {
153 OwningPtr<MemoryBuffer> Buff;
154
155 if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) {
156 errs() << ToolName << ": " << Filename << ": " << ec.message() << "\n";
157 return;
158 }
159
160 OwningPtr<ObjectFile> Obj(ObjectFile::createObjectFile(Buff.take()));
161
162 const Target *TheTarget = GetTarget(Obj.get());
163 if (!TheTarget) {
164 // GetTarget prints out stuff.
165 return;
166 }
Benjamin Kramer685a2502011-07-20 19:37:35 +0000167 const MCInstrInfo *InstrInfo = TheTarget->createMCInstrInfo();
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000168
169 outs() << '\n';
170 outs() << Filename
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000171 << ":\tfile format " << Obj->getFileFormatName() << "\n\n";
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000172
Michael J. Spencer25b15772011-06-25 17:55:23 +0000173 error_code ec;
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000174 for (ObjectFile::section_iterator i = Obj->begin_sections(),
175 e = Obj->end_sections();
Michael J. Spencer25b15772011-06-25 17:55:23 +0000176 i != e; i.increment(ec)) {
177 if (error(ec)) break;
178 bool text;
179 if (error(i->isText(text))) break;
180 if (!text) continue;
181
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000182 // Make a list of all the symbols in this section.
183 std::vector<std::pair<uint64_t, StringRef> > Symbols;
184 for (ObjectFile::symbol_iterator si = Obj->begin_symbols(),
185 se = Obj->end_symbols();
186 si != se; si.increment(ec)) {
187 bool contains;
188 if (!error(i->containsSymbol(*si, contains)) && contains) {
189 uint64_t Address;
190 if (error(si->getAddress(Address))) break;
191 StringRef Name;
192 if (error(si->getName(Name))) break;
193 Symbols.push_back(std::make_pair(Address, Name));
194 }
195 }
196
197 // Sort the symbols by address, just in case they didn't come in that way.
198 array_pod_sort(Symbols.begin(), Symbols.end());
199
Michael J. Spencer25b15772011-06-25 17:55:23 +0000200 StringRef name;
201 if (error(i->getName(name))) break;
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000202 outs() << "Disassembly of section " << name << ':';
203
204 // If the section has no symbols just insert a dummy one and disassemble
205 // the whole section.
206 if (Symbols.empty())
207 Symbols.push_back(std::make_pair(0, name));
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000208
209 // Set up disassembler.
Evan Cheng1abf2cb2011-07-14 23:50:31 +0000210 OwningPtr<const MCAsmInfo> AsmInfo(TheTarget->createMCAsmInfo(TripleName));
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000211
212 if (!AsmInfo) {
213 errs() << "error: no assembly info for target " << TripleName << "\n";
214 return;
215 }
216
217 OwningPtr<const MCDisassembler> DisAsm(TheTarget->createMCDisassembler());
218 if (!DisAsm) {
219 errs() << "error: no disassembler for target " << TripleName << "\n";
220 return;
221 }
222
223 int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
224 OwningPtr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
Evan Chengb2627992011-07-06 19:45:42 +0000225 AsmPrinterVariant, *AsmInfo));
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000226 if (!IP) {
227 errs() << "error: no instruction printer for target " << TripleName << '\n';
228 return;
229 }
230
Michael J. Spencer25b15772011-06-25 17:55:23 +0000231 StringRef Bytes;
232 if (error(i->getContents(Bytes))) break;
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000233 StringRefMemoryObject memoryObject(Bytes);
234 uint64_t Size;
235 uint64_t Index;
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000236 uint64_t SectSize;
237 if (error(i->getSize(SectSize))) break;
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000238
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000239 // Disassemble symbol by symbol.
240 for (unsigned si = 0, se = Symbols.size(); si != se; ++si) {
241 uint64_t Start = Symbols[si].first;
242 uint64_t End = si == se-1 ? SectSize : Symbols[si + 1].first - 1;
243 outs() << '\n' << Symbols[si].second << ":\n";
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000244
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000245#ifndef NDEBUG
246 raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
247#else
248 raw_ostream &DebugOut = nulls();
249#endif
250
Benjamin Kramera21d8132011-08-08 18:32:12 +0000251 if (!CFG) {
252 for (Index = Start; Index < End; Index += Size) {
253 MCInst Inst;
254 if (DisAsm->getInstruction(Inst, Size, memoryObject, Index,
255 DebugOut)) {
256 uint64_t addr;
257 if (error(i->getAddress(addr))) break;
258 outs() << format("%8x:\t", addr + Index);
259 DumpBytes(StringRef(Bytes.data() + Index, Size));
260 IP->printInst(&Inst, outs());
261 outs() << "\n";
262 } else {
263 errs() << ToolName << ": warning: invalid instruction encoding\n";
264 if (Size == 0)
265 Size = 1; // skip illegible bytes
266 }
Benjamin Kramer739b65b2011-07-15 18:39:24 +0000267 }
Benjamin Kramer685a2502011-07-20 19:37:35 +0000268
Benjamin Kramera21d8132011-08-08 18:32:12 +0000269 } else {
270 // Create CFG and use it for disassembly.
Benjamin Kramer685a2502011-07-20 19:37:35 +0000271 MCFunction f =
272 MCFunction::createFunctionFromMC(Symbols[si].second, DisAsm.get(),
273 memoryObject, Start, End, InstrInfo,
274 DebugOut);
275
Benjamin Kramera21d8132011-08-08 18:32:12 +0000276 for (MCFunction::iterator fi = f.begin(), fe = f.end(); fi != fe; ++fi){
277 bool hasPreds = false;
278 // Only print blocks that have predecessors.
279 // FIXME: Slow.
280 for (MCFunction::iterator pi = f.begin(), pe = f.end(); pi != pe;
281 ++pi)
282 if (pi->second.contains(&fi->second)) {
283 hasPreds = true;
284 break;
285 }
286
Benjamin Kramerc13464f2011-08-08 18:41:34 +0000287 // Data block.
288 if (!hasPreds && fi != f.begin()) {
289 uint64_t End = llvm::next(fi) == fe ? SectSize :
290 llvm::next(fi)->first;
291 uint64_t addr;
292 if (error(i->getAddress(addr))) break;
293 outs() << "# " << End-fi->first << " bytes of data:\n";
294 for (unsigned pos = fi->first; pos != End; ++pos) {
295 outs() << format("%8x:\t", addr + pos);
296 DumpBytes(StringRef(Bytes.data() + pos, 1));
297 outs() << format("\t.byte 0x%02x\n", (uint8_t)Bytes[pos]);
298 }
Benjamin Kramera21d8132011-08-08 18:32:12 +0000299 continue;
Benjamin Kramerc13464f2011-08-08 18:41:34 +0000300 }
301
302 if (fi->second.contains(&fi->second))
303 outs() << "# Loop begin:\n";
Benjamin Kramera21d8132011-08-08 18:32:12 +0000304
305 for (unsigned ii = 0, ie = fi->second.getInsts().size(); ii != ie;
306 ++ii) {
307 uint64_t addr;
308 if (error(i->getAddress(addr))) break;
309 const MCDecodedInst &Inst = fi->second.getInsts()[ii];
310 outs() << format("%8x:\t", addr + Inst.Address);
311 DumpBytes(StringRef(Bytes.data() + Inst.Address, Inst.Size));
Benjamin Kramerc13464f2011-08-08 18:41:34 +0000312 // Simple loops.
313 if (fi->second.contains(&fi->second))
314 outs() << '\t';
Benjamin Kramera21d8132011-08-08 18:32:12 +0000315 IP->printInst(&Inst.Inst, outs());
316 outs() << '\n';
317 }
318 }
319
Benjamin Kramer685a2502011-07-20 19:37:35 +0000320 // Start a new dot file.
321 std::string Error;
322 raw_fd_ostream Out((f.getName().str() + ".dot").c_str(), Error);
Benjamin Kramera503ede2011-07-22 18:35:11 +0000323 if (!Error.empty()) {
324 errs() << ToolName << ": warning: " << Error << '\n';
325 continue;
326 }
Benjamin Kramer685a2502011-07-20 19:37:35 +0000327
328 Out << "digraph " << f.getName() << " {\n";
329 Out << "graph [ rankdir = \"LR\" ];\n";
330 for (MCFunction::iterator i = f.begin(), e = f.end(); i != e; ++i) {
Benjamin Kramer853b0fd2011-07-25 23:04:36 +0000331 bool hasPreds = false;
332 // Only print blocks that have predecessors.
333 // FIXME: Slow.
334 for (MCFunction::iterator pi = f.begin(), pe = f.end(); pi != pe;
335 ++pi)
Benjamin Kramerdbc46d72011-07-25 23:10:23 +0000336 if (pi->second.contains(&i->second)) {
Benjamin Kramer853b0fd2011-07-25 23:04:36 +0000337 hasPreds = true;
338 break;
339 }
340
341 if (!hasPreds && i != f.begin())
342 continue;
343
Benjamin Kramer685a2502011-07-20 19:37:35 +0000344 Out << '"' << (uintptr_t)&i->second << "\" [ label=\"<a>";
345 // Print instructions.
346 for (unsigned ii = 0, ie = i->second.getInsts().size(); ii != ie;
347 ++ii) {
Benjamin Kramer853b0fd2011-07-25 23:04:36 +0000348 // Escape special chars and print the instruction in mnemonic form.
349 std::string Str;
350 raw_string_ostream OS(Str);
351 IP->printInst(&i->second.getInsts()[ii].Inst, OS);
352 Out << DOT::EscapeString(OS.str()) << '|';
Benjamin Kramer685a2502011-07-20 19:37:35 +0000353 }
354 Out << "<o>\" shape=\"record\" ];\n";
355
356 // Add edges.
357 for (MCBasicBlock::succ_iterator si = i->second.succ_begin(),
358 se = i->second.succ_end(); si != se; ++si)
359 Out << (uintptr_t)&i->second << ":o -> " << (uintptr_t)*si <<":a\n";
360 }
361 Out << "}\n";
362 }
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000363 }
364 }
365}
366
367int main(int argc, char **argv) {
368 // Print a stack trace if we signal out.
369 sys::PrintStackTraceOnErrorSignal();
370 PrettyStackTraceProgram X(argc, argv);
371 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
372
373 // Initialize targets and assembly printers/parsers.
374 llvm::InitializeAllTargetInfos();
Evan Chenge78085a2011-07-22 21:58:54 +0000375 llvm::InitializeAllTargetMCs();
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000376 llvm::InitializeAllAsmParsers();
377 llvm::InitializeAllDisassemblers();
378
Michael J. Spencer92e1deb2011-01-20 06:39:06 +0000379 cl::ParseCommandLineOptions(argc, argv, "llvm object file dumper\n");
380 TripleName = Triple::normalize(TripleName);
381
382 ToolName = argv[0];
383
384 // Defaults to a.out if no filenames specified.
385 if (InputFilenames.size() == 0)
386 InputFilenames.push_back("a.out");
387
388 // -d is the only flag that is currently implemented, so just print help if
389 // it is not set.
390 if (!Disassemble) {
391 cl::PrintHelpMessage();
392 return 2;
393 }
394
395 std::for_each(InputFilenames.begin(), InputFilenames.end(),
396 DisassembleInput);
397
398 return 0;
399}