Benjamin Kramer | 054f422 | 2013-08-09 10:31:14 +0000 | [diff] [blame] | 1 | //===- llvm-readobj.cpp - Dump contents of an Object File -----------------===// |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 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 | // |
Michael J. Spencer | d7e7003 | 2013-02-05 20:27:22 +0000 | [diff] [blame] | 10 | // This is a tool similar to readelf, except it works on multiple object file |
| 11 | // formats. The main purpose of this tool is to provide detailed output suitable |
| 12 | // for FileCheck. |
David Meyer | ae11a78 | 2012-03-02 23:43:51 +0000 | [diff] [blame] | 13 | // |
Michael J. Spencer | d7e7003 | 2013-02-05 20:27:22 +0000 | [diff] [blame] | 14 | // Flags should be similar to readelf where supported, but the output format |
| 15 | // does not need to be identical. The point is to not make users learn yet |
| 16 | // another set of flags. |
David Meyer | ae11a78 | 2012-03-02 23:43:51 +0000 | [diff] [blame] | 17 | // |
Michael J. Spencer | d7e7003 | 2013-02-05 20:27:22 +0000 | [diff] [blame] | 18 | // Output should be specialized for each format where appropriate. |
David Meyer | ae11a78 | 2012-03-02 23:43:51 +0000 | [diff] [blame] | 19 | // |
| 20 | //===----------------------------------------------------------------------===// |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 21 | |
Michael J. Spencer | 6a8746b | 2013-02-20 02:37:12 +0000 | [diff] [blame] | 22 | #include "llvm-readobj.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 23 | #include "Error.h" |
| 24 | #include "ObjDumper.h" |
| 25 | #include "StreamWriter.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 26 | #include "llvm/Object/Archive.h" |
Rui Ueyama | 71ba9bd | 2015-08-28 07:40:30 +0000 | [diff] [blame] | 27 | #include "llvm/Object/COFFImportFile.h" |
Rafael Espindola | 6762231 | 2014-08-08 16:39:22 +0000 | [diff] [blame] | 28 | #include "llvm/Object/ELFObjectFile.h" |
Rafael Espindola | 8448a24 | 2015-03-24 20:26:55 +0000 | [diff] [blame] | 29 | #include "llvm/Object/MachOUniversal.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 30 | #include "llvm/Object/ObjectFile.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 31 | #include "llvm/Support/Casting.h" |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 32 | #include "llvm/Support/CommandLine.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 33 | #include "llvm/Support/DataTypes.h" |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 34 | #include "llvm/Support/Debug.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 35 | #include "llvm/Support/FileSystem.h" |
| 36 | #include "llvm/Support/ManagedStatic.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 37 | #include "llvm/Support/PrettyStackTrace.h" |
| 38 | #include "llvm/Support/Signals.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 39 | #include "llvm/Support/TargetRegistry.h" |
| 40 | #include "llvm/Support/TargetSelect.h" |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 41 | #include <string> |
Rafael Espindola | a6e9c3e | 2014-06-12 17:38:55 +0000 | [diff] [blame] | 42 | #include <system_error> |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 43 | |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 44 | using namespace llvm; |
| 45 | using namespace llvm::object; |
| 46 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 47 | namespace opts { |
| 48 | cl::list<std::string> InputFilenames(cl::Positional, |
| 49 | cl::desc("<input object files>"), |
| 50 | cl::ZeroOrMore); |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 51 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 52 | // -file-headers, -h |
| 53 | cl::opt<bool> FileHeaders("file-headers", |
| 54 | cl::desc("Display file headers ")); |
| 55 | cl::alias FileHeadersShort("h", |
| 56 | cl::desc("Alias for --file-headers"), |
| 57 | cl::aliasopt(FileHeaders)); |
| 58 | |
| 59 | // -sections, -s |
| 60 | cl::opt<bool> Sections("sections", |
| 61 | cl::desc("Display all sections.")); |
| 62 | cl::alias SectionsShort("s", |
| 63 | cl::desc("Alias for --sections"), |
| 64 | cl::aliasopt(Sections)); |
| 65 | |
| 66 | // -section-relocations, -sr |
| 67 | cl::opt<bool> SectionRelocations("section-relocations", |
| 68 | cl::desc("Display relocations for each section shown.")); |
| 69 | cl::alias SectionRelocationsShort("sr", |
| 70 | cl::desc("Alias for --section-relocations"), |
| 71 | cl::aliasopt(SectionRelocations)); |
| 72 | |
| 73 | // -section-symbols, -st |
| 74 | cl::opt<bool> SectionSymbols("section-symbols", |
| 75 | cl::desc("Display symbols for each section shown.")); |
| 76 | cl::alias SectionSymbolsShort("st", |
| 77 | cl::desc("Alias for --section-symbols"), |
| 78 | cl::aliasopt(SectionSymbols)); |
| 79 | |
| 80 | // -section-data, -sd |
| 81 | cl::opt<bool> SectionData("section-data", |
| 82 | cl::desc("Display section data for each section shown.")); |
| 83 | cl::alias SectionDataShort("sd", |
| 84 | cl::desc("Alias for --section-data"), |
| 85 | cl::aliasopt(SectionData)); |
| 86 | |
| 87 | // -relocations, -r |
| 88 | cl::opt<bool> Relocations("relocations", |
| 89 | cl::desc("Display the relocation entries in the file")); |
| 90 | cl::alias RelocationsShort("r", |
| 91 | cl::desc("Alias for --relocations"), |
| 92 | cl::aliasopt(Relocations)); |
| 93 | |
Michael J. Spencer | 594c028 | 2015-06-25 21:47:32 +0000 | [diff] [blame] | 94 | // -dyn-relocations |
| 95 | cl::opt<bool> DynRelocs("dyn-relocations", |
| 96 | cl::desc("Display the dynamic relocation entries in the file")); |
| 97 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 98 | // -symbols, -t |
| 99 | cl::opt<bool> Symbols("symbols", |
| 100 | cl::desc("Display the symbol table")); |
| 101 | cl::alias SymbolsShort("t", |
| 102 | cl::desc("Alias for --symbols"), |
| 103 | cl::aliasopt(Symbols)); |
| 104 | |
| 105 | // -dyn-symbols, -dt |
| 106 | cl::opt<bool> DynamicSymbols("dyn-symbols", |
| 107 | cl::desc("Display the dynamic symbol table")); |
| 108 | cl::alias DynamicSymbolsShort("dt", |
| 109 | cl::desc("Alias for --dyn-symbols"), |
| 110 | cl::aliasopt(DynamicSymbols)); |
| 111 | |
| 112 | // -unwind, -u |
| 113 | cl::opt<bool> UnwindInfo("unwind", |
| 114 | cl::desc("Display unwind information")); |
| 115 | cl::alias UnwindInfoShort("u", |
| 116 | cl::desc("Alias for --unwind"), |
| 117 | cl::aliasopt(UnwindInfo)); |
| 118 | |
| 119 | // -dynamic-table |
| 120 | cl::opt<bool> DynamicTable("dynamic-table", |
| 121 | cl::desc("Display the ELF .dynamic section table")); |
| 122 | |
| 123 | // -needed-libs |
| 124 | cl::opt<bool> NeededLibraries("needed-libs", |
| 125 | cl::desc("Display the needed libraries")); |
Nico Rieck | f3f0b79 | 2013-04-12 04:01:52 +0000 | [diff] [blame] | 126 | |
Nico Rieck | d6df054 | 2013-04-12 04:07:39 +0000 | [diff] [blame] | 127 | // -program-headers |
| 128 | cl::opt<bool> ProgramHeaders("program-headers", |
| 129 | cl::desc("Display ELF program headers")); |
| 130 | |
Michael J. Spencer | 20546ff | 2015-07-09 22:32:24 +0000 | [diff] [blame] | 131 | // -hash-table |
| 132 | cl::opt<bool> HashTable("hash-table", |
| 133 | cl::desc("Display ELF hash table")); |
| 134 | |
Igor Kudrin | 496fb2f | 2015-10-14 12:11:50 +0000 | [diff] [blame] | 135 | // -gnu-hash-table |
| 136 | cl::opt<bool> GnuHashTable("gnu-hash-table", |
| 137 | cl::desc("Display ELF .gnu.hash section")); |
| 138 | |
Nico Rieck | f3f0b79 | 2013-04-12 04:01:52 +0000 | [diff] [blame] | 139 | // -expand-relocs |
| 140 | cl::opt<bool> ExpandRelocs("expand-relocs", |
| 141 | cl::desc("Expand each shown relocation to multiple lines")); |
Timur Iskhodzhanov | 48703be | 2013-12-19 11:37:14 +0000 | [diff] [blame] | 142 | |
Zachary Turner | 99f0215 | 2015-02-18 19:32:05 +0000 | [diff] [blame] | 143 | // -codeview |
| 144 | cl::opt<bool> CodeView("codeview", |
| 145 | cl::desc("Display CodeView debug information")); |
| 146 | |
| 147 | // -codeview-subsection-bytes |
| 148 | cl::opt<bool> CodeViewSubsectionBytes( |
| 149 | "codeview-subsection-bytes", |
| 150 | cl::desc("Dump raw contents of codeview debug sections and records")); |
Saleem Abdulrasool | 15d16d8 | 2014-01-30 04:46:33 +0000 | [diff] [blame] | 151 | |
| 152 | // -arm-attributes, -a |
| 153 | cl::opt<bool> ARMAttributes("arm-attributes", |
| 154 | cl::desc("Display the ARM attributes section")); |
| 155 | cl::alias ARMAttributesShort("-a", cl::desc("Alias for --arm-attributes"), |
| 156 | cl::aliasopt(ARMAttributes)); |
Simon Atanasyan | 8043390 | 2014-06-18 08:47:09 +0000 | [diff] [blame] | 157 | |
| 158 | // -mips-plt-got |
| 159 | cl::opt<bool> |
| 160 | MipsPLTGOT("mips-plt-got", |
| 161 | cl::desc("Display the MIPS GOT and PLT GOT sections")); |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 162 | |
Simon Atanasyan | c914de2 | 2015-05-07 15:40:35 +0000 | [diff] [blame] | 163 | // -mips-abi-flags |
| 164 | cl::opt<bool> MipsABIFlags("mips-abi-flags", |
| 165 | cl::desc("Display the MIPS.abiflags section")); |
| 166 | |
Simon Atanasyan | 6e07e93 | 2015-06-16 21:47:43 +0000 | [diff] [blame] | 167 | // -mips-reginfo |
| 168 | cl::opt<bool> MipsReginfo("mips-reginfo", |
| 169 | cl::desc("Display the MIPS .reginfo section")); |
| 170 | |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 171 | // -coff-imports |
| 172 | cl::opt<bool> |
| 173 | COFFImports("coff-imports", cl::desc("Display the PE/COFF import table")); |
Saleem Abdulrasool | f957863 | 2014-10-07 19:37:52 +0000 | [diff] [blame] | 174 | |
Saleem Abdulrasool | ddd9264 | 2015-01-03 21:35:09 +0000 | [diff] [blame] | 175 | // -coff-exports |
| 176 | cl::opt<bool> |
| 177 | COFFExports("coff-exports", cl::desc("Display the PE/COFF export table")); |
| 178 | |
Saleem Abdulrasool | f957863 | 2014-10-07 19:37:52 +0000 | [diff] [blame] | 179 | // -coff-directives |
| 180 | cl::opt<bool> |
| 181 | COFFDirectives("coff-directives", |
Rui Ueyama | 74e8513 | 2014-11-19 00:18:07 +0000 | [diff] [blame] | 182 | cl::desc("Display the PE/COFF .drectve section")); |
| 183 | |
| 184 | // -coff-basereloc |
| 185 | cl::opt<bool> |
| 186 | COFFBaseRelocs("coff-basereloc", |
| 187 | cl::desc("Display the PE/COFF .reloc section")); |
Lang Hames | 0000afd | 2015-06-26 23:56:53 +0000 | [diff] [blame] | 188 | |
Davide Italiano | 07e7acb | 2015-08-21 20:28:30 +0000 | [diff] [blame] | 189 | // -macho-data-in-code |
| 190 | cl::opt<bool> |
| 191 | MachODataInCode("macho-data-in-code", |
| 192 | cl::desc("Display MachO Data in Code command")); |
| 193 | |
Davide Italiano | 4410b22 | 2015-09-03 18:10:28 +0000 | [diff] [blame] | 194 | // -macho-indirect-symbols |
| 195 | cl::opt<bool> |
| 196 | MachOIndirectSymbols("macho-indirect-symbols", |
| 197 | cl::desc("Display MachO indirect symbols")); |
| 198 | |
Davide Italiano | 9a429b7 | 2015-09-09 00:21:18 +0000 | [diff] [blame] | 199 | // -macho-linker-options |
| 200 | cl::opt<bool> |
| 201 | MachOLinkerOptions("macho-linker-options", |
| 202 | cl::desc("Display MachO linker options")); |
| 203 | |
Davide Italiano | d1f0996 | 2015-09-02 16:24:24 +0000 | [diff] [blame] | 204 | // -macho-segment |
| 205 | cl::opt<bool> |
| 206 | MachOSegment("macho-segment", |
| 207 | cl::desc("Display MachO Segment command")); |
| 208 | |
Davide Italiano | 976f4da | 2015-08-27 15:11:32 +0000 | [diff] [blame] | 209 | // -macho-version-min |
| 210 | cl::opt<bool> |
| 211 | MachOVersionMin("macho-version-min", |
| 212 | cl::desc("Display MachO version min command")); |
Davide Italiano | 35eebe1 | 2015-08-31 19:32:31 +0000 | [diff] [blame] | 213 | |
| 214 | // -macho-dysymtab |
| 215 | cl::opt<bool> |
| 216 | MachODysymtab("macho-dysymtab", |
| 217 | cl::desc("Display MachO Dysymtab command")); |
| 218 | |
Lang Hames | 0000afd | 2015-06-26 23:56:53 +0000 | [diff] [blame] | 219 | // -stackmap |
| 220 | cl::opt<bool> |
| 221 | PrintStackMap("stackmap", |
| 222 | cl::desc("Display contents of stackmap section")); |
| 223 | |
Davide Italiano | 4f05f32 | 2015-10-16 23:19:01 +0000 | [diff] [blame] | 224 | // -version-info |
| 225 | cl::opt<bool> |
| 226 | VersionInfo("version-info", |
| 227 | cl::desc("Display ELF version sections (if present)")); |
| 228 | cl::alias VersionInfoShort("V", cl::desc("Alias for -version-info"), |
| 229 | cl::aliasopt(VersionInfo)); |
Hemant Kulkarni | ab4a46f | 2016-01-26 19:46:39 +0000 | [diff] [blame] | 230 | |
| 231 | cl::opt<bool> SectionGroups("elf-section-groups", |
| 232 | cl::desc("Display ELF section group contents")); |
| 233 | cl::alias SectionGroupsShort("g", cl::desc("Alias for -elf-sections-groups"), |
| 234 | cl::aliasopt(SectionGroups)); |
| 235 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 236 | } // namespace opts |
| 237 | |
Rafael Espindola | 00ddb14 | 2015-07-20 03:38:17 +0000 | [diff] [blame] | 238 | namespace llvm { |
| 239 | |
Davide Italiano | 1eb9234 | 2015-12-04 19:29:49 +0000 | [diff] [blame] | 240 | LLVM_ATTRIBUTE_NORETURN void reportError(Twine Msg) { |
Davide Italiano | 0a07a82 | 2015-12-23 19:29:34 +0000 | [diff] [blame] | 241 | errs() << "\nError reading file: " << Msg << ".\n"; |
| 242 | errs().flush(); |
Rafael Espindola | fb3acd6 | 2015-07-20 03:23:55 +0000 | [diff] [blame] | 243 | exit(1); |
Rafael Espindola | 724d4b4 | 2015-07-20 03:01:49 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Rafael Espindola | fb3acd6 | 2015-07-20 03:23:55 +0000 | [diff] [blame] | 246 | void error(std::error_code EC) { |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 247 | if (!EC) |
Rafael Espindola | fb3acd6 | 2015-07-20 03:23:55 +0000 | [diff] [blame] | 248 | return; |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 249 | |
Rafael Espindola | 8b3b09f | 2015-08-06 21:54:37 +0000 | [diff] [blame] | 250 | reportError(EC.message()); |
Rafael Espindola | 144af2c | 2012-12-31 16:05:21 +0000 | [diff] [blame] | 251 | } |
| 252 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 253 | bool relocAddressLess(RelocationRef a, RelocationRef b) { |
Rafael Espindola | c768930 | 2015-07-06 15:53:43 +0000 | [diff] [blame] | 254 | return a.getOffset() < b.getOffset(); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 255 | } |
| 256 | |
| 257 | } // namespace llvm |
| 258 | |
Rafael Espindola | 4453e4294 | 2014-06-13 03:07:50 +0000 | [diff] [blame] | 259 | static void reportError(StringRef Input, std::error_code EC) { |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 260 | if (Input == "-") |
| 261 | Input = "<stdin>"; |
| 262 | |
Rafael Espindola | 724d4b4 | 2015-07-20 03:01:49 +0000 | [diff] [blame] | 263 | reportError(Twine(Input) + ": " + EC.message()); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 264 | } |
| 265 | |
| 266 | static void reportError(StringRef Input, StringRef Message) { |
| 267 | if (Input == "-") |
| 268 | Input = "<stdin>"; |
| 269 | |
Rafael Espindola | 724d4b4 | 2015-07-20 03:01:49 +0000 | [diff] [blame] | 270 | reportError(Twine(Input) + ": " + Message); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 271 | } |
| 272 | |
Simon Atanasyan | 8043390 | 2014-06-18 08:47:09 +0000 | [diff] [blame] | 273 | static bool isMipsArch(unsigned Arch) { |
| 274 | switch (Arch) { |
| 275 | case llvm::Triple::mips: |
| 276 | case llvm::Triple::mipsel: |
| 277 | case llvm::Triple::mips64: |
| 278 | case llvm::Triple::mips64el: |
| 279 | return true; |
| 280 | default: |
| 281 | return false; |
| 282 | } |
| 283 | } |
| 284 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 285 | /// @brief Creates an format-specific object file dumper. |
Rafael Espindola | 4453e4294 | 2014-06-13 03:07:50 +0000 | [diff] [blame] | 286 | static std::error_code createDumper(const ObjectFile *Obj, StreamWriter &Writer, |
| 287 | std::unique_ptr<ObjDumper> &Result) { |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 288 | if (!Obj) |
| 289 | return readobj_error::unsupported_file_format; |
| 290 | |
| 291 | if (Obj->isCOFF()) |
| 292 | return createCOFFDumper(Obj, Writer, Result); |
| 293 | if (Obj->isELF()) |
| 294 | return createELFDumper(Obj, Writer, Result); |
| 295 | if (Obj->isMachO()) |
| 296 | return createMachODumper(Obj, Writer, Result); |
| 297 | |
| 298 | return readobj_error::unsupported_obj_file_format; |
| 299 | } |
| 300 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 301 | /// @brief Dumps the specified object file. |
| 302 | static void dumpObject(const ObjectFile *Obj) { |
| 303 | StreamWriter Writer(outs()); |
Ahmed Charles | 56440fd | 2014-03-06 05:51:42 +0000 | [diff] [blame] | 304 | std::unique_ptr<ObjDumper> Dumper; |
Davide Italiano | e66b73f | 2015-12-05 23:36:52 +0000 | [diff] [blame] | 305 | if (std::error_code EC = createDumper(Obj, Writer, Dumper)) |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 306 | reportError(Obj->getFileName(), EC); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 307 | |
Hemant Kulkarni | f46c92f | 2016-02-10 18:21:01 +0000 | [diff] [blame] | 308 | outs() << '\n'; |
| 309 | outs() << "File: " << Obj->getFileName() << "\n"; |
| 310 | outs() << "Format: " << Obj->getFileFormatName() << "\n"; |
| 311 | outs() << "Arch: " |
| 312 | << Triple::getArchTypeName((llvm::Triple::ArchType)Obj->getArch()) |
| 313 | << "\n"; |
| 314 | outs() << "AddressSize: " << (8*Obj->getBytesInAddress()) << "bit\n"; |
| 315 | Dumper->printLoadName(); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 316 | |
| 317 | if (opts::FileHeaders) |
| 318 | Dumper->printFileHeaders(); |
| 319 | if (opts::Sections) |
| 320 | Dumper->printSections(); |
| 321 | if (opts::Relocations) |
| 322 | Dumper->printRelocations(); |
Michael J. Spencer | 594c028 | 2015-06-25 21:47:32 +0000 | [diff] [blame] | 323 | if (opts::DynRelocs) |
| 324 | Dumper->printDynamicRelocations(); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 325 | if (opts::Symbols) |
| 326 | Dumper->printSymbols(); |
| 327 | if (opts::DynamicSymbols) |
| 328 | Dumper->printDynamicSymbols(); |
| 329 | if (opts::UnwindInfo) |
| 330 | Dumper->printUnwindInfo(); |
| 331 | if (opts::DynamicTable) |
| 332 | Dumper->printDynamicTable(); |
| 333 | if (opts::NeededLibraries) |
| 334 | Dumper->printNeededLibraries(); |
Nico Rieck | d6df054 | 2013-04-12 04:07:39 +0000 | [diff] [blame] | 335 | if (opts::ProgramHeaders) |
| 336 | Dumper->printProgramHeaders(); |
Michael J. Spencer | 20546ff | 2015-07-09 22:32:24 +0000 | [diff] [blame] | 337 | if (opts::HashTable) |
| 338 | Dumper->printHashTable(); |
Igor Kudrin | 496fb2f | 2015-10-14 12:11:50 +0000 | [diff] [blame] | 339 | if (opts::GnuHashTable) |
| 340 | Dumper->printGnuHashTable(); |
Davide Italiano | 4f05f32 | 2015-10-16 23:19:01 +0000 | [diff] [blame] | 341 | if (opts::VersionInfo) |
| 342 | Dumper->printVersionInfo(); |
Hemant Kulkarni | ab4a46f | 2016-01-26 19:46:39 +0000 | [diff] [blame] | 343 | if (Obj->isELF()) { |
| 344 | if (Obj->getArch() == llvm::Triple::arm) |
| 345 | if (opts::ARMAttributes) |
| 346 | Dumper->printAttributes(); |
| 347 | if (isMipsArch(Obj->getArch())) { |
| 348 | if (opts::MipsPLTGOT) |
| 349 | Dumper->printMipsPLTGOT(); |
| 350 | if (opts::MipsABIFlags) |
| 351 | Dumper->printMipsABIFlags(); |
| 352 | if (opts::MipsReginfo) |
| 353 | Dumper->printMipsReginfo(); |
| 354 | } |
| 355 | if (opts::SectionGroups) |
| 356 | Dumper->printGroupSections(); |
Simon Atanasyan | c914de2 | 2015-05-07 15:40:35 +0000 | [diff] [blame] | 357 | } |
Davide Italiano | cd1b6db | 2015-07-24 02:14:20 +0000 | [diff] [blame] | 358 | if (Obj->isCOFF()) { |
| 359 | if (opts::COFFImports) |
| 360 | Dumper->printCOFFImports(); |
| 361 | if (opts::COFFExports) |
| 362 | Dumper->printCOFFExports(); |
| 363 | if (opts::COFFDirectives) |
| 364 | Dumper->printCOFFDirectives(); |
| 365 | if (opts::COFFBaseRelocs) |
| 366 | Dumper->printCOFFBaseReloc(); |
Reid Kleckner | 83ebad3 | 2015-12-16 18:28:12 +0000 | [diff] [blame] | 367 | if (opts::CodeView) |
| 368 | Dumper->printCodeViewDebugInfo(); |
Davide Italiano | cd1b6db | 2015-07-24 02:14:20 +0000 | [diff] [blame] | 369 | } |
Davide Italiano | 1e12fc4 | 2015-08-31 17:12:23 +0000 | [diff] [blame] | 370 | if (Obj->isMachO()) { |
Davide Italiano | 07e7acb | 2015-08-21 20:28:30 +0000 | [diff] [blame] | 371 | if (opts::MachODataInCode) |
| 372 | Dumper->printMachODataInCode(); |
Davide Italiano | 4410b22 | 2015-09-03 18:10:28 +0000 | [diff] [blame] | 373 | if (opts::MachOIndirectSymbols) |
| 374 | Dumper->printMachOIndirectSymbols(); |
Davide Italiano | 9a429b7 | 2015-09-09 00:21:18 +0000 | [diff] [blame] | 375 | if (opts::MachOLinkerOptions) |
| 376 | Dumper->printMachOLinkerOptions(); |
Davide Italiano | d1f0996 | 2015-09-02 16:24:24 +0000 | [diff] [blame] | 377 | if (opts::MachOSegment) |
| 378 | Dumper->printMachOSegment(); |
Davide Italiano | 976f4da | 2015-08-27 15:11:32 +0000 | [diff] [blame] | 379 | if (opts::MachOVersionMin) |
| 380 | Dumper->printMachOVersionMin(); |
Davide Italiano | 35eebe1 | 2015-08-31 19:32:31 +0000 | [diff] [blame] | 381 | if (opts::MachODysymtab) |
| 382 | Dumper->printMachODysymtab(); |
Davide Italiano | 1e12fc4 | 2015-08-31 17:12:23 +0000 | [diff] [blame] | 383 | } |
Lang Hames | 0000afd | 2015-06-26 23:56:53 +0000 | [diff] [blame] | 384 | if (opts::PrintStackMap) |
| 385 | Dumper->printStackMap(); |
Rafael Espindola | 21bd841 | 2012-12-31 16:29:44 +0000 | [diff] [blame] | 386 | } |
| 387 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 388 | /// @brief Dumps each object file in \a Arc; |
| 389 | static void dumpArchive(const Archive *Arc) { |
Kevin Enderby | 7a96942 | 2015-11-05 19:24:56 +0000 | [diff] [blame] | 390 | for (auto &ErrorOrChild : Arc->children()) { |
| 391 | if (std::error_code EC = ErrorOrChild.getError()) |
| 392 | reportError(Arc->getFileName(), EC.message()); |
| 393 | const auto &Child = *ErrorOrChild; |
Davide Italiano | db8803b | 2015-08-07 00:35:28 +0000 | [diff] [blame] | 394 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = Child.getAsBinary(); |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 395 | if (std::error_code EC = ChildOrErr.getError()) { |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 396 | // Ignore non-object files. |
| 397 | if (EC != object_error::invalid_file_type) |
| 398 | reportError(Arc->getFileName(), EC.message()); |
| 399 | continue; |
David Meyer | 6c614bf | 2012-03-09 20:59:52 +0000 | [diff] [blame] | 400 | } |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 401 | |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 402 | if (ObjectFile *Obj = dyn_cast<ObjectFile>(&*ChildOrErr.get())) |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 403 | dumpObject(Obj); |
| 404 | else |
| 405 | reportError(Arc->getFileName(), readobj_error::unrecognized_file_format); |
| 406 | } |
| 407 | } |
| 408 | |
Rafael Espindola | 8448a24 | 2015-03-24 20:26:55 +0000 | [diff] [blame] | 409 | /// @brief Dumps each object file in \a MachO Universal Binary; |
| 410 | static void dumpMachOUniversalBinary(const MachOUniversalBinary *UBinary) { |
| 411 | for (const MachOUniversalBinary::ObjectForArch &Obj : UBinary->objects()) { |
| 412 | ErrorOr<std::unique_ptr<MachOObjectFile>> ObjOrErr = Obj.getAsObjectFile(); |
David Blaikie | 29ac43c | 2015-04-13 16:05:49 +0000 | [diff] [blame] | 413 | if (ObjOrErr) |
| 414 | dumpObject(&*ObjOrErr.get()); |
| 415 | else if (ErrorOr<std::unique_ptr<Archive>> AOrErr = Obj.getAsArchive()) |
| 416 | dumpArchive(&*AOrErr.get()); |
| 417 | else |
| 418 | reportError(UBinary->getFileName(), ObjOrErr.getError().message()); |
Rafael Espindola | 8448a24 | 2015-03-24 20:26:55 +0000 | [diff] [blame] | 419 | } |
| 420 | } |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 421 | |
| 422 | /// @brief Opens \a File and dumps it. |
| 423 | static void dumpInput(StringRef File) { |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 424 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 425 | // Attempt to open the binary. |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 426 | ErrorOr<OwningBinary<Binary>> BinaryOrErr = createBinary(File); |
Davide Italiano | e66b73f | 2015-12-05 23:36:52 +0000 | [diff] [blame] | 427 | if (std::error_code EC = BinaryOrErr.getError()) |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 428 | reportError(File, EC); |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 429 | Binary &Binary = *BinaryOrErr.get().getBinary(); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 430 | |
Rafael Espindola | 3f6481d | 2014-08-01 14:31:55 +0000 | [diff] [blame] | 431 | if (Archive *Arc = dyn_cast<Archive>(&Binary)) |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 432 | dumpArchive(Arc); |
Rafael Espindola | 8448a24 | 2015-03-24 20:26:55 +0000 | [diff] [blame] | 433 | else if (MachOUniversalBinary *UBinary = |
| 434 | dyn_cast<MachOUniversalBinary>(&Binary)) |
| 435 | dumpMachOUniversalBinary(UBinary); |
Rafael Espindola | 3f6481d | 2014-08-01 14:31:55 +0000 | [diff] [blame] | 436 | else if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary)) |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 437 | dumpObject(Obj); |
Rui Ueyama | 71ba9bd | 2015-08-28 07:40:30 +0000 | [diff] [blame] | 438 | else if (COFFImportFile *Import = dyn_cast<COFFImportFile>(&Binary)) |
| 439 | dumpCOFFImportFile(Import); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 440 | else |
| 441 | reportError(File, readobj_error::unrecognized_file_format); |
Rafael Espindola | 21bd841 | 2012-12-31 16:29:44 +0000 | [diff] [blame] | 442 | } |
| 443 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 444 | int main(int argc, const char *argv[]) { |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 445 | sys::PrintStackTraceOnErrorSignal(); |
| 446 | PrettyStackTraceProgram X(argc, argv); |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 447 | llvm_shutdown_obj Y; |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 448 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 449 | // Register the target printer for --version. |
| 450 | cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion); |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 451 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 452 | cl::ParseCommandLineOptions(argc, argv, "LLVM Object Reader\n"); |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 453 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 454 | // Default to stdin if no filename is specified. |
| 455 | if (opts::InputFilenames.size() == 0) |
| 456 | opts::InputFilenames.push_back("-"); |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 457 | |
Eric Christopher | 9cad53c | 2013-04-03 18:31:38 +0000 | [diff] [blame] | 458 | std::for_each(opts::InputFilenames.begin(), opts::InputFilenames.end(), |
| 459 | dumpInput); |
Rafael Espindola | 278e891 | 2012-12-31 16:53:01 +0000 | [diff] [blame] | 460 | |
Rafael Espindola | fb3acd6 | 2015-07-20 03:23:55 +0000 | [diff] [blame] | 461 | return 0; |
David Meyer | 2fc34c5 | 2012-03-01 01:36:50 +0000 | [diff] [blame] | 462 | } |