File: | build/source/llvm/include/llvm/Object/ObjectFile.h |
Warning: | line 464, column 10 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===-- MachODump.cpp - Object file dumping utility for llvm --------------===// | ||||
2 | // | ||||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||||
4 | // See https://llvm.org/LICENSE.txt for license information. | ||||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||||
6 | // | ||||
7 | //===----------------------------------------------------------------------===// | ||||
8 | // | ||||
9 | // This file implements the MachO-specific dumper for llvm-objdump. | ||||
10 | // | ||||
11 | //===----------------------------------------------------------------------===// | ||||
12 | |||||
13 | #include "MachODump.h" | ||||
14 | |||||
15 | #include "ObjdumpOptID.h" | ||||
16 | #include "llvm-objdump.h" | ||||
17 | #include "llvm-c/Disassembler.h" | ||||
18 | #include "llvm/ADT/STLExtras.h" | ||||
19 | #include "llvm/ADT/StringExtras.h" | ||||
20 | #include "llvm/BinaryFormat/MachO.h" | ||||
21 | #include "llvm/Config/config.h" | ||||
22 | #include "llvm/DebugInfo/DIContext.h" | ||||
23 | #include "llvm/DebugInfo/DWARF/DWARFContext.h" | ||||
24 | #include "llvm/Demangle/Demangle.h" | ||||
25 | #include "llvm/MC/MCAsmInfo.h" | ||||
26 | #include "llvm/MC/MCContext.h" | ||||
27 | #include "llvm/MC/MCDisassembler/MCDisassembler.h" | ||||
28 | #include "llvm/MC/MCInst.h" | ||||
29 | #include "llvm/MC/MCInstPrinter.h" | ||||
30 | #include "llvm/MC/MCInstrDesc.h" | ||||
31 | #include "llvm/MC/MCInstrInfo.h" | ||||
32 | #include "llvm/MC/MCRegisterInfo.h" | ||||
33 | #include "llvm/MC/MCSubtargetInfo.h" | ||||
34 | #include "llvm/MC/MCTargetOptions.h" | ||||
35 | #include "llvm/MC/TargetRegistry.h" | ||||
36 | #include "llvm/Object/MachO.h" | ||||
37 | #include "llvm/Object/MachOUniversal.h" | ||||
38 | #include "llvm/Option/ArgList.h" | ||||
39 | #include "llvm/Support/Casting.h" | ||||
40 | #include "llvm/Support/Debug.h" | ||||
41 | #include "llvm/Support/Endian.h" | ||||
42 | #include "llvm/Support/Format.h" | ||||
43 | #include "llvm/Support/FormattedStream.h" | ||||
44 | #include "llvm/Support/GraphWriter.h" | ||||
45 | #include "llvm/Support/LEB128.h" | ||||
46 | #include "llvm/Support/MemoryBuffer.h" | ||||
47 | #include "llvm/Support/TargetSelect.h" | ||||
48 | #include "llvm/Support/ToolOutputFile.h" | ||||
49 | #include "llvm/Support/WithColor.h" | ||||
50 | #include "llvm/Support/raw_ostream.h" | ||||
51 | #include "llvm/TargetParser/Triple.h" | ||||
52 | #include <algorithm> | ||||
53 | #include <cstring> | ||||
54 | #include <system_error> | ||||
55 | |||||
56 | #ifdef LLVM_HAVE_LIBXAR | ||||
57 | extern "C" { | ||||
58 | #include <xar/xar.h> | ||||
59 | } | ||||
60 | #endif | ||||
61 | |||||
62 | using namespace llvm; | ||||
63 | using namespace llvm::object; | ||||
64 | using namespace llvm::objdump; | ||||
65 | |||||
66 | bool objdump::FirstPrivateHeader; | ||||
67 | bool objdump::ExportsTrie; | ||||
68 | bool objdump::Rebase; | ||||
69 | bool objdump::Rpaths; | ||||
70 | bool objdump::Bind; | ||||
71 | bool objdump::LazyBind; | ||||
72 | bool objdump::WeakBind; | ||||
73 | static bool UseDbg; | ||||
74 | static std::string DSYMFile; | ||||
75 | bool objdump::FullLeadingAddr; | ||||
76 | bool objdump::LeadingHeaders; | ||||
77 | bool objdump::UniversalHeaders; | ||||
78 | static bool ArchiveMemberOffsets; | ||||
79 | bool objdump::IndirectSymbols; | ||||
80 | bool objdump::DataInCode; | ||||
81 | FunctionStartsMode objdump::FunctionStartsType = | ||||
82 | objdump::FunctionStartsMode::None; | ||||
83 | bool objdump::LinkOptHints; | ||||
84 | bool objdump::InfoPlist; | ||||
85 | bool objdump::ChainedFixups; | ||||
86 | bool objdump::DyldInfo; | ||||
87 | bool objdump::DylibsUsed; | ||||
88 | bool objdump::DylibId; | ||||
89 | bool objdump::Verbose; | ||||
90 | bool objdump::ObjcMetaData; | ||||
91 | std::string objdump::DisSymName; | ||||
92 | bool objdump::SymbolicOperands; | ||||
93 | static std::vector<std::string> ArchFlags; | ||||
94 | |||||
95 | static bool ArchAll = false; | ||||
96 | static std::string ThumbTripleName; | ||||
97 | |||||
98 | static StringRef ordinalName(const object::MachOObjectFile *, int); | ||||
99 | |||||
100 | void objdump::parseMachOOptions(const llvm::opt::InputArgList &InputArgs) { | ||||
101 | FirstPrivateHeader = InputArgs.hasArg(OBJDUMP_private_header); | ||||
102 | ExportsTrie = InputArgs.hasArg(OBJDUMP_exports_trie); | ||||
103 | Rebase = InputArgs.hasArg(OBJDUMP_rebase); | ||||
104 | Rpaths = InputArgs.hasArg(OBJDUMP_rpaths); | ||||
105 | Bind = InputArgs.hasArg(OBJDUMP_bind); | ||||
106 | LazyBind = InputArgs.hasArg(OBJDUMP_lazy_bind); | ||||
107 | WeakBind = InputArgs.hasArg(OBJDUMP_weak_bind); | ||||
108 | UseDbg = InputArgs.hasArg(OBJDUMP_g); | ||||
109 | DSYMFile = InputArgs.getLastArgValue(OBJDUMP_dsym_EQ).str(); | ||||
110 | FullLeadingAddr = InputArgs.hasArg(OBJDUMP_full_leading_addr); | ||||
111 | LeadingHeaders = !InputArgs.hasArg(OBJDUMP_no_leading_headers); | ||||
112 | UniversalHeaders = InputArgs.hasArg(OBJDUMP_universal_headers); | ||||
113 | ArchiveMemberOffsets = InputArgs.hasArg(OBJDUMP_archive_member_offsets); | ||||
114 | IndirectSymbols = InputArgs.hasArg(OBJDUMP_indirect_symbols); | ||||
115 | DataInCode = InputArgs.hasArg(OBJDUMP_data_in_code); | ||||
116 | if (const opt::Arg *A = InputArgs.getLastArg(OBJDUMP_function_starts_EQ)) { | ||||
117 | FunctionStartsType = StringSwitch<FunctionStartsMode>(A->getValue()) | ||||
118 | .Case("addrs", FunctionStartsMode::Addrs) | ||||
119 | .Case("names", FunctionStartsMode::Names) | ||||
120 | .Case("both", FunctionStartsMode::Both) | ||||
121 | .Default(FunctionStartsMode::None); | ||||
122 | if (FunctionStartsType == FunctionStartsMode::None) | ||||
123 | invalidArgValue(A); | ||||
124 | } | ||||
125 | LinkOptHints = InputArgs.hasArg(OBJDUMP_link_opt_hints); | ||||
126 | InfoPlist = InputArgs.hasArg(OBJDUMP_info_plist); | ||||
127 | ChainedFixups = InputArgs.hasArg(OBJDUMP_chained_fixups); | ||||
128 | DyldInfo = InputArgs.hasArg(OBJDUMP_dyld_info); | ||||
129 | DylibsUsed = InputArgs.hasArg(OBJDUMP_dylibs_used); | ||||
130 | DylibId = InputArgs.hasArg(OBJDUMP_dylib_id); | ||||
131 | Verbose = !InputArgs.hasArg(OBJDUMP_non_verbose); | ||||
132 | ObjcMetaData = InputArgs.hasArg(OBJDUMP_objc_meta_data); | ||||
133 | DisSymName = InputArgs.getLastArgValue(OBJDUMP_dis_symname).str(); | ||||
134 | SymbolicOperands = !InputArgs.hasArg(OBJDUMP_no_symbolic_operands); | ||||
135 | ArchFlags = InputArgs.getAllArgValues(OBJDUMP_arch_EQ); | ||||
136 | } | ||||
137 | |||||
138 | static const Target *GetTarget(const MachOObjectFile *MachOObj, | ||||
139 | const char **McpuDefault, | ||||
140 | const Target **ThumbTarget) { | ||||
141 | // Figure out the target triple. | ||||
142 | Triple TT(TripleName); | ||||
143 | if (TripleName.empty()) { | ||||
144 | TT = MachOObj->getArchTriple(McpuDefault); | ||||
145 | TripleName = TT.str(); | ||||
146 | } | ||||
147 | |||||
148 | if (TT.getArch() == Triple::arm) { | ||||
149 | // We've inferred a 32-bit ARM target from the object file. All MachO CPUs | ||||
150 | // that support ARM are also capable of Thumb mode. | ||||
151 | Triple ThumbTriple = TT; | ||||
152 | std::string ThumbName = (Twine("thumb") + TT.getArchName().substr(3)).str(); | ||||
153 | ThumbTriple.setArchName(ThumbName); | ||||
154 | ThumbTripleName = ThumbTriple.str(); | ||||
155 | } | ||||
156 | |||||
157 | // Get the target specific parser. | ||||
158 | std::string Error; | ||||
159 | const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error); | ||||
160 | if (TheTarget && ThumbTripleName.empty()) | ||||
161 | return TheTarget; | ||||
162 | |||||
163 | *ThumbTarget = TargetRegistry::lookupTarget(ThumbTripleName, Error); | ||||
164 | if (*ThumbTarget) | ||||
165 | return TheTarget; | ||||
166 | |||||
167 | WithColor::error(errs(), "llvm-objdump") << "unable to get target for '"; | ||||
168 | if (!TheTarget) | ||||
169 | errs() << TripleName; | ||||
170 | else | ||||
171 | errs() << ThumbTripleName; | ||||
172 | errs() << "', see --version and --triple.\n"; | ||||
173 | return nullptr; | ||||
174 | } | ||||
175 | |||||
176 | namespace { | ||||
177 | struct SymbolSorter { | ||||
178 | bool operator()(const SymbolRef &A, const SymbolRef &B) { | ||||
179 | Expected<SymbolRef::Type> ATypeOrErr = A.getType(); | ||||
180 | if (!ATypeOrErr) | ||||
181 | reportError(ATypeOrErr.takeError(), A.getObject()->getFileName()); | ||||
182 | SymbolRef::Type AType = *ATypeOrErr; | ||||
183 | Expected<SymbolRef::Type> BTypeOrErr = B.getType(); | ||||
184 | if (!BTypeOrErr) | ||||
185 | reportError(BTypeOrErr.takeError(), B.getObject()->getFileName()); | ||||
186 | SymbolRef::Type BType = *BTypeOrErr; | ||||
187 | uint64_t AAddr = | ||||
188 | (AType != SymbolRef::ST_Function) ? 0 : cantFail(A.getValue()); | ||||
189 | uint64_t BAddr = | ||||
190 | (BType != SymbolRef::ST_Function) ? 0 : cantFail(B.getValue()); | ||||
191 | return AAddr < BAddr; | ||||
192 | } | ||||
193 | }; | ||||
194 | } // namespace | ||||
195 | |||||
196 | // Types for the storted data in code table that is built before disassembly | ||||
197 | // and the predicate function to sort them. | ||||
198 | typedef std::pair<uint64_t, DiceRef> DiceTableEntry; | ||||
199 | typedef std::vector<DiceTableEntry> DiceTable; | ||||
200 | typedef DiceTable::iterator dice_table_iterator; | ||||
201 | |||||
202 | #ifdef LLVM_HAVE_LIBXAR | ||||
203 | namespace { | ||||
204 | struct ScopedXarFile { | ||||
205 | xar_t xar; | ||||
206 | ScopedXarFile(const char *filename, int32_t flags) { | ||||
207 | #pragma clang diagnostic push | ||||
208 | #pragma clang diagnostic ignored "-Wdeprecated-declarations" | ||||
209 | xar = xar_open(filename, flags); | ||||
210 | #pragma clang diagnostic pop | ||||
211 | } | ||||
212 | ~ScopedXarFile() { | ||||
213 | if (xar) | ||||
214 | xar_close(xar); | ||||
215 | } | ||||
216 | ScopedXarFile(const ScopedXarFile &) = delete; | ||||
217 | ScopedXarFile &operator=(const ScopedXarFile &) = delete; | ||||
218 | operator xar_t() { return xar; } | ||||
219 | }; | ||||
220 | |||||
221 | struct ScopedXarIter { | ||||
222 | xar_iter_t iter; | ||||
223 | ScopedXarIter() : iter(xar_iter_new()) {} | ||||
224 | ~ScopedXarIter() { | ||||
225 | if (iter) | ||||
226 | xar_iter_free(iter); | ||||
227 | } | ||||
228 | ScopedXarIter(const ScopedXarIter &) = delete; | ||||
229 | ScopedXarIter &operator=(const ScopedXarIter &) = delete; | ||||
230 | operator xar_iter_t() { return iter; } | ||||
231 | }; | ||||
232 | } // namespace | ||||
233 | #endif // defined(LLVM_HAVE_LIBXAR) | ||||
234 | |||||
235 | // This is used to search for a data in code table entry for the PC being | ||||
236 | // disassembled. The j parameter has the PC in j.first. A single data in code | ||||
237 | // table entry can cover many bytes for each of its Kind's. So if the offset, | ||||
238 | // aka the i.first value, of the data in code table entry plus its Length | ||||
239 | // covers the PC being searched for this will return true. If not it will | ||||
240 | // return false. | ||||
241 | static bool compareDiceTableEntries(const DiceTableEntry &i, | ||||
242 | const DiceTableEntry &j) { | ||||
243 | uint16_t Length; | ||||
244 | i.second.getLength(Length); | ||||
245 | |||||
246 | return j.first >= i.first && j.first < i.first + Length; | ||||
247 | } | ||||
248 | |||||
249 | static uint64_t DumpDataInCode(const uint8_t *bytes, uint64_t Length, | ||||
250 | unsigned short Kind) { | ||||
251 | uint32_t Value, Size = 1; | ||||
252 | |||||
253 | switch (Kind) { | ||||
254 | default: | ||||
255 | case MachO::DICE_KIND_DATA: | ||||
256 | if (Length >= 4) { | ||||
257 | if (ShowRawInsn) | ||||
258 | dumpBytes(ArrayRef(bytes, 4), outs()); | ||||
259 | Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; | ||||
260 | outs() << "\t.long " << Value; | ||||
261 | Size = 4; | ||||
262 | } else if (Length >= 2) { | ||||
263 | if (ShowRawInsn) | ||||
264 | dumpBytes(ArrayRef(bytes, 2), outs()); | ||||
265 | Value = bytes[1] << 8 | bytes[0]; | ||||
266 | outs() << "\t.short " << Value; | ||||
267 | Size = 2; | ||||
268 | } else { | ||||
269 | if (ShowRawInsn) | ||||
270 | dumpBytes(ArrayRef(bytes, 2), outs()); | ||||
271 | Value = bytes[0]; | ||||
272 | outs() << "\t.byte " << Value; | ||||
273 | Size = 1; | ||||
274 | } | ||||
275 | if (Kind == MachO::DICE_KIND_DATA) | ||||
276 | outs() << "\t@ KIND_DATA\n"; | ||||
277 | else | ||||
278 | outs() << "\t@ data in code kind = " << Kind << "\n"; | ||||
279 | break; | ||||
280 | case MachO::DICE_KIND_JUMP_TABLE8: | ||||
281 | if (ShowRawInsn) | ||||
282 | dumpBytes(ArrayRef(bytes, 1), outs()); | ||||
283 | Value = bytes[0]; | ||||
284 | outs() << "\t.byte " << format("%3u", Value) << "\t@ KIND_JUMP_TABLE8\n"; | ||||
285 | Size = 1; | ||||
286 | break; | ||||
287 | case MachO::DICE_KIND_JUMP_TABLE16: | ||||
288 | if (ShowRawInsn) | ||||
289 | dumpBytes(ArrayRef(bytes, 2), outs()); | ||||
290 | Value = bytes[1] << 8 | bytes[0]; | ||||
291 | outs() << "\t.short " << format("%5u", Value & 0xffff) | ||||
292 | << "\t@ KIND_JUMP_TABLE16\n"; | ||||
293 | Size = 2; | ||||
294 | break; | ||||
295 | case MachO::DICE_KIND_JUMP_TABLE32: | ||||
296 | case MachO::DICE_KIND_ABS_JUMP_TABLE32: | ||||
297 | if (ShowRawInsn) | ||||
298 | dumpBytes(ArrayRef(bytes, 4), outs()); | ||||
299 | Value = bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0]; | ||||
300 | outs() << "\t.long " << Value; | ||||
301 | if (Kind == MachO::DICE_KIND_JUMP_TABLE32) | ||||
302 | outs() << "\t@ KIND_JUMP_TABLE32\n"; | ||||
303 | else | ||||
304 | outs() << "\t@ KIND_ABS_JUMP_TABLE32\n"; | ||||
305 | Size = 4; | ||||
306 | break; | ||||
307 | } | ||||
308 | return Size; | ||||
309 | } | ||||
310 | |||||
311 | static void getSectionsAndSymbols(MachOObjectFile *MachOObj, | ||||
312 | std::vector<SectionRef> &Sections, | ||||
313 | std::vector<SymbolRef> &Symbols, | ||||
314 | SmallVectorImpl<uint64_t> &FoundFns, | ||||
315 | uint64_t &BaseSegmentAddress) { | ||||
316 | const StringRef FileName = MachOObj->getFileName(); | ||||
317 | for (const SymbolRef &Symbol : MachOObj->symbols()) { | ||||
318 | StringRef SymName = unwrapOrError(Symbol.getName(), FileName); | ||||
319 | if (!SymName.startswith("ltmp")) | ||||
320 | Symbols.push_back(Symbol); | ||||
321 | } | ||||
322 | |||||
323 | append_range(Sections, MachOObj->sections()); | ||||
324 | |||||
325 | bool BaseSegmentAddressSet = false; | ||||
326 | for (const auto &Command : MachOObj->load_commands()) { | ||||
327 | if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) { | ||||
328 | // We found a function starts segment, parse the addresses for later | ||||
329 | // consumption. | ||||
330 | MachO::linkedit_data_command LLC = | ||||
331 | MachOObj->getLinkeditDataLoadCommand(Command); | ||||
332 | |||||
333 | MachOObj->ReadULEB128s(LLC.dataoff, FoundFns); | ||||
334 | } else if (Command.C.cmd == MachO::LC_SEGMENT) { | ||||
335 | MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command); | ||||
336 | StringRef SegName = SLC.segname; | ||||
337 | if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") { | ||||
338 | BaseSegmentAddressSet = true; | ||||
339 | BaseSegmentAddress = SLC.vmaddr; | ||||
340 | } | ||||
341 | } else if (Command.C.cmd == MachO::LC_SEGMENT_64) { | ||||
342 | MachO::segment_command_64 SLC = MachOObj->getSegment64LoadCommand(Command); | ||||
343 | StringRef SegName = SLC.segname; | ||||
344 | if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") { | ||||
345 | BaseSegmentAddressSet = true; | ||||
346 | BaseSegmentAddress = SLC.vmaddr; | ||||
347 | } | ||||
348 | } | ||||
349 | } | ||||
350 | } | ||||
351 | |||||
352 | static bool DumpAndSkipDataInCode(uint64_t PC, const uint8_t *bytes, | ||||
353 | DiceTable &Dices, uint64_t &InstSize) { | ||||
354 | // Check the data in code table here to see if this is data not an | ||||
355 | // instruction to be disassembled. | ||||
356 | DiceTable Dice; | ||||
357 | Dice.push_back(std::make_pair(PC, DiceRef())); | ||||
358 | dice_table_iterator DTI = | ||||
359 | std::search(Dices.begin(), Dices.end(), Dice.begin(), Dice.end(), | ||||
360 | compareDiceTableEntries); | ||||
361 | if (DTI != Dices.end()) { | ||||
362 | uint16_t Length; | ||||
363 | DTI->second.getLength(Length); | ||||
364 | uint16_t Kind; | ||||
365 | DTI->second.getKind(Kind); | ||||
366 | InstSize = DumpDataInCode(bytes, Length, Kind); | ||||
367 | if ((Kind == MachO::DICE_KIND_JUMP_TABLE8) && | ||||
368 | (PC == (DTI->first + Length - 1)) && (Length & 1)) | ||||
369 | InstSize++; | ||||
370 | return true; | ||||
371 | } | ||||
372 | return false; | ||||
373 | } | ||||
374 | |||||
375 | static void printRelocationTargetName(const MachOObjectFile *O, | ||||
376 | const MachO::any_relocation_info &RE, | ||||
377 | raw_string_ostream &Fmt) { | ||||
378 | // Target of a scattered relocation is an address. In the interest of | ||||
379 | // generating pretty output, scan through the symbol table looking for a | ||||
380 | // symbol that aligns with that address. If we find one, print it. | ||||
381 | // Otherwise, we just print the hex address of the target. | ||||
382 | const StringRef FileName = O->getFileName(); | ||||
383 | if (O->isRelocationScattered(RE)) { | ||||
384 | uint32_t Val = O->getPlainRelocationSymbolNum(RE); | ||||
385 | |||||
386 | for (const SymbolRef &Symbol : O->symbols()) { | ||||
387 | uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName); | ||||
388 | if (Addr != Val) | ||||
389 | continue; | ||||
390 | Fmt << unwrapOrError(Symbol.getName(), FileName); | ||||
391 | return; | ||||
392 | } | ||||
393 | |||||
394 | // If we couldn't find a symbol that this relocation refers to, try | ||||
395 | // to find a section beginning instead. | ||||
396 | for (const SectionRef &Section : ToolSectionFilter(*O)) { | ||||
397 | uint64_t Addr = Section.getAddress(); | ||||
398 | if (Addr != Val) | ||||
399 | continue; | ||||
400 | StringRef NameOrErr = unwrapOrError(Section.getName(), O->getFileName()); | ||||
401 | Fmt << NameOrErr; | ||||
402 | return; | ||||
403 | } | ||||
404 | |||||
405 | Fmt << format("0x%x", Val); | ||||
406 | return; | ||||
407 | } | ||||
408 | |||||
409 | StringRef S; | ||||
410 | bool isExtern = O->getPlainRelocationExternal(RE); | ||||
411 | uint64_t Val = O->getPlainRelocationSymbolNum(RE); | ||||
412 | |||||
413 | if (O->getAnyRelocationType(RE) == MachO::ARM64_RELOC_ADDEND && | ||||
414 | (O->getArch() == Triple::aarch64 || O->getArch() == Triple::aarch64_be)) { | ||||
415 | Fmt << format("0x%0" PRIx64"l" "x", Val); | ||||
416 | return; | ||||
417 | } | ||||
418 | |||||
419 | if (isExtern) { | ||||
420 | symbol_iterator SI = O->symbol_begin(); | ||||
421 | std::advance(SI, Val); | ||||
422 | S = unwrapOrError(SI->getName(), FileName); | ||||
423 | } else { | ||||
424 | section_iterator SI = O->section_begin(); | ||||
425 | // Adjust for the fact that sections are 1-indexed. | ||||
426 | if (Val == 0) { | ||||
427 | Fmt << "0 (?,?)"; | ||||
428 | return; | ||||
429 | } | ||||
430 | uint32_t I = Val - 1; | ||||
431 | while (I != 0 && SI != O->section_end()) { | ||||
432 | --I; | ||||
433 | std::advance(SI, 1); | ||||
434 | } | ||||
435 | if (SI == O->section_end()) { | ||||
436 | Fmt << Val << " (?,?)"; | ||||
437 | } else { | ||||
438 | if (Expected<StringRef> NameOrErr = SI->getName()) | ||||
439 | S = *NameOrErr; | ||||
440 | else | ||||
441 | consumeError(NameOrErr.takeError()); | ||||
442 | } | ||||
443 | } | ||||
444 | |||||
445 | Fmt << S; | ||||
446 | } | ||||
447 | |||||
448 | Error objdump::getMachORelocationValueString(const MachOObjectFile *Obj, | ||||
449 | const RelocationRef &RelRef, | ||||
450 | SmallVectorImpl<char> &Result) { | ||||
451 | DataRefImpl Rel = RelRef.getRawDataRefImpl(); | ||||
452 | MachO::any_relocation_info RE = Obj->getRelocation(Rel); | ||||
453 | |||||
454 | unsigned Arch = Obj->getArch(); | ||||
455 | |||||
456 | std::string FmtBuf; | ||||
457 | raw_string_ostream Fmt(FmtBuf); | ||||
458 | unsigned Type = Obj->getAnyRelocationType(RE); | ||||
459 | bool IsPCRel = Obj->getAnyRelocationPCRel(RE); | ||||
460 | |||||
461 | // Determine any addends that should be displayed with the relocation. | ||||
462 | // These require decoding the relocation type, which is triple-specific. | ||||
463 | |||||
464 | // X86_64 has entirely custom relocation types. | ||||
465 | if (Arch == Triple::x86_64) { | ||||
466 | switch (Type) { | ||||
467 | case MachO::X86_64_RELOC_GOT_LOAD: | ||||
468 | case MachO::X86_64_RELOC_GOT: { | ||||
469 | printRelocationTargetName(Obj, RE, Fmt); | ||||
470 | Fmt << "@GOT"; | ||||
471 | if (IsPCRel) | ||||
472 | Fmt << "PCREL"; | ||||
473 | break; | ||||
474 | } | ||||
475 | case MachO::X86_64_RELOC_SUBTRACTOR: { | ||||
476 | DataRefImpl RelNext = Rel; | ||||
477 | Obj->moveRelocationNext(RelNext); | ||||
478 | MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); | ||||
479 | |||||
480 | // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type | ||||
481 | // X86_64_RELOC_UNSIGNED. | ||||
482 | // NOTE: Scattered relocations don't exist on x86_64. | ||||
483 | unsigned RType = Obj->getAnyRelocationType(RENext); | ||||
484 | if (RType != MachO::X86_64_RELOC_UNSIGNED) | ||||
485 | reportError(Obj->getFileName(), "Expected X86_64_RELOC_UNSIGNED after " | ||||
486 | "X86_64_RELOC_SUBTRACTOR."); | ||||
487 | |||||
488 | // The X86_64_RELOC_UNSIGNED contains the minuend symbol; | ||||
489 | // X86_64_RELOC_SUBTRACTOR contains the subtrahend. | ||||
490 | printRelocationTargetName(Obj, RENext, Fmt); | ||||
491 | Fmt << "-"; | ||||
492 | printRelocationTargetName(Obj, RE, Fmt); | ||||
493 | break; | ||||
494 | } | ||||
495 | case MachO::X86_64_RELOC_TLV: | ||||
496 | printRelocationTargetName(Obj, RE, Fmt); | ||||
497 | Fmt << "@TLV"; | ||||
498 | if (IsPCRel) | ||||
499 | Fmt << "P"; | ||||
500 | break; | ||||
501 | case MachO::X86_64_RELOC_SIGNED_1: | ||||
502 | printRelocationTargetName(Obj, RE, Fmt); | ||||
503 | Fmt << "-1"; | ||||
504 | break; | ||||
505 | case MachO::X86_64_RELOC_SIGNED_2: | ||||
506 | printRelocationTargetName(Obj, RE, Fmt); | ||||
507 | Fmt << "-2"; | ||||
508 | break; | ||||
509 | case MachO::X86_64_RELOC_SIGNED_4: | ||||
510 | printRelocationTargetName(Obj, RE, Fmt); | ||||
511 | Fmt << "-4"; | ||||
512 | break; | ||||
513 | default: | ||||
514 | printRelocationTargetName(Obj, RE, Fmt); | ||||
515 | break; | ||||
516 | } | ||||
517 | // X86 and ARM share some relocation types in common. | ||||
518 | } else if (Arch == Triple::x86 || Arch == Triple::arm || | ||||
519 | Arch == Triple::ppc) { | ||||
520 | // Generic relocation types... | ||||
521 | switch (Type) { | ||||
522 | case MachO::GENERIC_RELOC_PAIR: // prints no info | ||||
523 | return Error::success(); | ||||
524 | case MachO::GENERIC_RELOC_SECTDIFF: { | ||||
525 | DataRefImpl RelNext = Rel; | ||||
526 | Obj->moveRelocationNext(RelNext); | ||||
527 | MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); | ||||
528 | |||||
529 | // X86 sect diff's must be followed by a relocation of type | ||||
530 | // GENERIC_RELOC_PAIR. | ||||
531 | unsigned RType = Obj->getAnyRelocationType(RENext); | ||||
532 | |||||
533 | if (RType != MachO::GENERIC_RELOC_PAIR) | ||||
534 | reportError(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after " | ||||
535 | "GENERIC_RELOC_SECTDIFF."); | ||||
536 | |||||
537 | printRelocationTargetName(Obj, RE, Fmt); | ||||
538 | Fmt << "-"; | ||||
539 | printRelocationTargetName(Obj, RENext, Fmt); | ||||
540 | break; | ||||
541 | } | ||||
542 | } | ||||
543 | |||||
544 | if (Arch == Triple::x86 || Arch == Triple::ppc) { | ||||
545 | switch (Type) { | ||||
546 | case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: { | ||||
547 | DataRefImpl RelNext = Rel; | ||||
548 | Obj->moveRelocationNext(RelNext); | ||||
549 | MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); | ||||
550 | |||||
551 | // X86 sect diff's must be followed by a relocation of type | ||||
552 | // GENERIC_RELOC_PAIR. | ||||
553 | unsigned RType = Obj->getAnyRelocationType(RENext); | ||||
554 | if (RType != MachO::GENERIC_RELOC_PAIR) | ||||
555 | reportError(Obj->getFileName(), "Expected GENERIC_RELOC_PAIR after " | ||||
556 | "GENERIC_RELOC_LOCAL_SECTDIFF."); | ||||
557 | |||||
558 | printRelocationTargetName(Obj, RE, Fmt); | ||||
559 | Fmt << "-"; | ||||
560 | printRelocationTargetName(Obj, RENext, Fmt); | ||||
561 | break; | ||||
562 | } | ||||
563 | case MachO::GENERIC_RELOC_TLV: { | ||||
564 | printRelocationTargetName(Obj, RE, Fmt); | ||||
565 | Fmt << "@TLV"; | ||||
566 | if (IsPCRel) | ||||
567 | Fmt << "P"; | ||||
568 | break; | ||||
569 | } | ||||
570 | default: | ||||
571 | printRelocationTargetName(Obj, RE, Fmt); | ||||
572 | } | ||||
573 | } else { // ARM-specific relocations | ||||
574 | switch (Type) { | ||||
575 | case MachO::ARM_RELOC_HALF: | ||||
576 | case MachO::ARM_RELOC_HALF_SECTDIFF: { | ||||
577 | // Half relocations steal a bit from the length field to encode | ||||
578 | // whether this is an upper16 or a lower16 relocation. | ||||
579 | bool isUpper = (Obj->getAnyRelocationLength(RE) & 0x1) == 1; | ||||
580 | |||||
581 | if (isUpper) | ||||
582 | Fmt << ":upper16:("; | ||||
583 | else | ||||
584 | Fmt << ":lower16:("; | ||||
585 | printRelocationTargetName(Obj, RE, Fmt); | ||||
586 | |||||
587 | DataRefImpl RelNext = Rel; | ||||
588 | Obj->moveRelocationNext(RelNext); | ||||
589 | MachO::any_relocation_info RENext = Obj->getRelocation(RelNext); | ||||
590 | |||||
591 | // ARM half relocs must be followed by a relocation of type | ||||
592 | // ARM_RELOC_PAIR. | ||||
593 | unsigned RType = Obj->getAnyRelocationType(RENext); | ||||
594 | if (RType != MachO::ARM_RELOC_PAIR) | ||||
595 | reportError(Obj->getFileName(), "Expected ARM_RELOC_PAIR after " | ||||
596 | "ARM_RELOC_HALF"); | ||||
597 | |||||
598 | // NOTE: The half of the target virtual address is stashed in the | ||||
599 | // address field of the secondary relocation, but we can't reverse | ||||
600 | // engineer the constant offset from it without decoding the movw/movt | ||||
601 | // instruction to find the other half in its immediate field. | ||||
602 | |||||
603 | // ARM_RELOC_HALF_SECTDIFF encodes the second section in the | ||||
604 | // symbol/section pointer of the follow-on relocation. | ||||
605 | if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) { | ||||
606 | Fmt << "-"; | ||||
607 | printRelocationTargetName(Obj, RENext, Fmt); | ||||
608 | } | ||||
609 | |||||
610 | Fmt << ")"; | ||||
611 | break; | ||||
612 | } | ||||
613 | default: { | ||||
614 | printRelocationTargetName(Obj, RE, Fmt); | ||||
615 | } | ||||
616 | } | ||||
617 | } | ||||
618 | } else | ||||
619 | printRelocationTargetName(Obj, RE, Fmt); | ||||
620 | |||||
621 | Fmt.flush(); | ||||
622 | Result.append(FmtBuf.begin(), FmtBuf.end()); | ||||
623 | return Error::success(); | ||||
624 | } | ||||
625 | |||||
626 | static void PrintIndirectSymbolTable(MachOObjectFile *O, bool verbose, | ||||
627 | uint32_t n, uint32_t count, | ||||
628 | uint32_t stride, uint64_t addr) { | ||||
629 | MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand(); | ||||
630 | uint32_t nindirectsyms = Dysymtab.nindirectsyms; | ||||
631 | if (n > nindirectsyms) | ||||
632 | outs() << " (entries start past the end of the indirect symbol " | ||||
633 | "table) (reserved1 field greater than the table size)"; | ||||
634 | else if (n + count > nindirectsyms) | ||||
635 | outs() << " (entries extends past the end of the indirect symbol " | ||||
636 | "table)"; | ||||
637 | outs() << "\n"; | ||||
638 | uint32_t cputype = O->getHeader().cputype; | ||||
639 | if (cputype & MachO::CPU_ARCH_ABI64) | ||||
640 | outs() << "address index"; | ||||
641 | else | ||||
642 | outs() << "address index"; | ||||
643 | if (verbose) | ||||
644 | outs() << " name\n"; | ||||
645 | else | ||||
646 | outs() << "\n"; | ||||
647 | for (uint32_t j = 0; j < count && n + j < nindirectsyms; j++) { | ||||
648 | if (cputype & MachO::CPU_ARCH_ABI64) | ||||
649 | outs() << format("0x%016" PRIx64"l" "x", addr + j * stride) << " "; | ||||
650 | else | ||||
651 | outs() << format("0x%08" PRIx32"x", (uint32_t)addr + j * stride) << " "; | ||||
652 | MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand(); | ||||
653 | uint32_t indirect_symbol = O->getIndirectSymbolTableEntry(Dysymtab, n + j); | ||||
654 | if (indirect_symbol == MachO::INDIRECT_SYMBOL_LOCAL) { | ||||
655 | outs() << "LOCAL\n"; | ||||
656 | continue; | ||||
657 | } | ||||
658 | if (indirect_symbol == | ||||
659 | (MachO::INDIRECT_SYMBOL_LOCAL | MachO::INDIRECT_SYMBOL_ABS)) { | ||||
660 | outs() << "LOCAL ABSOLUTE\n"; | ||||
661 | continue; | ||||
662 | } | ||||
663 | if (indirect_symbol == MachO::INDIRECT_SYMBOL_ABS) { | ||||
664 | outs() << "ABSOLUTE\n"; | ||||
665 | continue; | ||||
666 | } | ||||
667 | outs() << format("%5u ", indirect_symbol); | ||||
668 | if (verbose) { | ||||
669 | MachO::symtab_command Symtab = O->getSymtabLoadCommand(); | ||||
670 | if (indirect_symbol < Symtab.nsyms) { | ||||
671 | symbol_iterator Sym = O->getSymbolByIndex(indirect_symbol); | ||||
672 | SymbolRef Symbol = *Sym; | ||||
673 | outs() << unwrapOrError(Symbol.getName(), O->getFileName()); | ||||
674 | } else { | ||||
675 | outs() << "?"; | ||||
676 | } | ||||
677 | } | ||||
678 | outs() << "\n"; | ||||
679 | } | ||||
680 | } | ||||
681 | |||||
682 | static void PrintIndirectSymbols(MachOObjectFile *O, bool verbose) { | ||||
683 | for (const auto &Load : O->load_commands()) { | ||||
684 | if (Load.C.cmd == MachO::LC_SEGMENT_64) { | ||||
685 | MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load); | ||||
686 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
687 | MachO::section_64 Sec = O->getSection64(Load, J); | ||||
688 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
689 | if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS || | ||||
690 | section_type == MachO::S_LAZY_SYMBOL_POINTERS || | ||||
691 | section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS || | ||||
692 | section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS || | ||||
693 | section_type == MachO::S_SYMBOL_STUBS) { | ||||
694 | uint32_t stride; | ||||
695 | if (section_type == MachO::S_SYMBOL_STUBS) | ||||
696 | stride = Sec.reserved2; | ||||
697 | else | ||||
698 | stride = 8; | ||||
699 | if (stride == 0) { | ||||
700 | outs() << "Can't print indirect symbols for (" << Sec.segname << "," | ||||
701 | << Sec.sectname << ") " | ||||
702 | << "(size of stubs in reserved2 field is zero)\n"; | ||||
703 | continue; | ||||
704 | } | ||||
705 | uint32_t count = Sec.size / stride; | ||||
706 | outs() << "Indirect symbols for (" << Sec.segname << "," | ||||
707 | << Sec.sectname << ") " << count << " entries"; | ||||
708 | uint32_t n = Sec.reserved1; | ||||
709 | PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr); | ||||
710 | } | ||||
711 | } | ||||
712 | } else if (Load.C.cmd == MachO::LC_SEGMENT) { | ||||
713 | MachO::segment_command Seg = O->getSegmentLoadCommand(Load); | ||||
714 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
715 | MachO::section Sec = O->getSection(Load, J); | ||||
716 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
717 | if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS || | ||||
718 | section_type == MachO::S_LAZY_SYMBOL_POINTERS || | ||||
719 | section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS || | ||||
720 | section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS || | ||||
721 | section_type == MachO::S_SYMBOL_STUBS) { | ||||
722 | uint32_t stride; | ||||
723 | if (section_type == MachO::S_SYMBOL_STUBS) | ||||
724 | stride = Sec.reserved2; | ||||
725 | else | ||||
726 | stride = 4; | ||||
727 | if (stride == 0) { | ||||
728 | outs() << "Can't print indirect symbols for (" << Sec.segname << "," | ||||
729 | << Sec.sectname << ") " | ||||
730 | << "(size of stubs in reserved2 field is zero)\n"; | ||||
731 | continue; | ||||
732 | } | ||||
733 | uint32_t count = Sec.size / stride; | ||||
734 | outs() << "Indirect symbols for (" << Sec.segname << "," | ||||
735 | << Sec.sectname << ") " << count << " entries"; | ||||
736 | uint32_t n = Sec.reserved1; | ||||
737 | PrintIndirectSymbolTable(O, verbose, n, count, stride, Sec.addr); | ||||
738 | } | ||||
739 | } | ||||
740 | } | ||||
741 | } | ||||
742 | } | ||||
743 | |||||
744 | static void PrintRType(const uint64_t cputype, const unsigned r_type) { | ||||
745 | static char const *generic_r_types[] = { | ||||
746 | "VANILLA ", "PAIR ", "SECTDIF ", "PBLAPTR ", "LOCSDIF ", "TLV ", | ||||
747 | " 6 (?) ", " 7 (?) ", " 8 (?) ", " 9 (?) ", " 10 (?) ", " 11 (?) ", | ||||
748 | " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) " | ||||
749 | }; | ||||
750 | static char const *x86_64_r_types[] = { | ||||
751 | "UNSIGND ", "SIGNED ", "BRANCH ", "GOT_LD ", "GOT ", "SUB ", | ||||
752 | "SIGNED1 ", "SIGNED2 ", "SIGNED4 ", "TLV ", " 10 (?) ", " 11 (?) ", | ||||
753 | " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) " | ||||
754 | }; | ||||
755 | static char const *arm_r_types[] = { | ||||
756 | "VANILLA ", "PAIR ", "SECTDIFF", "LOCSDIF ", "PBLAPTR ", | ||||
757 | "BR24 ", "T_BR22 ", "T_BR32 ", "HALF ", "HALFDIF ", | ||||
758 | " 10 (?) ", " 11 (?) ", " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) " | ||||
759 | }; | ||||
760 | static char const *arm64_r_types[] = { | ||||
761 | "UNSIGND ", "SUB ", "BR26 ", "PAGE21 ", "PAGOF12 ", | ||||
762 | "GOTLDP ", "GOTLDPOF", "PTRTGOT ", "TLVLDP ", "TLVLDPOF", | ||||
763 | "ADDEND ", " 11 (?) ", " 12 (?) ", " 13 (?) ", " 14 (?) ", " 15 (?) " | ||||
764 | }; | ||||
765 | |||||
766 | if (r_type > 0xf){ | ||||
767 | outs() << format("%-7u", r_type) << " "; | ||||
768 | return; | ||||
769 | } | ||||
770 | switch (cputype) { | ||||
771 | case MachO::CPU_TYPE_I386: | ||||
772 | outs() << generic_r_types[r_type]; | ||||
773 | break; | ||||
774 | case MachO::CPU_TYPE_X86_64: | ||||
775 | outs() << x86_64_r_types[r_type]; | ||||
776 | break; | ||||
777 | case MachO::CPU_TYPE_ARM: | ||||
778 | outs() << arm_r_types[r_type]; | ||||
779 | break; | ||||
780 | case MachO::CPU_TYPE_ARM64: | ||||
781 | case MachO::CPU_TYPE_ARM64_32: | ||||
782 | outs() << arm64_r_types[r_type]; | ||||
783 | break; | ||||
784 | default: | ||||
785 | outs() << format("%-7u ", r_type); | ||||
786 | } | ||||
787 | } | ||||
788 | |||||
789 | static void PrintRLength(const uint64_t cputype, const unsigned r_type, | ||||
790 | const unsigned r_length, const bool previous_arm_half){ | ||||
791 | if (cputype == MachO::CPU_TYPE_ARM && | ||||
792 | (r_type == MachO::ARM_RELOC_HALF || | ||||
793 | r_type == MachO::ARM_RELOC_HALF_SECTDIFF || previous_arm_half == true)) { | ||||
794 | if ((r_length & 0x1) == 0) | ||||
795 | outs() << "lo/"; | ||||
796 | else | ||||
797 | outs() << "hi/"; | ||||
798 | if ((r_length & 0x1) == 0) | ||||
799 | outs() << "arm "; | ||||
800 | else | ||||
801 | outs() << "thm "; | ||||
802 | } else { | ||||
803 | switch (r_length) { | ||||
804 | case 0: | ||||
805 | outs() << "byte "; | ||||
806 | break; | ||||
807 | case 1: | ||||
808 | outs() << "word "; | ||||
809 | break; | ||||
810 | case 2: | ||||
811 | outs() << "long "; | ||||
812 | break; | ||||
813 | case 3: | ||||
814 | if (cputype == MachO::CPU_TYPE_X86_64) | ||||
815 | outs() << "quad "; | ||||
816 | else | ||||
817 | outs() << format("?(%2d) ", r_length); | ||||
818 | break; | ||||
819 | default: | ||||
820 | outs() << format("?(%2d) ", r_length); | ||||
821 | } | ||||
822 | } | ||||
823 | } | ||||
824 | |||||
825 | static void PrintRelocationEntries(const MachOObjectFile *O, | ||||
826 | const relocation_iterator Begin, | ||||
827 | const relocation_iterator End, | ||||
828 | const uint64_t cputype, | ||||
829 | const bool verbose) { | ||||
830 | const MachO::symtab_command Symtab = O->getSymtabLoadCommand(); | ||||
831 | bool previous_arm_half = false; | ||||
832 | bool previous_sectdiff = false; | ||||
833 | uint32_t sectdiff_r_type = 0; | ||||
834 | |||||
835 | for (relocation_iterator Reloc = Begin; Reloc != End; ++Reloc) { | ||||
836 | const DataRefImpl Rel = Reloc->getRawDataRefImpl(); | ||||
837 | const MachO::any_relocation_info RE = O->getRelocation(Rel); | ||||
838 | const unsigned r_type = O->getAnyRelocationType(RE); | ||||
839 | const bool r_scattered = O->isRelocationScattered(RE); | ||||
840 | const unsigned r_pcrel = O->getAnyRelocationPCRel(RE); | ||||
841 | const unsigned r_length = O->getAnyRelocationLength(RE); | ||||
842 | const unsigned r_address = O->getAnyRelocationAddress(RE); | ||||
843 | const bool r_extern = (r_scattered ? false : | ||||
844 | O->getPlainRelocationExternal(RE)); | ||||
845 | const uint32_t r_value = (r_scattered ? | ||||
846 | O->getScatteredRelocationValue(RE) : 0); | ||||
847 | const unsigned r_symbolnum = (r_scattered ? 0 : | ||||
848 | O->getPlainRelocationSymbolNum(RE)); | ||||
849 | |||||
850 | if (r_scattered && cputype != MachO::CPU_TYPE_X86_64) { | ||||
851 | if (verbose) { | ||||
852 | // scattered: address | ||||
853 | if ((cputype == MachO::CPU_TYPE_I386 && | ||||
854 | r_type == MachO::GENERIC_RELOC_PAIR) || | ||||
855 | (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR)) | ||||
856 | outs() << " "; | ||||
857 | else | ||||
858 | outs() << format("%08x ", (unsigned int)r_address); | ||||
859 | |||||
860 | // scattered: pcrel | ||||
861 | if (r_pcrel) | ||||
862 | outs() << "True "; | ||||
863 | else | ||||
864 | outs() << "False "; | ||||
865 | |||||
866 | // scattered: length | ||||
867 | PrintRLength(cputype, r_type, r_length, previous_arm_half); | ||||
868 | |||||
869 | // scattered: extern & type | ||||
870 | outs() << "n/a "; | ||||
871 | PrintRType(cputype, r_type); | ||||
872 | |||||
873 | // scattered: scattered & value | ||||
874 | outs() << format("True 0x%08x", (unsigned int)r_value); | ||||
875 | if (previous_sectdiff == false) { | ||||
876 | if ((cputype == MachO::CPU_TYPE_ARM && | ||||
877 | r_type == MachO::ARM_RELOC_PAIR)) | ||||
878 | outs() << format(" half = 0x%04x ", (unsigned int)r_address); | ||||
879 | } else if (cputype == MachO::CPU_TYPE_ARM && | ||||
880 | sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF) | ||||
881 | outs() << format(" other_half = 0x%04x ", (unsigned int)r_address); | ||||
882 | if ((cputype == MachO::CPU_TYPE_I386 && | ||||
883 | (r_type == MachO::GENERIC_RELOC_SECTDIFF || | ||||
884 | r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) || | ||||
885 | (cputype == MachO::CPU_TYPE_ARM && | ||||
886 | (sectdiff_r_type == MachO::ARM_RELOC_SECTDIFF || | ||||
887 | sectdiff_r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF || | ||||
888 | sectdiff_r_type == MachO::ARM_RELOC_HALF_SECTDIFF))) { | ||||
889 | previous_sectdiff = true; | ||||
890 | sectdiff_r_type = r_type; | ||||
891 | } else { | ||||
892 | previous_sectdiff = false; | ||||
893 | sectdiff_r_type = 0; | ||||
894 | } | ||||
895 | if (cputype == MachO::CPU_TYPE_ARM && | ||||
896 | (r_type == MachO::ARM_RELOC_HALF || | ||||
897 | r_type == MachO::ARM_RELOC_HALF_SECTDIFF)) | ||||
898 | previous_arm_half = true; | ||||
899 | else | ||||
900 | previous_arm_half = false; | ||||
901 | outs() << "\n"; | ||||
902 | } | ||||
903 | else { | ||||
904 | // scattered: address pcrel length extern type scattered value | ||||
905 | outs() << format("%08x %1d %-2d n/a %-7d 1 0x%08x\n", | ||||
906 | (unsigned int)r_address, r_pcrel, r_length, r_type, | ||||
907 | (unsigned int)r_value); | ||||
908 | } | ||||
909 | } | ||||
910 | else { | ||||
911 | if (verbose) { | ||||
912 | // plain: address | ||||
913 | if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR) | ||||
914 | outs() << " "; | ||||
915 | else | ||||
916 | outs() << format("%08x ", (unsigned int)r_address); | ||||
917 | |||||
918 | // plain: pcrel | ||||
919 | if (r_pcrel) | ||||
920 | outs() << "True "; | ||||
921 | else | ||||
922 | outs() << "False "; | ||||
923 | |||||
924 | // plain: length | ||||
925 | PrintRLength(cputype, r_type, r_length, previous_arm_half); | ||||
926 | |||||
927 | if (r_extern) { | ||||
928 | // plain: extern & type & scattered | ||||
929 | outs() << "True "; | ||||
930 | PrintRType(cputype, r_type); | ||||
931 | outs() << "False "; | ||||
932 | |||||
933 | // plain: symbolnum/value | ||||
934 | if (r_symbolnum > Symtab.nsyms) | ||||
935 | outs() << format("?(%d)\n", r_symbolnum); | ||||
936 | else { | ||||
937 | SymbolRef Symbol = *O->getSymbolByIndex(r_symbolnum); | ||||
938 | Expected<StringRef> SymNameNext = Symbol.getName(); | ||||
939 | const char *name = nullptr; | ||||
940 | if (SymNameNext) | ||||
941 | name = SymNameNext->data(); | ||||
942 | if (name == nullptr) | ||||
943 | outs() << format("?(%d)\n", r_symbolnum); | ||||
944 | else | ||||
945 | outs() << name << "\n"; | ||||
946 | } | ||||
947 | } | ||||
948 | else { | ||||
949 | // plain: extern & type & scattered | ||||
950 | outs() << "False "; | ||||
951 | PrintRType(cputype, r_type); | ||||
952 | outs() << "False "; | ||||
953 | |||||
954 | // plain: symbolnum/value | ||||
955 | if (cputype == MachO::CPU_TYPE_ARM && r_type == MachO::ARM_RELOC_PAIR) | ||||
956 | outs() << format("other_half = 0x%04x\n", (unsigned int)r_address); | ||||
957 | else if ((cputype == MachO::CPU_TYPE_ARM64 || | ||||
958 | cputype == MachO::CPU_TYPE_ARM64_32) && | ||||
959 | r_type == MachO::ARM64_RELOC_ADDEND) | ||||
960 | outs() << format("addend = 0x%06x\n", (unsigned int)r_symbolnum); | ||||
961 | else { | ||||
962 | outs() << format("%d ", r_symbolnum); | ||||
963 | if (r_symbolnum == MachO::R_ABS) | ||||
964 | outs() << "R_ABS\n"; | ||||
965 | else { | ||||
966 | // in this case, r_symbolnum is actually a 1-based section number | ||||
967 | uint32_t nsects = O->section_end()->getRawDataRefImpl().d.a; | ||||
968 | if (r_symbolnum > 0 && r_symbolnum <= nsects) { | ||||
969 | object::DataRefImpl DRI; | ||||
970 | DRI.d.a = r_symbolnum-1; | ||||
971 | StringRef SegName = O->getSectionFinalSegmentName(DRI); | ||||
972 | if (Expected<StringRef> NameOrErr = O->getSectionName(DRI)) | ||||
973 | outs() << "(" << SegName << "," << *NameOrErr << ")\n"; | ||||
974 | else | ||||
975 | outs() << "(?,?)\n"; | ||||
976 | } | ||||
977 | else { | ||||
978 | outs() << "(?,?)\n"; | ||||
979 | } | ||||
980 | } | ||||
981 | } | ||||
982 | } | ||||
983 | if (cputype == MachO::CPU_TYPE_ARM && | ||||
984 | (r_type == MachO::ARM_RELOC_HALF || | ||||
985 | r_type == MachO::ARM_RELOC_HALF_SECTDIFF)) | ||||
986 | previous_arm_half = true; | ||||
987 | else | ||||
988 | previous_arm_half = false; | ||||
989 | } | ||||
990 | else { | ||||
991 | // plain: address pcrel length extern type scattered symbolnum/section | ||||
992 | outs() << format("%08x %1d %-2d %1d %-7d 0 %d\n", | ||||
993 | (unsigned int)r_address, r_pcrel, r_length, r_extern, | ||||
994 | r_type, r_symbolnum); | ||||
995 | } | ||||
996 | } | ||||
997 | } | ||||
998 | } | ||||
999 | |||||
1000 | static void PrintRelocations(const MachOObjectFile *O, const bool verbose) { | ||||
1001 | const uint64_t cputype = O->getHeader().cputype; | ||||
1002 | const MachO::dysymtab_command Dysymtab = O->getDysymtabLoadCommand(); | ||||
1003 | if (Dysymtab.nextrel != 0) { | ||||
1004 | outs() << "External relocation information " << Dysymtab.nextrel | ||||
1005 | << " entries"; | ||||
1006 | outs() << "\naddress pcrel length extern type scattered " | ||||
1007 | "symbolnum/value\n"; | ||||
1008 | PrintRelocationEntries(O, O->extrel_begin(), O->extrel_end(), cputype, | ||||
1009 | verbose); | ||||
1010 | } | ||||
1011 | if (Dysymtab.nlocrel != 0) { | ||||
1012 | outs() << format("Local relocation information %u entries", | ||||
1013 | Dysymtab.nlocrel); | ||||
1014 | outs() << "\naddress pcrel length extern type scattered " | ||||
1015 | "symbolnum/value\n"; | ||||
1016 | PrintRelocationEntries(O, O->locrel_begin(), O->locrel_end(), cputype, | ||||
1017 | verbose); | ||||
1018 | } | ||||
1019 | for (const auto &Load : O->load_commands()) { | ||||
1020 | if (Load.C.cmd == MachO::LC_SEGMENT_64) { | ||||
1021 | const MachO::segment_command_64 Seg = O->getSegment64LoadCommand(Load); | ||||
1022 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
1023 | const MachO::section_64 Sec = O->getSection64(Load, J); | ||||
1024 | if (Sec.nreloc != 0) { | ||||
1025 | DataRefImpl DRI; | ||||
1026 | DRI.d.a = J; | ||||
1027 | const StringRef SegName = O->getSectionFinalSegmentName(DRI); | ||||
1028 | if (Expected<StringRef> NameOrErr = O->getSectionName(DRI)) | ||||
1029 | outs() << "Relocation information (" << SegName << "," << *NameOrErr | ||||
1030 | << format(") %u entries", Sec.nreloc); | ||||
1031 | else | ||||
1032 | outs() << "Relocation information (" << SegName << ",?) " | ||||
1033 | << format("%u entries", Sec.nreloc); | ||||
1034 | outs() << "\naddress pcrel length extern type scattered " | ||||
1035 | "symbolnum/value\n"; | ||||
1036 | PrintRelocationEntries(O, O->section_rel_begin(DRI), | ||||
1037 | O->section_rel_end(DRI), cputype, verbose); | ||||
1038 | } | ||||
1039 | } | ||||
1040 | } else if (Load.C.cmd == MachO::LC_SEGMENT) { | ||||
1041 | const MachO::segment_command Seg = O->getSegmentLoadCommand(Load); | ||||
1042 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
1043 | const MachO::section Sec = O->getSection(Load, J); | ||||
1044 | if (Sec.nreloc != 0) { | ||||
1045 | DataRefImpl DRI; | ||||
1046 | DRI.d.a = J; | ||||
1047 | const StringRef SegName = O->getSectionFinalSegmentName(DRI); | ||||
1048 | if (Expected<StringRef> NameOrErr = O->getSectionName(DRI)) | ||||
1049 | outs() << "Relocation information (" << SegName << "," << *NameOrErr | ||||
1050 | << format(") %u entries", Sec.nreloc); | ||||
1051 | else | ||||
1052 | outs() << "Relocation information (" << SegName << ",?) " | ||||
1053 | << format("%u entries", Sec.nreloc); | ||||
1054 | outs() << "\naddress pcrel length extern type scattered " | ||||
1055 | "symbolnum/value\n"; | ||||
1056 | PrintRelocationEntries(O, O->section_rel_begin(DRI), | ||||
1057 | O->section_rel_end(DRI), cputype, verbose); | ||||
1058 | } | ||||
1059 | } | ||||
1060 | } | ||||
1061 | } | ||||
1062 | } | ||||
1063 | |||||
1064 | static void PrintFunctionStarts(MachOObjectFile *O) { | ||||
1065 | uint64_t BaseSegmentAddress = 0; | ||||
1066 | for (const MachOObjectFile::LoadCommandInfo &Command : O->load_commands()) { | ||||
1067 | if (Command.C.cmd == MachO::LC_SEGMENT) { | ||||
1068 | MachO::segment_command SLC = O->getSegmentLoadCommand(Command); | ||||
1069 | if (StringRef(SLC.segname) == "__TEXT") { | ||||
1070 | BaseSegmentAddress = SLC.vmaddr; | ||||
1071 | break; | ||||
1072 | } | ||||
1073 | } else if (Command.C.cmd == MachO::LC_SEGMENT_64) { | ||||
1074 | MachO::segment_command_64 SLC = O->getSegment64LoadCommand(Command); | ||||
1075 | if (StringRef(SLC.segname) == "__TEXT") { | ||||
1076 | BaseSegmentAddress = SLC.vmaddr; | ||||
1077 | break; | ||||
1078 | } | ||||
1079 | } | ||||
1080 | } | ||||
1081 | |||||
1082 | SmallVector<uint64_t, 8> FunctionStarts; | ||||
1083 | for (const MachOObjectFile::LoadCommandInfo &LC : O->load_commands()) { | ||||
1084 | if (LC.C.cmd == MachO::LC_FUNCTION_STARTS) { | ||||
1085 | MachO::linkedit_data_command FunctionStartsLC = | ||||
1086 | O->getLinkeditDataLoadCommand(LC); | ||||
1087 | O->ReadULEB128s(FunctionStartsLC.dataoff, FunctionStarts); | ||||
1088 | break; | ||||
1089 | } | ||||
1090 | } | ||||
1091 | |||||
1092 | DenseMap<uint64_t, StringRef> SymbolNames; | ||||
1093 | if (FunctionStartsType == FunctionStartsMode::Names || | ||||
1094 | FunctionStartsType == FunctionStartsMode::Both) { | ||||
1095 | for (SymbolRef Sym : O->symbols()) { | ||||
1096 | if (Expected<uint64_t> Addr = Sym.getAddress()) { | ||||
1097 | if (Expected<StringRef> Name = Sym.getName()) { | ||||
1098 | SymbolNames[*Addr] = *Name; | ||||
1099 | } | ||||
1100 | } | ||||
1101 | } | ||||
1102 | } | ||||
1103 | |||||
1104 | for (uint64_t S : FunctionStarts) { | ||||
1105 | uint64_t Addr = BaseSegmentAddress + S; | ||||
1106 | if (FunctionStartsType == FunctionStartsMode::Names) { | ||||
1107 | auto It = SymbolNames.find(Addr); | ||||
1108 | if (It != SymbolNames.end()) | ||||
1109 | outs() << It->second << "\n"; | ||||
1110 | } else { | ||||
1111 | if (O->is64Bit()) | ||||
1112 | outs() << format("%016" PRIx64"l" "x", Addr); | ||||
1113 | else | ||||
1114 | outs() << format("%08" PRIx32"x", static_cast<uint32_t>(Addr)); | ||||
1115 | |||||
1116 | if (FunctionStartsType == FunctionStartsMode::Both) { | ||||
1117 | auto It = SymbolNames.find(Addr); | ||||
1118 | if (It != SymbolNames.end()) | ||||
1119 | outs() << " " << It->second; | ||||
1120 | else | ||||
1121 | outs() << " ?"; | ||||
1122 | } | ||||
1123 | outs() << "\n"; | ||||
1124 | } | ||||
1125 | } | ||||
1126 | } | ||||
1127 | |||||
1128 | static void PrintDataInCodeTable(MachOObjectFile *O, bool verbose) { | ||||
1129 | MachO::linkedit_data_command DIC = O->getDataInCodeLoadCommand(); | ||||
1130 | uint32_t nentries = DIC.datasize / sizeof(struct MachO::data_in_code_entry); | ||||
1131 | outs() << "Data in code table (" << nentries << " entries)\n"; | ||||
1132 | outs() << "offset length kind\n"; | ||||
1133 | for (dice_iterator DI = O->begin_dices(), DE = O->end_dices(); DI != DE; | ||||
1134 | ++DI) { | ||||
1135 | uint32_t Offset; | ||||
1136 | DI->getOffset(Offset); | ||||
1137 | outs() << format("0x%08" PRIx32"x", Offset) << " "; | ||||
1138 | uint16_t Length; | ||||
1139 | DI->getLength(Length); | ||||
1140 | outs() << format("%6u", Length) << " "; | ||||
1141 | uint16_t Kind; | ||||
1142 | DI->getKind(Kind); | ||||
1143 | if (verbose) { | ||||
1144 | switch (Kind) { | ||||
1145 | case MachO::DICE_KIND_DATA: | ||||
1146 | outs() << "DATA"; | ||||
1147 | break; | ||||
1148 | case MachO::DICE_KIND_JUMP_TABLE8: | ||||
1149 | outs() << "JUMP_TABLE8"; | ||||
1150 | break; | ||||
1151 | case MachO::DICE_KIND_JUMP_TABLE16: | ||||
1152 | outs() << "JUMP_TABLE16"; | ||||
1153 | break; | ||||
1154 | case MachO::DICE_KIND_JUMP_TABLE32: | ||||
1155 | outs() << "JUMP_TABLE32"; | ||||
1156 | break; | ||||
1157 | case MachO::DICE_KIND_ABS_JUMP_TABLE32: | ||||
1158 | outs() << "ABS_JUMP_TABLE32"; | ||||
1159 | break; | ||||
1160 | default: | ||||
1161 | outs() << format("0x%04" PRIx32"x", Kind); | ||||
1162 | break; | ||||
1163 | } | ||||
1164 | } else | ||||
1165 | outs() << format("0x%04" PRIx32"x", Kind); | ||||
1166 | outs() << "\n"; | ||||
1167 | } | ||||
1168 | } | ||||
1169 | |||||
1170 | static void PrintLinkOptHints(MachOObjectFile *O) { | ||||
1171 | MachO::linkedit_data_command LohLC = O->getLinkOptHintsLoadCommand(); | ||||
1172 | const char *loh = O->getData().substr(LohLC.dataoff, 1).data(); | ||||
1173 | uint32_t nloh = LohLC.datasize; | ||||
1174 | outs() << "Linker optimiztion hints (" << nloh << " total bytes)\n"; | ||||
1175 | for (uint32_t i = 0; i < nloh;) { | ||||
1176 | unsigned n; | ||||
1177 | uint64_t identifier = decodeULEB128((const uint8_t *)(loh + i), &n); | ||||
1178 | i += n; | ||||
1179 | outs() << " identifier " << identifier << " "; | ||||
1180 | if (i >= nloh) | ||||
1181 | return; | ||||
1182 | switch (identifier) { | ||||
1183 | case 1: | ||||
1184 | outs() << "AdrpAdrp\n"; | ||||
1185 | break; | ||||
1186 | case 2: | ||||
1187 | outs() << "AdrpLdr\n"; | ||||
1188 | break; | ||||
1189 | case 3: | ||||
1190 | outs() << "AdrpAddLdr\n"; | ||||
1191 | break; | ||||
1192 | case 4: | ||||
1193 | outs() << "AdrpLdrGotLdr\n"; | ||||
1194 | break; | ||||
1195 | case 5: | ||||
1196 | outs() << "AdrpAddStr\n"; | ||||
1197 | break; | ||||
1198 | case 6: | ||||
1199 | outs() << "AdrpLdrGotStr\n"; | ||||
1200 | break; | ||||
1201 | case 7: | ||||
1202 | outs() << "AdrpAdd\n"; | ||||
1203 | break; | ||||
1204 | case 8: | ||||
1205 | outs() << "AdrpLdrGot\n"; | ||||
1206 | break; | ||||
1207 | default: | ||||
1208 | outs() << "Unknown identifier value\n"; | ||||
1209 | break; | ||||
1210 | } | ||||
1211 | uint64_t narguments = decodeULEB128((const uint8_t *)(loh + i), &n); | ||||
1212 | i += n; | ||||
1213 | outs() << " narguments " << narguments << "\n"; | ||||
1214 | if (i >= nloh) | ||||
1215 | return; | ||||
1216 | |||||
1217 | for (uint32_t j = 0; j < narguments; j++) { | ||||
1218 | uint64_t value = decodeULEB128((const uint8_t *)(loh + i), &n); | ||||
1219 | i += n; | ||||
1220 | outs() << "\tvalue " << format("0x%" PRIx64"l" "x", value) << "\n"; | ||||
1221 | if (i >= nloh) | ||||
1222 | return; | ||||
1223 | } | ||||
1224 | } | ||||
1225 | } | ||||
1226 | |||||
1227 | static SmallVector<std::string> GetSegmentNames(object::MachOObjectFile *O) { | ||||
1228 | SmallVector<std::string> Ret; | ||||
1229 | for (const MachOObjectFile::LoadCommandInfo &Command : O->load_commands()) { | ||||
1230 | if (Command.C.cmd == MachO::LC_SEGMENT) { | ||||
1231 | MachO::segment_command SLC = O->getSegmentLoadCommand(Command); | ||||
1232 | Ret.push_back(SLC.segname); | ||||
1233 | } else if (Command.C.cmd == MachO::LC_SEGMENT_64) { | ||||
1234 | MachO::segment_command_64 SLC = O->getSegment64LoadCommand(Command); | ||||
1235 | Ret.push_back(SLC.segname); | ||||
1236 | } | ||||
1237 | } | ||||
1238 | return Ret; | ||||
1239 | } | ||||
1240 | |||||
1241 | static void | ||||
1242 | PrintChainedFixupsHeader(const MachO::dyld_chained_fixups_header &H) { | ||||
1243 | outs() << "chained fixups header (LC_DYLD_CHAINED_FIXUPS)\n"; | ||||
1244 | outs() << " fixups_version = " << H.fixups_version << '\n'; | ||||
1245 | outs() << " starts_offset = " << H.starts_offset << '\n'; | ||||
1246 | outs() << " imports_offset = " << H.imports_offset << '\n'; | ||||
1247 | outs() << " symbols_offset = " << H.symbols_offset << '\n'; | ||||
1248 | outs() << " imports_count = " << H.imports_count << '\n'; | ||||
1249 | |||||
1250 | outs() << " imports_format = " << H.imports_format; | ||||
1251 | switch (H.imports_format) { | ||||
1252 | case llvm::MachO::DYLD_CHAINED_IMPORT: | ||||
1253 | outs() << " (DYLD_CHAINED_IMPORT)"; | ||||
1254 | break; | ||||
1255 | case llvm::MachO::DYLD_CHAINED_IMPORT_ADDEND: | ||||
1256 | outs() << " (DYLD_CHAINED_IMPORT_ADDEND)"; | ||||
1257 | break; | ||||
1258 | case llvm::MachO::DYLD_CHAINED_IMPORT_ADDEND64: | ||||
1259 | outs() << " (DYLD_CHAINED_IMPORT_ADDEND64)"; | ||||
1260 | break; | ||||
1261 | } | ||||
1262 | outs() << '\n'; | ||||
1263 | |||||
1264 | outs() << " symbols_format = " << H.symbols_format; | ||||
1265 | if (H.symbols_format == llvm::MachO::DYLD_CHAINED_SYMBOL_ZLIB) | ||||
1266 | outs() << " (zlib compressed)"; | ||||
1267 | outs() << '\n'; | ||||
1268 | } | ||||
1269 | |||||
1270 | static constexpr std::array<StringRef, 13> PointerFormats{ | ||||
1271 | "DYLD_CHAINED_PTR_ARM64E", | ||||
1272 | "DYLD_CHAINED_PTR_64", | ||||
1273 | "DYLD_CHAINED_PTR_32", | ||||
1274 | "DYLD_CHAINED_PTR_32_CACHE", | ||||
1275 | "DYLD_CHAINED_PTR_32_FIRMWARE", | ||||
1276 | "DYLD_CHAINED_PTR_64_OFFSET", | ||||
1277 | "DYLD_CHAINED_PTR_ARM64E_KERNEL", | ||||
1278 | "DYLD_CHAINED_PTR_64_KERNEL_CACHE", | ||||
1279 | "DYLD_CHAINED_PTR_ARM64E_USERLAND", | ||||
1280 | "DYLD_CHAINED_PTR_ARM64E_FIRMWARE", | ||||
1281 | "DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE", | ||||
1282 | "DYLD_CHAINED_PTR_ARM64E_USERLAND24", | ||||
1283 | }; | ||||
1284 | |||||
1285 | static void PrintChainedFixupsSegment(const ChainedFixupsSegment &Segment, | ||||
1286 | StringRef SegName) { | ||||
1287 | outs() << "chained starts in segment " << Segment.SegIdx << " (" << SegName | ||||
1288 | << ")\n"; | ||||
1289 | outs() << " size = " << Segment.Header.size << '\n'; | ||||
1290 | outs() << " page_size = " << format("0x%0" PRIx16"x", Segment.Header.page_size) | ||||
1291 | << '\n'; | ||||
1292 | |||||
1293 | outs() << " pointer_format = " << Segment.Header.pointer_format; | ||||
1294 | if ((Segment.Header.pointer_format - 1) < | ||||
1295 | MachO::DYLD_CHAINED_PTR_ARM64E_USERLAND24) | ||||
1296 | outs() << " (" << PointerFormats[Segment.Header.pointer_format - 1] << ")"; | ||||
1297 | outs() << '\n'; | ||||
1298 | |||||
1299 | outs() << " segment_offset = " | ||||
1300 | << format("0x%0" PRIx64"l" "x", Segment.Header.segment_offset) << '\n'; | ||||
1301 | outs() << " max_valid_pointer = " << Segment.Header.max_valid_pointer | ||||
1302 | << '\n'; | ||||
1303 | outs() << " page_count = " << Segment.Header.page_count << '\n'; | ||||
1304 | for (auto [Index, PageStart] : enumerate(Segment.PageStarts)) { | ||||
1305 | outs() << " page_start[" << Index << "] = " << PageStart; | ||||
1306 | // FIXME: Support DYLD_CHAINED_PTR_START_MULTI (32-bit only) | ||||
1307 | if (PageStart == MachO::DYLD_CHAINED_PTR_START_NONE) | ||||
1308 | outs() << " (DYLD_CHAINED_PTR_START_NONE)"; | ||||
1309 | outs() << '\n'; | ||||
1310 | } | ||||
1311 | } | ||||
1312 | |||||
1313 | static void PrintChainedFixupTarget(ChainedFixupTarget &Target, size_t Idx, | ||||
1314 | int Format, MachOObjectFile *O) { | ||||
1315 | if (Format == MachO::DYLD_CHAINED_IMPORT) | ||||
1316 | outs() << "dyld chained import"; | ||||
1317 | else if (Format == MachO::DYLD_CHAINED_IMPORT_ADDEND) | ||||
1318 | outs() << "dyld chained import addend"; | ||||
1319 | else if (Format == MachO::DYLD_CHAINED_IMPORT_ADDEND64) | ||||
1320 | outs() << "dyld chained import addend64"; | ||||
1321 | // FIXME: otool prints the encoded value as well. | ||||
1322 | outs() << '[' << Idx << "]\n"; | ||||
1323 | |||||
1324 | outs() << " lib_ordinal = " << Target.libOrdinal() << " (" | ||||
1325 | << ordinalName(O, Target.libOrdinal()) << ")\n"; | ||||
1326 | outs() << " weak_import = " << Target.weakImport() << '\n'; | ||||
1327 | outs() << " name_offset = " << Target.nameOffset() << " (" | ||||
1328 | << Target.symbolName() << ")\n"; | ||||
1329 | if (Format != MachO::DYLD_CHAINED_IMPORT) | ||||
1330 | outs() << " addend = " << (int64_t)Target.addend() << '\n'; | ||||
1331 | } | ||||
1332 | |||||
1333 | static void PrintChainedFixups(MachOObjectFile *O) { | ||||
1334 | // MachOObjectFile::getChainedFixupsHeader() reads LC_DYLD_CHAINED_FIXUPS. | ||||
1335 | // FIXME: Support chained fixups in __TEXT,__chain_starts section too. | ||||
1336 | auto ChainedFixupHeader = | ||||
1337 | unwrapOrError(O->getChainedFixupsHeader(), O->getFileName()); | ||||
1338 | if (!ChainedFixupHeader) | ||||
1339 | return; | ||||
1340 | |||||
1341 | PrintChainedFixupsHeader(*ChainedFixupHeader); | ||||
1342 | |||||
1343 | auto [SegCount, Segments] = | ||||
1344 | unwrapOrError(O->getChainedFixupsSegments(), O->getFileName()); | ||||
1345 | |||||
1346 | auto SegNames = GetSegmentNames(O); | ||||
1347 | |||||
1348 | size_t StartsIdx = 0; | ||||
1349 | outs() << "chained starts in image\n"; | ||||
1350 | outs() << " seg_count = " << SegCount << '\n'; | ||||
1351 | for (size_t I = 0; I < SegCount; ++I) { | ||||
1352 | uint64_t SegOffset = 0; | ||||
1353 | if (StartsIdx < Segments.size() && I == Segments[StartsIdx].SegIdx) { | ||||
1354 | SegOffset = Segments[StartsIdx].Offset; | ||||
1355 | ++StartsIdx; | ||||
1356 | } | ||||
1357 | |||||
1358 | outs() << " seg_offset[" << I << "] = " << SegOffset << " (" | ||||
1359 | << SegNames[I] << ")\n"; | ||||
1360 | } | ||||
1361 | |||||
1362 | for (const ChainedFixupsSegment &S : Segments) | ||||
1363 | PrintChainedFixupsSegment(S, SegNames[S.SegIdx]); | ||||
1364 | |||||
1365 | auto FixupTargets = | ||||
1366 | unwrapOrError(O->getDyldChainedFixupTargets(), O->getFileName()); | ||||
1367 | |||||
1368 | uint32_t ImportsFormat = ChainedFixupHeader->imports_format; | ||||
1369 | for (auto [Idx, Target] : enumerate(FixupTargets)) | ||||
1370 | PrintChainedFixupTarget(Target, Idx, ImportsFormat, O); | ||||
1371 | } | ||||
1372 | |||||
1373 | static void PrintDyldInfo(MachOObjectFile *O) { | ||||
1374 | Error Err = Error::success(); | ||||
1375 | |||||
1376 | size_t SegmentWidth = strlen("segment"); | ||||
1377 | size_t SectionWidth = strlen("section"); | ||||
1378 | size_t AddressWidth = strlen("address"); | ||||
1379 | size_t AddendWidth = strlen("addend"); | ||||
1380 | size_t DylibWidth = strlen("dylib"); | ||||
1381 | const size_t PointerWidth = 2 + O->getBytesInAddress() * 2; | ||||
1382 | |||||
1383 | auto HexLength = [](uint64_t Num) { | ||||
1384 | return Num ? (size_t)divideCeil(Log2_64(Num), 4) : 1; | ||||
1385 | }; | ||||
1386 | for (const object::MachOChainedFixupEntry &Entry : O->fixupTable(Err)) { | ||||
1387 | SegmentWidth = std::max(SegmentWidth, Entry.segmentName().size()); | ||||
1388 | SectionWidth = std::max(SectionWidth, Entry.sectionName().size()); | ||||
1389 | AddressWidth = std::max(AddressWidth, HexLength(Entry.address()) + 2); | ||||
1390 | if (Entry.isBind()) { | ||||
1391 | AddendWidth = std::max(AddendWidth, HexLength(Entry.addend()) + 2); | ||||
1392 | DylibWidth = std::max(DylibWidth, Entry.symbolName().size()); | ||||
1393 | } | ||||
1394 | } | ||||
1395 | // Errors will be handled when printing the table. | ||||
1396 | if (Err) | ||||
1397 | consumeError(std::move(Err)); | ||||
1398 | |||||
1399 | outs() << "dyld information:\n"; | ||||
1400 | outs() << left_justify("segment", SegmentWidth) << ' ' | ||||
1401 | << left_justify("section", SectionWidth) << ' ' | ||||
1402 | << left_justify("address", AddressWidth) << ' ' | ||||
1403 | << left_justify("pointer", PointerWidth) << " type " | ||||
1404 | << left_justify("addend", AddendWidth) << ' ' | ||||
1405 | << left_justify("dylib", DylibWidth) << " symbol/vm address\n"; | ||||
1406 | for (const object::MachOChainedFixupEntry &Entry : O->fixupTable(Err)) { | ||||
1407 | outs() << left_justify(Entry.segmentName(), SegmentWidth) << ' ' | ||||
1408 | << left_justify(Entry.sectionName(), SectionWidth) << ' ' << "0x" | ||||
1409 | << left_justify(utohexstr(Entry.address()), AddressWidth - 2) << ' ' | ||||
1410 | << format_hex(Entry.rawValue(), PointerWidth, true) << ' '; | ||||
1411 | if (Entry.isBind()) { | ||||
1412 | outs() << "bind " | ||||
1413 | << "0x" << left_justify(utohexstr(Entry.addend()), AddendWidth - 2) | ||||
1414 | << ' ' << left_justify(ordinalName(O, Entry.ordinal()), DylibWidth) | ||||
1415 | << ' ' << Entry.symbolName(); | ||||
1416 | if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT) | ||||
1417 | outs() << " (weak import)"; | ||||
1418 | outs() << '\n'; | ||||
1419 | } else { | ||||
1420 | assert(Entry.isRebase())(static_cast <bool> (Entry.isRebase()) ? void (0) : __assert_fail ("Entry.isRebase()", "llvm/tools/llvm-objdump/MachODump.cpp" , 1420, __extension__ __PRETTY_FUNCTION__)); | ||||
1421 | outs() << "rebase"; | ||||
1422 | outs().indent(AddendWidth + DylibWidth + 2); | ||||
1423 | outs() << format("0x%" PRIX64"l" "X", Entry.pointerValue()) << '\n'; | ||||
1424 | } | ||||
1425 | } | ||||
1426 | if (Err) | ||||
1427 | reportError(std::move(Err), O->getFileName()); | ||||
1428 | |||||
1429 | // TODO: Print opcode-based fixups if the object uses those. | ||||
1430 | } | ||||
1431 | |||||
1432 | static void PrintDylibs(MachOObjectFile *O, bool JustId) { | ||||
1433 | unsigned Index = 0; | ||||
1434 | for (const auto &Load : O->load_commands()) { | ||||
1435 | if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) || | ||||
1436 | (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB || | ||||
1437 | Load.C.cmd == MachO::LC_LOAD_DYLIB || | ||||
1438 | Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB || | ||||
1439 | Load.C.cmd == MachO::LC_REEXPORT_DYLIB || | ||||
1440 | Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB || | ||||
1441 | Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB))) { | ||||
1442 | MachO::dylib_command dl = O->getDylibIDLoadCommand(Load); | ||||
1443 | if (dl.dylib.name < dl.cmdsize) { | ||||
1444 | const char *p = (const char *)(Load.Ptr) + dl.dylib.name; | ||||
1445 | if (JustId) | ||||
1446 | outs() << p << "\n"; | ||||
1447 | else { | ||||
1448 | outs() << "\t" << p; | ||||
1449 | outs() << " (compatibility version " | ||||
1450 | << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "." | ||||
1451 | << ((dl.dylib.compatibility_version >> 8) & 0xff) << "." | ||||
1452 | << (dl.dylib.compatibility_version & 0xff) << ","; | ||||
1453 | outs() << " current version " | ||||
1454 | << ((dl.dylib.current_version >> 16) & 0xffff) << "." | ||||
1455 | << ((dl.dylib.current_version >> 8) & 0xff) << "." | ||||
1456 | << (dl.dylib.current_version & 0xff); | ||||
1457 | if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) | ||||
1458 | outs() << ", weak"; | ||||
1459 | if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) | ||||
1460 | outs() << ", reexport"; | ||||
1461 | if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) | ||||
1462 | outs() << ", upward"; | ||||
1463 | if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) | ||||
1464 | outs() << ", lazy"; | ||||
1465 | outs() << ")\n"; | ||||
1466 | } | ||||
1467 | } else { | ||||
1468 | outs() << "\tBad offset (" << dl.dylib.name << ") for name of "; | ||||
1469 | if (Load.C.cmd == MachO::LC_ID_DYLIB) | ||||
1470 | outs() << "LC_ID_DYLIB "; | ||||
1471 | else if (Load.C.cmd == MachO::LC_LOAD_DYLIB) | ||||
1472 | outs() << "LC_LOAD_DYLIB "; | ||||
1473 | else if (Load.C.cmd == MachO::LC_LOAD_WEAK_DYLIB) | ||||
1474 | outs() << "LC_LOAD_WEAK_DYLIB "; | ||||
1475 | else if (Load.C.cmd == MachO::LC_LAZY_LOAD_DYLIB) | ||||
1476 | outs() << "LC_LAZY_LOAD_DYLIB "; | ||||
1477 | else if (Load.C.cmd == MachO::LC_REEXPORT_DYLIB) | ||||
1478 | outs() << "LC_REEXPORT_DYLIB "; | ||||
1479 | else if (Load.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) | ||||
1480 | outs() << "LC_LOAD_UPWARD_DYLIB "; | ||||
1481 | else | ||||
1482 | outs() << "LC_??? "; | ||||
1483 | outs() << "command " << Index++ << "\n"; | ||||
1484 | } | ||||
1485 | } | ||||
1486 | } | ||||
1487 | } | ||||
1488 | |||||
1489 | static void printRpaths(MachOObjectFile *O) { | ||||
1490 | for (const auto &Command : O->load_commands()) { | ||||
1491 | if (Command.C.cmd == MachO::LC_RPATH) { | ||||
1492 | auto Rpath = O->getRpathCommand(Command); | ||||
1493 | const char *P = (const char *)(Command.Ptr) + Rpath.path; | ||||
1494 | outs() << P << "\n"; | ||||
1495 | } | ||||
1496 | } | ||||
1497 | } | ||||
1498 | |||||
1499 | typedef DenseMap<uint64_t, StringRef> SymbolAddressMap; | ||||
1500 | |||||
1501 | static void CreateSymbolAddressMap(MachOObjectFile *O, | ||||
1502 | SymbolAddressMap *AddrMap) { | ||||
1503 | // Create a map of symbol addresses to symbol names. | ||||
1504 | const StringRef FileName = O->getFileName(); | ||||
1505 | for (const SymbolRef &Symbol : O->symbols()) { | ||||
1506 | SymbolRef::Type ST = unwrapOrError(Symbol.getType(), FileName); | ||||
1507 | if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data || | ||||
1508 | ST == SymbolRef::ST_Other) { | ||||
1509 | uint64_t Address = cantFail(Symbol.getValue()); | ||||
1510 | StringRef SymName = unwrapOrError(Symbol.getName(), FileName); | ||||
1511 | if (!SymName.startswith(".objc")) | ||||
1512 | (*AddrMap)[Address] = SymName; | ||||
1513 | } | ||||
1514 | } | ||||
1515 | } | ||||
1516 | |||||
1517 | // GuessSymbolName is passed the address of what might be a symbol and a | ||||
1518 | // pointer to the SymbolAddressMap. It returns the name of a symbol | ||||
1519 | // with that address or nullptr if no symbol is found with that address. | ||||
1520 | static const char *GuessSymbolName(uint64_t value, SymbolAddressMap *AddrMap) { | ||||
1521 | const char *SymbolName = nullptr; | ||||
1522 | // A DenseMap can't lookup up some values. | ||||
1523 | if (value != 0xffffffffffffffffULL && value != 0xfffffffffffffffeULL) { | ||||
1524 | StringRef name = AddrMap->lookup(value); | ||||
1525 | if (!name.empty()) | ||||
1526 | SymbolName = name.data(); | ||||
1527 | } | ||||
1528 | return SymbolName; | ||||
1529 | } | ||||
1530 | |||||
1531 | static void DumpCstringChar(const char c) { | ||||
1532 | char p[2]; | ||||
1533 | p[0] = c; | ||||
1534 | p[1] = '\0'; | ||||
1535 | outs().write_escaped(p); | ||||
1536 | } | ||||
1537 | |||||
1538 | static void DumpCstringSection(MachOObjectFile *O, const char *sect, | ||||
1539 | uint32_t sect_size, uint64_t sect_addr, | ||||
1540 | bool print_addresses) { | ||||
1541 | for (uint32_t i = 0; i < sect_size; i++) { | ||||
1542 | if (print_addresses) { | ||||
1543 | if (O->is64Bit()) | ||||
1544 | outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1545 | else | ||||
1546 | outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1547 | } | ||||
1548 | for (; i < sect_size && sect[i] != '\0'; i++) | ||||
1549 | DumpCstringChar(sect[i]); | ||||
1550 | if (i < sect_size && sect[i] == '\0') | ||||
1551 | outs() << "\n"; | ||||
1552 | } | ||||
1553 | } | ||||
1554 | |||||
1555 | static void DumpLiteral4(uint32_t l, float f) { | ||||
1556 | outs() << format("0x%08" PRIx32"x", l); | ||||
1557 | if ((l & 0x7f800000) != 0x7f800000) | ||||
1558 | outs() << format(" (%.16e)\n", f); | ||||
1559 | else { | ||||
1560 | if (l == 0x7f800000) | ||||
1561 | outs() << " (+Infinity)\n"; | ||||
1562 | else if (l == 0xff800000) | ||||
1563 | outs() << " (-Infinity)\n"; | ||||
1564 | else if ((l & 0x00400000) == 0x00400000) | ||||
1565 | outs() << " (non-signaling Not-a-Number)\n"; | ||||
1566 | else | ||||
1567 | outs() << " (signaling Not-a-Number)\n"; | ||||
1568 | } | ||||
1569 | } | ||||
1570 | |||||
1571 | static void DumpLiteral4Section(MachOObjectFile *O, const char *sect, | ||||
1572 | uint32_t sect_size, uint64_t sect_addr, | ||||
1573 | bool print_addresses) { | ||||
1574 | for (uint32_t i = 0; i < sect_size; i += sizeof(float)) { | ||||
1575 | if (print_addresses) { | ||||
1576 | if (O->is64Bit()) | ||||
1577 | outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1578 | else | ||||
1579 | outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1580 | } | ||||
1581 | float f; | ||||
1582 | memcpy(&f, sect + i, sizeof(float)); | ||||
1583 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1584 | sys::swapByteOrder(f); | ||||
1585 | uint32_t l; | ||||
1586 | memcpy(&l, sect + i, sizeof(uint32_t)); | ||||
1587 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1588 | sys::swapByteOrder(l); | ||||
1589 | DumpLiteral4(l, f); | ||||
1590 | } | ||||
1591 | } | ||||
1592 | |||||
1593 | static void DumpLiteral8(MachOObjectFile *O, uint32_t l0, uint32_t l1, | ||||
1594 | double d) { | ||||
1595 | outs() << format("0x%08" PRIx32"x", l0) << " " << format("0x%08" PRIx32"x", l1); | ||||
1596 | uint32_t Hi, Lo; | ||||
1597 | Hi = (O->isLittleEndian()) ? l1 : l0; | ||||
1598 | Lo = (O->isLittleEndian()) ? l0 : l1; | ||||
1599 | |||||
1600 | // Hi is the high word, so this is equivalent to if(isfinite(d)) | ||||
1601 | if ((Hi & 0x7ff00000) != 0x7ff00000) | ||||
1602 | outs() << format(" (%.16e)\n", d); | ||||
1603 | else { | ||||
1604 | if (Hi == 0x7ff00000 && Lo == 0) | ||||
1605 | outs() << " (+Infinity)\n"; | ||||
1606 | else if (Hi == 0xfff00000 && Lo == 0) | ||||
1607 | outs() << " (-Infinity)\n"; | ||||
1608 | else if ((Hi & 0x00080000) == 0x00080000) | ||||
1609 | outs() << " (non-signaling Not-a-Number)\n"; | ||||
1610 | else | ||||
1611 | outs() << " (signaling Not-a-Number)\n"; | ||||
1612 | } | ||||
1613 | } | ||||
1614 | |||||
1615 | static void DumpLiteral8Section(MachOObjectFile *O, const char *sect, | ||||
1616 | uint32_t sect_size, uint64_t sect_addr, | ||||
1617 | bool print_addresses) { | ||||
1618 | for (uint32_t i = 0; i < sect_size; i += sizeof(double)) { | ||||
1619 | if (print_addresses) { | ||||
1620 | if (O->is64Bit()) | ||||
1621 | outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1622 | else | ||||
1623 | outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1624 | } | ||||
1625 | double d; | ||||
1626 | memcpy(&d, sect + i, sizeof(double)); | ||||
1627 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1628 | sys::swapByteOrder(d); | ||||
1629 | uint32_t l0, l1; | ||||
1630 | memcpy(&l0, sect + i, sizeof(uint32_t)); | ||||
1631 | memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t)); | ||||
1632 | if (O->isLittleEndian() != sys::IsLittleEndianHost) { | ||||
1633 | sys::swapByteOrder(l0); | ||||
1634 | sys::swapByteOrder(l1); | ||||
1635 | } | ||||
1636 | DumpLiteral8(O, l0, l1, d); | ||||
1637 | } | ||||
1638 | } | ||||
1639 | |||||
1640 | static void DumpLiteral16(uint32_t l0, uint32_t l1, uint32_t l2, uint32_t l3) { | ||||
1641 | outs() << format("0x%08" PRIx32"x", l0) << " "; | ||||
1642 | outs() << format("0x%08" PRIx32"x", l1) << " "; | ||||
1643 | outs() << format("0x%08" PRIx32"x", l2) << " "; | ||||
1644 | outs() << format("0x%08" PRIx32"x", l3) << "\n"; | ||||
1645 | } | ||||
1646 | |||||
1647 | static void DumpLiteral16Section(MachOObjectFile *O, const char *sect, | ||||
1648 | uint32_t sect_size, uint64_t sect_addr, | ||||
1649 | bool print_addresses) { | ||||
1650 | for (uint32_t i = 0; i < sect_size; i += 16) { | ||||
1651 | if (print_addresses) { | ||||
1652 | if (O->is64Bit()) | ||||
1653 | outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1654 | else | ||||
1655 | outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1656 | } | ||||
1657 | uint32_t l0, l1, l2, l3; | ||||
1658 | memcpy(&l0, sect + i, sizeof(uint32_t)); | ||||
1659 | memcpy(&l1, sect + i + sizeof(uint32_t), sizeof(uint32_t)); | ||||
1660 | memcpy(&l2, sect + i + 2 * sizeof(uint32_t), sizeof(uint32_t)); | ||||
1661 | memcpy(&l3, sect + i + 3 * sizeof(uint32_t), sizeof(uint32_t)); | ||||
1662 | if (O->isLittleEndian() != sys::IsLittleEndianHost) { | ||||
1663 | sys::swapByteOrder(l0); | ||||
1664 | sys::swapByteOrder(l1); | ||||
1665 | sys::swapByteOrder(l2); | ||||
1666 | sys::swapByteOrder(l3); | ||||
1667 | } | ||||
1668 | DumpLiteral16(l0, l1, l2, l3); | ||||
1669 | } | ||||
1670 | } | ||||
1671 | |||||
1672 | static void DumpLiteralPointerSection(MachOObjectFile *O, | ||||
1673 | const SectionRef &Section, | ||||
1674 | const char *sect, uint32_t sect_size, | ||||
1675 | uint64_t sect_addr, | ||||
1676 | bool print_addresses) { | ||||
1677 | // Collect the literal sections in this Mach-O file. | ||||
1678 | std::vector<SectionRef> LiteralSections; | ||||
1679 | for (const SectionRef &Section : O->sections()) { | ||||
1680 | DataRefImpl Ref = Section.getRawDataRefImpl(); | ||||
1681 | uint32_t section_type; | ||||
1682 | if (O->is64Bit()) { | ||||
1683 | const MachO::section_64 Sec = O->getSection64(Ref); | ||||
1684 | section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
1685 | } else { | ||||
1686 | const MachO::section Sec = O->getSection(Ref); | ||||
1687 | section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
1688 | } | ||||
1689 | if (section_type == MachO::S_CSTRING_LITERALS || | ||||
1690 | section_type == MachO::S_4BYTE_LITERALS || | ||||
1691 | section_type == MachO::S_8BYTE_LITERALS || | ||||
1692 | section_type == MachO::S_16BYTE_LITERALS) | ||||
1693 | LiteralSections.push_back(Section); | ||||
1694 | } | ||||
1695 | |||||
1696 | // Set the size of the literal pointer. | ||||
1697 | uint32_t lp_size = O->is64Bit() ? 8 : 4; | ||||
1698 | |||||
1699 | // Collect the external relocation symbols for the literal pointers. | ||||
1700 | std::vector<std::pair<uint64_t, SymbolRef>> Relocs; | ||||
1701 | for (const RelocationRef &Reloc : Section.relocations()) { | ||||
1702 | DataRefImpl Rel; | ||||
1703 | MachO::any_relocation_info RE; | ||||
1704 | bool isExtern = false; | ||||
1705 | Rel = Reloc.getRawDataRefImpl(); | ||||
1706 | RE = O->getRelocation(Rel); | ||||
1707 | isExtern = O->getPlainRelocationExternal(RE); | ||||
1708 | if (isExtern) { | ||||
1709 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
1710 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
1711 | Relocs.push_back(std::make_pair(RelocOffset, *RelocSym)); | ||||
1712 | } | ||||
1713 | } | ||||
1714 | array_pod_sort(Relocs.begin(), Relocs.end()); | ||||
1715 | |||||
1716 | // Dump each literal pointer. | ||||
1717 | for (uint32_t i = 0; i < sect_size; i += lp_size) { | ||||
1718 | if (print_addresses) { | ||||
1719 | if (O->is64Bit()) | ||||
1720 | outs() << format("%016" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1721 | else | ||||
1722 | outs() << format("%08" PRIx64"l" "x", sect_addr + i) << " "; | ||||
1723 | } | ||||
1724 | uint64_t lp; | ||||
1725 | if (O->is64Bit()) { | ||||
1726 | memcpy(&lp, sect + i, sizeof(uint64_t)); | ||||
1727 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1728 | sys::swapByteOrder(lp); | ||||
1729 | } else { | ||||
1730 | uint32_t li; | ||||
1731 | memcpy(&li, sect + i, sizeof(uint32_t)); | ||||
1732 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1733 | sys::swapByteOrder(li); | ||||
1734 | lp = li; | ||||
1735 | } | ||||
1736 | |||||
1737 | // First look for an external relocation entry for this literal pointer. | ||||
1738 | auto Reloc = find_if(Relocs, [&](const std::pair<uint64_t, SymbolRef> &P) { | ||||
1739 | return P.first == i; | ||||
1740 | }); | ||||
1741 | if (Reloc != Relocs.end()) { | ||||
1742 | symbol_iterator RelocSym = Reloc->second; | ||||
1743 | StringRef SymName = unwrapOrError(RelocSym->getName(), O->getFileName()); | ||||
1744 | outs() << "external relocation entry for symbol:" << SymName << "\n"; | ||||
1745 | continue; | ||||
1746 | } | ||||
1747 | |||||
1748 | // For local references see what the section the literal pointer points to. | ||||
1749 | auto Sect = find_if(LiteralSections, [&](const SectionRef &R) { | ||||
1750 | return lp >= R.getAddress() && lp < R.getAddress() + R.getSize(); | ||||
1751 | }); | ||||
1752 | if (Sect == LiteralSections.end()) { | ||||
1753 | outs() << format("0x%" PRIx64"l" "x", lp) << " (not in a literal section)\n"; | ||||
1754 | continue; | ||||
1755 | } | ||||
1756 | |||||
1757 | uint64_t SectAddress = Sect->getAddress(); | ||||
1758 | uint64_t SectSize = Sect->getSize(); | ||||
1759 | |||||
1760 | StringRef SectName; | ||||
1761 | Expected<StringRef> SectNameOrErr = Sect->getName(); | ||||
1762 | if (SectNameOrErr) | ||||
1763 | SectName = *SectNameOrErr; | ||||
1764 | else | ||||
1765 | consumeError(SectNameOrErr.takeError()); | ||||
1766 | |||||
1767 | DataRefImpl Ref = Sect->getRawDataRefImpl(); | ||||
1768 | StringRef SegmentName = O->getSectionFinalSegmentName(Ref); | ||||
1769 | outs() << SegmentName << ":" << SectName << ":"; | ||||
1770 | |||||
1771 | uint32_t section_type; | ||||
1772 | if (O->is64Bit()) { | ||||
1773 | const MachO::section_64 Sec = O->getSection64(Ref); | ||||
1774 | section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
1775 | } else { | ||||
1776 | const MachO::section Sec = O->getSection(Ref); | ||||
1777 | section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
1778 | } | ||||
1779 | |||||
1780 | StringRef BytesStr = unwrapOrError(Sect->getContents(), O->getFileName()); | ||||
1781 | |||||
1782 | const char *Contents = reinterpret_cast<const char *>(BytesStr.data()); | ||||
1783 | |||||
1784 | switch (section_type) { | ||||
1785 | case MachO::S_CSTRING_LITERALS: | ||||
1786 | for (uint64_t i = lp - SectAddress; i < SectSize && Contents[i] != '\0'; | ||||
1787 | i++) { | ||||
1788 | DumpCstringChar(Contents[i]); | ||||
1789 | } | ||||
1790 | outs() << "\n"; | ||||
1791 | break; | ||||
1792 | case MachO::S_4BYTE_LITERALS: | ||||
1793 | float f; | ||||
1794 | memcpy(&f, Contents + (lp - SectAddress), sizeof(float)); | ||||
1795 | uint32_t l; | ||||
1796 | memcpy(&l, Contents + (lp - SectAddress), sizeof(uint32_t)); | ||||
1797 | if (O->isLittleEndian() != sys::IsLittleEndianHost) { | ||||
1798 | sys::swapByteOrder(f); | ||||
1799 | sys::swapByteOrder(l); | ||||
1800 | } | ||||
1801 | DumpLiteral4(l, f); | ||||
1802 | break; | ||||
1803 | case MachO::S_8BYTE_LITERALS: { | ||||
1804 | double d; | ||||
1805 | memcpy(&d, Contents + (lp - SectAddress), sizeof(double)); | ||||
1806 | uint32_t l0, l1; | ||||
1807 | memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t)); | ||||
1808 | memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t), | ||||
1809 | sizeof(uint32_t)); | ||||
1810 | if (O->isLittleEndian() != sys::IsLittleEndianHost) { | ||||
1811 | sys::swapByteOrder(f); | ||||
1812 | sys::swapByteOrder(l0); | ||||
1813 | sys::swapByteOrder(l1); | ||||
1814 | } | ||||
1815 | DumpLiteral8(O, l0, l1, d); | ||||
1816 | break; | ||||
1817 | } | ||||
1818 | case MachO::S_16BYTE_LITERALS: { | ||||
1819 | uint32_t l0, l1, l2, l3; | ||||
1820 | memcpy(&l0, Contents + (lp - SectAddress), sizeof(uint32_t)); | ||||
1821 | memcpy(&l1, Contents + (lp - SectAddress) + sizeof(uint32_t), | ||||
1822 | sizeof(uint32_t)); | ||||
1823 | memcpy(&l2, Contents + (lp - SectAddress) + 2 * sizeof(uint32_t), | ||||
1824 | sizeof(uint32_t)); | ||||
1825 | memcpy(&l3, Contents + (lp - SectAddress) + 3 * sizeof(uint32_t), | ||||
1826 | sizeof(uint32_t)); | ||||
1827 | if (O->isLittleEndian() != sys::IsLittleEndianHost) { | ||||
1828 | sys::swapByteOrder(l0); | ||||
1829 | sys::swapByteOrder(l1); | ||||
1830 | sys::swapByteOrder(l2); | ||||
1831 | sys::swapByteOrder(l3); | ||||
1832 | } | ||||
1833 | DumpLiteral16(l0, l1, l2, l3); | ||||
1834 | break; | ||||
1835 | } | ||||
1836 | } | ||||
1837 | } | ||||
1838 | } | ||||
1839 | |||||
1840 | static void DumpInitTermPointerSection(MachOObjectFile *O, | ||||
1841 | const SectionRef &Section, | ||||
1842 | const char *sect, | ||||
1843 | uint32_t sect_size, uint64_t sect_addr, | ||||
1844 | SymbolAddressMap *AddrMap, | ||||
1845 | bool verbose) { | ||||
1846 | uint32_t stride; | ||||
1847 | stride = (O->is64Bit()) ? sizeof(uint64_t) : sizeof(uint32_t); | ||||
1848 | |||||
1849 | // Collect the external relocation symbols for the pointers. | ||||
1850 | std::vector<std::pair<uint64_t, SymbolRef>> Relocs; | ||||
1851 | for (const RelocationRef &Reloc : Section.relocations()) { | ||||
1852 | DataRefImpl Rel; | ||||
1853 | MachO::any_relocation_info RE; | ||||
1854 | bool isExtern = false; | ||||
1855 | Rel = Reloc.getRawDataRefImpl(); | ||||
1856 | RE = O->getRelocation(Rel); | ||||
1857 | isExtern = O->getPlainRelocationExternal(RE); | ||||
1858 | if (isExtern) { | ||||
1859 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
1860 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
1861 | Relocs.push_back(std::make_pair(RelocOffset, *RelocSym)); | ||||
1862 | } | ||||
1863 | } | ||||
1864 | array_pod_sort(Relocs.begin(), Relocs.end()); | ||||
1865 | |||||
1866 | for (uint32_t i = 0; i < sect_size; i += stride) { | ||||
1867 | const char *SymbolName = nullptr; | ||||
1868 | uint64_t p; | ||||
1869 | if (O->is64Bit()) { | ||||
1870 | outs() << format("0x%016" PRIx64"l" "x", sect_addr + i * stride) << " "; | ||||
1871 | uint64_t pointer_value; | ||||
1872 | memcpy(&pointer_value, sect + i, stride); | ||||
1873 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1874 | sys::swapByteOrder(pointer_value); | ||||
1875 | outs() << format("0x%016" PRIx64"l" "x", pointer_value); | ||||
1876 | p = pointer_value; | ||||
1877 | } else { | ||||
1878 | outs() << format("0x%08" PRIx64"l" "x", sect_addr + i * stride) << " "; | ||||
1879 | uint32_t pointer_value; | ||||
1880 | memcpy(&pointer_value, sect + i, stride); | ||||
1881 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1882 | sys::swapByteOrder(pointer_value); | ||||
1883 | outs() << format("0x%08" PRIx32"x", pointer_value); | ||||
1884 | p = pointer_value; | ||||
1885 | } | ||||
1886 | if (verbose) { | ||||
1887 | // First look for an external relocation entry for this pointer. | ||||
1888 | auto Reloc = find_if(Relocs, [&](const std::pair<uint64_t, SymbolRef> &P) { | ||||
1889 | return P.first == i; | ||||
1890 | }); | ||||
1891 | if (Reloc != Relocs.end()) { | ||||
1892 | symbol_iterator RelocSym = Reloc->second; | ||||
1893 | outs() << " " << unwrapOrError(RelocSym->getName(), O->getFileName()); | ||||
1894 | } else { | ||||
1895 | SymbolName = GuessSymbolName(p, AddrMap); | ||||
1896 | if (SymbolName) | ||||
1897 | outs() << " " << SymbolName; | ||||
1898 | } | ||||
1899 | } | ||||
1900 | outs() << "\n"; | ||||
1901 | } | ||||
1902 | } | ||||
1903 | |||||
1904 | static void DumpRawSectionContents(MachOObjectFile *O, const char *sect, | ||||
1905 | uint32_t size, uint64_t addr) { | ||||
1906 | uint32_t cputype = O->getHeader().cputype; | ||||
1907 | if (cputype == MachO::CPU_TYPE_I386 || cputype == MachO::CPU_TYPE_X86_64) { | ||||
1908 | uint32_t j; | ||||
1909 | for (uint32_t i = 0; i < size; i += j, addr += j) { | ||||
1910 | if (O->is64Bit()) | ||||
1911 | outs() << format("%016" PRIx64"l" "x", addr) << "\t"; | ||||
1912 | else | ||||
1913 | outs() << format("%08" PRIx64"l" "x", addr) << "\t"; | ||||
1914 | for (j = 0; j < 16 && i + j < size; j++) { | ||||
1915 | uint8_t byte_word = *(sect + i + j); | ||||
1916 | outs() << format("%02" PRIx32"x", (uint32_t)byte_word) << " "; | ||||
1917 | } | ||||
1918 | outs() << "\n"; | ||||
1919 | } | ||||
1920 | } else { | ||||
1921 | uint32_t j; | ||||
1922 | for (uint32_t i = 0; i < size; i += j, addr += j) { | ||||
1923 | if (O->is64Bit()) | ||||
1924 | outs() << format("%016" PRIx64"l" "x", addr) << "\t"; | ||||
1925 | else | ||||
1926 | outs() << format("%08" PRIx64"l" "x", addr) << "\t"; | ||||
1927 | for (j = 0; j < 4 * sizeof(int32_t) && i + j < size; | ||||
1928 | j += sizeof(int32_t)) { | ||||
1929 | if (i + j + sizeof(int32_t) <= size) { | ||||
1930 | uint32_t long_word; | ||||
1931 | memcpy(&long_word, sect + i + j, sizeof(int32_t)); | ||||
1932 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
1933 | sys::swapByteOrder(long_word); | ||||
1934 | outs() << format("%08" PRIx32"x", long_word) << " "; | ||||
1935 | } else { | ||||
1936 | for (uint32_t k = 0; i + j + k < size; k++) { | ||||
1937 | uint8_t byte_word = *(sect + i + j + k); | ||||
1938 | outs() << format("%02" PRIx32"x", (uint32_t)byte_word) << " "; | ||||
1939 | } | ||||
1940 | } | ||||
1941 | } | ||||
1942 | outs() << "\n"; | ||||
1943 | } | ||||
1944 | } | ||||
1945 | } | ||||
1946 | |||||
1947 | static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF, | ||||
1948 | StringRef DisSegName, StringRef DisSectName); | ||||
1949 | static void DumpProtocolSection(MachOObjectFile *O, const char *sect, | ||||
1950 | uint32_t size, uint32_t addr); | ||||
1951 | #ifdef LLVM_HAVE_LIBXAR | ||||
1952 | static void DumpBitcodeSection(MachOObjectFile *O, const char *sect, | ||||
1953 | uint32_t size, bool verbose, | ||||
1954 | bool PrintXarHeader, bool PrintXarFileHeaders, | ||||
1955 | std::string XarMemberName); | ||||
1956 | #endif // defined(LLVM_HAVE_LIBXAR) | ||||
1957 | |||||
1958 | static void DumpSectionContents(StringRef Filename, MachOObjectFile *O, | ||||
1959 | bool verbose) { | ||||
1960 | SymbolAddressMap AddrMap; | ||||
1961 | if (verbose) | ||||
1962 | CreateSymbolAddressMap(O, &AddrMap); | ||||
1963 | |||||
1964 | for (unsigned i = 0; i < FilterSections.size(); ++i) { | ||||
1965 | StringRef DumpSection = FilterSections[i]; | ||||
1966 | std::pair<StringRef, StringRef> DumpSegSectName; | ||||
1967 | DumpSegSectName = DumpSection.split(','); | ||||
1968 | StringRef DumpSegName, DumpSectName; | ||||
1969 | if (!DumpSegSectName.second.empty()) { | ||||
1970 | DumpSegName = DumpSegSectName.first; | ||||
1971 | DumpSectName = DumpSegSectName.second; | ||||
1972 | } else { | ||||
1973 | DumpSegName = ""; | ||||
1974 | DumpSectName = DumpSegSectName.first; | ||||
1975 | } | ||||
1976 | for (const SectionRef &Section : O->sections()) { | ||||
1977 | StringRef SectName; | ||||
1978 | Expected<StringRef> SecNameOrErr = Section.getName(); | ||||
1979 | if (SecNameOrErr) | ||||
1980 | SectName = *SecNameOrErr; | ||||
1981 | else | ||||
1982 | consumeError(SecNameOrErr.takeError()); | ||||
1983 | |||||
1984 | if (!DumpSection.empty()) | ||||
1985 | FoundSectionSet.insert(DumpSection); | ||||
1986 | |||||
1987 | DataRefImpl Ref = Section.getRawDataRefImpl(); | ||||
1988 | StringRef SegName = O->getSectionFinalSegmentName(Ref); | ||||
1989 | if ((DumpSegName.empty() || SegName == DumpSegName) && | ||||
1990 | (SectName == DumpSectName)) { | ||||
1991 | |||||
1992 | uint32_t section_flags; | ||||
1993 | if (O->is64Bit()) { | ||||
1994 | const MachO::section_64 Sec = O->getSection64(Ref); | ||||
1995 | section_flags = Sec.flags; | ||||
1996 | |||||
1997 | } else { | ||||
1998 | const MachO::section Sec = O->getSection(Ref); | ||||
1999 | section_flags = Sec.flags; | ||||
2000 | } | ||||
2001 | uint32_t section_type = section_flags & MachO::SECTION_TYPE; | ||||
2002 | |||||
2003 | StringRef BytesStr = | ||||
2004 | unwrapOrError(Section.getContents(), O->getFileName()); | ||||
2005 | const char *sect = reinterpret_cast<const char *>(BytesStr.data()); | ||||
2006 | uint32_t sect_size = BytesStr.size(); | ||||
2007 | uint64_t sect_addr = Section.getAddress(); | ||||
2008 | |||||
2009 | if (LeadingHeaders) | ||||
2010 | outs() << "Contents of (" << SegName << "," << SectName | ||||
2011 | << ") section\n"; | ||||
2012 | |||||
2013 | if (verbose) { | ||||
2014 | if ((section_flags & MachO::S_ATTR_PURE_INSTRUCTIONS) || | ||||
2015 | (section_flags & MachO::S_ATTR_SOME_INSTRUCTIONS)) { | ||||
2016 | DisassembleMachO(Filename, O, SegName, SectName); | ||||
2017 | continue; | ||||
2018 | } | ||||
2019 | if (SegName == "__TEXT" && SectName == "__info_plist") { | ||||
2020 | outs() << sect; | ||||
2021 | continue; | ||||
2022 | } | ||||
2023 | if (SegName == "__OBJC" && SectName == "__protocol") { | ||||
2024 | DumpProtocolSection(O, sect, sect_size, sect_addr); | ||||
2025 | continue; | ||||
2026 | } | ||||
2027 | #ifdef LLVM_HAVE_LIBXAR | ||||
2028 | if (SegName == "__LLVM" && SectName == "__bundle") { | ||||
2029 | DumpBitcodeSection(O, sect, sect_size, verbose, SymbolicOperands, | ||||
2030 | ArchiveHeaders, ""); | ||||
2031 | continue; | ||||
2032 | } | ||||
2033 | #endif // defined(LLVM_HAVE_LIBXAR) | ||||
2034 | switch (section_type) { | ||||
2035 | case MachO::S_REGULAR: | ||||
2036 | DumpRawSectionContents(O, sect, sect_size, sect_addr); | ||||
2037 | break; | ||||
2038 | case MachO::S_ZEROFILL: | ||||
2039 | outs() << "zerofill section and has no contents in the file\n"; | ||||
2040 | break; | ||||
2041 | case MachO::S_CSTRING_LITERALS: | ||||
2042 | DumpCstringSection(O, sect, sect_size, sect_addr, LeadingAddr); | ||||
2043 | break; | ||||
2044 | case MachO::S_4BYTE_LITERALS: | ||||
2045 | DumpLiteral4Section(O, sect, sect_size, sect_addr, LeadingAddr); | ||||
2046 | break; | ||||
2047 | case MachO::S_8BYTE_LITERALS: | ||||
2048 | DumpLiteral8Section(O, sect, sect_size, sect_addr, LeadingAddr); | ||||
2049 | break; | ||||
2050 | case MachO::S_16BYTE_LITERALS: | ||||
2051 | DumpLiteral16Section(O, sect, sect_size, sect_addr, LeadingAddr); | ||||
2052 | break; | ||||
2053 | case MachO::S_LITERAL_POINTERS: | ||||
2054 | DumpLiteralPointerSection(O, Section, sect, sect_size, sect_addr, | ||||
2055 | LeadingAddr); | ||||
2056 | break; | ||||
2057 | case MachO::S_MOD_INIT_FUNC_POINTERS: | ||||
2058 | case MachO::S_MOD_TERM_FUNC_POINTERS: | ||||
2059 | DumpInitTermPointerSection(O, Section, sect, sect_size, sect_addr, | ||||
2060 | &AddrMap, verbose); | ||||
2061 | break; | ||||
2062 | default: | ||||
2063 | outs() << "Unknown section type (" | ||||
2064 | << format("0x%08" PRIx32"x", section_type) << ")\n"; | ||||
2065 | DumpRawSectionContents(O, sect, sect_size, sect_addr); | ||||
2066 | break; | ||||
2067 | } | ||||
2068 | } else { | ||||
2069 | if (section_type == MachO::S_ZEROFILL) | ||||
2070 | outs() << "zerofill section and has no contents in the file\n"; | ||||
2071 | else | ||||
2072 | DumpRawSectionContents(O, sect, sect_size, sect_addr); | ||||
2073 | } | ||||
2074 | } | ||||
2075 | } | ||||
2076 | } | ||||
2077 | } | ||||
2078 | |||||
2079 | static void DumpInfoPlistSectionContents(StringRef Filename, | ||||
2080 | MachOObjectFile *O) { | ||||
2081 | for (const SectionRef &Section : O->sections()) { | ||||
2082 | StringRef SectName; | ||||
2083 | Expected<StringRef> SecNameOrErr = Section.getName(); | ||||
2084 | if (SecNameOrErr) | ||||
2085 | SectName = *SecNameOrErr; | ||||
2086 | else | ||||
2087 | consumeError(SecNameOrErr.takeError()); | ||||
2088 | |||||
2089 | DataRefImpl Ref = Section.getRawDataRefImpl(); | ||||
2090 | StringRef SegName = O->getSectionFinalSegmentName(Ref); | ||||
2091 | if (SegName == "__TEXT" && SectName == "__info_plist") { | ||||
2092 | if (LeadingHeaders) | ||||
2093 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
2094 | StringRef BytesStr = | ||||
2095 | unwrapOrError(Section.getContents(), O->getFileName()); | ||||
2096 | const char *sect = reinterpret_cast<const char *>(BytesStr.data()); | ||||
2097 | outs() << format("%.*s", BytesStr.size(), sect) << "\n"; | ||||
2098 | return; | ||||
2099 | } | ||||
2100 | } | ||||
2101 | } | ||||
2102 | |||||
2103 | // checkMachOAndArchFlags() checks to see if the ObjectFile is a Mach-O file | ||||
2104 | // and if it is and there is a list of architecture flags is specified then | ||||
2105 | // check to make sure this Mach-O file is one of those architectures or all | ||||
2106 | // architectures were specified. If not then an error is generated and this | ||||
2107 | // routine returns false. Else it returns true. | ||||
2108 | static bool checkMachOAndArchFlags(ObjectFile *O, StringRef Filename) { | ||||
2109 | auto *MachO = dyn_cast<MachOObjectFile>(O); | ||||
2110 | |||||
2111 | if (!MachO || ArchAll || ArchFlags.empty()) | ||||
2112 | return true; | ||||
2113 | |||||
2114 | MachO::mach_header H; | ||||
2115 | MachO::mach_header_64 H_64; | ||||
2116 | Triple T; | ||||
2117 | const char *McpuDefault, *ArchFlag; | ||||
2118 | if (MachO->is64Bit()) { | ||||
2119 | H_64 = MachO->MachOObjectFile::getHeader64(); | ||||
2120 | T = MachOObjectFile::getArchTriple(H_64.cputype, H_64.cpusubtype, | ||||
2121 | &McpuDefault, &ArchFlag); | ||||
2122 | } else { | ||||
2123 | H = MachO->MachOObjectFile::getHeader(); | ||||
2124 | T = MachOObjectFile::getArchTriple(H.cputype, H.cpusubtype, | ||||
2125 | &McpuDefault, &ArchFlag); | ||||
2126 | } | ||||
2127 | const std::string ArchFlagName(ArchFlag); | ||||
2128 | if (!llvm::is_contained(ArchFlags, ArchFlagName)) { | ||||
2129 | WithColor::error(errs(), "llvm-objdump") | ||||
2130 | << Filename << ": no architecture specified.\n"; | ||||
2131 | return false; | ||||
2132 | } | ||||
2133 | return true; | ||||
2134 | } | ||||
2135 | |||||
2136 | static void printObjcMetaData(MachOObjectFile *O, bool verbose); | ||||
2137 | |||||
2138 | // ProcessMachO() is passed a single opened Mach-O file, which may be an | ||||
2139 | // archive member and or in a slice of a universal file. It prints the | ||||
2140 | // the file name and header info and then processes it according to the | ||||
2141 | // command line options. | ||||
2142 | static void ProcessMachO(StringRef Name, MachOObjectFile *MachOOF, | ||||
2143 | StringRef ArchiveMemberName = StringRef(), | ||||
2144 | StringRef ArchitectureName = StringRef()) { | ||||
2145 | // If we are doing some processing here on the Mach-O file print the header | ||||
2146 | // info. And don't print it otherwise like in the case of printing the | ||||
2147 | // UniversalHeaders or ArchiveHeaders. | ||||
2148 | if (Disassemble || Relocations || PrivateHeaders || ExportsTrie || Rebase || | ||||
| |||||
2149 | Bind || SymbolTable || LazyBind || WeakBind || IndirectSymbols || | ||||
2150 | DataInCode || FunctionStartsType != FunctionStartsMode::None || | ||||
2151 | LinkOptHints || ChainedFixups || DyldInfo || DylibsUsed || DylibId || | ||||
2152 | Rpaths || ObjcMetaData || (!FilterSections.empty())) { | ||||
2153 | if (LeadingHeaders) { | ||||
2154 | outs() << Name; | ||||
2155 | if (!ArchiveMemberName.empty()) | ||||
2156 | outs() << '(' << ArchiveMemberName << ')'; | ||||
2157 | if (!ArchitectureName.empty()) | ||||
2158 | outs() << " (architecture " << ArchitectureName << ")"; | ||||
2159 | outs() << ":\n"; | ||||
2160 | } | ||||
2161 | } | ||||
2162 | // To use the report_error() form with an ArchiveName and FileName set | ||||
2163 | // these up based on what is passed for Name and ArchiveMemberName. | ||||
2164 | StringRef ArchiveName; | ||||
2165 | StringRef FileName; | ||||
2166 | if (!ArchiveMemberName.empty()) { | ||||
2167 | ArchiveName = Name; | ||||
2168 | FileName = ArchiveMemberName; | ||||
2169 | } else { | ||||
2170 | ArchiveName = StringRef(); | ||||
2171 | FileName = Name; | ||||
2172 | } | ||||
2173 | |||||
2174 | // If we need the symbol table to do the operation then check it here to | ||||
2175 | // produce a good error message as to where the Mach-O file comes from in | ||||
2176 | // the error message. | ||||
2177 | if (Disassemble || IndirectSymbols || !FilterSections.empty() || UnwindInfo) | ||||
2178 | if (Error Err = MachOOF->checkSymbolTable()) | ||||
2179 | reportError(std::move(Err), FileName, ArchiveName, ArchitectureName); | ||||
2180 | |||||
2181 | if (DisassembleAll) { | ||||
2182 | for (const SectionRef &Section : MachOOF->sections()) { | ||||
2183 | StringRef SectName; | ||||
2184 | if (Expected<StringRef> NameOrErr = Section.getName()) | ||||
2185 | SectName = *NameOrErr; | ||||
2186 | else | ||||
2187 | consumeError(NameOrErr.takeError()); | ||||
2188 | |||||
2189 | if (SectName.equals("__text")) { | ||||
2190 | DataRefImpl Ref = Section.getRawDataRefImpl(); | ||||
2191 | StringRef SegName = MachOOF->getSectionFinalSegmentName(Ref); | ||||
2192 | DisassembleMachO(FileName, MachOOF, SegName, SectName); | ||||
2193 | } | ||||
2194 | } | ||||
2195 | } | ||||
2196 | else if (Disassemble
| ||||
2197 | if (MachOOF->getHeader().filetype == MachO::MH_KEXT_BUNDLE && | ||||
2198 | MachOOF->getHeader().cputype == MachO::CPU_TYPE_ARM64) | ||||
2199 | DisassembleMachO(FileName, MachOOF, "__TEXT_EXEC", "__text"); | ||||
2200 | else | ||||
2201 | DisassembleMachO(FileName, MachOOF, "__TEXT", "__text"); | ||||
2202 | } | ||||
2203 | if (IndirectSymbols
| ||||
2204 | PrintIndirectSymbols(MachOOF, Verbose); | ||||
2205 | if (DataInCode) | ||||
2206 | PrintDataInCodeTable(MachOOF, Verbose); | ||||
2207 | if (FunctionStartsType != FunctionStartsMode::None) | ||||
2208 | PrintFunctionStarts(MachOOF); | ||||
2209 | if (LinkOptHints) | ||||
2210 | PrintLinkOptHints(MachOOF); | ||||
2211 | if (Relocations) | ||||
2212 | PrintRelocations(MachOOF, Verbose); | ||||
2213 | if (SectionHeaders) | ||||
2214 | printSectionHeaders(*MachOOF); | ||||
2215 | if (SectionContents) | ||||
2216 | printSectionContents(MachOOF); | ||||
2217 | if (!FilterSections.empty()) | ||||
2218 | DumpSectionContents(FileName, MachOOF, Verbose); | ||||
2219 | if (InfoPlist) | ||||
2220 | DumpInfoPlistSectionContents(FileName, MachOOF); | ||||
2221 | if (DyldInfo) | ||||
2222 | PrintDyldInfo(MachOOF); | ||||
2223 | if (ChainedFixups) | ||||
2224 | PrintChainedFixups(MachOOF); | ||||
2225 | if (DylibsUsed) | ||||
2226 | PrintDylibs(MachOOF, false); | ||||
2227 | if (DylibId) | ||||
2228 | PrintDylibs(MachOOF, true); | ||||
2229 | if (SymbolTable) | ||||
2230 | printSymbolTable(*MachOOF, ArchiveName, ArchitectureName); | ||||
2231 | if (UnwindInfo
| ||||
2232 | printMachOUnwindInfo(MachOOF); | ||||
2233 | if (PrivateHeaders) { | ||||
2234 | printMachOFileHeader(MachOOF); | ||||
2235 | printMachOLoadCommands(MachOOF); | ||||
2236 | } | ||||
2237 | if (FirstPrivateHeader) | ||||
2238 | printMachOFileHeader(MachOOF); | ||||
2239 | if (ObjcMetaData) | ||||
2240 | printObjcMetaData(MachOOF, Verbose); | ||||
2241 | if (ExportsTrie) | ||||
2242 | printExportsTrie(MachOOF); | ||||
2243 | if (Rebase) | ||||
2244 | printRebaseTable(MachOOF); | ||||
2245 | if (Rpaths) | ||||
2246 | printRpaths(MachOOF); | ||||
2247 | if (Bind) | ||||
2248 | printBindTable(MachOOF); | ||||
2249 | if (LazyBind) | ||||
2250 | printLazyBindTable(MachOOF); | ||||
2251 | if (WeakBind) | ||||
2252 | printWeakBindTable(MachOOF); | ||||
2253 | |||||
2254 | if (DwarfDumpType != DIDT_Null) { | ||||
2255 | std::unique_ptr<DIContext> DICtx = DWARFContext::create(*MachOOF); | ||||
2256 | // Dump the complete DWARF structure. | ||||
2257 | DIDumpOptions DumpOpts; | ||||
2258 | DumpOpts.DumpType = DwarfDumpType; | ||||
2259 | DICtx->dump(outs(), DumpOpts); | ||||
2260 | } | ||||
2261 | } | ||||
2262 | |||||
2263 | // printUnknownCPUType() helps print_fat_headers for unknown CPU's. | ||||
2264 | static void printUnknownCPUType(uint32_t cputype, uint32_t cpusubtype) { | ||||
2265 | outs() << " cputype (" << cputype << ")\n"; | ||||
2266 | outs() << " cpusubtype (" << cpusubtype << ")\n"; | ||||
2267 | } | ||||
2268 | |||||
2269 | // printCPUType() helps print_fat_headers by printing the cputype and | ||||
2270 | // pusubtype (symbolically for the one's it knows about). | ||||
2271 | static void printCPUType(uint32_t cputype, uint32_t cpusubtype) { | ||||
2272 | switch (cputype) { | ||||
2273 | case MachO::CPU_TYPE_I386: | ||||
2274 | switch (cpusubtype) { | ||||
2275 | case MachO::CPU_SUBTYPE_I386_ALL: | ||||
2276 | outs() << " cputype CPU_TYPE_I386\n"; | ||||
2277 | outs() << " cpusubtype CPU_SUBTYPE_I386_ALL\n"; | ||||
2278 | break; | ||||
2279 | default: | ||||
2280 | printUnknownCPUType(cputype, cpusubtype); | ||||
2281 | break; | ||||
2282 | } | ||||
2283 | break; | ||||
2284 | case MachO::CPU_TYPE_X86_64: | ||||
2285 | switch (cpusubtype) { | ||||
2286 | case MachO::CPU_SUBTYPE_X86_64_ALL: | ||||
2287 | outs() << " cputype CPU_TYPE_X86_64\n"; | ||||
2288 | outs() << " cpusubtype CPU_SUBTYPE_X86_64_ALL\n"; | ||||
2289 | break; | ||||
2290 | case MachO::CPU_SUBTYPE_X86_64_H: | ||||
2291 | outs() << " cputype CPU_TYPE_X86_64\n"; | ||||
2292 | outs() << " cpusubtype CPU_SUBTYPE_X86_64_H\n"; | ||||
2293 | break; | ||||
2294 | default: | ||||
2295 | printUnknownCPUType(cputype, cpusubtype); | ||||
2296 | break; | ||||
2297 | } | ||||
2298 | break; | ||||
2299 | case MachO::CPU_TYPE_ARM: | ||||
2300 | switch (cpusubtype) { | ||||
2301 | case MachO::CPU_SUBTYPE_ARM_ALL: | ||||
2302 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2303 | outs() << " cpusubtype CPU_SUBTYPE_ARM_ALL\n"; | ||||
2304 | break; | ||||
2305 | case MachO::CPU_SUBTYPE_ARM_V4T: | ||||
2306 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2307 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V4T\n"; | ||||
2308 | break; | ||||
2309 | case MachO::CPU_SUBTYPE_ARM_V5TEJ: | ||||
2310 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2311 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V5TEJ\n"; | ||||
2312 | break; | ||||
2313 | case MachO::CPU_SUBTYPE_ARM_XSCALE: | ||||
2314 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2315 | outs() << " cpusubtype CPU_SUBTYPE_ARM_XSCALE\n"; | ||||
2316 | break; | ||||
2317 | case MachO::CPU_SUBTYPE_ARM_V6: | ||||
2318 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2319 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V6\n"; | ||||
2320 | break; | ||||
2321 | case MachO::CPU_SUBTYPE_ARM_V6M: | ||||
2322 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2323 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V6M\n"; | ||||
2324 | break; | ||||
2325 | case MachO::CPU_SUBTYPE_ARM_V7: | ||||
2326 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2327 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V7\n"; | ||||
2328 | break; | ||||
2329 | case MachO::CPU_SUBTYPE_ARM_V7EM: | ||||
2330 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2331 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V7EM\n"; | ||||
2332 | break; | ||||
2333 | case MachO::CPU_SUBTYPE_ARM_V7K: | ||||
2334 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2335 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V7K\n"; | ||||
2336 | break; | ||||
2337 | case MachO::CPU_SUBTYPE_ARM_V7M: | ||||
2338 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2339 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V7M\n"; | ||||
2340 | break; | ||||
2341 | case MachO::CPU_SUBTYPE_ARM_V7S: | ||||
2342 | outs() << " cputype CPU_TYPE_ARM\n"; | ||||
2343 | outs() << " cpusubtype CPU_SUBTYPE_ARM_V7S\n"; | ||||
2344 | break; | ||||
2345 | default: | ||||
2346 | printUnknownCPUType(cputype, cpusubtype); | ||||
2347 | break; | ||||
2348 | } | ||||
2349 | break; | ||||
2350 | case MachO::CPU_TYPE_ARM64: | ||||
2351 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
2352 | case MachO::CPU_SUBTYPE_ARM64_ALL: | ||||
2353 | outs() << " cputype CPU_TYPE_ARM64\n"; | ||||
2354 | outs() << " cpusubtype CPU_SUBTYPE_ARM64_ALL\n"; | ||||
2355 | break; | ||||
2356 | case MachO::CPU_SUBTYPE_ARM64_V8: | ||||
2357 | outs() << " cputype CPU_TYPE_ARM64\n"; | ||||
2358 | outs() << " cpusubtype CPU_SUBTYPE_ARM64_V8\n"; | ||||
2359 | break; | ||||
2360 | case MachO::CPU_SUBTYPE_ARM64E: | ||||
2361 | outs() << " cputype CPU_TYPE_ARM64\n"; | ||||
2362 | outs() << " cpusubtype CPU_SUBTYPE_ARM64E\n"; | ||||
2363 | break; | ||||
2364 | default: | ||||
2365 | printUnknownCPUType(cputype, cpusubtype); | ||||
2366 | break; | ||||
2367 | } | ||||
2368 | break; | ||||
2369 | case MachO::CPU_TYPE_ARM64_32: | ||||
2370 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
2371 | case MachO::CPU_SUBTYPE_ARM64_32_V8: | ||||
2372 | outs() << " cputype CPU_TYPE_ARM64_32\n"; | ||||
2373 | outs() << " cpusubtype CPU_SUBTYPE_ARM64_32_V8\n"; | ||||
2374 | break; | ||||
2375 | default: | ||||
2376 | printUnknownCPUType(cputype, cpusubtype); | ||||
2377 | break; | ||||
2378 | } | ||||
2379 | break; | ||||
2380 | default: | ||||
2381 | printUnknownCPUType(cputype, cpusubtype); | ||||
2382 | break; | ||||
2383 | } | ||||
2384 | } | ||||
2385 | |||||
2386 | static void printMachOUniversalHeaders(const object::MachOUniversalBinary *UB, | ||||
2387 | bool verbose) { | ||||
2388 | outs() << "Fat headers\n"; | ||||
2389 | if (verbose) { | ||||
2390 | if (UB->getMagic() == MachO::FAT_MAGIC) | ||||
2391 | outs() << "fat_magic FAT_MAGIC\n"; | ||||
2392 | else // UB->getMagic() == MachO::FAT_MAGIC_64 | ||||
2393 | outs() << "fat_magic FAT_MAGIC_64\n"; | ||||
2394 | } else | ||||
2395 | outs() << "fat_magic " << format("0x%" PRIx32"x", MachO::FAT_MAGIC) << "\n"; | ||||
2396 | |||||
2397 | uint32_t nfat_arch = UB->getNumberOfObjects(); | ||||
2398 | StringRef Buf = UB->getData(); | ||||
2399 | uint64_t size = Buf.size(); | ||||
2400 | uint64_t big_size = sizeof(struct MachO::fat_header) + | ||||
2401 | nfat_arch * sizeof(struct MachO::fat_arch); | ||||
2402 | outs() << "nfat_arch " << UB->getNumberOfObjects(); | ||||
2403 | if (nfat_arch == 0) | ||||
2404 | outs() << " (malformed, contains zero architecture types)\n"; | ||||
2405 | else if (big_size > size) | ||||
2406 | outs() << " (malformed, architectures past end of file)\n"; | ||||
2407 | else | ||||
2408 | outs() << "\n"; | ||||
2409 | |||||
2410 | for (uint32_t i = 0; i < nfat_arch; ++i) { | ||||
2411 | MachOUniversalBinary::ObjectForArch OFA(UB, i); | ||||
2412 | uint32_t cputype = OFA.getCPUType(); | ||||
2413 | uint32_t cpusubtype = OFA.getCPUSubType(); | ||||
2414 | outs() << "architecture "; | ||||
2415 | for (uint32_t j = 0; i != 0 && j <= i - 1; j++) { | ||||
2416 | MachOUniversalBinary::ObjectForArch other_OFA(UB, j); | ||||
2417 | uint32_t other_cputype = other_OFA.getCPUType(); | ||||
2418 | uint32_t other_cpusubtype = other_OFA.getCPUSubType(); | ||||
2419 | if (cputype != 0 && cpusubtype != 0 && cputype == other_cputype && | ||||
2420 | (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) == | ||||
2421 | (other_cpusubtype & ~MachO::CPU_SUBTYPE_MASK)) { | ||||
2422 | outs() << "(illegal duplicate architecture) "; | ||||
2423 | break; | ||||
2424 | } | ||||
2425 | } | ||||
2426 | if (verbose) { | ||||
2427 | outs() << OFA.getArchFlagName() << "\n"; | ||||
2428 | printCPUType(cputype, cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
2429 | } else { | ||||
2430 | outs() << i << "\n"; | ||||
2431 | outs() << " cputype " << cputype << "\n"; | ||||
2432 | outs() << " cpusubtype " << (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) | ||||
2433 | << "\n"; | ||||
2434 | } | ||||
2435 | if (verbose && | ||||
2436 | (cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64) | ||||
2437 | outs() << " capabilities CPU_SUBTYPE_LIB64\n"; | ||||
2438 | else | ||||
2439 | outs() << " capabilities " | ||||
2440 | << format("0x%" PRIx32"x", | ||||
2441 | (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24) << "\n"; | ||||
2442 | outs() << " offset " << OFA.getOffset(); | ||||
2443 | if (OFA.getOffset() > size) | ||||
2444 | outs() << " (past end of file)"; | ||||
2445 | if (OFA.getOffset() % (1ull << OFA.getAlign()) != 0) | ||||
2446 | outs() << " (not aligned on it's alignment (2^" << OFA.getAlign() << ")"; | ||||
2447 | outs() << "\n"; | ||||
2448 | outs() << " size " << OFA.getSize(); | ||||
2449 | big_size = OFA.getOffset() + OFA.getSize(); | ||||
2450 | if (big_size > size) | ||||
2451 | outs() << " (past end of file)"; | ||||
2452 | outs() << "\n"; | ||||
2453 | outs() << " align 2^" << OFA.getAlign() << " (" << (1 << OFA.getAlign()) | ||||
2454 | << ")\n"; | ||||
2455 | } | ||||
2456 | } | ||||
2457 | |||||
2458 | static void printArchiveChild(StringRef Filename, const Archive::Child &C, | ||||
2459 | size_t ChildIndex, bool verbose, | ||||
2460 | bool print_offset, | ||||
2461 | StringRef ArchitectureName = StringRef()) { | ||||
2462 | if (print_offset) | ||||
2463 | outs() << C.getChildOffset() << "\t"; | ||||
2464 | sys::fs::perms Mode = | ||||
2465 | unwrapOrError(C.getAccessMode(), getFileNameForError(C, ChildIndex), | ||||
2466 | Filename, ArchitectureName); | ||||
2467 | if (verbose) { | ||||
2468 | // FIXME: this first dash, "-", is for (Mode & S_IFMT) == S_IFREG. | ||||
2469 | // But there is nothing in sys::fs::perms for S_IFMT or S_IFREG. | ||||
2470 | outs() << "-"; | ||||
2471 | outs() << ((Mode & sys::fs::owner_read) ? "r" : "-"); | ||||
2472 | outs() << ((Mode & sys::fs::owner_write) ? "w" : "-"); | ||||
2473 | outs() << ((Mode & sys::fs::owner_exe) ? "x" : "-"); | ||||
2474 | outs() << ((Mode & sys::fs::group_read) ? "r" : "-"); | ||||
2475 | outs() << ((Mode & sys::fs::group_write) ? "w" : "-"); | ||||
2476 | outs() << ((Mode & sys::fs::group_exe) ? "x" : "-"); | ||||
2477 | outs() << ((Mode & sys::fs::others_read) ? "r" : "-"); | ||||
2478 | outs() << ((Mode & sys::fs::others_write) ? "w" : "-"); | ||||
2479 | outs() << ((Mode & sys::fs::others_exe) ? "x" : "-"); | ||||
2480 | } else { | ||||
2481 | outs() << format("0%o ", Mode); | ||||
2482 | } | ||||
2483 | |||||
2484 | outs() << format("%3d/%-3d %5" PRId64"l" "d" " ", | ||||
2485 | unwrapOrError(C.getUID(), getFileNameForError(C, ChildIndex), | ||||
2486 | Filename, ArchitectureName), | ||||
2487 | unwrapOrError(C.getGID(), getFileNameForError(C, ChildIndex), | ||||
2488 | Filename, ArchitectureName), | ||||
2489 | unwrapOrError(C.getRawSize(), | ||||
2490 | getFileNameForError(C, ChildIndex), Filename, | ||||
2491 | ArchitectureName)); | ||||
2492 | |||||
2493 | StringRef RawLastModified = C.getRawLastModified(); | ||||
2494 | if (verbose) { | ||||
2495 | unsigned Seconds; | ||||
2496 | if (RawLastModified.getAsInteger(10, Seconds)) | ||||
2497 | outs() << "(date: \"" << RawLastModified | ||||
2498 | << "\" contains non-decimal chars) "; | ||||
2499 | else { | ||||
2500 | // Since cime(3) returns a 26 character string of the form: | ||||
2501 | // "Sun Sep 16 01:03:52 1973\n\0" | ||||
2502 | // just print 24 characters. | ||||
2503 | time_t t = Seconds; | ||||
2504 | outs() << format("%.24s ", ctime(&t)); | ||||
2505 | } | ||||
2506 | } else { | ||||
2507 | outs() << RawLastModified << " "; | ||||
2508 | } | ||||
2509 | |||||
2510 | if (verbose) { | ||||
2511 | Expected<StringRef> NameOrErr = C.getName(); | ||||
2512 | if (!NameOrErr) { | ||||
2513 | consumeError(NameOrErr.takeError()); | ||||
2514 | outs() << unwrapOrError(C.getRawName(), | ||||
2515 | getFileNameForError(C, ChildIndex), Filename, | ||||
2516 | ArchitectureName) | ||||
2517 | << "\n"; | ||||
2518 | } else { | ||||
2519 | StringRef Name = NameOrErr.get(); | ||||
2520 | outs() << Name << "\n"; | ||||
2521 | } | ||||
2522 | } else { | ||||
2523 | outs() << unwrapOrError(C.getRawName(), getFileNameForError(C, ChildIndex), | ||||
2524 | Filename, ArchitectureName) | ||||
2525 | << "\n"; | ||||
2526 | } | ||||
2527 | } | ||||
2528 | |||||
2529 | static void printArchiveHeaders(StringRef Filename, Archive *A, bool verbose, | ||||
2530 | bool print_offset, | ||||
2531 | StringRef ArchitectureName = StringRef()) { | ||||
2532 | Error Err = Error::success(); | ||||
2533 | size_t I = 0; | ||||
2534 | for (const auto &C : A->children(Err, false)) | ||||
2535 | printArchiveChild(Filename, C, I++, verbose, print_offset, | ||||
2536 | ArchitectureName); | ||||
2537 | |||||
2538 | if (Err) | ||||
2539 | reportError(std::move(Err), Filename, "", ArchitectureName); | ||||
2540 | } | ||||
2541 | |||||
2542 | static bool ValidateArchFlags() { | ||||
2543 | // Check for -arch all and verifiy the -arch flags are valid. | ||||
2544 | for (unsigned i = 0; i < ArchFlags.size(); ++i) { | ||||
2545 | if (ArchFlags[i] == "all") { | ||||
2546 | ArchAll = true; | ||||
2547 | } else { | ||||
2548 | if (!MachOObjectFile::isValidArch(ArchFlags[i])) { | ||||
2549 | WithColor::error(errs(), "llvm-objdump") | ||||
2550 | << "unknown architecture named '" + ArchFlags[i] + | ||||
2551 | "'for the -arch option\n"; | ||||
2552 | return false; | ||||
2553 | } | ||||
2554 | } | ||||
2555 | } | ||||
2556 | return true; | ||||
2557 | } | ||||
2558 | |||||
2559 | // ParseInputMachO() parses the named Mach-O file in Filename and handles the | ||||
2560 | // -arch flags selecting just those slices as specified by them and also parses | ||||
2561 | // archive files. Then for each individual Mach-O file ProcessMachO() is | ||||
2562 | // called to process the file based on the command line options. | ||||
2563 | void objdump::parseInputMachO(StringRef Filename) { | ||||
2564 | if (!ValidateArchFlags()) | ||||
2565 | return; | ||||
2566 | |||||
2567 | // Attempt to open the binary. | ||||
2568 | Expected<OwningBinary<Binary>> BinaryOrErr = createBinary(Filename); | ||||
2569 | if (!BinaryOrErr) { | ||||
2570 | if (Error E = isNotObjectErrorInvalidFileType(BinaryOrErr.takeError())) | ||||
2571 | reportError(std::move(E), Filename); | ||||
2572 | else | ||||
2573 | outs() << Filename << ": is not an object file\n"; | ||||
2574 | return; | ||||
2575 | } | ||||
2576 | Binary &Bin = *BinaryOrErr.get().getBinary(); | ||||
2577 | |||||
2578 | if (Archive *A = dyn_cast<Archive>(&Bin)) { | ||||
2579 | outs() << "Archive : " << Filename << "\n"; | ||||
2580 | if (ArchiveHeaders) | ||||
2581 | printArchiveHeaders(Filename, A, Verbose, ArchiveMemberOffsets); | ||||
2582 | |||||
2583 | Error Err = Error::success(); | ||||
2584 | unsigned I = -1; | ||||
2585 | for (auto &C : A->children(Err)) { | ||||
2586 | ++I; | ||||
2587 | Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); | ||||
2588 | if (!ChildOrErr) { | ||||
2589 | if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) | ||||
2590 | reportError(std::move(E), getFileNameForError(C, I), Filename); | ||||
2591 | continue; | ||||
2592 | } | ||||
2593 | if (MachOObjectFile *O = dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) { | ||||
2594 | if (!checkMachOAndArchFlags(O, Filename)) | ||||
2595 | return; | ||||
2596 | ProcessMachO(Filename, O, O->getFileName()); | ||||
2597 | } | ||||
2598 | } | ||||
2599 | if (Err) | ||||
2600 | reportError(std::move(Err), Filename); | ||||
2601 | return; | ||||
2602 | } | ||||
2603 | if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) { | ||||
2604 | parseInputMachO(UB); | ||||
2605 | return; | ||||
2606 | } | ||||
2607 | if (ObjectFile *O = dyn_cast<ObjectFile>(&Bin)) { | ||||
2608 | if (!checkMachOAndArchFlags(O, Filename)) | ||||
2609 | return; | ||||
2610 | if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&*O)) | ||||
2611 | ProcessMachO(Filename, MachOOF); | ||||
2612 | else | ||||
2613 | WithColor::error(errs(), "llvm-objdump") | ||||
2614 | << Filename << "': " | ||||
2615 | << "object is not a Mach-O file type.\n"; | ||||
2616 | return; | ||||
2617 | } | ||||
2618 | llvm_unreachable("Input object can't be invalid at this point")::llvm::llvm_unreachable_internal("Input object can't be invalid at this point" , "llvm/tools/llvm-objdump/MachODump.cpp", 2618); | ||||
2619 | } | ||||
2620 | |||||
2621 | void objdump::parseInputMachO(MachOUniversalBinary *UB) { | ||||
2622 | if (!ValidateArchFlags()) | ||||
2623 | return; | ||||
2624 | |||||
2625 | auto Filename = UB->getFileName(); | ||||
2626 | |||||
2627 | if (UniversalHeaders) | ||||
2628 | printMachOUniversalHeaders(UB, Verbose); | ||||
2629 | |||||
2630 | // If we have a list of architecture flags specified dump only those. | ||||
2631 | if (!ArchAll && !ArchFlags.empty()) { | ||||
2632 | // Look for a slice in the universal binary that matches each ArchFlag. | ||||
2633 | bool ArchFound; | ||||
2634 | for (unsigned i = 0; i < ArchFlags.size(); ++i) { | ||||
2635 | ArchFound = false; | ||||
2636 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), | ||||
2637 | E = UB->end_objects(); | ||||
2638 | I != E; ++I) { | ||||
2639 | if (ArchFlags[i] == I->getArchFlagName()) { | ||||
2640 | ArchFound = true; | ||||
2641 | Expected<std::unique_ptr<ObjectFile>> ObjOrErr = | ||||
2642 | I->getAsObjectFile(); | ||||
2643 | std::string ArchitectureName; | ||||
2644 | if (ArchFlags.size() > 1) | ||||
2645 | ArchitectureName = I->getArchFlagName(); | ||||
2646 | if (ObjOrErr) { | ||||
2647 | ObjectFile &O = *ObjOrErr.get(); | ||||
2648 | if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O)) | ||||
2649 | ProcessMachO(Filename, MachOOF, "", ArchitectureName); | ||||
2650 | } else if (Error E = isNotObjectErrorInvalidFileType( | ||||
2651 | ObjOrErr.takeError())) { | ||||
2652 | reportError(std::move(E), "", Filename, ArchitectureName); | ||||
2653 | continue; | ||||
2654 | } else if (Expected<std::unique_ptr<Archive>> AOrErr = | ||||
2655 | I->getAsArchive()) { | ||||
2656 | std::unique_ptr<Archive> &A = *AOrErr; | ||||
2657 | outs() << "Archive : " << Filename; | ||||
2658 | if (!ArchitectureName.empty()) | ||||
2659 | outs() << " (architecture " << ArchitectureName << ")"; | ||||
2660 | outs() << "\n"; | ||||
2661 | if (ArchiveHeaders) | ||||
2662 | printArchiveHeaders(Filename, A.get(), Verbose, | ||||
2663 | ArchiveMemberOffsets, ArchitectureName); | ||||
2664 | Error Err = Error::success(); | ||||
2665 | unsigned I = -1; | ||||
2666 | for (auto &C : A->children(Err)) { | ||||
2667 | ++I; | ||||
2668 | Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); | ||||
2669 | if (!ChildOrErr) { | ||||
2670 | if (Error E = | ||||
2671 | isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) | ||||
2672 | reportError(std::move(E), getFileNameForError(C, I), Filename, | ||||
2673 | ArchitectureName); | ||||
2674 | continue; | ||||
2675 | } | ||||
2676 | if (MachOObjectFile *O = | ||||
2677 | dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) | ||||
2678 | ProcessMachO(Filename, O, O->getFileName(), ArchitectureName); | ||||
2679 | } | ||||
2680 | if (Err) | ||||
2681 | reportError(std::move(Err), Filename); | ||||
2682 | } else { | ||||
2683 | consumeError(AOrErr.takeError()); | ||||
2684 | reportError(Filename, | ||||
2685 | "Mach-O universal file for architecture " + | ||||
2686 | StringRef(I->getArchFlagName()) + | ||||
2687 | " is not a Mach-O file or an archive file"); | ||||
2688 | } | ||||
2689 | } | ||||
2690 | } | ||||
2691 | if (!ArchFound) { | ||||
2692 | WithColor::error(errs(), "llvm-objdump") | ||||
2693 | << "file: " + Filename + " does not contain " | ||||
2694 | << "architecture: " + ArchFlags[i] + "\n"; | ||||
2695 | return; | ||||
2696 | } | ||||
2697 | } | ||||
2698 | return; | ||||
2699 | } | ||||
2700 | // No architecture flags were specified so if this contains a slice that | ||||
2701 | // matches the host architecture dump only that. | ||||
2702 | if (!ArchAll) { | ||||
2703 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), | ||||
2704 | E = UB->end_objects(); | ||||
2705 | I != E; ++I) { | ||||
2706 | if (MachOObjectFile::getHostArch().getArchName() == | ||||
2707 | I->getArchFlagName()) { | ||||
2708 | Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile(); | ||||
2709 | std::string ArchiveName; | ||||
2710 | ArchiveName.clear(); | ||||
2711 | if (ObjOrErr) { | ||||
2712 | ObjectFile &O = *ObjOrErr.get(); | ||||
2713 | if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&O)) | ||||
2714 | ProcessMachO(Filename, MachOOF); | ||||
2715 | } else if (Error E = | ||||
2716 | isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) { | ||||
2717 | reportError(std::move(E), Filename); | ||||
2718 | } else if (Expected<std::unique_ptr<Archive>> AOrErr = | ||||
2719 | I->getAsArchive()) { | ||||
2720 | std::unique_ptr<Archive> &A = *AOrErr; | ||||
2721 | outs() << "Archive : " << Filename << "\n"; | ||||
2722 | if (ArchiveHeaders) | ||||
2723 | printArchiveHeaders(Filename, A.get(), Verbose, | ||||
2724 | ArchiveMemberOffsets); | ||||
2725 | Error Err = Error::success(); | ||||
2726 | unsigned I = -1; | ||||
2727 | for (auto &C : A->children(Err)) { | ||||
2728 | ++I; | ||||
2729 | Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); | ||||
2730 | if (!ChildOrErr) { | ||||
2731 | if (Error E = | ||||
2732 | isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) | ||||
2733 | reportError(std::move(E), getFileNameForError(C, I), Filename); | ||||
2734 | continue; | ||||
2735 | } | ||||
2736 | if (MachOObjectFile *O = | ||||
2737 | dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) | ||||
2738 | ProcessMachO(Filename, O, O->getFileName()); | ||||
2739 | } | ||||
2740 | if (Err) | ||||
2741 | reportError(std::move(Err), Filename); | ||||
2742 | } else { | ||||
2743 | consumeError(AOrErr.takeError()); | ||||
2744 | reportError(Filename, "Mach-O universal file for architecture " + | ||||
2745 | StringRef(I->getArchFlagName()) + | ||||
2746 | " is not a Mach-O file or an archive file"); | ||||
2747 | } | ||||
2748 | return; | ||||
2749 | } | ||||
2750 | } | ||||
2751 | } | ||||
2752 | // Either all architectures have been specified or none have been specified | ||||
2753 | // and this does not contain the host architecture so dump all the slices. | ||||
2754 | bool moreThanOneArch = UB->getNumberOfObjects() > 1; | ||||
2755 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), | ||||
2756 | E = UB->end_objects(); | ||||
2757 | I != E; ++I) { | ||||
2758 | Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile(); | ||||
2759 | std::string ArchitectureName; | ||||
2760 | if (moreThanOneArch) | ||||
2761 | ArchitectureName = I->getArchFlagName(); | ||||
2762 | if (ObjOrErr) { | ||||
2763 | ObjectFile &Obj = *ObjOrErr.get(); | ||||
2764 | if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(&Obj)) | ||||
2765 | ProcessMachO(Filename, MachOOF, "", ArchitectureName); | ||||
2766 | } else if (Error E = | ||||
2767 | isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) { | ||||
2768 | reportError(std::move(E), Filename, "", ArchitectureName); | ||||
2769 | } else if (Expected<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) { | ||||
2770 | std::unique_ptr<Archive> &A = *AOrErr; | ||||
2771 | outs() << "Archive : " << Filename; | ||||
2772 | if (!ArchitectureName.empty()) | ||||
2773 | outs() << " (architecture " << ArchitectureName << ")"; | ||||
2774 | outs() << "\n"; | ||||
2775 | if (ArchiveHeaders) | ||||
2776 | printArchiveHeaders(Filename, A.get(), Verbose, ArchiveMemberOffsets, | ||||
2777 | ArchitectureName); | ||||
2778 | Error Err = Error::success(); | ||||
2779 | unsigned I = -1; | ||||
2780 | for (auto &C : A->children(Err)) { | ||||
2781 | ++I; | ||||
2782 | Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(); | ||||
2783 | if (!ChildOrErr) { | ||||
2784 | if (Error E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError())) | ||||
2785 | reportError(std::move(E), getFileNameForError(C, I), Filename, | ||||
2786 | ArchitectureName); | ||||
2787 | continue; | ||||
2788 | } | ||||
2789 | if (MachOObjectFile *O = | ||||
2790 | dyn_cast<MachOObjectFile>(&*ChildOrErr.get())) { | ||||
2791 | if (MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(O)) | ||||
2792 | ProcessMachO(Filename, MachOOF, MachOOF->getFileName(), | ||||
2793 | ArchitectureName); | ||||
2794 | } | ||||
2795 | } | ||||
2796 | if (Err) | ||||
2797 | reportError(std::move(Err), Filename); | ||||
2798 | } else { | ||||
2799 | consumeError(AOrErr.takeError()); | ||||
2800 | reportError(Filename, "Mach-O universal file for architecture " + | ||||
2801 | StringRef(I->getArchFlagName()) + | ||||
2802 | " is not a Mach-O file or an archive file"); | ||||
2803 | } | ||||
2804 | } | ||||
2805 | } | ||||
2806 | |||||
2807 | namespace { | ||||
2808 | // The block of info used by the Symbolizer call backs. | ||||
2809 | struct DisassembleInfo { | ||||
2810 | DisassembleInfo(MachOObjectFile *O, SymbolAddressMap *AddrMap, | ||||
2811 | std::vector<SectionRef> *Sections, bool verbose) | ||||
2812 | : verbose(verbose), O(O), AddrMap(AddrMap), Sections(Sections) {} | ||||
2813 | bool verbose; | ||||
2814 | MachOObjectFile *O; | ||||
2815 | SectionRef S; | ||||
2816 | SymbolAddressMap *AddrMap; | ||||
2817 | std::vector<SectionRef> *Sections; | ||||
2818 | const char *class_name = nullptr; | ||||
2819 | const char *selector_name = nullptr; | ||||
2820 | std::unique_ptr<char[]> method = nullptr; | ||||
2821 | char *demangled_name = nullptr; | ||||
2822 | uint64_t adrp_addr = 0; | ||||
2823 | uint32_t adrp_inst = 0; | ||||
2824 | std::unique_ptr<SymbolAddressMap> bindtable; | ||||
2825 | uint32_t depth = 0; | ||||
2826 | }; | ||||
2827 | } // namespace | ||||
2828 | |||||
2829 | // SymbolizerGetOpInfo() is the operand information call back function. | ||||
2830 | // This is called to get the symbolic information for operand(s) of an | ||||
2831 | // instruction when it is being done. This routine does this from | ||||
2832 | // the relocation information, symbol table, etc. That block of information | ||||
2833 | // is a pointer to the struct DisassembleInfo that was passed when the | ||||
2834 | // disassembler context was created and passed to back to here when | ||||
2835 | // called back by the disassembler for instruction operands that could have | ||||
2836 | // relocation information. The address of the instruction containing operand is | ||||
2837 | // at the Pc parameter. The immediate value the operand has is passed in | ||||
2838 | // op_info->Value and is at Offset past the start of the instruction and has a | ||||
2839 | // byte Size of 1, 2 or 4. The symbolc information is returned in TagBuf is the | ||||
2840 | // LLVMOpInfo1 struct defined in the header "llvm-c/Disassembler.h" as symbol | ||||
2841 | // names and addends of the symbolic expression to add for the operand. The | ||||
2842 | // value of TagType is currently 1 (for the LLVMOpInfo1 struct). If symbolic | ||||
2843 | // information is returned then this function returns 1 else it returns 0. | ||||
2844 | static int SymbolizerGetOpInfo(void *DisInfo, uint64_t Pc, uint64_t Offset, | ||||
2845 | uint64_t OpSize, uint64_t InstSize, int TagType, | ||||
2846 | void *TagBuf) { | ||||
2847 | struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo; | ||||
2848 | struct LLVMOpInfo1 *op_info = (struct LLVMOpInfo1 *)TagBuf; | ||||
2849 | uint64_t value = op_info->Value; | ||||
2850 | |||||
2851 | // Make sure all fields returned are zero if we don't set them. | ||||
2852 | memset((void *)op_info, '\0', sizeof(struct LLVMOpInfo1)); | ||||
2853 | op_info->Value = value; | ||||
2854 | |||||
2855 | // If the TagType is not the value 1 which it code knows about or if no | ||||
2856 | // verbose symbolic information is wanted then just return 0, indicating no | ||||
2857 | // information is being returned. | ||||
2858 | if (TagType != 1 || !info->verbose) | ||||
2859 | return 0; | ||||
2860 | |||||
2861 | unsigned int Arch = info->O->getArch(); | ||||
2862 | if (Arch == Triple::x86) { | ||||
2863 | if (OpSize != 1 && OpSize != 2 && OpSize != 4 && OpSize != 0) | ||||
2864 | return 0; | ||||
2865 | if (info->O->getHeader().filetype != MachO::MH_OBJECT) { | ||||
2866 | // TODO: | ||||
2867 | // Search the external relocation entries of a fully linked image | ||||
2868 | // (if any) for an entry that matches this segment offset. | ||||
2869 | // uint32_t seg_offset = (Pc + Offset); | ||||
2870 | return 0; | ||||
2871 | } | ||||
2872 | // In MH_OBJECT filetypes search the section's relocation entries (if any) | ||||
2873 | // for an entry for this section offset. | ||||
2874 | uint32_t sect_addr = info->S.getAddress(); | ||||
2875 | uint32_t sect_offset = (Pc + Offset) - sect_addr; | ||||
2876 | bool reloc_found = false; | ||||
2877 | DataRefImpl Rel; | ||||
2878 | MachO::any_relocation_info RE; | ||||
2879 | bool isExtern = false; | ||||
2880 | SymbolRef Symbol; | ||||
2881 | bool r_scattered = false; | ||||
2882 | uint32_t r_value, pair_r_value, r_type; | ||||
2883 | for (const RelocationRef &Reloc : info->S.relocations()) { | ||||
2884 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
2885 | if (RelocOffset == sect_offset) { | ||||
2886 | Rel = Reloc.getRawDataRefImpl(); | ||||
2887 | RE = info->O->getRelocation(Rel); | ||||
2888 | r_type = info->O->getAnyRelocationType(RE); | ||||
2889 | r_scattered = info->O->isRelocationScattered(RE); | ||||
2890 | if (r_scattered) { | ||||
2891 | r_value = info->O->getScatteredRelocationValue(RE); | ||||
2892 | if (r_type == MachO::GENERIC_RELOC_SECTDIFF || | ||||
2893 | r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF) { | ||||
2894 | DataRefImpl RelNext = Rel; | ||||
2895 | info->O->moveRelocationNext(RelNext); | ||||
2896 | MachO::any_relocation_info RENext; | ||||
2897 | RENext = info->O->getRelocation(RelNext); | ||||
2898 | if (info->O->isRelocationScattered(RENext)) | ||||
2899 | pair_r_value = info->O->getScatteredRelocationValue(RENext); | ||||
2900 | else | ||||
2901 | return 0; | ||||
2902 | } | ||||
2903 | } else { | ||||
2904 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
2905 | if (isExtern) { | ||||
2906 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
2907 | Symbol = *RelocSym; | ||||
2908 | } | ||||
2909 | } | ||||
2910 | reloc_found = true; | ||||
2911 | break; | ||||
2912 | } | ||||
2913 | } | ||||
2914 | if (reloc_found && isExtern) { | ||||
2915 | op_info->AddSymbol.Present = 1; | ||||
2916 | op_info->AddSymbol.Name = | ||||
2917 | unwrapOrError(Symbol.getName(), info->O->getFileName()).data(); | ||||
2918 | // For i386 extern relocation entries the value in the instruction is | ||||
2919 | // the offset from the symbol, and value is already set in op_info->Value. | ||||
2920 | return 1; | ||||
2921 | } | ||||
2922 | if (reloc_found && (r_type == MachO::GENERIC_RELOC_SECTDIFF || | ||||
2923 | r_type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF)) { | ||||
2924 | const char *add = GuessSymbolName(r_value, info->AddrMap); | ||||
2925 | const char *sub = GuessSymbolName(pair_r_value, info->AddrMap); | ||||
2926 | uint32_t offset = value - (r_value - pair_r_value); | ||||
2927 | op_info->AddSymbol.Present = 1; | ||||
2928 | if (add != nullptr) | ||||
2929 | op_info->AddSymbol.Name = add; | ||||
2930 | else | ||||
2931 | op_info->AddSymbol.Value = r_value; | ||||
2932 | op_info->SubtractSymbol.Present = 1; | ||||
2933 | if (sub != nullptr) | ||||
2934 | op_info->SubtractSymbol.Name = sub; | ||||
2935 | else | ||||
2936 | op_info->SubtractSymbol.Value = pair_r_value; | ||||
2937 | op_info->Value = offset; | ||||
2938 | return 1; | ||||
2939 | } | ||||
2940 | return 0; | ||||
2941 | } | ||||
2942 | if (Arch == Triple::x86_64) { | ||||
2943 | if (OpSize != 1 && OpSize != 2 && OpSize != 4 && OpSize != 0) | ||||
2944 | return 0; | ||||
2945 | // For non MH_OBJECT types, like MH_KEXT_BUNDLE, Search the external | ||||
2946 | // relocation entries of a linked image (if any) for an entry that matches | ||||
2947 | // this segment offset. | ||||
2948 | if (info->O->getHeader().filetype != MachO::MH_OBJECT) { | ||||
2949 | uint64_t seg_offset = Pc + Offset; | ||||
2950 | bool reloc_found = false; | ||||
2951 | DataRefImpl Rel; | ||||
2952 | MachO::any_relocation_info RE; | ||||
2953 | bool isExtern = false; | ||||
2954 | SymbolRef Symbol; | ||||
2955 | for (const RelocationRef &Reloc : info->O->external_relocations()) { | ||||
2956 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
2957 | if (RelocOffset == seg_offset) { | ||||
2958 | Rel = Reloc.getRawDataRefImpl(); | ||||
2959 | RE = info->O->getRelocation(Rel); | ||||
2960 | // external relocation entries should always be external. | ||||
2961 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
2962 | if (isExtern) { | ||||
2963 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
2964 | Symbol = *RelocSym; | ||||
2965 | } | ||||
2966 | reloc_found = true; | ||||
2967 | break; | ||||
2968 | } | ||||
2969 | } | ||||
2970 | if (reloc_found && isExtern) { | ||||
2971 | // The Value passed in will be adjusted by the Pc if the instruction | ||||
2972 | // adds the Pc. But for x86_64 external relocation entries the Value | ||||
2973 | // is the offset from the external symbol. | ||||
2974 | if (info->O->getAnyRelocationPCRel(RE)) | ||||
2975 | op_info->Value -= Pc + InstSize; | ||||
2976 | const char *name = | ||||
2977 | unwrapOrError(Symbol.getName(), info->O->getFileName()).data(); | ||||
2978 | op_info->AddSymbol.Present = 1; | ||||
2979 | op_info->AddSymbol.Name = name; | ||||
2980 | return 1; | ||||
2981 | } | ||||
2982 | return 0; | ||||
2983 | } | ||||
2984 | // In MH_OBJECT filetypes search the section's relocation entries (if any) | ||||
2985 | // for an entry for this section offset. | ||||
2986 | uint64_t sect_addr = info->S.getAddress(); | ||||
2987 | uint64_t sect_offset = (Pc + Offset) - sect_addr; | ||||
2988 | bool reloc_found = false; | ||||
2989 | DataRefImpl Rel; | ||||
2990 | MachO::any_relocation_info RE; | ||||
2991 | bool isExtern = false; | ||||
2992 | SymbolRef Symbol; | ||||
2993 | for (const RelocationRef &Reloc : info->S.relocations()) { | ||||
2994 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
2995 | if (RelocOffset == sect_offset) { | ||||
2996 | Rel = Reloc.getRawDataRefImpl(); | ||||
2997 | RE = info->O->getRelocation(Rel); | ||||
2998 | // NOTE: Scattered relocations don't exist on x86_64. | ||||
2999 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
3000 | if (isExtern) { | ||||
3001 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
3002 | Symbol = *RelocSym; | ||||
3003 | } | ||||
3004 | reloc_found = true; | ||||
3005 | break; | ||||
3006 | } | ||||
3007 | } | ||||
3008 | if (reloc_found && isExtern) { | ||||
3009 | // The Value passed in will be adjusted by the Pc if the instruction | ||||
3010 | // adds the Pc. But for x86_64 external relocation entries the Value | ||||
3011 | // is the offset from the external symbol. | ||||
3012 | if (info->O->getAnyRelocationPCRel(RE)) | ||||
3013 | op_info->Value -= Pc + InstSize; | ||||
3014 | const char *name = | ||||
3015 | unwrapOrError(Symbol.getName(), info->O->getFileName()).data(); | ||||
3016 | unsigned Type = info->O->getAnyRelocationType(RE); | ||||
3017 | if (Type == MachO::X86_64_RELOC_SUBTRACTOR) { | ||||
3018 | DataRefImpl RelNext = Rel; | ||||
3019 | info->O->moveRelocationNext(RelNext); | ||||
3020 | MachO::any_relocation_info RENext = info->O->getRelocation(RelNext); | ||||
3021 | unsigned TypeNext = info->O->getAnyRelocationType(RENext); | ||||
3022 | bool isExternNext = info->O->getPlainRelocationExternal(RENext); | ||||
3023 | unsigned SymbolNum = info->O->getPlainRelocationSymbolNum(RENext); | ||||
3024 | if (TypeNext == MachO::X86_64_RELOC_UNSIGNED && isExternNext) { | ||||
3025 | op_info->SubtractSymbol.Present = 1; | ||||
3026 | op_info->SubtractSymbol.Name = name; | ||||
3027 | symbol_iterator RelocSymNext = info->O->getSymbolByIndex(SymbolNum); | ||||
3028 | Symbol = *RelocSymNext; | ||||
3029 | name = unwrapOrError(Symbol.getName(), info->O->getFileName()).data(); | ||||
3030 | } | ||||
3031 | } | ||||
3032 | // TODO: add the VariantKinds to op_info->VariantKind for relocation types | ||||
3033 | // like: X86_64_RELOC_TLV, X86_64_RELOC_GOT_LOAD and X86_64_RELOC_GOT. | ||||
3034 | op_info->AddSymbol.Present = 1; | ||||
3035 | op_info->AddSymbol.Name = name; | ||||
3036 | return 1; | ||||
3037 | } | ||||
3038 | return 0; | ||||
3039 | } | ||||
3040 | if (Arch == Triple::arm) { | ||||
3041 | if (Offset != 0 || (InstSize != 4 && InstSize != 2)) | ||||
3042 | return 0; | ||||
3043 | if (info->O->getHeader().filetype != MachO::MH_OBJECT) { | ||||
3044 | // TODO: | ||||
3045 | // Search the external relocation entries of a fully linked image | ||||
3046 | // (if any) for an entry that matches this segment offset. | ||||
3047 | // uint32_t seg_offset = (Pc + Offset); | ||||
3048 | return 0; | ||||
3049 | } | ||||
3050 | // In MH_OBJECT filetypes search the section's relocation entries (if any) | ||||
3051 | // for an entry for this section offset. | ||||
3052 | uint32_t sect_addr = info->S.getAddress(); | ||||
3053 | uint32_t sect_offset = (Pc + Offset) - sect_addr; | ||||
3054 | DataRefImpl Rel; | ||||
3055 | MachO::any_relocation_info RE; | ||||
3056 | bool isExtern = false; | ||||
3057 | SymbolRef Symbol; | ||||
3058 | bool r_scattered = false; | ||||
3059 | uint32_t r_value, pair_r_value, r_type, r_length, other_half; | ||||
3060 | auto Reloc = | ||||
3061 | find_if(info->S.relocations(), [&](const RelocationRef &Reloc) { | ||||
3062 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
3063 | return RelocOffset == sect_offset; | ||||
3064 | }); | ||||
3065 | |||||
3066 | if (Reloc == info->S.relocations().end()) | ||||
3067 | return 0; | ||||
3068 | |||||
3069 | Rel = Reloc->getRawDataRefImpl(); | ||||
3070 | RE = info->O->getRelocation(Rel); | ||||
3071 | r_length = info->O->getAnyRelocationLength(RE); | ||||
3072 | r_scattered = info->O->isRelocationScattered(RE); | ||||
3073 | if (r_scattered) { | ||||
3074 | r_value = info->O->getScatteredRelocationValue(RE); | ||||
3075 | r_type = info->O->getScatteredRelocationType(RE); | ||||
3076 | } else { | ||||
3077 | r_type = info->O->getAnyRelocationType(RE); | ||||
3078 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
3079 | if (isExtern) { | ||||
3080 | symbol_iterator RelocSym = Reloc->getSymbol(); | ||||
3081 | Symbol = *RelocSym; | ||||
3082 | } | ||||
3083 | } | ||||
3084 | if (r_type == MachO::ARM_RELOC_HALF || | ||||
3085 | r_type == MachO::ARM_RELOC_SECTDIFF || | ||||
3086 | r_type == MachO::ARM_RELOC_LOCAL_SECTDIFF || | ||||
3087 | r_type == MachO::ARM_RELOC_HALF_SECTDIFF) { | ||||
3088 | DataRefImpl RelNext = Rel; | ||||
3089 | info->O->moveRelocationNext(RelNext); | ||||
3090 | MachO::any_relocation_info RENext; | ||||
3091 | RENext = info->O->getRelocation(RelNext); | ||||
3092 | other_half = info->O->getAnyRelocationAddress(RENext) & 0xffff; | ||||
3093 | if (info->O->isRelocationScattered(RENext)) | ||||
3094 | pair_r_value = info->O->getScatteredRelocationValue(RENext); | ||||
3095 | } | ||||
3096 | |||||
3097 | if (isExtern) { | ||||
3098 | const char *name = | ||||
3099 | unwrapOrError(Symbol.getName(), info->O->getFileName()).data(); | ||||
3100 | op_info->AddSymbol.Present = 1; | ||||
3101 | op_info->AddSymbol.Name = name; | ||||
3102 | switch (r_type) { | ||||
3103 | case MachO::ARM_RELOC_HALF: | ||||
3104 | if ((r_length & 0x1) == 1) { | ||||
3105 | op_info->Value = value << 16 | other_half; | ||||
3106 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161; | ||||
3107 | } else { | ||||
3108 | op_info->Value = other_half << 16 | value; | ||||
3109 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162; | ||||
3110 | } | ||||
3111 | break; | ||||
3112 | default: | ||||
3113 | break; | ||||
3114 | } | ||||
3115 | return 1; | ||||
3116 | } | ||||
3117 | // If we have a branch that is not an external relocation entry then | ||||
3118 | // return 0 so the code in tryAddingSymbolicOperand() can use the | ||||
3119 | // SymbolLookUp call back with the branch target address to look up the | ||||
3120 | // symbol and possibility add an annotation for a symbol stub. | ||||
3121 | if (isExtern == 0 && (r_type == MachO::ARM_RELOC_BR24 || | ||||
3122 | r_type == MachO::ARM_THUMB_RELOC_BR22)) | ||||
3123 | return 0; | ||||
3124 | |||||
3125 | uint32_t offset = 0; | ||||
3126 | if (r_type == MachO::ARM_RELOC_HALF || | ||||
3127 | r_type == MachO::ARM_RELOC_HALF_SECTDIFF) { | ||||
3128 | if ((r_length & 0x1) == 1) | ||||
3129 | value = value << 16 | other_half; | ||||
3130 | else | ||||
3131 | value = other_half << 16 | value; | ||||
3132 | } | ||||
3133 | if (r_scattered && (r_type != MachO::ARM_RELOC_HALF && | ||||
3134 | r_type != MachO::ARM_RELOC_HALF_SECTDIFF)) { | ||||
3135 | offset = value - r_value; | ||||
3136 | value = r_value; | ||||
3137 | } | ||||
3138 | |||||
3139 | if (r_type == MachO::ARM_RELOC_HALF_SECTDIFF) { | ||||
3140 | if ((r_length & 0x1) == 1) | ||||
3141 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161; | ||||
3142 | else | ||||
3143 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162; | ||||
3144 | const char *add = GuessSymbolName(r_value, info->AddrMap); | ||||
3145 | const char *sub = GuessSymbolName(pair_r_value, info->AddrMap); | ||||
3146 | int32_t offset = value - (r_value - pair_r_value); | ||||
3147 | op_info->AddSymbol.Present = 1; | ||||
3148 | if (add != nullptr) | ||||
3149 | op_info->AddSymbol.Name = add; | ||||
3150 | else | ||||
3151 | op_info->AddSymbol.Value = r_value; | ||||
3152 | op_info->SubtractSymbol.Present = 1; | ||||
3153 | if (sub != nullptr) | ||||
3154 | op_info->SubtractSymbol.Name = sub; | ||||
3155 | else | ||||
3156 | op_info->SubtractSymbol.Value = pair_r_value; | ||||
3157 | op_info->Value = offset; | ||||
3158 | return 1; | ||||
3159 | } | ||||
3160 | |||||
3161 | op_info->AddSymbol.Present = 1; | ||||
3162 | op_info->Value = offset; | ||||
3163 | if (r_type == MachO::ARM_RELOC_HALF) { | ||||
3164 | if ((r_length & 0x1) == 1) | ||||
3165 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_HI161; | ||||
3166 | else | ||||
3167 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM_LO162; | ||||
3168 | } | ||||
3169 | const char *add = GuessSymbolName(value, info->AddrMap); | ||||
3170 | if (add != nullptr) { | ||||
3171 | op_info->AddSymbol.Name = add; | ||||
3172 | return 1; | ||||
3173 | } | ||||
3174 | op_info->AddSymbol.Value = value; | ||||
3175 | return 1; | ||||
3176 | } | ||||
3177 | if (Arch == Triple::aarch64) { | ||||
3178 | if (Offset != 0 || InstSize != 4) | ||||
3179 | return 0; | ||||
3180 | if (info->O->getHeader().filetype != MachO::MH_OBJECT) { | ||||
3181 | // TODO: | ||||
3182 | // Search the external relocation entries of a fully linked image | ||||
3183 | // (if any) for an entry that matches this segment offset. | ||||
3184 | // uint64_t seg_offset = (Pc + Offset); | ||||
3185 | return 0; | ||||
3186 | } | ||||
3187 | // In MH_OBJECT filetypes search the section's relocation entries (if any) | ||||
3188 | // for an entry for this section offset. | ||||
3189 | uint64_t sect_addr = info->S.getAddress(); | ||||
3190 | uint64_t sect_offset = (Pc + Offset) - sect_addr; | ||||
3191 | auto Reloc = | ||||
3192 | find_if(info->S.relocations(), [&](const RelocationRef &Reloc) { | ||||
3193 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
3194 | return RelocOffset == sect_offset; | ||||
3195 | }); | ||||
3196 | |||||
3197 | if (Reloc == info->S.relocations().end()) | ||||
3198 | return 0; | ||||
3199 | |||||
3200 | DataRefImpl Rel = Reloc->getRawDataRefImpl(); | ||||
3201 | MachO::any_relocation_info RE = info->O->getRelocation(Rel); | ||||
3202 | uint32_t r_type = info->O->getAnyRelocationType(RE); | ||||
3203 | if (r_type == MachO::ARM64_RELOC_ADDEND) { | ||||
3204 | DataRefImpl RelNext = Rel; | ||||
3205 | info->O->moveRelocationNext(RelNext); | ||||
3206 | MachO::any_relocation_info RENext = info->O->getRelocation(RelNext); | ||||
3207 | if (value == 0) { | ||||
3208 | value = info->O->getPlainRelocationSymbolNum(RENext); | ||||
3209 | op_info->Value = value; | ||||
3210 | } | ||||
3211 | } | ||||
3212 | // NOTE: Scattered relocations don't exist on arm64. | ||||
3213 | if (!info->O->getPlainRelocationExternal(RE)) | ||||
3214 | return 0; | ||||
3215 | const char *name = | ||||
3216 | unwrapOrError(Reloc->getSymbol()->getName(), info->O->getFileName()) | ||||
3217 | .data(); | ||||
3218 | op_info->AddSymbol.Present = 1; | ||||
3219 | op_info->AddSymbol.Name = name; | ||||
3220 | |||||
3221 | switch (r_type) { | ||||
3222 | case MachO::ARM64_RELOC_PAGE21: | ||||
3223 | /* @page */ | ||||
3224 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGE1; | ||||
3225 | break; | ||||
3226 | case MachO::ARM64_RELOC_PAGEOFF12: | ||||
3227 | /* @pageoff */ | ||||
3228 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_PAGEOFF2; | ||||
3229 | break; | ||||
3230 | case MachO::ARM64_RELOC_GOT_LOAD_PAGE21: | ||||
3231 | /* @gotpage */ | ||||
3232 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGE3; | ||||
3233 | break; | ||||
3234 | case MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12: | ||||
3235 | /* @gotpageoff */ | ||||
3236 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF4; | ||||
3237 | break; | ||||
3238 | case MachO::ARM64_RELOC_TLVP_LOAD_PAGE21: | ||||
3239 | /* @tvlppage is not implemented in llvm-mc */ | ||||
3240 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVP5; | ||||
3241 | break; | ||||
3242 | case MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12: | ||||
3243 | /* @tvlppageoff is not implemented in llvm-mc */ | ||||
3244 | op_info->VariantKind = LLVMDisassembler_VariantKind_ARM64_TLVOFF6; | ||||
3245 | break; | ||||
3246 | default: | ||||
3247 | case MachO::ARM64_RELOC_BRANCH26: | ||||
3248 | op_info->VariantKind = LLVMDisassembler_VariantKind_None0; | ||||
3249 | break; | ||||
3250 | } | ||||
3251 | return 1; | ||||
3252 | } | ||||
3253 | return 0; | ||||
3254 | } | ||||
3255 | |||||
3256 | // GuessCstringPointer is passed the address of what might be a pointer to a | ||||
3257 | // literal string in a cstring section. If that address is in a cstring section | ||||
3258 | // it returns a pointer to that string. Else it returns nullptr. | ||||
3259 | static const char *GuessCstringPointer(uint64_t ReferenceValue, | ||||
3260 | struct DisassembleInfo *info) { | ||||
3261 | for (const auto &Load : info->O->load_commands()) { | ||||
3262 | if (Load.C.cmd == MachO::LC_SEGMENT_64) { | ||||
3263 | MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load); | ||||
3264 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
3265 | MachO::section_64 Sec = info->O->getSection64(Load, J); | ||||
3266 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
3267 | if (section_type == MachO::S_CSTRING_LITERALS && | ||||
3268 | ReferenceValue >= Sec.addr && | ||||
3269 | ReferenceValue < Sec.addr + Sec.size) { | ||||
3270 | uint64_t sect_offset = ReferenceValue - Sec.addr; | ||||
3271 | uint64_t object_offset = Sec.offset + sect_offset; | ||||
3272 | StringRef MachOContents = info->O->getData(); | ||||
3273 | uint64_t object_size = MachOContents.size(); | ||||
3274 | const char *object_addr = (const char *)MachOContents.data(); | ||||
3275 | if (object_offset < object_size) { | ||||
3276 | const char *name = object_addr + object_offset; | ||||
3277 | return name; | ||||
3278 | } else { | ||||
3279 | return nullptr; | ||||
3280 | } | ||||
3281 | } | ||||
3282 | } | ||||
3283 | } else if (Load.C.cmd == MachO::LC_SEGMENT) { | ||||
3284 | MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load); | ||||
3285 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
3286 | MachO::section Sec = info->O->getSection(Load, J); | ||||
3287 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
3288 | if (section_type == MachO::S_CSTRING_LITERALS && | ||||
3289 | ReferenceValue >= Sec.addr && | ||||
3290 | ReferenceValue < Sec.addr + Sec.size) { | ||||
3291 | uint64_t sect_offset = ReferenceValue - Sec.addr; | ||||
3292 | uint64_t object_offset = Sec.offset + sect_offset; | ||||
3293 | StringRef MachOContents = info->O->getData(); | ||||
3294 | uint64_t object_size = MachOContents.size(); | ||||
3295 | const char *object_addr = (const char *)MachOContents.data(); | ||||
3296 | if (object_offset < object_size) { | ||||
3297 | const char *name = object_addr + object_offset; | ||||
3298 | return name; | ||||
3299 | } else { | ||||
3300 | return nullptr; | ||||
3301 | } | ||||
3302 | } | ||||
3303 | } | ||||
3304 | } | ||||
3305 | } | ||||
3306 | return nullptr; | ||||
3307 | } | ||||
3308 | |||||
3309 | // GuessIndirectSymbol returns the name of the indirect symbol for the | ||||
3310 | // ReferenceValue passed in or nullptr. This is used when ReferenceValue maybe | ||||
3311 | // an address of a symbol stub or a lazy or non-lazy pointer to associate the | ||||
3312 | // symbol name being referenced by the stub or pointer. | ||||
3313 | static const char *GuessIndirectSymbol(uint64_t ReferenceValue, | ||||
3314 | struct DisassembleInfo *info) { | ||||
3315 | MachO::dysymtab_command Dysymtab = info->O->getDysymtabLoadCommand(); | ||||
3316 | MachO::symtab_command Symtab = info->O->getSymtabLoadCommand(); | ||||
3317 | for (const auto &Load : info->O->load_commands()) { | ||||
3318 | if (Load.C.cmd == MachO::LC_SEGMENT_64) { | ||||
3319 | MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load); | ||||
3320 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
3321 | MachO::section_64 Sec = info->O->getSection64(Load, J); | ||||
3322 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
3323 | if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS || | ||||
3324 | section_type == MachO::S_LAZY_SYMBOL_POINTERS || | ||||
3325 | section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS || | ||||
3326 | section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS || | ||||
3327 | section_type == MachO::S_SYMBOL_STUBS) && | ||||
3328 | ReferenceValue >= Sec.addr && | ||||
3329 | ReferenceValue < Sec.addr + Sec.size) { | ||||
3330 | uint32_t stride; | ||||
3331 | if (section_type == MachO::S_SYMBOL_STUBS) | ||||
3332 | stride = Sec.reserved2; | ||||
3333 | else | ||||
3334 | stride = 8; | ||||
3335 | if (stride == 0) | ||||
3336 | return nullptr; | ||||
3337 | uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride; | ||||
3338 | if (index < Dysymtab.nindirectsyms) { | ||||
3339 | uint32_t indirect_symbol = | ||||
3340 | info->O->getIndirectSymbolTableEntry(Dysymtab, index); | ||||
3341 | if (indirect_symbol < Symtab.nsyms) { | ||||
3342 | symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol); | ||||
3343 | return unwrapOrError(Sym->getName(), info->O->getFileName()) | ||||
3344 | .data(); | ||||
3345 | } | ||||
3346 | } | ||||
3347 | } | ||||
3348 | } | ||||
3349 | } else if (Load.C.cmd == MachO::LC_SEGMENT) { | ||||
3350 | MachO::segment_command Seg = info->O->getSegmentLoadCommand(Load); | ||||
3351 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
3352 | MachO::section Sec = info->O->getSection(Load, J); | ||||
3353 | uint32_t section_type = Sec.flags & MachO::SECTION_TYPE; | ||||
3354 | if ((section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS || | ||||
3355 | section_type == MachO::S_LAZY_SYMBOL_POINTERS || | ||||
3356 | section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS || | ||||
3357 | section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS || | ||||
3358 | section_type == MachO::S_SYMBOL_STUBS) && | ||||
3359 | ReferenceValue >= Sec.addr && | ||||
3360 | ReferenceValue < Sec.addr + Sec.size) { | ||||
3361 | uint32_t stride; | ||||
3362 | if (section_type == MachO::S_SYMBOL_STUBS) | ||||
3363 | stride = Sec.reserved2; | ||||
3364 | else | ||||
3365 | stride = 4; | ||||
3366 | if (stride == 0) | ||||
3367 | return nullptr; | ||||
3368 | uint32_t index = Sec.reserved1 + (ReferenceValue - Sec.addr) / stride; | ||||
3369 | if (index < Dysymtab.nindirectsyms) { | ||||
3370 | uint32_t indirect_symbol = | ||||
3371 | info->O->getIndirectSymbolTableEntry(Dysymtab, index); | ||||
3372 | if (indirect_symbol < Symtab.nsyms) { | ||||
3373 | symbol_iterator Sym = info->O->getSymbolByIndex(indirect_symbol); | ||||
3374 | return unwrapOrError(Sym->getName(), info->O->getFileName()) | ||||
3375 | .data(); | ||||
3376 | } | ||||
3377 | } | ||||
3378 | } | ||||
3379 | } | ||||
3380 | } | ||||
3381 | } | ||||
3382 | return nullptr; | ||||
3383 | } | ||||
3384 | |||||
3385 | // method_reference() is called passing it the ReferenceName that might be | ||||
3386 | // a reference it to an Objective-C method call. If so then it allocates and | ||||
3387 | // assembles a method call string with the values last seen and saved in | ||||
3388 | // the DisassembleInfo's class_name and selector_name fields. This is saved | ||||
3389 | // into the method field of the info and any previous string is free'ed. | ||||
3390 | // Then the class_name field in the info is set to nullptr. The method call | ||||
3391 | // string is set into ReferenceName and ReferenceType is set to | ||||
3392 | // LLVMDisassembler_ReferenceType_Out_Objc_Message. If this not a method call | ||||
3393 | // then both ReferenceType and ReferenceName are left unchanged. | ||||
3394 | static void method_reference(struct DisassembleInfo *info, | ||||
3395 | uint64_t *ReferenceType, | ||||
3396 | const char **ReferenceName) { | ||||
3397 | unsigned int Arch = info->O->getArch(); | ||||
3398 | if (*ReferenceName != nullptr) { | ||||
3399 | if (strcmp(*ReferenceName, "_objc_msgSend") == 0) { | ||||
3400 | if (info->selector_name != nullptr) { | ||||
3401 | if (info->class_name != nullptr) { | ||||
3402 | info->method = std::make_unique<char[]>( | ||||
3403 | 5 + strlen(info->class_name) + strlen(info->selector_name)); | ||||
3404 | char *method = info->method.get(); | ||||
3405 | if (method != nullptr) { | ||||
3406 | strcpy(method, "+["); | ||||
3407 | strcat(method, info->class_name); | ||||
3408 | strcat(method, " "); | ||||
3409 | strcat(method, info->selector_name); | ||||
3410 | strcat(method, "]"); | ||||
3411 | *ReferenceName = method; | ||||
3412 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5; | ||||
3413 | } | ||||
3414 | } else { | ||||
3415 | info->method = | ||||
3416 | std::make_unique<char[]>(9 + strlen(info->selector_name)); | ||||
3417 | char *method = info->method.get(); | ||||
3418 | if (method != nullptr) { | ||||
3419 | if (Arch == Triple::x86_64) | ||||
3420 | strcpy(method, "-[%rdi "); | ||||
3421 | else if (Arch == Triple::aarch64) | ||||
3422 | strcpy(method, "-[x0 "); | ||||
3423 | else | ||||
3424 | strcpy(method, "-[r? "); | ||||
3425 | strcat(method, info->selector_name); | ||||
3426 | strcat(method, "]"); | ||||
3427 | *ReferenceName = method; | ||||
3428 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5; | ||||
3429 | } | ||||
3430 | } | ||||
3431 | info->class_name = nullptr; | ||||
3432 | } | ||||
3433 | } else if (strcmp(*ReferenceName, "_objc_msgSendSuper2") == 0) { | ||||
3434 | if (info->selector_name != nullptr) { | ||||
3435 | info->method = | ||||
3436 | std::make_unique<char[]>(17 + strlen(info->selector_name)); | ||||
3437 | char *method = info->method.get(); | ||||
3438 | if (method != nullptr) { | ||||
3439 | if (Arch == Triple::x86_64) | ||||
3440 | strcpy(method, "-[[%rdi super] "); | ||||
3441 | else if (Arch == Triple::aarch64) | ||||
3442 | strcpy(method, "-[[x0 super] "); | ||||
3443 | else | ||||
3444 | strcpy(method, "-[[r? super] "); | ||||
3445 | strcat(method, info->selector_name); | ||||
3446 | strcat(method, "]"); | ||||
3447 | *ReferenceName = method; | ||||
3448 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message5; | ||||
3449 | } | ||||
3450 | info->class_name = nullptr; | ||||
3451 | } | ||||
3452 | } | ||||
3453 | } | ||||
3454 | } | ||||
3455 | |||||
3456 | // GuessPointerPointer() is passed the address of what might be a pointer to | ||||
3457 | // a reference to an Objective-C class, selector, message ref or cfstring. | ||||
3458 | // If so the value of the pointer is returned and one of the booleans are set | ||||
3459 | // to true. If not zero is returned and all the booleans are set to false. | ||||
3460 | static uint64_t GuessPointerPointer(uint64_t ReferenceValue, | ||||
3461 | struct DisassembleInfo *info, | ||||
3462 | bool &classref, bool &selref, bool &msgref, | ||||
3463 | bool &cfstring) { | ||||
3464 | classref = false; | ||||
3465 | selref = false; | ||||
3466 | msgref = false; | ||||
3467 | cfstring = false; | ||||
3468 | for (const auto &Load : info->O->load_commands()) { | ||||
3469 | if (Load.C.cmd == MachO::LC_SEGMENT_64) { | ||||
3470 | MachO::segment_command_64 Seg = info->O->getSegment64LoadCommand(Load); | ||||
3471 | for (unsigned J = 0; J < Seg.nsects; ++J) { | ||||
3472 | MachO::section_64 Sec = info->O->getSection64(Load, J); | ||||
3473 | if ((strncmp(Sec.sectname, "__objc_selrefs", 16) == 0 || | ||||
3474 | strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 || | ||||
3475 | strncmp(Sec.sectname, "__objc_superrefs", 16) == 0 || | ||||
3476 | strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 || | ||||
3477 | strncmp(Sec.sectname, "__cfstring", 16) == 0) && | ||||
3478 | ReferenceValue >= Sec.addr && | ||||
3479 | ReferenceValue < Sec.addr + Sec.size) { | ||||
3480 | uint64_t sect_offset = ReferenceValue - Sec.addr; | ||||
3481 | uint64_t object_offset = Sec.offset + sect_offset; | ||||
3482 | StringRef MachOContents = info->O->getData(); | ||||
3483 | uint64_t object_size = MachOContents.size(); | ||||
3484 | const char *object_addr = (const char *)MachOContents.data(); | ||||
3485 | if (object_offset < object_size) { | ||||
3486 | uint64_t pointer_value; | ||||
3487 | memcpy(&pointer_value, object_addr + object_offset, | ||||
3488 | sizeof(uint64_t)); | ||||
3489 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
3490 | sys::swapByteOrder(pointer_value); | ||||
3491 | if (strncmp(Sec.sectname, "__objc_selrefs", 16) == 0) | ||||
3492 | selref = true; | ||||
3493 | else if (strncmp(Sec.sectname, "__objc_classrefs", 16) == 0 || | ||||
3494 | strncmp(Sec.sectname, "__objc_superrefs", 16) == 0) | ||||
3495 | classref = true; | ||||
3496 | else if (strncmp(Sec.sectname, "__objc_msgrefs", 16) == 0 && | ||||
3497 | ReferenceValue + 8 < Sec.addr + Sec.size) { | ||||
3498 | msgref = true; | ||||
3499 | memcpy(&pointer_value, object_addr + object_offset + 8, | ||||
3500 | sizeof(uint64_t)); | ||||
3501 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
3502 | sys::swapByteOrder(pointer_value); | ||||
3503 | } else if (strncmp(Sec.sectname, "__cfstring", 16) == 0) | ||||
3504 | cfstring = true; | ||||
3505 | return pointer_value; | ||||
3506 | } else { | ||||
3507 | return 0; | ||||
3508 | } | ||||
3509 | } | ||||
3510 | } | ||||
3511 | } | ||||
3512 | // TODO: Look for LC_SEGMENT for 32-bit Mach-O files. | ||||
3513 | } | ||||
3514 | return 0; | ||||
3515 | } | ||||
3516 | |||||
3517 | // get_pointer_64 returns a pointer to the bytes in the object file at the | ||||
3518 | // Address from a section in the Mach-O file. And indirectly returns the | ||||
3519 | // offset into the section, number of bytes left in the section past the offset | ||||
3520 | // and which section is was being referenced. If the Address is not in a | ||||
3521 | // section nullptr is returned. | ||||
3522 | static const char *get_pointer_64(uint64_t Address, uint32_t &offset, | ||||
3523 | uint32_t &left, SectionRef &S, | ||||
3524 | DisassembleInfo *info, | ||||
3525 | bool objc_only = false) { | ||||
3526 | offset = 0; | ||||
3527 | left = 0; | ||||
3528 | S = SectionRef(); | ||||
3529 | for (unsigned SectIdx = 0; SectIdx != info->Sections->size(); SectIdx++) { | ||||
3530 | uint64_t SectAddress = ((*(info->Sections))[SectIdx]).getAddress(); | ||||
3531 | uint64_t SectSize = ((*(info->Sections))[SectIdx]).getSize(); | ||||
3532 | if (SectSize == 0) | ||||
3533 | continue; | ||||
3534 | if (objc_only) { | ||||
3535 | StringRef SectName; | ||||
3536 | Expected<StringRef> SecNameOrErr = | ||||
3537 | ((*(info->Sections))[SectIdx]).getName(); | ||||
3538 | if (SecNameOrErr) | ||||
3539 | SectName = *SecNameOrErr; | ||||
3540 | else | ||||
3541 | consumeError(SecNameOrErr.takeError()); | ||||
3542 | |||||
3543 | DataRefImpl Ref = ((*(info->Sections))[SectIdx]).getRawDataRefImpl(); | ||||
3544 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
3545 | if (SegName != "__OBJC" && SectName != "__cstring") | ||||
3546 | continue; | ||||
3547 | } | ||||
3548 | if (Address >= SectAddress && Address < SectAddress + SectSize) { | ||||
3549 | S = (*(info->Sections))[SectIdx]; | ||||
3550 | offset = Address - SectAddress; | ||||
3551 | left = SectSize - offset; | ||||
3552 | StringRef SectContents = unwrapOrError( | ||||
3553 | ((*(info->Sections))[SectIdx]).getContents(), info->O->getFileName()); | ||||
3554 | return SectContents.data() + offset; | ||||
3555 | } | ||||
3556 | } | ||||
3557 | return nullptr; | ||||
3558 | } | ||||
3559 | |||||
3560 | static const char *get_pointer_32(uint32_t Address, uint32_t &offset, | ||||
3561 | uint32_t &left, SectionRef &S, | ||||
3562 | DisassembleInfo *info, | ||||
3563 | bool objc_only = false) { | ||||
3564 | return get_pointer_64(Address, offset, left, S, info, objc_only); | ||||
3565 | } | ||||
3566 | |||||
3567 | // get_symbol_64() returns the name of a symbol (or nullptr) and the address of | ||||
3568 | // the symbol indirectly through n_value. Based on the relocation information | ||||
3569 | // for the specified section offset in the specified section reference. | ||||
3570 | // If no relocation information is found and a non-zero ReferenceValue for the | ||||
3571 | // symbol is passed, look up that address in the info's AddrMap. | ||||
3572 | static const char *get_symbol_64(uint32_t sect_offset, SectionRef S, | ||||
3573 | DisassembleInfo *info, uint64_t &n_value, | ||||
3574 | uint64_t ReferenceValue = 0) { | ||||
3575 | n_value = 0; | ||||
3576 | if (!info->verbose) | ||||
3577 | return nullptr; | ||||
3578 | |||||
3579 | // See if there is an external relocation entry at the sect_offset. | ||||
3580 | bool reloc_found = false; | ||||
3581 | DataRefImpl Rel; | ||||
3582 | MachO::any_relocation_info RE; | ||||
3583 | bool isExtern = false; | ||||
3584 | SymbolRef Symbol; | ||||
3585 | for (const RelocationRef &Reloc : S.relocations()) { | ||||
3586 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
3587 | if (RelocOffset == sect_offset) { | ||||
3588 | Rel = Reloc.getRawDataRefImpl(); | ||||
3589 | RE = info->O->getRelocation(Rel); | ||||
3590 | if (info->O->isRelocationScattered(RE)) | ||||
3591 | continue; | ||||
3592 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
3593 | if (isExtern) { | ||||
3594 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
3595 | Symbol = *RelocSym; | ||||
3596 | } | ||||
3597 | reloc_found = true; | ||||
3598 | break; | ||||
3599 | } | ||||
3600 | } | ||||
3601 | // If there is an external relocation entry for a symbol in this section | ||||
3602 | // at this section_offset then use that symbol's value for the n_value | ||||
3603 | // and return its name. | ||||
3604 | const char *SymbolName = nullptr; | ||||
3605 | if (reloc_found && isExtern) { | ||||
3606 | n_value = cantFail(Symbol.getValue()); | ||||
3607 | StringRef Name = unwrapOrError(Symbol.getName(), info->O->getFileName()); | ||||
3608 | if (!Name.empty()) { | ||||
3609 | SymbolName = Name.data(); | ||||
3610 | return SymbolName; | ||||
3611 | } | ||||
3612 | } | ||||
3613 | |||||
3614 | // TODO: For fully linked images, look through the external relocation | ||||
3615 | // entries off the dynamic symtab command. For these the r_offset is from the | ||||
3616 | // start of the first writeable segment in the Mach-O file. So the offset | ||||
3617 | // to this section from that segment is passed to this routine by the caller, | ||||
3618 | // as the database_offset. Which is the difference of the section's starting | ||||
3619 | // address and the first writable segment. | ||||
3620 | // | ||||
3621 | // NOTE: need add passing the database_offset to this routine. | ||||
3622 | |||||
3623 | // We did not find an external relocation entry so look up the ReferenceValue | ||||
3624 | // as an address of a symbol and if found return that symbol's name. | ||||
3625 | SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap); | ||||
3626 | |||||
3627 | return SymbolName; | ||||
3628 | } | ||||
3629 | |||||
3630 | static const char *get_symbol_32(uint32_t sect_offset, SectionRef S, | ||||
3631 | DisassembleInfo *info, | ||||
3632 | uint32_t ReferenceValue) { | ||||
3633 | uint64_t n_value64; | ||||
3634 | return get_symbol_64(sect_offset, S, info, n_value64, ReferenceValue); | ||||
3635 | } | ||||
3636 | |||||
3637 | namespace { | ||||
3638 | |||||
3639 | // These are structs in the Objective-C meta data and read to produce the | ||||
3640 | // comments for disassembly. While these are part of the ABI they are no | ||||
3641 | // public defintions. So the are here not in include/llvm/BinaryFormat/MachO.h | ||||
3642 | // . | ||||
3643 | |||||
3644 | // The cfstring object in a 64-bit Mach-O file. | ||||
3645 | struct cfstring64_t { | ||||
3646 | uint64_t isa; // class64_t * (64-bit pointer) | ||||
3647 | uint64_t flags; // flag bits | ||||
3648 | uint64_t characters; // char * (64-bit pointer) | ||||
3649 | uint64_t length; // number of non-NULL characters in above | ||||
3650 | }; | ||||
3651 | |||||
3652 | // The class object in a 64-bit Mach-O file. | ||||
3653 | struct class64_t { | ||||
3654 | uint64_t isa; // class64_t * (64-bit pointer) | ||||
3655 | uint64_t superclass; // class64_t * (64-bit pointer) | ||||
3656 | uint64_t cache; // Cache (64-bit pointer) | ||||
3657 | uint64_t vtable; // IMP * (64-bit pointer) | ||||
3658 | uint64_t data; // class_ro64_t * (64-bit pointer) | ||||
3659 | }; | ||||
3660 | |||||
3661 | struct class32_t { | ||||
3662 | uint32_t isa; /* class32_t * (32-bit pointer) */ | ||||
3663 | uint32_t superclass; /* class32_t * (32-bit pointer) */ | ||||
3664 | uint32_t cache; /* Cache (32-bit pointer) */ | ||||
3665 | uint32_t vtable; /* IMP * (32-bit pointer) */ | ||||
3666 | uint32_t data; /* class_ro32_t * (32-bit pointer) */ | ||||
3667 | }; | ||||
3668 | |||||
3669 | struct class_ro64_t { | ||||
3670 | uint32_t flags; | ||||
3671 | uint32_t instanceStart; | ||||
3672 | uint32_t instanceSize; | ||||
3673 | uint32_t reserved; | ||||
3674 | uint64_t ivarLayout; // const uint8_t * (64-bit pointer) | ||||
3675 | uint64_t name; // const char * (64-bit pointer) | ||||
3676 | uint64_t baseMethods; // const method_list_t * (64-bit pointer) | ||||
3677 | uint64_t baseProtocols; // const protocol_list_t * (64-bit pointer) | ||||
3678 | uint64_t ivars; // const ivar_list_t * (64-bit pointer) | ||||
3679 | uint64_t weakIvarLayout; // const uint8_t * (64-bit pointer) | ||||
3680 | uint64_t baseProperties; // const struct objc_property_list (64-bit pointer) | ||||
3681 | }; | ||||
3682 | |||||
3683 | struct class_ro32_t { | ||||
3684 | uint32_t flags; | ||||
3685 | uint32_t instanceStart; | ||||
3686 | uint32_t instanceSize; | ||||
3687 | uint32_t ivarLayout; /* const uint8_t * (32-bit pointer) */ | ||||
3688 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3689 | uint32_t baseMethods; /* const method_list_t * (32-bit pointer) */ | ||||
3690 | uint32_t baseProtocols; /* const protocol_list_t * (32-bit pointer) */ | ||||
3691 | uint32_t ivars; /* const ivar_list_t * (32-bit pointer) */ | ||||
3692 | uint32_t weakIvarLayout; /* const uint8_t * (32-bit pointer) */ | ||||
3693 | uint32_t baseProperties; /* const struct objc_property_list * | ||||
3694 | (32-bit pointer) */ | ||||
3695 | }; | ||||
3696 | |||||
3697 | /* Values for class_ro{64,32}_t->flags */ | ||||
3698 | #define RO_META(1 << 0) (1 << 0) | ||||
3699 | #define RO_ROOT(1 << 1) (1 << 1) | ||||
3700 | #define RO_HAS_CXX_STRUCTORS(1 << 2) (1 << 2) | ||||
3701 | |||||
3702 | struct method_list64_t { | ||||
3703 | uint32_t entsize; | ||||
3704 | uint32_t count; | ||||
3705 | /* struct method64_t first; These structures follow inline */ | ||||
3706 | }; | ||||
3707 | |||||
3708 | struct method_list32_t { | ||||
3709 | uint32_t entsize; | ||||
3710 | uint32_t count; | ||||
3711 | /* struct method32_t first; These structures follow inline */ | ||||
3712 | }; | ||||
3713 | |||||
3714 | struct method64_t { | ||||
3715 | uint64_t name; /* SEL (64-bit pointer) */ | ||||
3716 | uint64_t types; /* const char * (64-bit pointer) */ | ||||
3717 | uint64_t imp; /* IMP (64-bit pointer) */ | ||||
3718 | }; | ||||
3719 | |||||
3720 | struct method32_t { | ||||
3721 | uint32_t name; /* SEL (32-bit pointer) */ | ||||
3722 | uint32_t types; /* const char * (32-bit pointer) */ | ||||
3723 | uint32_t imp; /* IMP (32-bit pointer) */ | ||||
3724 | }; | ||||
3725 | |||||
3726 | struct protocol_list64_t { | ||||
3727 | uint64_t count; /* uintptr_t (a 64-bit value) */ | ||||
3728 | /* struct protocol64_t * list[0]; These pointers follow inline */ | ||||
3729 | }; | ||||
3730 | |||||
3731 | struct protocol_list32_t { | ||||
3732 | uint32_t count; /* uintptr_t (a 32-bit value) */ | ||||
3733 | /* struct protocol32_t * list[0]; These pointers follow inline */ | ||||
3734 | }; | ||||
3735 | |||||
3736 | struct protocol64_t { | ||||
3737 | uint64_t isa; /* id * (64-bit pointer) */ | ||||
3738 | uint64_t name; /* const char * (64-bit pointer) */ | ||||
3739 | uint64_t protocols; /* struct protocol_list64_t * | ||||
3740 | (64-bit pointer) */ | ||||
3741 | uint64_t instanceMethods; /* method_list_t * (64-bit pointer) */ | ||||
3742 | uint64_t classMethods; /* method_list_t * (64-bit pointer) */ | ||||
3743 | uint64_t optionalInstanceMethods; /* method_list_t * (64-bit pointer) */ | ||||
3744 | uint64_t optionalClassMethods; /* method_list_t * (64-bit pointer) */ | ||||
3745 | uint64_t instanceProperties; /* struct objc_property_list * | ||||
3746 | (64-bit pointer) */ | ||||
3747 | }; | ||||
3748 | |||||
3749 | struct protocol32_t { | ||||
3750 | uint32_t isa; /* id * (32-bit pointer) */ | ||||
3751 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3752 | uint32_t protocols; /* struct protocol_list_t * | ||||
3753 | (32-bit pointer) */ | ||||
3754 | uint32_t instanceMethods; /* method_list_t * (32-bit pointer) */ | ||||
3755 | uint32_t classMethods; /* method_list_t * (32-bit pointer) */ | ||||
3756 | uint32_t optionalInstanceMethods; /* method_list_t * (32-bit pointer) */ | ||||
3757 | uint32_t optionalClassMethods; /* method_list_t * (32-bit pointer) */ | ||||
3758 | uint32_t instanceProperties; /* struct objc_property_list * | ||||
3759 | (32-bit pointer) */ | ||||
3760 | }; | ||||
3761 | |||||
3762 | struct ivar_list64_t { | ||||
3763 | uint32_t entsize; | ||||
3764 | uint32_t count; | ||||
3765 | /* struct ivar64_t first; These structures follow inline */ | ||||
3766 | }; | ||||
3767 | |||||
3768 | struct ivar_list32_t { | ||||
3769 | uint32_t entsize; | ||||
3770 | uint32_t count; | ||||
3771 | /* struct ivar32_t first; These structures follow inline */ | ||||
3772 | }; | ||||
3773 | |||||
3774 | struct ivar64_t { | ||||
3775 | uint64_t offset; /* uintptr_t * (64-bit pointer) */ | ||||
3776 | uint64_t name; /* const char * (64-bit pointer) */ | ||||
3777 | uint64_t type; /* const char * (64-bit pointer) */ | ||||
3778 | uint32_t alignment; | ||||
3779 | uint32_t size; | ||||
3780 | }; | ||||
3781 | |||||
3782 | struct ivar32_t { | ||||
3783 | uint32_t offset; /* uintptr_t * (32-bit pointer) */ | ||||
3784 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3785 | uint32_t type; /* const char * (32-bit pointer) */ | ||||
3786 | uint32_t alignment; | ||||
3787 | uint32_t size; | ||||
3788 | }; | ||||
3789 | |||||
3790 | struct objc_property_list64 { | ||||
3791 | uint32_t entsize; | ||||
3792 | uint32_t count; | ||||
3793 | /* struct objc_property64 first; These structures follow inline */ | ||||
3794 | }; | ||||
3795 | |||||
3796 | struct objc_property_list32 { | ||||
3797 | uint32_t entsize; | ||||
3798 | uint32_t count; | ||||
3799 | /* struct objc_property32 first; These structures follow inline */ | ||||
3800 | }; | ||||
3801 | |||||
3802 | struct objc_property64 { | ||||
3803 | uint64_t name; /* const char * (64-bit pointer) */ | ||||
3804 | uint64_t attributes; /* const char * (64-bit pointer) */ | ||||
3805 | }; | ||||
3806 | |||||
3807 | struct objc_property32 { | ||||
3808 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3809 | uint32_t attributes; /* const char * (32-bit pointer) */ | ||||
3810 | }; | ||||
3811 | |||||
3812 | struct category64_t { | ||||
3813 | uint64_t name; /* const char * (64-bit pointer) */ | ||||
3814 | uint64_t cls; /* struct class_t * (64-bit pointer) */ | ||||
3815 | uint64_t instanceMethods; /* struct method_list_t * (64-bit pointer) */ | ||||
3816 | uint64_t classMethods; /* struct method_list_t * (64-bit pointer) */ | ||||
3817 | uint64_t protocols; /* struct protocol_list_t * (64-bit pointer) */ | ||||
3818 | uint64_t instanceProperties; /* struct objc_property_list * | ||||
3819 | (64-bit pointer) */ | ||||
3820 | }; | ||||
3821 | |||||
3822 | struct category32_t { | ||||
3823 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3824 | uint32_t cls; /* struct class_t * (32-bit pointer) */ | ||||
3825 | uint32_t instanceMethods; /* struct method_list_t * (32-bit pointer) */ | ||||
3826 | uint32_t classMethods; /* struct method_list_t * (32-bit pointer) */ | ||||
3827 | uint32_t protocols; /* struct protocol_list_t * (32-bit pointer) */ | ||||
3828 | uint32_t instanceProperties; /* struct objc_property_list * | ||||
3829 | (32-bit pointer) */ | ||||
3830 | }; | ||||
3831 | |||||
3832 | struct objc_image_info64 { | ||||
3833 | uint32_t version; | ||||
3834 | uint32_t flags; | ||||
3835 | }; | ||||
3836 | struct objc_image_info32 { | ||||
3837 | uint32_t version; | ||||
3838 | uint32_t flags; | ||||
3839 | }; | ||||
3840 | struct imageInfo_t { | ||||
3841 | uint32_t version; | ||||
3842 | uint32_t flags; | ||||
3843 | }; | ||||
3844 | /* masks for objc_image_info.flags */ | ||||
3845 | #define OBJC_IMAGE_IS_REPLACEMENT(1 << 0) (1 << 0) | ||||
3846 | #define OBJC_IMAGE_SUPPORTS_GC(1 << 1) (1 << 1) | ||||
3847 | #define OBJC_IMAGE_IS_SIMULATED(1 << 5) (1 << 5) | ||||
3848 | #define OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES(1 << 6) (1 << 6) | ||||
3849 | |||||
3850 | struct message_ref64 { | ||||
3851 | uint64_t imp; /* IMP (64-bit pointer) */ | ||||
3852 | uint64_t sel; /* SEL (64-bit pointer) */ | ||||
3853 | }; | ||||
3854 | |||||
3855 | struct message_ref32 { | ||||
3856 | uint32_t imp; /* IMP (32-bit pointer) */ | ||||
3857 | uint32_t sel; /* SEL (32-bit pointer) */ | ||||
3858 | }; | ||||
3859 | |||||
3860 | // Objective-C 1 (32-bit only) meta data structs. | ||||
3861 | |||||
3862 | struct objc_module_t { | ||||
3863 | uint32_t version; | ||||
3864 | uint32_t size; | ||||
3865 | uint32_t name; /* char * (32-bit pointer) */ | ||||
3866 | uint32_t symtab; /* struct objc_symtab * (32-bit pointer) */ | ||||
3867 | }; | ||||
3868 | |||||
3869 | struct objc_symtab_t { | ||||
3870 | uint32_t sel_ref_cnt; | ||||
3871 | uint32_t refs; /* SEL * (32-bit pointer) */ | ||||
3872 | uint16_t cls_def_cnt; | ||||
3873 | uint16_t cat_def_cnt; | ||||
3874 | // uint32_t defs[1]; /* void * (32-bit pointer) variable size */ | ||||
3875 | }; | ||||
3876 | |||||
3877 | struct objc_class_t { | ||||
3878 | uint32_t isa; /* struct objc_class * (32-bit pointer) */ | ||||
3879 | uint32_t super_class; /* struct objc_class * (32-bit pointer) */ | ||||
3880 | uint32_t name; /* const char * (32-bit pointer) */ | ||||
3881 | int32_t version; | ||||
3882 | int32_t info; | ||||
3883 | int32_t instance_size; | ||||
3884 | uint32_t ivars; /* struct objc_ivar_list * (32-bit pointer) */ | ||||
3885 | uint32_t methodLists; /* struct objc_method_list ** (32-bit pointer) */ | ||||
3886 | uint32_t cache; /* struct objc_cache * (32-bit pointer) */ | ||||
3887 | uint32_t protocols; /* struct objc_protocol_list * (32-bit pointer) */ | ||||
3888 | }; | ||||
3889 | |||||
3890 | #define CLS_GETINFO(cls, infomask)((cls)->info & (infomask)) ((cls)->info & (infomask)) | ||||
3891 | // class is not a metaclass | ||||
3892 | #define CLS_CLASS0x1 0x1 | ||||
3893 | // class is a metaclass | ||||
3894 | #define CLS_META0x2 0x2 | ||||
3895 | |||||
3896 | struct objc_category_t { | ||||
3897 | uint32_t category_name; /* char * (32-bit pointer) */ | ||||
3898 | uint32_t class_name; /* char * (32-bit pointer) */ | ||||
3899 | uint32_t instance_methods; /* struct objc_method_list * (32-bit pointer) */ | ||||
3900 | uint32_t class_methods; /* struct objc_method_list * (32-bit pointer) */ | ||||
3901 | uint32_t protocols; /* struct objc_protocol_list * (32-bit ptr) */ | ||||
3902 | }; | ||||
3903 | |||||
3904 | struct objc_ivar_t { | ||||
3905 | uint32_t ivar_name; /* char * (32-bit pointer) */ | ||||
3906 | uint32_t ivar_type; /* char * (32-bit pointer) */ | ||||
3907 | int32_t ivar_offset; | ||||
3908 | }; | ||||
3909 | |||||
3910 | struct objc_ivar_list_t { | ||||
3911 | int32_t ivar_count; | ||||
3912 | // struct objc_ivar_t ivar_list[1]; /* variable length structure */ | ||||
3913 | }; | ||||
3914 | |||||
3915 | struct objc_method_list_t { | ||||
3916 | uint32_t obsolete; /* struct objc_method_list * (32-bit pointer) */ | ||||
3917 | int32_t method_count; | ||||
3918 | // struct objc_method_t method_list[1]; /* variable length structure */ | ||||
3919 | }; | ||||
3920 | |||||
3921 | struct objc_method_t { | ||||
3922 | uint32_t method_name; /* SEL, aka struct objc_selector * (32-bit pointer) */ | ||||
3923 | uint32_t method_types; /* char * (32-bit pointer) */ | ||||
3924 | uint32_t method_imp; /* IMP, aka function pointer, (*IMP)(id, SEL, ...) | ||||
3925 | (32-bit pointer) */ | ||||
3926 | }; | ||||
3927 | |||||
3928 | struct objc_protocol_list_t { | ||||
3929 | uint32_t next; /* struct objc_protocol_list * (32-bit pointer) */ | ||||
3930 | int32_t count; | ||||
3931 | // uint32_t list[1]; /* Protocol *, aka struct objc_protocol_t * | ||||
3932 | // (32-bit pointer) */ | ||||
3933 | }; | ||||
3934 | |||||
3935 | struct objc_protocol_t { | ||||
3936 | uint32_t isa; /* struct objc_class * (32-bit pointer) */ | ||||
3937 | uint32_t protocol_name; /* char * (32-bit pointer) */ | ||||
3938 | uint32_t protocol_list; /* struct objc_protocol_list * (32-bit pointer) */ | ||||
3939 | uint32_t instance_methods; /* struct objc_method_description_list * | ||||
3940 | (32-bit pointer) */ | ||||
3941 | uint32_t class_methods; /* struct objc_method_description_list * | ||||
3942 | (32-bit pointer) */ | ||||
3943 | }; | ||||
3944 | |||||
3945 | struct objc_method_description_list_t { | ||||
3946 | int32_t count; | ||||
3947 | // struct objc_method_description_t list[1]; | ||||
3948 | }; | ||||
3949 | |||||
3950 | struct objc_method_description_t { | ||||
3951 | uint32_t name; /* SEL, aka struct objc_selector * (32-bit pointer) */ | ||||
3952 | uint32_t types; /* char * (32-bit pointer) */ | ||||
3953 | }; | ||||
3954 | |||||
3955 | inline void swapStruct(struct cfstring64_t &cfs) { | ||||
3956 | sys::swapByteOrder(cfs.isa); | ||||
3957 | sys::swapByteOrder(cfs.flags); | ||||
3958 | sys::swapByteOrder(cfs.characters); | ||||
3959 | sys::swapByteOrder(cfs.length); | ||||
3960 | } | ||||
3961 | |||||
3962 | inline void swapStruct(struct class64_t &c) { | ||||
3963 | sys::swapByteOrder(c.isa); | ||||
3964 | sys::swapByteOrder(c.superclass); | ||||
3965 | sys::swapByteOrder(c.cache); | ||||
3966 | sys::swapByteOrder(c.vtable); | ||||
3967 | sys::swapByteOrder(c.data); | ||||
3968 | } | ||||
3969 | |||||
3970 | inline void swapStruct(struct class32_t &c) { | ||||
3971 | sys::swapByteOrder(c.isa); | ||||
3972 | sys::swapByteOrder(c.superclass); | ||||
3973 | sys::swapByteOrder(c.cache); | ||||
3974 | sys::swapByteOrder(c.vtable); | ||||
3975 | sys::swapByteOrder(c.data); | ||||
3976 | } | ||||
3977 | |||||
3978 | inline void swapStruct(struct class_ro64_t &cro) { | ||||
3979 | sys::swapByteOrder(cro.flags); | ||||
3980 | sys::swapByteOrder(cro.instanceStart); | ||||
3981 | sys::swapByteOrder(cro.instanceSize); | ||||
3982 | sys::swapByteOrder(cro.reserved); | ||||
3983 | sys::swapByteOrder(cro.ivarLayout); | ||||
3984 | sys::swapByteOrder(cro.name); | ||||
3985 | sys::swapByteOrder(cro.baseMethods); | ||||
3986 | sys::swapByteOrder(cro.baseProtocols); | ||||
3987 | sys::swapByteOrder(cro.ivars); | ||||
3988 | sys::swapByteOrder(cro.weakIvarLayout); | ||||
3989 | sys::swapByteOrder(cro.baseProperties); | ||||
3990 | } | ||||
3991 | |||||
3992 | inline void swapStruct(struct class_ro32_t &cro) { | ||||
3993 | sys::swapByteOrder(cro.flags); | ||||
3994 | sys::swapByteOrder(cro.instanceStart); | ||||
3995 | sys::swapByteOrder(cro.instanceSize); | ||||
3996 | sys::swapByteOrder(cro.ivarLayout); | ||||
3997 | sys::swapByteOrder(cro.name); | ||||
3998 | sys::swapByteOrder(cro.baseMethods); | ||||
3999 | sys::swapByteOrder(cro.baseProtocols); | ||||
4000 | sys::swapByteOrder(cro.ivars); | ||||
4001 | sys::swapByteOrder(cro.weakIvarLayout); | ||||
4002 | sys::swapByteOrder(cro.baseProperties); | ||||
4003 | } | ||||
4004 | |||||
4005 | inline void swapStruct(struct method_list64_t &ml) { | ||||
4006 | sys::swapByteOrder(ml.entsize); | ||||
4007 | sys::swapByteOrder(ml.count); | ||||
4008 | } | ||||
4009 | |||||
4010 | inline void swapStruct(struct method_list32_t &ml) { | ||||
4011 | sys::swapByteOrder(ml.entsize); | ||||
4012 | sys::swapByteOrder(ml.count); | ||||
4013 | } | ||||
4014 | |||||
4015 | inline void swapStruct(struct method64_t &m) { | ||||
4016 | sys::swapByteOrder(m.name); | ||||
4017 | sys::swapByteOrder(m.types); | ||||
4018 | sys::swapByteOrder(m.imp); | ||||
4019 | } | ||||
4020 | |||||
4021 | inline void swapStruct(struct method32_t &m) { | ||||
4022 | sys::swapByteOrder(m.name); | ||||
4023 | sys::swapByteOrder(m.types); | ||||
4024 | sys::swapByteOrder(m.imp); | ||||
4025 | } | ||||
4026 | |||||
4027 | inline void swapStruct(struct protocol_list64_t &pl) { | ||||
4028 | sys::swapByteOrder(pl.count); | ||||
4029 | } | ||||
4030 | |||||
4031 | inline void swapStruct(struct protocol_list32_t &pl) { | ||||
4032 | sys::swapByteOrder(pl.count); | ||||
4033 | } | ||||
4034 | |||||
4035 | inline void swapStruct(struct protocol64_t &p) { | ||||
4036 | sys::swapByteOrder(p.isa); | ||||
4037 | sys::swapByteOrder(p.name); | ||||
4038 | sys::swapByteOrder(p.protocols); | ||||
4039 | sys::swapByteOrder(p.instanceMethods); | ||||
4040 | sys::swapByteOrder(p.classMethods); | ||||
4041 | sys::swapByteOrder(p.optionalInstanceMethods); | ||||
4042 | sys::swapByteOrder(p.optionalClassMethods); | ||||
4043 | sys::swapByteOrder(p.instanceProperties); | ||||
4044 | } | ||||
4045 | |||||
4046 | inline void swapStruct(struct protocol32_t &p) { | ||||
4047 | sys::swapByteOrder(p.isa); | ||||
4048 | sys::swapByteOrder(p.name); | ||||
4049 | sys::swapByteOrder(p.protocols); | ||||
4050 | sys::swapByteOrder(p.instanceMethods); | ||||
4051 | sys::swapByteOrder(p.classMethods); | ||||
4052 | sys::swapByteOrder(p.optionalInstanceMethods); | ||||
4053 | sys::swapByteOrder(p.optionalClassMethods); | ||||
4054 | sys::swapByteOrder(p.instanceProperties); | ||||
4055 | } | ||||
4056 | |||||
4057 | inline void swapStruct(struct ivar_list64_t &il) { | ||||
4058 | sys::swapByteOrder(il.entsize); | ||||
4059 | sys::swapByteOrder(il.count); | ||||
4060 | } | ||||
4061 | |||||
4062 | inline void swapStruct(struct ivar_list32_t &il) { | ||||
4063 | sys::swapByteOrder(il.entsize); | ||||
4064 | sys::swapByteOrder(il.count); | ||||
4065 | } | ||||
4066 | |||||
4067 | inline void swapStruct(struct ivar64_t &i) { | ||||
4068 | sys::swapByteOrder(i.offset); | ||||
4069 | sys::swapByteOrder(i.name); | ||||
4070 | sys::swapByteOrder(i.type); | ||||
4071 | sys::swapByteOrder(i.alignment); | ||||
4072 | sys::swapByteOrder(i.size); | ||||
4073 | } | ||||
4074 | |||||
4075 | inline void swapStruct(struct ivar32_t &i) { | ||||
4076 | sys::swapByteOrder(i.offset); | ||||
4077 | sys::swapByteOrder(i.name); | ||||
4078 | sys::swapByteOrder(i.type); | ||||
4079 | sys::swapByteOrder(i.alignment); | ||||
4080 | sys::swapByteOrder(i.size); | ||||
4081 | } | ||||
4082 | |||||
4083 | inline void swapStruct(struct objc_property_list64 &pl) { | ||||
4084 | sys::swapByteOrder(pl.entsize); | ||||
4085 | sys::swapByteOrder(pl.count); | ||||
4086 | } | ||||
4087 | |||||
4088 | inline void swapStruct(struct objc_property_list32 &pl) { | ||||
4089 | sys::swapByteOrder(pl.entsize); | ||||
4090 | sys::swapByteOrder(pl.count); | ||||
4091 | } | ||||
4092 | |||||
4093 | inline void swapStruct(struct objc_property64 &op) { | ||||
4094 | sys::swapByteOrder(op.name); | ||||
4095 | sys::swapByteOrder(op.attributes); | ||||
4096 | } | ||||
4097 | |||||
4098 | inline void swapStruct(struct objc_property32 &op) { | ||||
4099 | sys::swapByteOrder(op.name); | ||||
4100 | sys::swapByteOrder(op.attributes); | ||||
4101 | } | ||||
4102 | |||||
4103 | inline void swapStruct(struct category64_t &c) { | ||||
4104 | sys::swapByteOrder(c.name); | ||||
4105 | sys::swapByteOrder(c.cls); | ||||
4106 | sys::swapByteOrder(c.instanceMethods); | ||||
4107 | sys::swapByteOrder(c.classMethods); | ||||
4108 | sys::swapByteOrder(c.protocols); | ||||
4109 | sys::swapByteOrder(c.instanceProperties); | ||||
4110 | } | ||||
4111 | |||||
4112 | inline void swapStruct(struct category32_t &c) { | ||||
4113 | sys::swapByteOrder(c.name); | ||||
4114 | sys::swapByteOrder(c.cls); | ||||
4115 | sys::swapByteOrder(c.instanceMethods); | ||||
4116 | sys::swapByteOrder(c.classMethods); | ||||
4117 | sys::swapByteOrder(c.protocols); | ||||
4118 | sys::swapByteOrder(c.instanceProperties); | ||||
4119 | } | ||||
4120 | |||||
4121 | inline void swapStruct(struct objc_image_info64 &o) { | ||||
4122 | sys::swapByteOrder(o.version); | ||||
4123 | sys::swapByteOrder(o.flags); | ||||
4124 | } | ||||
4125 | |||||
4126 | inline void swapStruct(struct objc_image_info32 &o) { | ||||
4127 | sys::swapByteOrder(o.version); | ||||
4128 | sys::swapByteOrder(o.flags); | ||||
4129 | } | ||||
4130 | |||||
4131 | inline void swapStruct(struct imageInfo_t &o) { | ||||
4132 | sys::swapByteOrder(o.version); | ||||
4133 | sys::swapByteOrder(o.flags); | ||||
4134 | } | ||||
4135 | |||||
4136 | inline void swapStruct(struct message_ref64 &mr) { | ||||
4137 | sys::swapByteOrder(mr.imp); | ||||
4138 | sys::swapByteOrder(mr.sel); | ||||
4139 | } | ||||
4140 | |||||
4141 | inline void swapStruct(struct message_ref32 &mr) { | ||||
4142 | sys::swapByteOrder(mr.imp); | ||||
4143 | sys::swapByteOrder(mr.sel); | ||||
4144 | } | ||||
4145 | |||||
4146 | inline void swapStruct(struct objc_module_t &module) { | ||||
4147 | sys::swapByteOrder(module.version); | ||||
4148 | sys::swapByteOrder(module.size); | ||||
4149 | sys::swapByteOrder(module.name); | ||||
4150 | sys::swapByteOrder(module.symtab); | ||||
4151 | } | ||||
4152 | |||||
4153 | inline void swapStruct(struct objc_symtab_t &symtab) { | ||||
4154 | sys::swapByteOrder(symtab.sel_ref_cnt); | ||||
4155 | sys::swapByteOrder(symtab.refs); | ||||
4156 | sys::swapByteOrder(symtab.cls_def_cnt); | ||||
4157 | sys::swapByteOrder(symtab.cat_def_cnt); | ||||
4158 | } | ||||
4159 | |||||
4160 | inline void swapStruct(struct objc_class_t &objc_class) { | ||||
4161 | sys::swapByteOrder(objc_class.isa); | ||||
4162 | sys::swapByteOrder(objc_class.super_class); | ||||
4163 | sys::swapByteOrder(objc_class.name); | ||||
4164 | sys::swapByteOrder(objc_class.version); | ||||
4165 | sys::swapByteOrder(objc_class.info); | ||||
4166 | sys::swapByteOrder(objc_class.instance_size); | ||||
4167 | sys::swapByteOrder(objc_class.ivars); | ||||
4168 | sys::swapByteOrder(objc_class.methodLists); | ||||
4169 | sys::swapByteOrder(objc_class.cache); | ||||
4170 | sys::swapByteOrder(objc_class.protocols); | ||||
4171 | } | ||||
4172 | |||||
4173 | inline void swapStruct(struct objc_category_t &objc_category) { | ||||
4174 | sys::swapByteOrder(objc_category.category_name); | ||||
4175 | sys::swapByteOrder(objc_category.class_name); | ||||
4176 | sys::swapByteOrder(objc_category.instance_methods); | ||||
4177 | sys::swapByteOrder(objc_category.class_methods); | ||||
4178 | sys::swapByteOrder(objc_category.protocols); | ||||
4179 | } | ||||
4180 | |||||
4181 | inline void swapStruct(struct objc_ivar_list_t &objc_ivar_list) { | ||||
4182 | sys::swapByteOrder(objc_ivar_list.ivar_count); | ||||
4183 | } | ||||
4184 | |||||
4185 | inline void swapStruct(struct objc_ivar_t &objc_ivar) { | ||||
4186 | sys::swapByteOrder(objc_ivar.ivar_name); | ||||
4187 | sys::swapByteOrder(objc_ivar.ivar_type); | ||||
4188 | sys::swapByteOrder(objc_ivar.ivar_offset); | ||||
4189 | } | ||||
4190 | |||||
4191 | inline void swapStruct(struct objc_method_list_t &method_list) { | ||||
4192 | sys::swapByteOrder(method_list.obsolete); | ||||
4193 | sys::swapByteOrder(method_list.method_count); | ||||
4194 | } | ||||
4195 | |||||
4196 | inline void swapStruct(struct objc_method_t &method) { | ||||
4197 | sys::swapByteOrder(method.method_name); | ||||
4198 | sys::swapByteOrder(method.method_types); | ||||
4199 | sys::swapByteOrder(method.method_imp); | ||||
4200 | } | ||||
4201 | |||||
4202 | inline void swapStruct(struct objc_protocol_list_t &protocol_list) { | ||||
4203 | sys::swapByteOrder(protocol_list.next); | ||||
4204 | sys::swapByteOrder(protocol_list.count); | ||||
4205 | } | ||||
4206 | |||||
4207 | inline void swapStruct(struct objc_protocol_t &protocol) { | ||||
4208 | sys::swapByteOrder(protocol.isa); | ||||
4209 | sys::swapByteOrder(protocol.protocol_name); | ||||
4210 | sys::swapByteOrder(protocol.protocol_list); | ||||
4211 | sys::swapByteOrder(protocol.instance_methods); | ||||
4212 | sys::swapByteOrder(protocol.class_methods); | ||||
4213 | } | ||||
4214 | |||||
4215 | inline void swapStruct(struct objc_method_description_list_t &mdl) { | ||||
4216 | sys::swapByteOrder(mdl.count); | ||||
4217 | } | ||||
4218 | |||||
4219 | inline void swapStruct(struct objc_method_description_t &md) { | ||||
4220 | sys::swapByteOrder(md.name); | ||||
4221 | sys::swapByteOrder(md.types); | ||||
4222 | } | ||||
4223 | |||||
4224 | } // namespace | ||||
4225 | |||||
4226 | static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue, | ||||
4227 | struct DisassembleInfo *info); | ||||
4228 | |||||
4229 | // get_objc2_64bit_class_name() is used for disassembly and is passed a pointer | ||||
4230 | // to an Objective-C class and returns the class name. It is also passed the | ||||
4231 | // address of the pointer, so when the pointer is zero as it can be in an .o | ||||
4232 | // file, that is used to look for an external relocation entry with a symbol | ||||
4233 | // name. | ||||
4234 | static const char *get_objc2_64bit_class_name(uint64_t pointer_value, | ||||
4235 | uint64_t ReferenceValue, | ||||
4236 | struct DisassembleInfo *info) { | ||||
4237 | const char *r; | ||||
4238 | uint32_t offset, left; | ||||
4239 | SectionRef S; | ||||
4240 | |||||
4241 | // The pointer_value can be 0 in an object file and have a relocation | ||||
4242 | // entry for the class symbol at the ReferenceValue (the address of the | ||||
4243 | // pointer). | ||||
4244 | if (pointer_value == 0) { | ||||
4245 | r = get_pointer_64(ReferenceValue, offset, left, S, info); | ||||
4246 | if (r == nullptr || left < sizeof(uint64_t)) | ||||
4247 | return nullptr; | ||||
4248 | uint64_t n_value; | ||||
4249 | const char *symbol_name = get_symbol_64(offset, S, info, n_value); | ||||
4250 | if (symbol_name == nullptr) | ||||
4251 | return nullptr; | ||||
4252 | const char *class_name = strrchr(symbol_name, '$'); | ||||
4253 | if (class_name != nullptr && class_name[1] == '_' && class_name[2] != '\0') | ||||
4254 | return class_name + 2; | ||||
4255 | else | ||||
4256 | return nullptr; | ||||
4257 | } | ||||
4258 | |||||
4259 | // The case were the pointer_value is non-zero and points to a class defined | ||||
4260 | // in this Mach-O file. | ||||
4261 | r = get_pointer_64(pointer_value, offset, left, S, info); | ||||
4262 | if (r == nullptr || left < sizeof(struct class64_t)) | ||||
4263 | return nullptr; | ||||
4264 | struct class64_t c; | ||||
4265 | memcpy(&c, r, sizeof(struct class64_t)); | ||||
4266 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4267 | swapStruct(c); | ||||
4268 | if (c.data == 0) | ||||
4269 | return nullptr; | ||||
4270 | r = get_pointer_64(c.data, offset, left, S, info); | ||||
4271 | if (r == nullptr || left < sizeof(struct class_ro64_t)) | ||||
4272 | return nullptr; | ||||
4273 | struct class_ro64_t cro; | ||||
4274 | memcpy(&cro, r, sizeof(struct class_ro64_t)); | ||||
4275 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4276 | swapStruct(cro); | ||||
4277 | if (cro.name == 0) | ||||
4278 | return nullptr; | ||||
4279 | const char *name = get_pointer_64(cro.name, offset, left, S, info); | ||||
4280 | return name; | ||||
4281 | } | ||||
4282 | |||||
4283 | // get_objc2_64bit_cfstring_name is used for disassembly and is passed a | ||||
4284 | // pointer to a cfstring and returns its name or nullptr. | ||||
4285 | static const char *get_objc2_64bit_cfstring_name(uint64_t ReferenceValue, | ||||
4286 | struct DisassembleInfo *info) { | ||||
4287 | const char *r, *name; | ||||
4288 | uint32_t offset, left; | ||||
4289 | SectionRef S; | ||||
4290 | struct cfstring64_t cfs; | ||||
4291 | uint64_t cfs_characters; | ||||
4292 | |||||
4293 | r = get_pointer_64(ReferenceValue, offset, left, S, info); | ||||
4294 | if (r == nullptr || left < sizeof(struct cfstring64_t)) | ||||
4295 | return nullptr; | ||||
4296 | memcpy(&cfs, r, sizeof(struct cfstring64_t)); | ||||
4297 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4298 | swapStruct(cfs); | ||||
4299 | if (cfs.characters == 0) { | ||||
4300 | uint64_t n_value; | ||||
4301 | const char *symbol_name = get_symbol_64( | ||||
4302 | offset + offsetof(struct cfstring64_t, characters)__builtin_offsetof(struct cfstring64_t, characters), S, info, n_value); | ||||
4303 | if (symbol_name == nullptr) | ||||
4304 | return nullptr; | ||||
4305 | cfs_characters = n_value; | ||||
4306 | } else | ||||
4307 | cfs_characters = cfs.characters; | ||||
4308 | name = get_pointer_64(cfs_characters, offset, left, S, info); | ||||
4309 | |||||
4310 | return name; | ||||
4311 | } | ||||
4312 | |||||
4313 | // get_objc2_64bit_selref() is used for disassembly and is passed a the address | ||||
4314 | // of a pointer to an Objective-C selector reference when the pointer value is | ||||
4315 | // zero as in a .o file and is likely to have a external relocation entry with | ||||
4316 | // who's symbol's n_value is the real pointer to the selector name. If that is | ||||
4317 | // the case the real pointer to the selector name is returned else 0 is | ||||
4318 | // returned | ||||
4319 | static uint64_t get_objc2_64bit_selref(uint64_t ReferenceValue, | ||||
4320 | struct DisassembleInfo *info) { | ||||
4321 | uint32_t offset, left; | ||||
4322 | SectionRef S; | ||||
4323 | |||||
4324 | const char *r = get_pointer_64(ReferenceValue, offset, left, S, info); | ||||
4325 | if (r == nullptr || left < sizeof(uint64_t)) | ||||
4326 | return 0; | ||||
4327 | uint64_t n_value; | ||||
4328 | const char *symbol_name = get_symbol_64(offset, S, info, n_value); | ||||
4329 | if (symbol_name == nullptr) | ||||
4330 | return 0; | ||||
4331 | return n_value; | ||||
4332 | } | ||||
4333 | |||||
4334 | static const SectionRef get_section(MachOObjectFile *O, const char *segname, | ||||
4335 | const char *sectname) { | ||||
4336 | for (const SectionRef &Section : O->sections()) { | ||||
4337 | StringRef SectName; | ||||
4338 | Expected<StringRef> SecNameOrErr = Section.getName(); | ||||
4339 | if (SecNameOrErr) | ||||
4340 | SectName = *SecNameOrErr; | ||||
4341 | else | ||||
4342 | consumeError(SecNameOrErr.takeError()); | ||||
4343 | |||||
4344 | DataRefImpl Ref = Section.getRawDataRefImpl(); | ||||
4345 | StringRef SegName = O->getSectionFinalSegmentName(Ref); | ||||
4346 | if (SegName == segname && SectName == sectname) | ||||
4347 | return Section; | ||||
4348 | } | ||||
4349 | return SectionRef(); | ||||
4350 | } | ||||
4351 | |||||
4352 | static void | ||||
4353 | walk_pointer_list_64(const char *listname, const SectionRef S, | ||||
4354 | MachOObjectFile *O, struct DisassembleInfo *info, | ||||
4355 | void (*func)(uint64_t, struct DisassembleInfo *info)) { | ||||
4356 | if (S == SectionRef()) | ||||
4357 | return; | ||||
4358 | |||||
4359 | StringRef SectName; | ||||
4360 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
4361 | if (SecNameOrErr) | ||||
4362 | SectName = *SecNameOrErr; | ||||
4363 | else | ||||
4364 | consumeError(SecNameOrErr.takeError()); | ||||
4365 | |||||
4366 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
4367 | StringRef SegName = O->getSectionFinalSegmentName(Ref); | ||||
4368 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
4369 | |||||
4370 | StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName()); | ||||
4371 | const char *Contents = reinterpret_cast<const char *>(BytesStr.data()); | ||||
4372 | |||||
4373 | for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint64_t)) { | ||||
4374 | uint32_t left = S.getSize() - i; | ||||
4375 | uint32_t size = left < sizeof(uint64_t) ? left : sizeof(uint64_t); | ||||
4376 | uint64_t p = 0; | ||||
4377 | memcpy(&p, Contents + i, size); | ||||
4378 | if (i + sizeof(uint64_t) > S.getSize()) | ||||
4379 | outs() << listname << " list pointer extends past end of (" << SegName | ||||
4380 | << "," << SectName << ") section\n"; | ||||
4381 | outs() << format("%016" PRIx64"l" "x", S.getAddress() + i) << " "; | ||||
4382 | |||||
4383 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4384 | sys::swapByteOrder(p); | ||||
4385 | |||||
4386 | uint64_t n_value = 0; | ||||
4387 | const char *name = get_symbol_64(i, S, info, n_value, p); | ||||
4388 | if (name == nullptr) | ||||
4389 | name = get_dyld_bind_info_symbolname(S.getAddress() + i, info); | ||||
4390 | |||||
4391 | if (n_value != 0) { | ||||
4392 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4393 | if (p != 0) | ||||
4394 | outs() << " + " << format("0x%" PRIx64"l" "x", p); | ||||
4395 | } else | ||||
4396 | outs() << format("0x%" PRIx64"l" "x", p); | ||||
4397 | if (name != nullptr) | ||||
4398 | outs() << " " << name; | ||||
4399 | outs() << "\n"; | ||||
4400 | |||||
4401 | p += n_value; | ||||
4402 | if (func) | ||||
4403 | func(p, info); | ||||
4404 | } | ||||
4405 | } | ||||
4406 | |||||
4407 | static void | ||||
4408 | walk_pointer_list_32(const char *listname, const SectionRef S, | ||||
4409 | MachOObjectFile *O, struct DisassembleInfo *info, | ||||
4410 | void (*func)(uint32_t, struct DisassembleInfo *info)) { | ||||
4411 | if (S == SectionRef()) | ||||
4412 | return; | ||||
4413 | |||||
4414 | StringRef SectName = unwrapOrError(S.getName(), O->getFileName()); | ||||
4415 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
4416 | StringRef SegName = O->getSectionFinalSegmentName(Ref); | ||||
4417 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
4418 | |||||
4419 | StringRef BytesStr = unwrapOrError(S.getContents(), O->getFileName()); | ||||
4420 | const char *Contents = reinterpret_cast<const char *>(BytesStr.data()); | ||||
4421 | |||||
4422 | for (uint32_t i = 0; i < S.getSize(); i += sizeof(uint32_t)) { | ||||
4423 | uint32_t left = S.getSize() - i; | ||||
4424 | uint32_t size = left < sizeof(uint32_t) ? left : sizeof(uint32_t); | ||||
4425 | uint32_t p = 0; | ||||
4426 | memcpy(&p, Contents + i, size); | ||||
4427 | if (i + sizeof(uint32_t) > S.getSize()) | ||||
4428 | outs() << listname << " list pointer extends past end of (" << SegName | ||||
4429 | << "," << SectName << ") section\n"; | ||||
4430 | uint32_t Address = S.getAddress() + i; | ||||
4431 | outs() << format("%08" PRIx32"x", Address) << " "; | ||||
4432 | |||||
4433 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4434 | sys::swapByteOrder(p); | ||||
4435 | outs() << format("0x%" PRIx32"x", p); | ||||
4436 | |||||
4437 | const char *name = get_symbol_32(i, S, info, p); | ||||
4438 | if (name != nullptr) | ||||
4439 | outs() << " " << name; | ||||
4440 | outs() << "\n"; | ||||
4441 | |||||
4442 | if (func) | ||||
4443 | func(p, info); | ||||
4444 | } | ||||
4445 | } | ||||
4446 | |||||
4447 | static void print_layout_map(const char *layout_map, uint32_t left) { | ||||
4448 | if (layout_map == nullptr) | ||||
4449 | return; | ||||
4450 | outs() << " layout map: "; | ||||
4451 | do { | ||||
4452 | outs() << format("0x%02" PRIx32"x", (*layout_map) & 0xff) << " "; | ||||
4453 | left--; | ||||
4454 | layout_map++; | ||||
4455 | } while (*layout_map != '\0' && left != 0); | ||||
4456 | outs() << "\n"; | ||||
4457 | } | ||||
4458 | |||||
4459 | static void print_layout_map64(uint64_t p, struct DisassembleInfo *info) { | ||||
4460 | uint32_t offset, left; | ||||
4461 | SectionRef S; | ||||
4462 | const char *layout_map; | ||||
4463 | |||||
4464 | if (p == 0) | ||||
4465 | return; | ||||
4466 | layout_map = get_pointer_64(p, offset, left, S, info); | ||||
4467 | print_layout_map(layout_map, left); | ||||
4468 | } | ||||
4469 | |||||
4470 | static void print_layout_map32(uint32_t p, struct DisassembleInfo *info) { | ||||
4471 | uint32_t offset, left; | ||||
4472 | SectionRef S; | ||||
4473 | const char *layout_map; | ||||
4474 | |||||
4475 | if (p == 0) | ||||
4476 | return; | ||||
4477 | layout_map = get_pointer_32(p, offset, left, S, info); | ||||
4478 | print_layout_map(layout_map, left); | ||||
4479 | } | ||||
4480 | |||||
4481 | static void print_method_list64_t(uint64_t p, struct DisassembleInfo *info, | ||||
4482 | const char *indent) { | ||||
4483 | struct method_list64_t ml; | ||||
4484 | struct method64_t m; | ||||
4485 | const char *r; | ||||
4486 | uint32_t offset, xoffset, left, i; | ||||
4487 | SectionRef S, xS; | ||||
4488 | const char *name, *sym_name; | ||||
4489 | uint64_t n_value; | ||||
4490 | |||||
4491 | r = get_pointer_64(p, offset, left, S, info); | ||||
4492 | if (r == nullptr) | ||||
4493 | return; | ||||
4494 | memset(&ml, '\0', sizeof(struct method_list64_t)); | ||||
4495 | if (left < sizeof(struct method_list64_t)) { | ||||
4496 | memcpy(&ml, r, left); | ||||
4497 | outs() << " (method_list_t entends past the end of the section)\n"; | ||||
4498 | } else | ||||
4499 | memcpy(&ml, r, sizeof(struct method_list64_t)); | ||||
4500 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4501 | swapStruct(ml); | ||||
4502 | outs() << indent << "\t\t entsize " << ml.entsize << "\n"; | ||||
4503 | outs() << indent << "\t\t count " << ml.count << "\n"; | ||||
4504 | |||||
4505 | p += sizeof(struct method_list64_t); | ||||
4506 | offset += sizeof(struct method_list64_t); | ||||
4507 | for (i = 0; i < ml.count; i++) { | ||||
4508 | r = get_pointer_64(p, offset, left, S, info); | ||||
4509 | if (r == nullptr) | ||||
4510 | return; | ||||
4511 | memset(&m, '\0', sizeof(struct method64_t)); | ||||
4512 | if (left < sizeof(struct method64_t)) { | ||||
4513 | memcpy(&m, r, left); | ||||
4514 | outs() << indent << " (method_t extends past the end of the section)\n"; | ||||
4515 | } else | ||||
4516 | memcpy(&m, r, sizeof(struct method64_t)); | ||||
4517 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4518 | swapStruct(m); | ||||
4519 | |||||
4520 | outs() << indent << "\t\t name "; | ||||
4521 | sym_name = get_symbol_64(offset + offsetof(struct method64_t, name)__builtin_offsetof(struct method64_t, name), S, | ||||
4522 | info, n_value, m.name); | ||||
4523 | if (n_value != 0) { | ||||
4524 | if (info->verbose && sym_name != nullptr) | ||||
4525 | outs() << sym_name; | ||||
4526 | else | ||||
4527 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4528 | if (m.name != 0) | ||||
4529 | outs() << " + " << format("0x%" PRIx64"l" "x", m.name); | ||||
4530 | } else | ||||
4531 | outs() << format("0x%" PRIx64"l" "x", m.name); | ||||
4532 | name = get_pointer_64(m.name + n_value, xoffset, left, xS, info); | ||||
4533 | if (name != nullptr) | ||||
4534 | outs() << format(" %.*s", left, name); | ||||
4535 | outs() << "\n"; | ||||
4536 | |||||
4537 | outs() << indent << "\t\t types "; | ||||
4538 | sym_name = get_symbol_64(offset + offsetof(struct method64_t, types)__builtin_offsetof(struct method64_t, types), S, | ||||
4539 | info, n_value, m.types); | ||||
4540 | if (n_value != 0) { | ||||
4541 | if (info->verbose && sym_name != nullptr) | ||||
4542 | outs() << sym_name; | ||||
4543 | else | ||||
4544 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4545 | if (m.types != 0) | ||||
4546 | outs() << " + " << format("0x%" PRIx64"l" "x", m.types); | ||||
4547 | } else | ||||
4548 | outs() << format("0x%" PRIx64"l" "x", m.types); | ||||
4549 | name = get_pointer_64(m.types + n_value, xoffset, left, xS, info); | ||||
4550 | if (name != nullptr) | ||||
4551 | outs() << format(" %.*s", left, name); | ||||
4552 | outs() << "\n"; | ||||
4553 | |||||
4554 | outs() << indent << "\t\t imp "; | ||||
4555 | name = get_symbol_64(offset + offsetof(struct method64_t, imp)__builtin_offsetof(struct method64_t, imp), S, info, | ||||
4556 | n_value, m.imp); | ||||
4557 | if (info->verbose && name == nullptr) { | ||||
4558 | if (n_value != 0) { | ||||
4559 | outs() << format("0x%" PRIx64"l" "x", n_value) << " "; | ||||
4560 | if (m.imp != 0) | ||||
4561 | outs() << "+ " << format("0x%" PRIx64"l" "x", m.imp) << " "; | ||||
4562 | } else | ||||
4563 | outs() << format("0x%" PRIx64"l" "x", m.imp) << " "; | ||||
4564 | } | ||||
4565 | if (name != nullptr) | ||||
4566 | outs() << name; | ||||
4567 | outs() << "\n"; | ||||
4568 | |||||
4569 | p += sizeof(struct method64_t); | ||||
4570 | offset += sizeof(struct method64_t); | ||||
4571 | } | ||||
4572 | } | ||||
4573 | |||||
4574 | static void print_method_list32_t(uint64_t p, struct DisassembleInfo *info, | ||||
4575 | const char *indent) { | ||||
4576 | struct method_list32_t ml; | ||||
4577 | struct method32_t m; | ||||
4578 | const char *r, *name; | ||||
4579 | uint32_t offset, xoffset, left, i; | ||||
4580 | SectionRef S, xS; | ||||
4581 | |||||
4582 | r = get_pointer_32(p, offset, left, S, info); | ||||
4583 | if (r == nullptr) | ||||
4584 | return; | ||||
4585 | memset(&ml, '\0', sizeof(struct method_list32_t)); | ||||
4586 | if (left < sizeof(struct method_list32_t)) { | ||||
4587 | memcpy(&ml, r, left); | ||||
4588 | outs() << " (method_list_t entends past the end of the section)\n"; | ||||
4589 | } else | ||||
4590 | memcpy(&ml, r, sizeof(struct method_list32_t)); | ||||
4591 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4592 | swapStruct(ml); | ||||
4593 | outs() << indent << "\t\t entsize " << ml.entsize << "\n"; | ||||
4594 | outs() << indent << "\t\t count " << ml.count << "\n"; | ||||
4595 | |||||
4596 | p += sizeof(struct method_list32_t); | ||||
4597 | offset += sizeof(struct method_list32_t); | ||||
4598 | for (i = 0; i < ml.count; i++) { | ||||
4599 | r = get_pointer_32(p, offset, left, S, info); | ||||
4600 | if (r == nullptr) | ||||
4601 | return; | ||||
4602 | memset(&m, '\0', sizeof(struct method32_t)); | ||||
4603 | if (left < sizeof(struct method32_t)) { | ||||
4604 | memcpy(&ml, r, left); | ||||
4605 | outs() << indent << " (method_t entends past the end of the section)\n"; | ||||
4606 | } else | ||||
4607 | memcpy(&m, r, sizeof(struct method32_t)); | ||||
4608 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4609 | swapStruct(m); | ||||
4610 | |||||
4611 | outs() << indent << "\t\t name " << format("0x%" PRIx32"x", m.name); | ||||
4612 | name = get_pointer_32(m.name, xoffset, left, xS, info); | ||||
4613 | if (name != nullptr) | ||||
4614 | outs() << format(" %.*s", left, name); | ||||
4615 | outs() << "\n"; | ||||
4616 | |||||
4617 | outs() << indent << "\t\t types " << format("0x%" PRIx32"x", m.types); | ||||
4618 | name = get_pointer_32(m.types, xoffset, left, xS, info); | ||||
4619 | if (name != nullptr) | ||||
4620 | outs() << format(" %.*s", left, name); | ||||
4621 | outs() << "\n"; | ||||
4622 | |||||
4623 | outs() << indent << "\t\t imp " << format("0x%" PRIx32"x", m.imp); | ||||
4624 | name = get_symbol_32(offset + offsetof(struct method32_t, imp)__builtin_offsetof(struct method32_t, imp), S, info, | ||||
4625 | m.imp); | ||||
4626 | if (name != nullptr) | ||||
4627 | outs() << " " << name; | ||||
4628 | outs() << "\n"; | ||||
4629 | |||||
4630 | p += sizeof(struct method32_t); | ||||
4631 | offset += sizeof(struct method32_t); | ||||
4632 | } | ||||
4633 | } | ||||
4634 | |||||
4635 | static bool print_method_list(uint32_t p, struct DisassembleInfo *info) { | ||||
4636 | uint32_t offset, left, xleft; | ||||
4637 | SectionRef S; | ||||
4638 | struct objc_method_list_t method_list; | ||||
4639 | struct objc_method_t method; | ||||
4640 | const char *r, *methods, *name, *SymbolName; | ||||
4641 | int32_t i; | ||||
4642 | |||||
4643 | r = get_pointer_32(p, offset, left, S, info, true); | ||||
4644 | if (r == nullptr) | ||||
4645 | return true; | ||||
4646 | |||||
4647 | outs() << "\n"; | ||||
4648 | if (left > sizeof(struct objc_method_list_t)) { | ||||
4649 | memcpy(&method_list, r, sizeof(struct objc_method_list_t)); | ||||
4650 | } else { | ||||
4651 | outs() << "\t\t objc_method_list extends past end of the section\n"; | ||||
4652 | memset(&method_list, '\0', sizeof(struct objc_method_list_t)); | ||||
4653 | memcpy(&method_list, r, left); | ||||
4654 | } | ||||
4655 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4656 | swapStruct(method_list); | ||||
4657 | |||||
4658 | outs() << "\t\t obsolete " | ||||
4659 | << format("0x%08" PRIx32"x", method_list.obsolete) << "\n"; | ||||
4660 | outs() << "\t\t method_count " << method_list.method_count << "\n"; | ||||
4661 | |||||
4662 | methods = r + sizeof(struct objc_method_list_t); | ||||
4663 | for (i = 0; i < method_list.method_count; i++) { | ||||
4664 | if ((i + 1) * sizeof(struct objc_method_t) > left) { | ||||
4665 | outs() << "\t\t remaining method's extend past the of the section\n"; | ||||
4666 | break; | ||||
4667 | } | ||||
4668 | memcpy(&method, methods + i * sizeof(struct objc_method_t), | ||||
4669 | sizeof(struct objc_method_t)); | ||||
4670 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4671 | swapStruct(method); | ||||
4672 | |||||
4673 | outs() << "\t\t method_name " | ||||
4674 | << format("0x%08" PRIx32"x", method.method_name); | ||||
4675 | if (info->verbose) { | ||||
4676 | name = get_pointer_32(method.method_name, offset, xleft, S, info, true); | ||||
4677 | if (name != nullptr) | ||||
4678 | outs() << format(" %.*s", xleft, name); | ||||
4679 | else | ||||
4680 | outs() << " (not in an __OBJC section)"; | ||||
4681 | } | ||||
4682 | outs() << "\n"; | ||||
4683 | |||||
4684 | outs() << "\t\t method_types " | ||||
4685 | << format("0x%08" PRIx32"x", method.method_types); | ||||
4686 | if (info->verbose) { | ||||
4687 | name = get_pointer_32(method.method_types, offset, xleft, S, info, true); | ||||
4688 | if (name != nullptr) | ||||
4689 | outs() << format(" %.*s", xleft, name); | ||||
4690 | else | ||||
4691 | outs() << " (not in an __OBJC section)"; | ||||
4692 | } | ||||
4693 | outs() << "\n"; | ||||
4694 | |||||
4695 | outs() << "\t\t method_imp " | ||||
4696 | << format("0x%08" PRIx32"x", method.method_imp) << " "; | ||||
4697 | if (info->verbose) { | ||||
4698 | SymbolName = GuessSymbolName(method.method_imp, info->AddrMap); | ||||
4699 | if (SymbolName != nullptr) | ||||
4700 | outs() << SymbolName; | ||||
4701 | } | ||||
4702 | outs() << "\n"; | ||||
4703 | } | ||||
4704 | return false; | ||||
4705 | } | ||||
4706 | |||||
4707 | static void print_protocol_list64_t(uint64_t p, struct DisassembleInfo *info) { | ||||
4708 | struct protocol_list64_t pl; | ||||
4709 | uint64_t q, n_value; | ||||
4710 | struct protocol64_t pc; | ||||
4711 | const char *r; | ||||
4712 | uint32_t offset, xoffset, left, i; | ||||
4713 | SectionRef S, xS; | ||||
4714 | const char *name, *sym_name; | ||||
4715 | |||||
4716 | r = get_pointer_64(p, offset, left, S, info); | ||||
4717 | if (r == nullptr) | ||||
4718 | return; | ||||
4719 | memset(&pl, '\0', sizeof(struct protocol_list64_t)); | ||||
4720 | if (left < sizeof(struct protocol_list64_t)) { | ||||
4721 | memcpy(&pl, r, left); | ||||
4722 | outs() << " (protocol_list_t entends past the end of the section)\n"; | ||||
4723 | } else | ||||
4724 | memcpy(&pl, r, sizeof(struct protocol_list64_t)); | ||||
4725 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4726 | swapStruct(pl); | ||||
4727 | outs() << " count " << pl.count << "\n"; | ||||
4728 | |||||
4729 | p += sizeof(struct protocol_list64_t); | ||||
4730 | offset += sizeof(struct protocol_list64_t); | ||||
4731 | for (i = 0; i < pl.count; i++) { | ||||
4732 | r = get_pointer_64(p, offset, left, S, info); | ||||
4733 | if (r == nullptr) | ||||
4734 | return; | ||||
4735 | q = 0; | ||||
4736 | if (left < sizeof(uint64_t)) { | ||||
4737 | memcpy(&q, r, left); | ||||
4738 | outs() << " (protocol_t * entends past the end of the section)\n"; | ||||
4739 | } else | ||||
4740 | memcpy(&q, r, sizeof(uint64_t)); | ||||
4741 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4742 | sys::swapByteOrder(q); | ||||
4743 | |||||
4744 | outs() << "\t\t list[" << i << "] "; | ||||
4745 | sym_name = get_symbol_64(offset, S, info, n_value, q); | ||||
4746 | if (n_value != 0) { | ||||
4747 | if (info->verbose && sym_name != nullptr) | ||||
4748 | outs() << sym_name; | ||||
4749 | else | ||||
4750 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4751 | if (q != 0) | ||||
4752 | outs() << " + " << format("0x%" PRIx64"l" "x", q); | ||||
4753 | } else | ||||
4754 | outs() << format("0x%" PRIx64"l" "x", q); | ||||
4755 | outs() << " (struct protocol_t *)\n"; | ||||
4756 | |||||
4757 | r = get_pointer_64(q + n_value, offset, left, S, info); | ||||
4758 | if (r == nullptr) | ||||
4759 | return; | ||||
4760 | memset(&pc, '\0', sizeof(struct protocol64_t)); | ||||
4761 | if (left < sizeof(struct protocol64_t)) { | ||||
4762 | memcpy(&pc, r, left); | ||||
4763 | outs() << " (protocol_t entends past the end of the section)\n"; | ||||
4764 | } else | ||||
4765 | memcpy(&pc, r, sizeof(struct protocol64_t)); | ||||
4766 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4767 | swapStruct(pc); | ||||
4768 | |||||
4769 | outs() << "\t\t\t isa " << format("0x%" PRIx64"l" "x", pc.isa) << "\n"; | ||||
4770 | |||||
4771 | outs() << "\t\t\t name "; | ||||
4772 | sym_name = get_symbol_64(offset + offsetof(struct protocol64_t, name)__builtin_offsetof(struct protocol64_t, name), S, | ||||
4773 | info, n_value, pc.name); | ||||
4774 | if (n_value != 0) { | ||||
4775 | if (info->verbose && sym_name != nullptr) | ||||
4776 | outs() << sym_name; | ||||
4777 | else | ||||
4778 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4779 | if (pc.name != 0) | ||||
4780 | outs() << " + " << format("0x%" PRIx64"l" "x", pc.name); | ||||
4781 | } else | ||||
4782 | outs() << format("0x%" PRIx64"l" "x", pc.name); | ||||
4783 | name = get_pointer_64(pc.name + n_value, xoffset, left, xS, info); | ||||
4784 | if (name != nullptr) | ||||
4785 | outs() << format(" %.*s", left, name); | ||||
4786 | outs() << "\n"; | ||||
4787 | |||||
4788 | outs() << "\t\t\tprotocols " << format("0x%" PRIx64"l" "x", pc.protocols) << "\n"; | ||||
4789 | |||||
4790 | outs() << "\t\t instanceMethods "; | ||||
4791 | sym_name = | ||||
4792 | get_symbol_64(offset + offsetof(struct protocol64_t, instanceMethods)__builtin_offsetof(struct protocol64_t, instanceMethods), | ||||
4793 | S, info, n_value, pc.instanceMethods); | ||||
4794 | if (n_value != 0) { | ||||
4795 | if (info->verbose && sym_name != nullptr) | ||||
4796 | outs() << sym_name; | ||||
4797 | else | ||||
4798 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4799 | if (pc.instanceMethods != 0) | ||||
4800 | outs() << " + " << format("0x%" PRIx64"l" "x", pc.instanceMethods); | ||||
4801 | } else | ||||
4802 | outs() << format("0x%" PRIx64"l" "x", pc.instanceMethods); | ||||
4803 | outs() << " (struct method_list_t *)\n"; | ||||
4804 | if (pc.instanceMethods + n_value != 0) | ||||
4805 | print_method_list64_t(pc.instanceMethods + n_value, info, "\t"); | ||||
4806 | |||||
4807 | outs() << "\t\t classMethods "; | ||||
4808 | sym_name = | ||||
4809 | get_symbol_64(offset + offsetof(struct protocol64_t, classMethods)__builtin_offsetof(struct protocol64_t, classMethods), S, | ||||
4810 | info, n_value, pc.classMethods); | ||||
4811 | if (n_value != 0) { | ||||
4812 | if (info->verbose && sym_name != nullptr) | ||||
4813 | outs() << sym_name; | ||||
4814 | else | ||||
4815 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
4816 | if (pc.classMethods != 0) | ||||
4817 | outs() << " + " << format("0x%" PRIx64"l" "x", pc.classMethods); | ||||
4818 | } else | ||||
4819 | outs() << format("0x%" PRIx64"l" "x", pc.classMethods); | ||||
4820 | outs() << " (struct method_list_t *)\n"; | ||||
4821 | if (pc.classMethods + n_value != 0) | ||||
4822 | print_method_list64_t(pc.classMethods + n_value, info, "\t"); | ||||
4823 | |||||
4824 | outs() << "\t optionalInstanceMethods " | ||||
4825 | << format("0x%" PRIx64"l" "x", pc.optionalInstanceMethods) << "\n"; | ||||
4826 | outs() << "\t optionalClassMethods " | ||||
4827 | << format("0x%" PRIx64"l" "x", pc.optionalClassMethods) << "\n"; | ||||
4828 | outs() << "\t instanceProperties " | ||||
4829 | << format("0x%" PRIx64"l" "x", pc.instanceProperties) << "\n"; | ||||
4830 | |||||
4831 | p += sizeof(uint64_t); | ||||
4832 | offset += sizeof(uint64_t); | ||||
4833 | } | ||||
4834 | } | ||||
4835 | |||||
4836 | static void print_protocol_list32_t(uint32_t p, struct DisassembleInfo *info) { | ||||
4837 | struct protocol_list32_t pl; | ||||
4838 | uint32_t q; | ||||
4839 | struct protocol32_t pc; | ||||
4840 | const char *r; | ||||
4841 | uint32_t offset, xoffset, left, i; | ||||
4842 | SectionRef S, xS; | ||||
4843 | const char *name; | ||||
4844 | |||||
4845 | r = get_pointer_32(p, offset, left, S, info); | ||||
4846 | if (r == nullptr) | ||||
4847 | return; | ||||
4848 | memset(&pl, '\0', sizeof(struct protocol_list32_t)); | ||||
4849 | if (left < sizeof(struct protocol_list32_t)) { | ||||
4850 | memcpy(&pl, r, left); | ||||
4851 | outs() << " (protocol_list_t entends past the end of the section)\n"; | ||||
4852 | } else | ||||
4853 | memcpy(&pl, r, sizeof(struct protocol_list32_t)); | ||||
4854 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4855 | swapStruct(pl); | ||||
4856 | outs() << " count " << pl.count << "\n"; | ||||
4857 | |||||
4858 | p += sizeof(struct protocol_list32_t); | ||||
4859 | offset += sizeof(struct protocol_list32_t); | ||||
4860 | for (i = 0; i < pl.count; i++) { | ||||
4861 | r = get_pointer_32(p, offset, left, S, info); | ||||
4862 | if (r == nullptr) | ||||
4863 | return; | ||||
4864 | q = 0; | ||||
4865 | if (left < sizeof(uint32_t)) { | ||||
4866 | memcpy(&q, r, left); | ||||
4867 | outs() << " (protocol_t * entends past the end of the section)\n"; | ||||
4868 | } else | ||||
4869 | memcpy(&q, r, sizeof(uint32_t)); | ||||
4870 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4871 | sys::swapByteOrder(q); | ||||
4872 | outs() << "\t\t list[" << i << "] " << format("0x%" PRIx32"x", q) | ||||
4873 | << " (struct protocol_t *)\n"; | ||||
4874 | r = get_pointer_32(q, offset, left, S, info); | ||||
4875 | if (r == nullptr) | ||||
4876 | return; | ||||
4877 | memset(&pc, '\0', sizeof(struct protocol32_t)); | ||||
4878 | if (left < sizeof(struct protocol32_t)) { | ||||
4879 | memcpy(&pc, r, left); | ||||
4880 | outs() << " (protocol_t entends past the end of the section)\n"; | ||||
4881 | } else | ||||
4882 | memcpy(&pc, r, sizeof(struct protocol32_t)); | ||||
4883 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4884 | swapStruct(pc); | ||||
4885 | outs() << "\t\t\t isa " << format("0x%" PRIx32"x", pc.isa) << "\n"; | ||||
4886 | outs() << "\t\t\t name " << format("0x%" PRIx32"x", pc.name); | ||||
4887 | name = get_pointer_32(pc.name, xoffset, left, xS, info); | ||||
4888 | if (name != nullptr) | ||||
4889 | outs() << format(" %.*s", left, name); | ||||
4890 | outs() << "\n"; | ||||
4891 | outs() << "\t\t\tprotocols " << format("0x%" PRIx32"x", pc.protocols) << "\n"; | ||||
4892 | outs() << "\t\t instanceMethods " | ||||
4893 | << format("0x%" PRIx32"x", pc.instanceMethods) | ||||
4894 | << " (struct method_list_t *)\n"; | ||||
4895 | if (pc.instanceMethods != 0) | ||||
4896 | print_method_list32_t(pc.instanceMethods, info, "\t"); | ||||
4897 | outs() << "\t\t classMethods " << format("0x%" PRIx32"x", pc.classMethods) | ||||
4898 | << " (struct method_list_t *)\n"; | ||||
4899 | if (pc.classMethods != 0) | ||||
4900 | print_method_list32_t(pc.classMethods, info, "\t"); | ||||
4901 | outs() << "\t optionalInstanceMethods " | ||||
4902 | << format("0x%" PRIx32"x", pc.optionalInstanceMethods) << "\n"; | ||||
4903 | outs() << "\t optionalClassMethods " | ||||
4904 | << format("0x%" PRIx32"x", pc.optionalClassMethods) << "\n"; | ||||
4905 | outs() << "\t instanceProperties " | ||||
4906 | << format("0x%" PRIx32"x", pc.instanceProperties) << "\n"; | ||||
4907 | p += sizeof(uint32_t); | ||||
4908 | offset += sizeof(uint32_t); | ||||
4909 | } | ||||
4910 | } | ||||
4911 | |||||
4912 | static void print_indent(uint32_t indent) { | ||||
4913 | for (uint32_t i = 0; i < indent;) { | ||||
4914 | if (indent - i >= 8) { | ||||
4915 | outs() << "\t"; | ||||
4916 | i += 8; | ||||
4917 | } else { | ||||
4918 | for (uint32_t j = i; j < indent; j++) | ||||
4919 | outs() << " "; | ||||
4920 | return; | ||||
4921 | } | ||||
4922 | } | ||||
4923 | } | ||||
4924 | |||||
4925 | static bool print_method_description_list(uint32_t p, uint32_t indent, | ||||
4926 | struct DisassembleInfo *info) { | ||||
4927 | uint32_t offset, left, xleft; | ||||
4928 | SectionRef S; | ||||
4929 | struct objc_method_description_list_t mdl; | ||||
4930 | struct objc_method_description_t md; | ||||
4931 | const char *r, *list, *name; | ||||
4932 | int32_t i; | ||||
4933 | |||||
4934 | r = get_pointer_32(p, offset, left, S, info, true); | ||||
4935 | if (r == nullptr) | ||||
4936 | return true; | ||||
4937 | |||||
4938 | outs() << "\n"; | ||||
4939 | if (left > sizeof(struct objc_method_description_list_t)) { | ||||
4940 | memcpy(&mdl, r, sizeof(struct objc_method_description_list_t)); | ||||
4941 | } else { | ||||
4942 | print_indent(indent); | ||||
4943 | outs() << " objc_method_description_list extends past end of the section\n"; | ||||
4944 | memset(&mdl, '\0', sizeof(struct objc_method_description_list_t)); | ||||
4945 | memcpy(&mdl, r, left); | ||||
4946 | } | ||||
4947 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4948 | swapStruct(mdl); | ||||
4949 | |||||
4950 | print_indent(indent); | ||||
4951 | outs() << " count " << mdl.count << "\n"; | ||||
4952 | |||||
4953 | list = r + sizeof(struct objc_method_description_list_t); | ||||
4954 | for (i = 0; i < mdl.count; i++) { | ||||
4955 | if ((i + 1) * sizeof(struct objc_method_description_t) > left) { | ||||
4956 | print_indent(indent); | ||||
4957 | outs() << " remaining list entries extend past the of the section\n"; | ||||
4958 | break; | ||||
4959 | } | ||||
4960 | print_indent(indent); | ||||
4961 | outs() << " list[" << i << "]\n"; | ||||
4962 | memcpy(&md, list + i * sizeof(struct objc_method_description_t), | ||||
4963 | sizeof(struct objc_method_description_t)); | ||||
4964 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
4965 | swapStruct(md); | ||||
4966 | |||||
4967 | print_indent(indent); | ||||
4968 | outs() << " name " << format("0x%08" PRIx32"x", md.name); | ||||
4969 | if (info->verbose) { | ||||
4970 | name = get_pointer_32(md.name, offset, xleft, S, info, true); | ||||
4971 | if (name != nullptr) | ||||
4972 | outs() << format(" %.*s", xleft, name); | ||||
4973 | else | ||||
4974 | outs() << " (not in an __OBJC section)"; | ||||
4975 | } | ||||
4976 | outs() << "\n"; | ||||
4977 | |||||
4978 | print_indent(indent); | ||||
4979 | outs() << " types " << format("0x%08" PRIx32"x", md.types); | ||||
4980 | if (info->verbose) { | ||||
4981 | name = get_pointer_32(md.types, offset, xleft, S, info, true); | ||||
4982 | if (name != nullptr) | ||||
4983 | outs() << format(" %.*s", xleft, name); | ||||
4984 | else | ||||
4985 | outs() << " (not in an __OBJC section)"; | ||||
4986 | } | ||||
4987 | outs() << "\n"; | ||||
4988 | } | ||||
4989 | return false; | ||||
4990 | } | ||||
4991 | |||||
4992 | static bool print_protocol_list(uint32_t p, uint32_t indent, | ||||
4993 | struct DisassembleInfo *info); | ||||
4994 | |||||
4995 | static bool print_protocol(uint32_t p, uint32_t indent, | ||||
4996 | struct DisassembleInfo *info) { | ||||
4997 | uint32_t offset, left; | ||||
4998 | SectionRef S; | ||||
4999 | struct objc_protocol_t protocol; | ||||
5000 | const char *r, *name; | ||||
5001 | |||||
5002 | r = get_pointer_32(p, offset, left, S, info, true); | ||||
5003 | if (r == nullptr) | ||||
5004 | return true; | ||||
5005 | |||||
5006 | outs() << "\n"; | ||||
5007 | if (left >= sizeof(struct objc_protocol_t)) { | ||||
5008 | memcpy(&protocol, r, sizeof(struct objc_protocol_t)); | ||||
5009 | } else { | ||||
5010 | print_indent(indent); | ||||
5011 | outs() << " Protocol extends past end of the section\n"; | ||||
5012 | memset(&protocol, '\0', sizeof(struct objc_protocol_t)); | ||||
5013 | memcpy(&protocol, r, left); | ||||
5014 | } | ||||
5015 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5016 | swapStruct(protocol); | ||||
5017 | |||||
5018 | print_indent(indent); | ||||
5019 | outs() << " isa " << format("0x%08" PRIx32"x", protocol.isa) | ||||
5020 | << "\n"; | ||||
5021 | |||||
5022 | print_indent(indent); | ||||
5023 | outs() << " protocol_name " | ||||
5024 | << format("0x%08" PRIx32"x", protocol.protocol_name); | ||||
5025 | if (info->verbose) { | ||||
5026 | name = get_pointer_32(protocol.protocol_name, offset, left, S, info, true); | ||||
5027 | if (name != nullptr) | ||||
5028 | outs() << format(" %.*s", left, name); | ||||
5029 | else | ||||
5030 | outs() << " (not in an __OBJC section)"; | ||||
5031 | } | ||||
5032 | outs() << "\n"; | ||||
5033 | |||||
5034 | print_indent(indent); | ||||
5035 | outs() << " protocol_list " | ||||
5036 | << format("0x%08" PRIx32"x", protocol.protocol_list); | ||||
5037 | if (print_protocol_list(protocol.protocol_list, indent + 4, info)) | ||||
5038 | outs() << " (not in an __OBJC section)\n"; | ||||
5039 | |||||
5040 | print_indent(indent); | ||||
5041 | outs() << " instance_methods " | ||||
5042 | << format("0x%08" PRIx32"x", protocol.instance_methods); | ||||
5043 | if (print_method_description_list(protocol.instance_methods, indent, info)) | ||||
5044 | outs() << " (not in an __OBJC section)\n"; | ||||
5045 | |||||
5046 | print_indent(indent); | ||||
5047 | outs() << " class_methods " | ||||
5048 | << format("0x%08" PRIx32"x", protocol.class_methods); | ||||
5049 | if (print_method_description_list(protocol.class_methods, indent, info)) | ||||
5050 | outs() << " (not in an __OBJC section)\n"; | ||||
5051 | |||||
5052 | return false; | ||||
5053 | } | ||||
5054 | |||||
5055 | static bool print_protocol_list(uint32_t p, uint32_t indent, | ||||
5056 | struct DisassembleInfo *info) { | ||||
5057 | uint32_t offset, left, l; | ||||
5058 | SectionRef S; | ||||
5059 | struct objc_protocol_list_t protocol_list; | ||||
5060 | const char *r, *list; | ||||
5061 | int32_t i; | ||||
5062 | |||||
5063 | r = get_pointer_32(p, offset, left, S, info, true); | ||||
5064 | if (r == nullptr) | ||||
5065 | return true; | ||||
5066 | |||||
5067 | outs() << "\n"; | ||||
5068 | if (left > sizeof(struct objc_protocol_list_t)) { | ||||
5069 | memcpy(&protocol_list, r, sizeof(struct objc_protocol_list_t)); | ||||
5070 | } else { | ||||
5071 | outs() << "\t\t objc_protocol_list_t extends past end of the section\n"; | ||||
5072 | memset(&protocol_list, '\0', sizeof(struct objc_protocol_list_t)); | ||||
5073 | memcpy(&protocol_list, r, left); | ||||
5074 | } | ||||
5075 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5076 | swapStruct(protocol_list); | ||||
5077 | |||||
5078 | print_indent(indent); | ||||
5079 | outs() << " next " << format("0x%08" PRIx32"x", protocol_list.next) | ||||
5080 | << "\n"; | ||||
5081 | print_indent(indent); | ||||
5082 | outs() << " count " << protocol_list.count << "\n"; | ||||
5083 | |||||
5084 | list = r + sizeof(struct objc_protocol_list_t); | ||||
5085 | for (i = 0; i < protocol_list.count; i++) { | ||||
5086 | if ((i + 1) * sizeof(uint32_t) > left) { | ||||
5087 | outs() << "\t\t remaining list entries extend past the of the section\n"; | ||||
5088 | break; | ||||
5089 | } | ||||
5090 | memcpy(&l, list + i * sizeof(uint32_t), sizeof(uint32_t)); | ||||
5091 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5092 | sys::swapByteOrder(l); | ||||
5093 | |||||
5094 | print_indent(indent); | ||||
5095 | outs() << " list[" << i << "] " << format("0x%08" PRIx32"x", l); | ||||
5096 | if (print_protocol(l, indent, info)) | ||||
5097 | outs() << "(not in an __OBJC section)\n"; | ||||
5098 | } | ||||
5099 | return false; | ||||
5100 | } | ||||
5101 | |||||
5102 | static void print_ivar_list64_t(uint64_t p, struct DisassembleInfo *info) { | ||||
5103 | struct ivar_list64_t il; | ||||
5104 | struct ivar64_t i; | ||||
5105 | const char *r; | ||||
5106 | uint32_t offset, xoffset, left, j; | ||||
5107 | SectionRef S, xS; | ||||
5108 | const char *name, *sym_name, *ivar_offset_p; | ||||
5109 | uint64_t ivar_offset, n_value; | ||||
5110 | |||||
5111 | r = get_pointer_64(p, offset, left, S, info); | ||||
5112 | if (r == nullptr) | ||||
5113 | return; | ||||
5114 | memset(&il, '\0', sizeof(struct ivar_list64_t)); | ||||
5115 | if (left < sizeof(struct ivar_list64_t)) { | ||||
5116 | memcpy(&il, r, left); | ||||
5117 | outs() << " (ivar_list_t entends past the end of the section)\n"; | ||||
5118 | } else | ||||
5119 | memcpy(&il, r, sizeof(struct ivar_list64_t)); | ||||
5120 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5121 | swapStruct(il); | ||||
5122 | outs() << " entsize " << il.entsize << "\n"; | ||||
5123 | outs() << " count " << il.count << "\n"; | ||||
5124 | |||||
5125 | p += sizeof(struct ivar_list64_t); | ||||
5126 | offset += sizeof(struct ivar_list64_t); | ||||
5127 | for (j = 0; j < il.count; j++) { | ||||
5128 | r = get_pointer_64(p, offset, left, S, info); | ||||
5129 | if (r == nullptr) | ||||
5130 | return; | ||||
5131 | memset(&i, '\0', sizeof(struct ivar64_t)); | ||||
5132 | if (left < sizeof(struct ivar64_t)) { | ||||
5133 | memcpy(&i, r, left); | ||||
5134 | outs() << " (ivar_t entends past the end of the section)\n"; | ||||
5135 | } else | ||||
5136 | memcpy(&i, r, sizeof(struct ivar64_t)); | ||||
5137 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5138 | swapStruct(i); | ||||
5139 | |||||
5140 | outs() << "\t\t\t offset "; | ||||
5141 | sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, offset)__builtin_offsetof(struct ivar64_t, offset), S, | ||||
5142 | info, n_value, i.offset); | ||||
5143 | if (n_value != 0) { | ||||
5144 | if (info->verbose && sym_name != nullptr) | ||||
5145 | outs() << sym_name; | ||||
5146 | else | ||||
5147 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5148 | if (i.offset != 0) | ||||
5149 | outs() << " + " << format("0x%" PRIx64"l" "x", i.offset); | ||||
5150 | } else | ||||
5151 | outs() << format("0x%" PRIx64"l" "x", i.offset); | ||||
5152 | ivar_offset_p = get_pointer_64(i.offset + n_value, xoffset, left, xS, info); | ||||
5153 | if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) { | ||||
5154 | memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset)); | ||||
5155 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5156 | sys::swapByteOrder(ivar_offset); | ||||
5157 | outs() << " " << ivar_offset << "\n"; | ||||
5158 | } else | ||||
5159 | outs() << "\n"; | ||||
5160 | |||||
5161 | outs() << "\t\t\t name "; | ||||
5162 | sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, name)__builtin_offsetof(struct ivar64_t, name), S, info, | ||||
5163 | n_value, i.name); | ||||
5164 | if (n_value != 0) { | ||||
5165 | if (info->verbose && sym_name != nullptr) | ||||
5166 | outs() << sym_name; | ||||
5167 | else | ||||
5168 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5169 | if (i.name != 0) | ||||
5170 | outs() << " + " << format("0x%" PRIx64"l" "x", i.name); | ||||
5171 | } else | ||||
5172 | outs() << format("0x%" PRIx64"l" "x", i.name); | ||||
5173 | name = get_pointer_64(i.name + n_value, xoffset, left, xS, info); | ||||
5174 | if (name != nullptr) | ||||
5175 | outs() << format(" %.*s", left, name); | ||||
5176 | outs() << "\n"; | ||||
5177 | |||||
5178 | outs() << "\t\t\t type "; | ||||
5179 | sym_name = get_symbol_64(offset + offsetof(struct ivar64_t, type)__builtin_offsetof(struct ivar64_t, type), S, info, | ||||
5180 | n_value, i.name); | ||||
5181 | name = get_pointer_64(i.type + n_value, xoffset, left, xS, info); | ||||
5182 | if (n_value != 0) { | ||||
5183 | if (info->verbose && sym_name != nullptr) | ||||
5184 | outs() << sym_name; | ||||
5185 | else | ||||
5186 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5187 | if (i.type != 0) | ||||
5188 | outs() << " + " << format("0x%" PRIx64"l" "x", i.type); | ||||
5189 | } else | ||||
5190 | outs() << format("0x%" PRIx64"l" "x", i.type); | ||||
5191 | if (name != nullptr) | ||||
5192 | outs() << format(" %.*s", left, name); | ||||
5193 | outs() << "\n"; | ||||
5194 | |||||
5195 | outs() << "\t\t\talignment " << i.alignment << "\n"; | ||||
5196 | outs() << "\t\t\t size " << i.size << "\n"; | ||||
5197 | |||||
5198 | p += sizeof(struct ivar64_t); | ||||
5199 | offset += sizeof(struct ivar64_t); | ||||
5200 | } | ||||
5201 | } | ||||
5202 | |||||
5203 | static void print_ivar_list32_t(uint32_t p, struct DisassembleInfo *info) { | ||||
5204 | struct ivar_list32_t il; | ||||
5205 | struct ivar32_t i; | ||||
5206 | const char *r; | ||||
5207 | uint32_t offset, xoffset, left, j; | ||||
5208 | SectionRef S, xS; | ||||
5209 | const char *name, *ivar_offset_p; | ||||
5210 | uint32_t ivar_offset; | ||||
5211 | |||||
5212 | r = get_pointer_32(p, offset, left, S, info); | ||||
5213 | if (r == nullptr) | ||||
5214 | return; | ||||
5215 | memset(&il, '\0', sizeof(struct ivar_list32_t)); | ||||
5216 | if (left < sizeof(struct ivar_list32_t)) { | ||||
5217 | memcpy(&il, r, left); | ||||
5218 | outs() << " (ivar_list_t entends past the end of the section)\n"; | ||||
5219 | } else | ||||
5220 | memcpy(&il, r, sizeof(struct ivar_list32_t)); | ||||
5221 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5222 | swapStruct(il); | ||||
5223 | outs() << " entsize " << il.entsize << "\n"; | ||||
5224 | outs() << " count " << il.count << "\n"; | ||||
5225 | |||||
5226 | p += sizeof(struct ivar_list32_t); | ||||
5227 | offset += sizeof(struct ivar_list32_t); | ||||
5228 | for (j = 0; j < il.count; j++) { | ||||
5229 | r = get_pointer_32(p, offset, left, S, info); | ||||
5230 | if (r == nullptr) | ||||
5231 | return; | ||||
5232 | memset(&i, '\0', sizeof(struct ivar32_t)); | ||||
5233 | if (left < sizeof(struct ivar32_t)) { | ||||
5234 | memcpy(&i, r, left); | ||||
5235 | outs() << " (ivar_t entends past the end of the section)\n"; | ||||
5236 | } else | ||||
5237 | memcpy(&i, r, sizeof(struct ivar32_t)); | ||||
5238 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5239 | swapStruct(i); | ||||
5240 | |||||
5241 | outs() << "\t\t\t offset " << format("0x%" PRIx32"x", i.offset); | ||||
5242 | ivar_offset_p = get_pointer_32(i.offset, xoffset, left, xS, info); | ||||
5243 | if (ivar_offset_p != nullptr && left >= sizeof(*ivar_offset_p)) { | ||||
5244 | memcpy(&ivar_offset, ivar_offset_p, sizeof(ivar_offset)); | ||||
5245 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5246 | sys::swapByteOrder(ivar_offset); | ||||
5247 | outs() << " " << ivar_offset << "\n"; | ||||
5248 | } else | ||||
5249 | outs() << "\n"; | ||||
5250 | |||||
5251 | outs() << "\t\t\t name " << format("0x%" PRIx32"x", i.name); | ||||
5252 | name = get_pointer_32(i.name, xoffset, left, xS, info); | ||||
5253 | if (name != nullptr) | ||||
5254 | outs() << format(" %.*s", left, name); | ||||
5255 | outs() << "\n"; | ||||
5256 | |||||
5257 | outs() << "\t\t\t type " << format("0x%" PRIx32"x", i.type); | ||||
5258 | name = get_pointer_32(i.type, xoffset, left, xS, info); | ||||
5259 | if (name != nullptr) | ||||
5260 | outs() << format(" %.*s", left, name); | ||||
5261 | outs() << "\n"; | ||||
5262 | |||||
5263 | outs() << "\t\t\talignment " << i.alignment << "\n"; | ||||
5264 | outs() << "\t\t\t size " << i.size << "\n"; | ||||
5265 | |||||
5266 | p += sizeof(struct ivar32_t); | ||||
5267 | offset += sizeof(struct ivar32_t); | ||||
5268 | } | ||||
5269 | } | ||||
5270 | |||||
5271 | static void print_objc_property_list64(uint64_t p, | ||||
5272 | struct DisassembleInfo *info) { | ||||
5273 | struct objc_property_list64 opl; | ||||
5274 | struct objc_property64 op; | ||||
5275 | const char *r; | ||||
5276 | uint32_t offset, xoffset, left, j; | ||||
5277 | SectionRef S, xS; | ||||
5278 | const char *name, *sym_name; | ||||
5279 | uint64_t n_value; | ||||
5280 | |||||
5281 | r = get_pointer_64(p, offset, left, S, info); | ||||
5282 | if (r == nullptr) | ||||
5283 | return; | ||||
5284 | memset(&opl, '\0', sizeof(struct objc_property_list64)); | ||||
5285 | if (left < sizeof(struct objc_property_list64)) { | ||||
5286 | memcpy(&opl, r, left); | ||||
5287 | outs() << " (objc_property_list entends past the end of the section)\n"; | ||||
5288 | } else | ||||
5289 | memcpy(&opl, r, sizeof(struct objc_property_list64)); | ||||
5290 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5291 | swapStruct(opl); | ||||
5292 | outs() << " entsize " << opl.entsize << "\n"; | ||||
5293 | outs() << " count " << opl.count << "\n"; | ||||
5294 | |||||
5295 | p += sizeof(struct objc_property_list64); | ||||
5296 | offset += sizeof(struct objc_property_list64); | ||||
5297 | for (j = 0; j < opl.count; j++) { | ||||
5298 | r = get_pointer_64(p, offset, left, S, info); | ||||
5299 | if (r == nullptr) | ||||
5300 | return; | ||||
5301 | memset(&op, '\0', sizeof(struct objc_property64)); | ||||
5302 | if (left < sizeof(struct objc_property64)) { | ||||
5303 | memcpy(&op, r, left); | ||||
5304 | outs() << " (objc_property entends past the end of the section)\n"; | ||||
5305 | } else | ||||
5306 | memcpy(&op, r, sizeof(struct objc_property64)); | ||||
5307 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5308 | swapStruct(op); | ||||
5309 | |||||
5310 | outs() << "\t\t\t name "; | ||||
5311 | sym_name = get_symbol_64(offset + offsetof(struct objc_property64, name)__builtin_offsetof(struct objc_property64, name), S, | ||||
5312 | info, n_value, op.name); | ||||
5313 | if (n_value != 0) { | ||||
5314 | if (info->verbose && sym_name != nullptr) | ||||
5315 | outs() << sym_name; | ||||
5316 | else | ||||
5317 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5318 | if (op.name != 0) | ||||
5319 | outs() << " + " << format("0x%" PRIx64"l" "x", op.name); | ||||
5320 | } else | ||||
5321 | outs() << format("0x%" PRIx64"l" "x", op.name); | ||||
5322 | name = get_pointer_64(op.name + n_value, xoffset, left, xS, info); | ||||
5323 | if (name != nullptr) | ||||
5324 | outs() << format(" %.*s", left, name); | ||||
5325 | outs() << "\n"; | ||||
5326 | |||||
5327 | outs() << "\t\t\tattributes "; | ||||
5328 | sym_name = | ||||
5329 | get_symbol_64(offset + offsetof(struct objc_property64, attributes)__builtin_offsetof(struct objc_property64, attributes), S, | ||||
5330 | info, n_value, op.attributes); | ||||
5331 | if (n_value != 0) { | ||||
5332 | if (info->verbose && sym_name != nullptr) | ||||
5333 | outs() << sym_name; | ||||
5334 | else | ||||
5335 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5336 | if (op.attributes != 0) | ||||
5337 | outs() << " + " << format("0x%" PRIx64"l" "x", op.attributes); | ||||
5338 | } else | ||||
5339 | outs() << format("0x%" PRIx64"l" "x", op.attributes); | ||||
5340 | name = get_pointer_64(op.attributes + n_value, xoffset, left, xS, info); | ||||
5341 | if (name != nullptr) | ||||
5342 | outs() << format(" %.*s", left, name); | ||||
5343 | outs() << "\n"; | ||||
5344 | |||||
5345 | p += sizeof(struct objc_property64); | ||||
5346 | offset += sizeof(struct objc_property64); | ||||
5347 | } | ||||
5348 | } | ||||
5349 | |||||
5350 | static void print_objc_property_list32(uint32_t p, | ||||
5351 | struct DisassembleInfo *info) { | ||||
5352 | struct objc_property_list32 opl; | ||||
5353 | struct objc_property32 op; | ||||
5354 | const char *r; | ||||
5355 | uint32_t offset, xoffset, left, j; | ||||
5356 | SectionRef S, xS; | ||||
5357 | const char *name; | ||||
5358 | |||||
5359 | r = get_pointer_32(p, offset, left, S, info); | ||||
5360 | if (r == nullptr) | ||||
5361 | return; | ||||
5362 | memset(&opl, '\0', sizeof(struct objc_property_list32)); | ||||
5363 | if (left < sizeof(struct objc_property_list32)) { | ||||
5364 | memcpy(&opl, r, left); | ||||
5365 | outs() << " (objc_property_list entends past the end of the section)\n"; | ||||
5366 | } else | ||||
5367 | memcpy(&opl, r, sizeof(struct objc_property_list32)); | ||||
5368 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5369 | swapStruct(opl); | ||||
5370 | outs() << " entsize " << opl.entsize << "\n"; | ||||
5371 | outs() << " count " << opl.count << "\n"; | ||||
5372 | |||||
5373 | p += sizeof(struct objc_property_list32); | ||||
5374 | offset += sizeof(struct objc_property_list32); | ||||
5375 | for (j = 0; j < opl.count; j++) { | ||||
5376 | r = get_pointer_32(p, offset, left, S, info); | ||||
5377 | if (r == nullptr) | ||||
5378 | return; | ||||
5379 | memset(&op, '\0', sizeof(struct objc_property32)); | ||||
5380 | if (left < sizeof(struct objc_property32)) { | ||||
5381 | memcpy(&op, r, left); | ||||
5382 | outs() << " (objc_property entends past the end of the section)\n"; | ||||
5383 | } else | ||||
5384 | memcpy(&op, r, sizeof(struct objc_property32)); | ||||
5385 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5386 | swapStruct(op); | ||||
5387 | |||||
5388 | outs() << "\t\t\t name " << format("0x%" PRIx32"x", op.name); | ||||
5389 | name = get_pointer_32(op.name, xoffset, left, xS, info); | ||||
5390 | if (name != nullptr) | ||||
5391 | outs() << format(" %.*s", left, name); | ||||
5392 | outs() << "\n"; | ||||
5393 | |||||
5394 | outs() << "\t\t\tattributes " << format("0x%" PRIx32"x", op.attributes); | ||||
5395 | name = get_pointer_32(op.attributes, xoffset, left, xS, info); | ||||
5396 | if (name != nullptr) | ||||
5397 | outs() << format(" %.*s", left, name); | ||||
5398 | outs() << "\n"; | ||||
5399 | |||||
5400 | p += sizeof(struct objc_property32); | ||||
5401 | offset += sizeof(struct objc_property32); | ||||
5402 | } | ||||
5403 | } | ||||
5404 | |||||
5405 | static bool print_class_ro64_t(uint64_t p, struct DisassembleInfo *info, | ||||
5406 | bool &is_meta_class) { | ||||
5407 | struct class_ro64_t cro; | ||||
5408 | const char *r; | ||||
5409 | uint32_t offset, xoffset, left; | ||||
5410 | SectionRef S, xS; | ||||
5411 | const char *name, *sym_name; | ||||
5412 | uint64_t n_value; | ||||
5413 | |||||
5414 | r = get_pointer_64(p, offset, left, S, info); | ||||
5415 | if (r == nullptr || left < sizeof(struct class_ro64_t)) | ||||
5416 | return false; | ||||
5417 | memcpy(&cro, r, sizeof(struct class_ro64_t)); | ||||
5418 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5419 | swapStruct(cro); | ||||
5420 | outs() << " flags " << format("0x%" PRIx32"x", cro.flags); | ||||
5421 | if (cro.flags & RO_META(1 << 0)) | ||||
5422 | outs() << " RO_META"; | ||||
5423 | if (cro.flags & RO_ROOT(1 << 1)) | ||||
5424 | outs() << " RO_ROOT"; | ||||
5425 | if (cro.flags & RO_HAS_CXX_STRUCTORS(1 << 2)) | ||||
5426 | outs() << " RO_HAS_CXX_STRUCTORS"; | ||||
5427 | outs() << "\n"; | ||||
5428 | outs() << " instanceStart " << cro.instanceStart << "\n"; | ||||
5429 | outs() << " instanceSize " << cro.instanceSize << "\n"; | ||||
5430 | outs() << " reserved " << format("0x%" PRIx32"x", cro.reserved) | ||||
5431 | << "\n"; | ||||
5432 | outs() << " ivarLayout " << format("0x%" PRIx64"l" "x", cro.ivarLayout) | ||||
5433 | << "\n"; | ||||
5434 | print_layout_map64(cro.ivarLayout, info); | ||||
5435 | |||||
5436 | outs() << " name "; | ||||
5437 | sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, name)__builtin_offsetof(struct class_ro64_t, name), S, | ||||
5438 | info, n_value, cro.name); | ||||
5439 | if (n_value != 0) { | ||||
5440 | if (info->verbose && sym_name != nullptr) | ||||
5441 | outs() << sym_name; | ||||
5442 | else | ||||
5443 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5444 | if (cro.name != 0) | ||||
5445 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.name); | ||||
5446 | } else | ||||
5447 | outs() << format("0x%" PRIx64"l" "x", cro.name); | ||||
5448 | name = get_pointer_64(cro.name + n_value, xoffset, left, xS, info); | ||||
5449 | if (name != nullptr) | ||||
5450 | outs() << format(" %.*s", left, name); | ||||
5451 | outs() << "\n"; | ||||
5452 | |||||
5453 | outs() << " baseMethods "; | ||||
5454 | sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, baseMethods)__builtin_offsetof(struct class_ro64_t, baseMethods), | ||||
5455 | S, info, n_value, cro.baseMethods); | ||||
5456 | if (n_value != 0) { | ||||
5457 | if (info->verbose && sym_name != nullptr) | ||||
5458 | outs() << sym_name; | ||||
5459 | else | ||||
5460 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5461 | if (cro.baseMethods != 0) | ||||
5462 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseMethods); | ||||
5463 | } else | ||||
5464 | outs() << format("0x%" PRIx64"l" "x", cro.baseMethods); | ||||
5465 | outs() << " (struct method_list_t *)\n"; | ||||
5466 | if (cro.baseMethods + n_value != 0) | ||||
5467 | print_method_list64_t(cro.baseMethods + n_value, info, ""); | ||||
5468 | |||||
5469 | outs() << " baseProtocols "; | ||||
5470 | sym_name = | ||||
5471 | get_symbol_64(offset + offsetof(struct class_ro64_t, baseProtocols)__builtin_offsetof(struct class_ro64_t, baseProtocols), S, | ||||
5472 | info, n_value, cro.baseProtocols); | ||||
5473 | if (n_value != 0) { | ||||
5474 | if (info->verbose && sym_name != nullptr) | ||||
5475 | outs() << sym_name; | ||||
5476 | else | ||||
5477 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5478 | if (cro.baseProtocols != 0) | ||||
5479 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseProtocols); | ||||
5480 | } else | ||||
5481 | outs() << format("0x%" PRIx64"l" "x", cro.baseProtocols); | ||||
5482 | outs() << "\n"; | ||||
5483 | if (cro.baseProtocols + n_value != 0) | ||||
5484 | print_protocol_list64_t(cro.baseProtocols + n_value, info); | ||||
5485 | |||||
5486 | outs() << " ivars "; | ||||
5487 | sym_name = get_symbol_64(offset + offsetof(struct class_ro64_t, ivars)__builtin_offsetof(struct class_ro64_t, ivars), S, | ||||
5488 | info, n_value, cro.ivars); | ||||
5489 | if (n_value != 0) { | ||||
5490 | if (info->verbose && sym_name != nullptr) | ||||
5491 | outs() << sym_name; | ||||
5492 | else | ||||
5493 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5494 | if (cro.ivars != 0) | ||||
5495 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.ivars); | ||||
5496 | } else | ||||
5497 | outs() << format("0x%" PRIx64"l" "x", cro.ivars); | ||||
5498 | outs() << "\n"; | ||||
5499 | if (cro.ivars + n_value != 0) | ||||
5500 | print_ivar_list64_t(cro.ivars + n_value, info); | ||||
5501 | |||||
5502 | outs() << " weakIvarLayout "; | ||||
5503 | sym_name = | ||||
5504 | get_symbol_64(offset + offsetof(struct class_ro64_t, weakIvarLayout)__builtin_offsetof(struct class_ro64_t, weakIvarLayout), S, | ||||
5505 | info, n_value, cro.weakIvarLayout); | ||||
5506 | if (n_value != 0) { | ||||
5507 | if (info->verbose && sym_name != nullptr) | ||||
5508 | outs() << sym_name; | ||||
5509 | else | ||||
5510 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5511 | if (cro.weakIvarLayout != 0) | ||||
5512 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.weakIvarLayout); | ||||
5513 | } else | ||||
5514 | outs() << format("0x%" PRIx64"l" "x", cro.weakIvarLayout); | ||||
5515 | outs() << "\n"; | ||||
5516 | print_layout_map64(cro.weakIvarLayout + n_value, info); | ||||
5517 | |||||
5518 | outs() << " baseProperties "; | ||||
5519 | sym_name = | ||||
5520 | get_symbol_64(offset + offsetof(struct class_ro64_t, baseProperties)__builtin_offsetof(struct class_ro64_t, baseProperties), S, | ||||
5521 | info, n_value, cro.baseProperties); | ||||
5522 | if (n_value != 0) { | ||||
5523 | if (info->verbose && sym_name != nullptr) | ||||
5524 | outs() << sym_name; | ||||
5525 | else | ||||
5526 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5527 | if (cro.baseProperties != 0) | ||||
5528 | outs() << " + " << format("0x%" PRIx64"l" "x", cro.baseProperties); | ||||
5529 | } else | ||||
5530 | outs() << format("0x%" PRIx64"l" "x", cro.baseProperties); | ||||
5531 | outs() << "\n"; | ||||
5532 | if (cro.baseProperties + n_value != 0) | ||||
5533 | print_objc_property_list64(cro.baseProperties + n_value, info); | ||||
5534 | |||||
5535 | is_meta_class = (cro.flags & RO_META(1 << 0)) != 0; | ||||
5536 | return true; | ||||
5537 | } | ||||
5538 | |||||
5539 | static bool print_class_ro32_t(uint32_t p, struct DisassembleInfo *info, | ||||
5540 | bool &is_meta_class) { | ||||
5541 | struct class_ro32_t cro; | ||||
5542 | const char *r; | ||||
5543 | uint32_t offset, xoffset, left; | ||||
5544 | SectionRef S, xS; | ||||
5545 | const char *name; | ||||
5546 | |||||
5547 | r = get_pointer_32(p, offset, left, S, info); | ||||
5548 | if (r == nullptr) | ||||
5549 | return false; | ||||
5550 | memset(&cro, '\0', sizeof(struct class_ro32_t)); | ||||
5551 | if (left < sizeof(struct class_ro32_t)) { | ||||
5552 | memcpy(&cro, r, left); | ||||
5553 | outs() << " (class_ro_t entends past the end of the section)\n"; | ||||
5554 | } else | ||||
5555 | memcpy(&cro, r, sizeof(struct class_ro32_t)); | ||||
5556 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5557 | swapStruct(cro); | ||||
5558 | outs() << " flags " << format("0x%" PRIx32"x", cro.flags); | ||||
5559 | if (cro.flags & RO_META(1 << 0)) | ||||
5560 | outs() << " RO_META"; | ||||
5561 | if (cro.flags & RO_ROOT(1 << 1)) | ||||
5562 | outs() << " RO_ROOT"; | ||||
5563 | if (cro.flags & RO_HAS_CXX_STRUCTORS(1 << 2)) | ||||
5564 | outs() << " RO_HAS_CXX_STRUCTORS"; | ||||
5565 | outs() << "\n"; | ||||
5566 | outs() << " instanceStart " << cro.instanceStart << "\n"; | ||||
5567 | outs() << " instanceSize " << cro.instanceSize << "\n"; | ||||
5568 | outs() << " ivarLayout " << format("0x%" PRIx32"x", cro.ivarLayout) | ||||
5569 | << "\n"; | ||||
5570 | print_layout_map32(cro.ivarLayout, info); | ||||
5571 | |||||
5572 | outs() << " name " << format("0x%" PRIx32"x", cro.name); | ||||
5573 | name = get_pointer_32(cro.name, xoffset, left, xS, info); | ||||
5574 | if (name != nullptr) | ||||
5575 | outs() << format(" %.*s", left, name); | ||||
5576 | outs() << "\n"; | ||||
5577 | |||||
5578 | outs() << " baseMethods " | ||||
5579 | << format("0x%" PRIx32"x", cro.baseMethods) | ||||
5580 | << " (struct method_list_t *)\n"; | ||||
5581 | if (cro.baseMethods != 0) | ||||
5582 | print_method_list32_t(cro.baseMethods, info, ""); | ||||
5583 | |||||
5584 | outs() << " baseProtocols " | ||||
5585 | << format("0x%" PRIx32"x", cro.baseProtocols) << "\n"; | ||||
5586 | if (cro.baseProtocols != 0) | ||||
5587 | print_protocol_list32_t(cro.baseProtocols, info); | ||||
5588 | outs() << " ivars " << format("0x%" PRIx32"x", cro.ivars) | ||||
5589 | << "\n"; | ||||
5590 | if (cro.ivars != 0) | ||||
5591 | print_ivar_list32_t(cro.ivars, info); | ||||
5592 | outs() << " weakIvarLayout " | ||||
5593 | << format("0x%" PRIx32"x", cro.weakIvarLayout) << "\n"; | ||||
5594 | print_layout_map32(cro.weakIvarLayout, info); | ||||
5595 | outs() << " baseProperties " | ||||
5596 | << format("0x%" PRIx32"x", cro.baseProperties) << "\n"; | ||||
5597 | if (cro.baseProperties != 0) | ||||
5598 | print_objc_property_list32(cro.baseProperties, info); | ||||
5599 | is_meta_class = (cro.flags & RO_META(1 << 0)) != 0; | ||||
5600 | return true; | ||||
5601 | } | ||||
5602 | |||||
5603 | static void print_class64_t(uint64_t p, struct DisassembleInfo *info) { | ||||
5604 | struct class64_t c; | ||||
5605 | const char *r; | ||||
5606 | uint32_t offset, left; | ||||
5607 | SectionRef S; | ||||
5608 | const char *name; | ||||
5609 | uint64_t isa_n_value, n_value; | ||||
5610 | |||||
5611 | r = get_pointer_64(p, offset, left, S, info); | ||||
5612 | if (r == nullptr || left < sizeof(struct class64_t)) | ||||
5613 | return; | ||||
5614 | memcpy(&c, r, sizeof(struct class64_t)); | ||||
5615 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5616 | swapStruct(c); | ||||
5617 | |||||
5618 | outs() << " isa " << format("0x%" PRIx64"l" "x", c.isa); | ||||
5619 | name = get_symbol_64(offset + offsetof(struct class64_t, isa)__builtin_offsetof(struct class64_t, isa), S, info, | ||||
5620 | isa_n_value, c.isa); | ||||
5621 | if (name != nullptr) | ||||
5622 | outs() << " " << name; | ||||
5623 | outs() << "\n"; | ||||
5624 | |||||
5625 | outs() << " superclass " << format("0x%" PRIx64"l" "x", c.superclass); | ||||
5626 | name = get_symbol_64(offset + offsetof(struct class64_t, superclass)__builtin_offsetof(struct class64_t, superclass), S, info, | ||||
5627 | n_value, c.superclass); | ||||
5628 | if (name != nullptr) | ||||
5629 | outs() << " " << name; | ||||
5630 | else { | ||||
5631 | name = get_dyld_bind_info_symbolname(S.getAddress() + | ||||
5632 | offset + offsetof(struct class64_t, superclass)__builtin_offsetof(struct class64_t, superclass), info); | ||||
5633 | if (name != nullptr) | ||||
5634 | outs() << " " << name; | ||||
5635 | } | ||||
5636 | outs() << "\n"; | ||||
5637 | |||||
5638 | outs() << " cache " << format("0x%" PRIx64"l" "x", c.cache); | ||||
5639 | name = get_symbol_64(offset + offsetof(struct class64_t, cache)__builtin_offsetof(struct class64_t, cache), S, info, | ||||
5640 | n_value, c.cache); | ||||
5641 | if (name != nullptr) | ||||
5642 | outs() << " " << name; | ||||
5643 | outs() << "\n"; | ||||
5644 | |||||
5645 | outs() << " vtable " << format("0x%" PRIx64"l" "x", c.vtable); | ||||
5646 | name = get_symbol_64(offset + offsetof(struct class64_t, vtable)__builtin_offsetof(struct class64_t, vtable), S, info, | ||||
5647 | n_value, c.vtable); | ||||
5648 | if (name != nullptr) | ||||
5649 | outs() << " " << name; | ||||
5650 | outs() << "\n"; | ||||
5651 | |||||
5652 | name = get_symbol_64(offset + offsetof(struct class64_t, data)__builtin_offsetof(struct class64_t, data), S, info, | ||||
5653 | n_value, c.data); | ||||
5654 | outs() << " data "; | ||||
5655 | if (n_value != 0) { | ||||
5656 | if (info->verbose && name != nullptr) | ||||
5657 | outs() << name; | ||||
5658 | else | ||||
5659 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5660 | if (c.data != 0) | ||||
5661 | outs() << " + " << format("0x%" PRIx64"l" "x", c.data); | ||||
5662 | } else | ||||
5663 | outs() << format("0x%" PRIx64"l" "x", c.data); | ||||
5664 | outs() << " (struct class_ro_t *)"; | ||||
5665 | |||||
5666 | // This is a Swift class if some of the low bits of the pointer are set. | ||||
5667 | if ((c.data + n_value) & 0x7) | ||||
5668 | outs() << " Swift class"; | ||||
5669 | outs() << "\n"; | ||||
5670 | bool is_meta_class; | ||||
5671 | if (!print_class_ro64_t((c.data + n_value) & ~0x7, info, is_meta_class)) | ||||
5672 | return; | ||||
5673 | |||||
5674 | if (!is_meta_class && | ||||
5675 | c.isa + isa_n_value != p && | ||||
5676 | c.isa + isa_n_value != 0 && | ||||
5677 | info->depth < 100) { | ||||
5678 | info->depth++; | ||||
5679 | outs() << "Meta Class\n"; | ||||
5680 | print_class64_t(c.isa + isa_n_value, info); | ||||
5681 | } | ||||
5682 | } | ||||
5683 | |||||
5684 | static void print_class32_t(uint32_t p, struct DisassembleInfo *info) { | ||||
5685 | struct class32_t c; | ||||
5686 | const char *r; | ||||
5687 | uint32_t offset, left; | ||||
5688 | SectionRef S; | ||||
5689 | const char *name; | ||||
5690 | |||||
5691 | r = get_pointer_32(p, offset, left, S, info); | ||||
5692 | if (r == nullptr) | ||||
5693 | return; | ||||
5694 | memset(&c, '\0', sizeof(struct class32_t)); | ||||
5695 | if (left < sizeof(struct class32_t)) { | ||||
5696 | memcpy(&c, r, left); | ||||
5697 | outs() << " (class_t entends past the end of the section)\n"; | ||||
5698 | } else | ||||
5699 | memcpy(&c, r, sizeof(struct class32_t)); | ||||
5700 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5701 | swapStruct(c); | ||||
5702 | |||||
5703 | outs() << " isa " << format("0x%" PRIx32"x", c.isa); | ||||
5704 | name = | ||||
5705 | get_symbol_32(offset + offsetof(struct class32_t, isa)__builtin_offsetof(struct class32_t, isa), S, info, c.isa); | ||||
5706 | if (name != nullptr) | ||||
5707 | outs() << " " << name; | ||||
5708 | outs() << "\n"; | ||||
5709 | |||||
5710 | outs() << " superclass " << format("0x%" PRIx32"x", c.superclass); | ||||
5711 | name = get_symbol_32(offset + offsetof(struct class32_t, superclass)__builtin_offsetof(struct class32_t, superclass), S, info, | ||||
5712 | c.superclass); | ||||
5713 | if (name != nullptr) | ||||
5714 | outs() << " " << name; | ||||
5715 | outs() << "\n"; | ||||
5716 | |||||
5717 | outs() << " cache " << format("0x%" PRIx32"x", c.cache); | ||||
5718 | name = get_symbol_32(offset + offsetof(struct class32_t, cache)__builtin_offsetof(struct class32_t, cache), S, info, | ||||
5719 | c.cache); | ||||
5720 | if (name != nullptr) | ||||
5721 | outs() << " " << name; | ||||
5722 | outs() << "\n"; | ||||
5723 | |||||
5724 | outs() << " vtable " << format("0x%" PRIx32"x", c.vtable); | ||||
5725 | name = get_symbol_32(offset + offsetof(struct class32_t, vtable)__builtin_offsetof(struct class32_t, vtable), S, info, | ||||
5726 | c.vtable); | ||||
5727 | if (name != nullptr) | ||||
5728 | outs() << " " << name; | ||||
5729 | outs() << "\n"; | ||||
5730 | |||||
5731 | name = | ||||
5732 | get_symbol_32(offset + offsetof(struct class32_t, data)__builtin_offsetof(struct class32_t, data), S, info, c.data); | ||||
5733 | outs() << " data " << format("0x%" PRIx32"x", c.data) | ||||
5734 | << " (struct class_ro_t *)"; | ||||
5735 | |||||
5736 | // This is a Swift class if some of the low bits of the pointer are set. | ||||
5737 | if (c.data & 0x3) | ||||
5738 | outs() << " Swift class"; | ||||
5739 | outs() << "\n"; | ||||
5740 | bool is_meta_class; | ||||
5741 | if (!print_class_ro32_t(c.data & ~0x3, info, is_meta_class)) | ||||
5742 | return; | ||||
5743 | |||||
5744 | if (!is_meta_class) { | ||||
5745 | outs() << "Meta Class\n"; | ||||
5746 | print_class32_t(c.isa, info); | ||||
5747 | } | ||||
5748 | } | ||||
5749 | |||||
5750 | static void print_objc_class_t(struct objc_class_t *objc_class, | ||||
5751 | struct DisassembleInfo *info) { | ||||
5752 | uint32_t offset, left, xleft; | ||||
5753 | const char *name, *p, *ivar_list; | ||||
5754 | SectionRef S; | ||||
5755 | int32_t i; | ||||
5756 | struct objc_ivar_list_t objc_ivar_list; | ||||
5757 | struct objc_ivar_t ivar; | ||||
5758 | |||||
5759 | outs() << "\t\t isa " << format("0x%08" PRIx32"x", objc_class->isa); | ||||
5760 | if (info->verbose && CLS_GETINFO(objc_class, CLS_META)((objc_class)->info & (0x2))) { | ||||
5761 | name = get_pointer_32(objc_class->isa, offset, left, S, info, true); | ||||
5762 | if (name != nullptr) | ||||
5763 | outs() << format(" %.*s", left, name); | ||||
5764 | else | ||||
5765 | outs() << " (not in an __OBJC section)"; | ||||
5766 | } | ||||
5767 | outs() << "\n"; | ||||
5768 | |||||
5769 | outs() << "\t super_class " | ||||
5770 | << format("0x%08" PRIx32"x", objc_class->super_class); | ||||
5771 | if (info->verbose) { | ||||
5772 | name = get_pointer_32(objc_class->super_class, offset, left, S, info, true); | ||||
5773 | if (name != nullptr) | ||||
5774 | outs() << format(" %.*s", left, name); | ||||
5775 | else | ||||
5776 | outs() << " (not in an __OBJC section)"; | ||||
5777 | } | ||||
5778 | outs() << "\n"; | ||||
5779 | |||||
5780 | outs() << "\t\t name " << format("0x%08" PRIx32"x", objc_class->name); | ||||
5781 | if (info->verbose) { | ||||
5782 | name = get_pointer_32(objc_class->name, offset, left, S, info, true); | ||||
5783 | if (name != nullptr) | ||||
5784 | outs() << format(" %.*s", left, name); | ||||
5785 | else | ||||
5786 | outs() << " (not in an __OBJC section)"; | ||||
5787 | } | ||||
5788 | outs() << "\n"; | ||||
5789 | |||||
5790 | outs() << "\t\t version " << format("0x%08" PRIx32"x", objc_class->version) | ||||
5791 | << "\n"; | ||||
5792 | |||||
5793 | outs() << "\t\t info " << format("0x%08" PRIx32"x", objc_class->info); | ||||
5794 | if (info->verbose) { | ||||
5795 | if (CLS_GETINFO(objc_class, CLS_CLASS)((objc_class)->info & (0x1))) | ||||
5796 | outs() << " CLS_CLASS"; | ||||
5797 | else if (CLS_GETINFO(objc_class, CLS_META)((objc_class)->info & (0x2))) | ||||
5798 | outs() << " CLS_META"; | ||||
5799 | } | ||||
5800 | outs() << "\n"; | ||||
5801 | |||||
5802 | outs() << "\t instance_size " | ||||
5803 | << format("0x%08" PRIx32"x", objc_class->instance_size) << "\n"; | ||||
5804 | |||||
5805 | p = get_pointer_32(objc_class->ivars, offset, left, S, info, true); | ||||
5806 | outs() << "\t\t ivars " << format("0x%08" PRIx32"x", objc_class->ivars); | ||||
5807 | if (p != nullptr) { | ||||
5808 | if (left > sizeof(struct objc_ivar_list_t)) { | ||||
5809 | outs() << "\n"; | ||||
5810 | memcpy(&objc_ivar_list, p, sizeof(struct objc_ivar_list_t)); | ||||
5811 | } else { | ||||
5812 | outs() << " (entends past the end of the section)\n"; | ||||
5813 | memset(&objc_ivar_list, '\0', sizeof(struct objc_ivar_list_t)); | ||||
5814 | memcpy(&objc_ivar_list, p, left); | ||||
5815 | } | ||||
5816 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5817 | swapStruct(objc_ivar_list); | ||||
5818 | outs() << "\t\t ivar_count " << objc_ivar_list.ivar_count << "\n"; | ||||
5819 | ivar_list = p + sizeof(struct objc_ivar_list_t); | ||||
5820 | for (i = 0; i < objc_ivar_list.ivar_count; i++) { | ||||
5821 | if ((i + 1) * sizeof(struct objc_ivar_t) > left) { | ||||
5822 | outs() << "\t\t remaining ivar's extend past the of the section\n"; | ||||
5823 | break; | ||||
5824 | } | ||||
5825 | memcpy(&ivar, ivar_list + i * sizeof(struct objc_ivar_t), | ||||
5826 | sizeof(struct objc_ivar_t)); | ||||
5827 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5828 | swapStruct(ivar); | ||||
5829 | |||||
5830 | outs() << "\t\t\tivar_name " << format("0x%08" PRIx32"x", ivar.ivar_name); | ||||
5831 | if (info->verbose) { | ||||
5832 | name = get_pointer_32(ivar.ivar_name, offset, xleft, S, info, true); | ||||
5833 | if (name != nullptr) | ||||
5834 | outs() << format(" %.*s", xleft, name); | ||||
5835 | else | ||||
5836 | outs() << " (not in an __OBJC section)"; | ||||
5837 | } | ||||
5838 | outs() << "\n"; | ||||
5839 | |||||
5840 | outs() << "\t\t\tivar_type " << format("0x%08" PRIx32"x", ivar.ivar_type); | ||||
5841 | if (info->verbose) { | ||||
5842 | name = get_pointer_32(ivar.ivar_type, offset, xleft, S, info, true); | ||||
5843 | if (name != nullptr) | ||||
5844 | outs() << format(" %.*s", xleft, name); | ||||
5845 | else | ||||
5846 | outs() << " (not in an __OBJC section)"; | ||||
5847 | } | ||||
5848 | outs() << "\n"; | ||||
5849 | |||||
5850 | outs() << "\t\t ivar_offset " | ||||
5851 | << format("0x%08" PRIx32"x", ivar.ivar_offset) << "\n"; | ||||
5852 | } | ||||
5853 | } else { | ||||
5854 | outs() << " (not in an __OBJC section)\n"; | ||||
5855 | } | ||||
5856 | |||||
5857 | outs() << "\t\t methods " << format("0x%08" PRIx32"x", objc_class->methodLists); | ||||
5858 | if (print_method_list(objc_class->methodLists, info)) | ||||
5859 | outs() << " (not in an __OBJC section)\n"; | ||||
5860 | |||||
5861 | outs() << "\t\t cache " << format("0x%08" PRIx32"x", objc_class->cache) | ||||
5862 | << "\n"; | ||||
5863 | |||||
5864 | outs() << "\t\tprotocols " << format("0x%08" PRIx32"x", objc_class->protocols); | ||||
5865 | if (print_protocol_list(objc_class->protocols, 16, info)) | ||||
5866 | outs() << " (not in an __OBJC section)\n"; | ||||
5867 | } | ||||
5868 | |||||
5869 | static void print_objc_objc_category_t(struct objc_category_t *objc_category, | ||||
5870 | struct DisassembleInfo *info) { | ||||
5871 | uint32_t offset, left; | ||||
5872 | const char *name; | ||||
5873 | SectionRef S; | ||||
5874 | |||||
5875 | outs() << "\t category name " | ||||
5876 | << format("0x%08" PRIx32"x", objc_category->category_name); | ||||
5877 | if (info->verbose) { | ||||
5878 | name = get_pointer_32(objc_category->category_name, offset, left, S, info, | ||||
5879 | true); | ||||
5880 | if (name != nullptr) | ||||
5881 | outs() << format(" %.*s", left, name); | ||||
5882 | else | ||||
5883 | outs() << " (not in an __OBJC section)"; | ||||
5884 | } | ||||
5885 | outs() << "\n"; | ||||
5886 | |||||
5887 | outs() << "\t\t class name " | ||||
5888 | << format("0x%08" PRIx32"x", objc_category->class_name); | ||||
5889 | if (info->verbose) { | ||||
5890 | name = | ||||
5891 | get_pointer_32(objc_category->class_name, offset, left, S, info, true); | ||||
5892 | if (name != nullptr) | ||||
5893 | outs() << format(" %.*s", left, name); | ||||
5894 | else | ||||
5895 | outs() << " (not in an __OBJC section)"; | ||||
5896 | } | ||||
5897 | outs() << "\n"; | ||||
5898 | |||||
5899 | outs() << "\t instance methods " | ||||
5900 | << format("0x%08" PRIx32"x", objc_category->instance_methods); | ||||
5901 | if (print_method_list(objc_category->instance_methods, info)) | ||||
5902 | outs() << " (not in an __OBJC section)\n"; | ||||
5903 | |||||
5904 | outs() << "\t class methods " | ||||
5905 | << format("0x%08" PRIx32"x", objc_category->class_methods); | ||||
5906 | if (print_method_list(objc_category->class_methods, info)) | ||||
5907 | outs() << " (not in an __OBJC section)\n"; | ||||
5908 | } | ||||
5909 | |||||
5910 | static void print_category64_t(uint64_t p, struct DisassembleInfo *info) { | ||||
5911 | struct category64_t c; | ||||
5912 | const char *r; | ||||
5913 | uint32_t offset, xoffset, left; | ||||
5914 | SectionRef S, xS; | ||||
5915 | const char *name, *sym_name; | ||||
5916 | uint64_t n_value; | ||||
5917 | |||||
5918 | r = get_pointer_64(p, offset, left, S, info); | ||||
5919 | if (r == nullptr) | ||||
5920 | return; | ||||
5921 | memset(&c, '\0', sizeof(struct category64_t)); | ||||
5922 | if (left < sizeof(struct category64_t)) { | ||||
5923 | memcpy(&c, r, left); | ||||
5924 | outs() << " (category_t entends past the end of the section)\n"; | ||||
5925 | } else | ||||
5926 | memcpy(&c, r, sizeof(struct category64_t)); | ||||
5927 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
5928 | swapStruct(c); | ||||
5929 | |||||
5930 | outs() << " name "; | ||||
5931 | sym_name = get_symbol_64(offset + offsetof(struct category64_t, name)__builtin_offsetof(struct category64_t, name), S, | ||||
5932 | info, n_value, c.name); | ||||
5933 | if (n_value != 0) { | ||||
5934 | if (info->verbose && sym_name != nullptr) | ||||
5935 | outs() << sym_name; | ||||
5936 | else | ||||
5937 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5938 | if (c.name != 0) | ||||
5939 | outs() << " + " << format("0x%" PRIx64"l" "x", c.name); | ||||
5940 | } else | ||||
5941 | outs() << format("0x%" PRIx64"l" "x", c.name); | ||||
5942 | name = get_pointer_64(c.name + n_value, xoffset, left, xS, info); | ||||
5943 | if (name != nullptr) | ||||
5944 | outs() << format(" %.*s", left, name); | ||||
5945 | outs() << "\n"; | ||||
5946 | |||||
5947 | outs() << " cls "; | ||||
5948 | sym_name = get_symbol_64(offset + offsetof(struct category64_t, cls)__builtin_offsetof(struct category64_t, cls), S, info, | ||||
5949 | n_value, c.cls); | ||||
5950 | if (n_value != 0) { | ||||
5951 | if (info->verbose && sym_name != nullptr) | ||||
5952 | outs() << sym_name; | ||||
5953 | else | ||||
5954 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5955 | if (c.cls != 0) | ||||
5956 | outs() << " + " << format("0x%" PRIx64"l" "x", c.cls); | ||||
5957 | } else | ||||
5958 | outs() << format("0x%" PRIx64"l" "x", c.cls); | ||||
5959 | outs() << "\n"; | ||||
5960 | if (c.cls + n_value != 0) | ||||
5961 | print_class64_t(c.cls + n_value, info); | ||||
5962 | |||||
5963 | outs() << " instanceMethods "; | ||||
5964 | sym_name = | ||||
5965 | get_symbol_64(offset + offsetof(struct category64_t, instanceMethods)__builtin_offsetof(struct category64_t, instanceMethods), S, | ||||
5966 | info, n_value, c.instanceMethods); | ||||
5967 | if (n_value != 0) { | ||||
5968 | if (info->verbose && sym_name != nullptr) | ||||
5969 | outs() << sym_name; | ||||
5970 | else | ||||
5971 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5972 | if (c.instanceMethods != 0) | ||||
5973 | outs() << " + " << format("0x%" PRIx64"l" "x", c.instanceMethods); | ||||
5974 | } else | ||||
5975 | outs() << format("0x%" PRIx64"l" "x", c.instanceMethods); | ||||
5976 | outs() << "\n"; | ||||
5977 | if (c.instanceMethods + n_value != 0) | ||||
5978 | print_method_list64_t(c.instanceMethods + n_value, info, ""); | ||||
5979 | |||||
5980 | outs() << " classMethods "; | ||||
5981 | sym_name = get_symbol_64(offset + offsetof(struct category64_t, classMethods)__builtin_offsetof(struct category64_t, classMethods), | ||||
5982 | S, info, n_value, c.classMethods); | ||||
5983 | if (n_value != 0) { | ||||
5984 | if (info->verbose && sym_name != nullptr) | ||||
5985 | outs() << sym_name; | ||||
5986 | else | ||||
5987 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
5988 | if (c.classMethods != 0) | ||||
5989 | outs() << " + " << format("0x%" PRIx64"l" "x", c.classMethods); | ||||
5990 | } else | ||||
5991 | outs() << format("0x%" PRIx64"l" "x", c.classMethods); | ||||
5992 | outs() << "\n"; | ||||
5993 | if (c.classMethods + n_value != 0) | ||||
5994 | print_method_list64_t(c.classMethods + n_value, info, ""); | ||||
5995 | |||||
5996 | outs() << " protocols "; | ||||
5997 | sym_name = get_symbol_64(offset + offsetof(struct category64_t, protocols)__builtin_offsetof(struct category64_t, protocols), S, | ||||
5998 | info, n_value, c.protocols); | ||||
5999 | if (n_value != 0) { | ||||
6000 | if (info->verbose && sym_name != nullptr) | ||||
6001 | outs() << sym_name; | ||||
6002 | else | ||||
6003 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
6004 | if (c.protocols != 0) | ||||
6005 | outs() << " + " << format("0x%" PRIx64"l" "x", c.protocols); | ||||
6006 | } else | ||||
6007 | outs() << format("0x%" PRIx64"l" "x", c.protocols); | ||||
6008 | outs() << "\n"; | ||||
6009 | if (c.protocols + n_value != 0) | ||||
6010 | print_protocol_list64_t(c.protocols + n_value, info); | ||||
6011 | |||||
6012 | outs() << "instanceProperties "; | ||||
6013 | sym_name = | ||||
6014 | get_symbol_64(offset + offsetof(struct category64_t, instanceProperties)__builtin_offsetof(struct category64_t, instanceProperties), | ||||
6015 | S, info, n_value, c.instanceProperties); | ||||
6016 | if (n_value != 0) { | ||||
6017 | if (info->verbose && sym_name != nullptr) | ||||
6018 | outs() << sym_name; | ||||
6019 | else | ||||
6020 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
6021 | if (c.instanceProperties != 0) | ||||
6022 | outs() << " + " << format("0x%" PRIx64"l" "x", c.instanceProperties); | ||||
6023 | } else | ||||
6024 | outs() << format("0x%" PRIx64"l" "x", c.instanceProperties); | ||||
6025 | outs() << "\n"; | ||||
6026 | if (c.instanceProperties + n_value != 0) | ||||
6027 | print_objc_property_list64(c.instanceProperties + n_value, info); | ||||
6028 | } | ||||
6029 | |||||
6030 | static void print_category32_t(uint32_t p, struct DisassembleInfo *info) { | ||||
6031 | struct category32_t c; | ||||
6032 | const char *r; | ||||
6033 | uint32_t offset, left; | ||||
6034 | SectionRef S, xS; | ||||
6035 | const char *name; | ||||
6036 | |||||
6037 | r = get_pointer_32(p, offset, left, S, info); | ||||
6038 | if (r == nullptr) | ||||
6039 | return; | ||||
6040 | memset(&c, '\0', sizeof(struct category32_t)); | ||||
6041 | if (left < sizeof(struct category32_t)) { | ||||
6042 | memcpy(&c, r, left); | ||||
6043 | outs() << " (category_t entends past the end of the section)\n"; | ||||
6044 | } else | ||||
6045 | memcpy(&c, r, sizeof(struct category32_t)); | ||||
6046 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6047 | swapStruct(c); | ||||
6048 | |||||
6049 | outs() << " name " << format("0x%" PRIx32"x", c.name); | ||||
6050 | name = get_symbol_32(offset + offsetof(struct category32_t, name)__builtin_offsetof(struct category32_t, name), S, info, | ||||
6051 | c.name); | ||||
6052 | if (name) | ||||
6053 | outs() << " " << name; | ||||
6054 | outs() << "\n"; | ||||
6055 | |||||
6056 | outs() << " cls " << format("0x%" PRIx32"x", c.cls) << "\n"; | ||||
6057 | if (c.cls != 0) | ||||
6058 | print_class32_t(c.cls, info); | ||||
6059 | outs() << " instanceMethods " << format("0x%" PRIx32"x", c.instanceMethods) | ||||
6060 | << "\n"; | ||||
6061 | if (c.instanceMethods != 0) | ||||
6062 | print_method_list32_t(c.instanceMethods, info, ""); | ||||
6063 | outs() << " classMethods " << format("0x%" PRIx32"x", c.classMethods) | ||||
6064 | << "\n"; | ||||
6065 | if (c.classMethods != 0) | ||||
6066 | print_method_list32_t(c.classMethods, info, ""); | ||||
6067 | outs() << " protocols " << format("0x%" PRIx32"x", c.protocols) << "\n"; | ||||
6068 | if (c.protocols != 0) | ||||
6069 | print_protocol_list32_t(c.protocols, info); | ||||
6070 | outs() << "instanceProperties " << format("0x%" PRIx32"x", c.instanceProperties) | ||||
6071 | << "\n"; | ||||
6072 | if (c.instanceProperties != 0) | ||||
6073 | print_objc_property_list32(c.instanceProperties, info); | ||||
6074 | } | ||||
6075 | |||||
6076 | static void print_message_refs64(SectionRef S, struct DisassembleInfo *info) { | ||||
6077 | uint32_t i, left, offset, xoffset; | ||||
6078 | uint64_t p, n_value; | ||||
6079 | struct message_ref64 mr; | ||||
6080 | const char *name, *sym_name; | ||||
6081 | const char *r; | ||||
6082 | SectionRef xS; | ||||
6083 | |||||
6084 | if (S == SectionRef()) | ||||
6085 | return; | ||||
6086 | |||||
6087 | StringRef SectName; | ||||
6088 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
6089 | if (SecNameOrErr) | ||||
6090 | SectName = *SecNameOrErr; | ||||
6091 | else | ||||
6092 | consumeError(SecNameOrErr.takeError()); | ||||
6093 | |||||
6094 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
6095 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
6096 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
6097 | offset = 0; | ||||
6098 | for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) { | ||||
6099 | p = S.getAddress() + i; | ||||
6100 | r = get_pointer_64(p, offset, left, S, info); | ||||
6101 | if (r == nullptr) | ||||
6102 | return; | ||||
6103 | memset(&mr, '\0', sizeof(struct message_ref64)); | ||||
6104 | if (left < sizeof(struct message_ref64)) { | ||||
6105 | memcpy(&mr, r, left); | ||||
6106 | outs() << " (message_ref entends past the end of the section)\n"; | ||||
6107 | } else | ||||
6108 | memcpy(&mr, r, sizeof(struct message_ref64)); | ||||
6109 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6110 | swapStruct(mr); | ||||
6111 | |||||
6112 | outs() << " imp "; | ||||
6113 | name = get_symbol_64(offset + offsetof(struct message_ref64, imp)__builtin_offsetof(struct message_ref64, imp), S, info, | ||||
6114 | n_value, mr.imp); | ||||
6115 | if (n_value != 0) { | ||||
6116 | outs() << format("0x%" PRIx64"l" "x", n_value) << " "; | ||||
6117 | if (mr.imp != 0) | ||||
6118 | outs() << "+ " << format("0x%" PRIx64"l" "x", mr.imp) << " "; | ||||
6119 | } else | ||||
6120 | outs() << format("0x%" PRIx64"l" "x", mr.imp) << " "; | ||||
6121 | if (name != nullptr) | ||||
6122 | outs() << " " << name; | ||||
6123 | outs() << "\n"; | ||||
6124 | |||||
6125 | outs() << " sel "; | ||||
6126 | sym_name = get_symbol_64(offset + offsetof(struct message_ref64, sel)__builtin_offsetof(struct message_ref64, sel), S, | ||||
6127 | info, n_value, mr.sel); | ||||
6128 | if (n_value != 0) { | ||||
6129 | if (info->verbose && sym_name != nullptr) | ||||
6130 | outs() << sym_name; | ||||
6131 | else | ||||
6132 | outs() << format("0x%" PRIx64"l" "x", n_value); | ||||
6133 | if (mr.sel != 0) | ||||
6134 | outs() << " + " << format("0x%" PRIx64"l" "x", mr.sel); | ||||
6135 | } else | ||||
6136 | outs() << format("0x%" PRIx64"l" "x", mr.sel); | ||||
6137 | name = get_pointer_64(mr.sel + n_value, xoffset, left, xS, info); | ||||
6138 | if (name != nullptr) | ||||
6139 | outs() << format(" %.*s", left, name); | ||||
6140 | outs() << "\n"; | ||||
6141 | |||||
6142 | offset += sizeof(struct message_ref64); | ||||
6143 | } | ||||
6144 | } | ||||
6145 | |||||
6146 | static void print_message_refs32(SectionRef S, struct DisassembleInfo *info) { | ||||
6147 | uint32_t i, left, offset, xoffset, p; | ||||
6148 | struct message_ref32 mr; | ||||
6149 | const char *name, *r; | ||||
6150 | SectionRef xS; | ||||
6151 | |||||
6152 | if (S == SectionRef()) | ||||
6153 | return; | ||||
6154 | |||||
6155 | StringRef SectName; | ||||
6156 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
6157 | if (SecNameOrErr) | ||||
6158 | SectName = *SecNameOrErr; | ||||
6159 | else | ||||
6160 | consumeError(SecNameOrErr.takeError()); | ||||
6161 | |||||
6162 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
6163 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
6164 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
6165 | offset = 0; | ||||
6166 | for (i = 0; i < S.getSize(); i += sizeof(struct message_ref64)) { | ||||
6167 | p = S.getAddress() + i; | ||||
6168 | r = get_pointer_32(p, offset, left, S, info); | ||||
6169 | if (r == nullptr) | ||||
6170 | return; | ||||
6171 | memset(&mr, '\0', sizeof(struct message_ref32)); | ||||
6172 | if (left < sizeof(struct message_ref32)) { | ||||
6173 | memcpy(&mr, r, left); | ||||
6174 | outs() << " (message_ref entends past the end of the section)\n"; | ||||
6175 | } else | ||||
6176 | memcpy(&mr, r, sizeof(struct message_ref32)); | ||||
6177 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6178 | swapStruct(mr); | ||||
6179 | |||||
6180 | outs() << " imp " << format("0x%" PRIx32"x", mr.imp); | ||||
6181 | name = get_symbol_32(offset + offsetof(struct message_ref32, imp)__builtin_offsetof(struct message_ref32, imp), S, info, | ||||
6182 | mr.imp); | ||||
6183 | if (name != nullptr) | ||||
6184 | outs() << " " << name; | ||||
6185 | outs() << "\n"; | ||||
6186 | |||||
6187 | outs() << " sel " << format("0x%" PRIx32"x", mr.sel); | ||||
6188 | name = get_pointer_32(mr.sel, xoffset, left, xS, info); | ||||
6189 | if (name != nullptr) | ||||
6190 | outs() << " " << name; | ||||
6191 | outs() << "\n"; | ||||
6192 | |||||
6193 | offset += sizeof(struct message_ref32); | ||||
6194 | } | ||||
6195 | } | ||||
6196 | |||||
6197 | static void print_image_info64(SectionRef S, struct DisassembleInfo *info) { | ||||
6198 | uint32_t left, offset, swift_version; | ||||
6199 | uint64_t p; | ||||
6200 | struct objc_image_info64 o; | ||||
6201 | const char *r; | ||||
6202 | |||||
6203 | if (S == SectionRef()) | ||||
6204 | return; | ||||
6205 | |||||
6206 | StringRef SectName; | ||||
6207 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
6208 | if (SecNameOrErr) | ||||
6209 | SectName = *SecNameOrErr; | ||||
6210 | else | ||||
6211 | consumeError(SecNameOrErr.takeError()); | ||||
6212 | |||||
6213 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
6214 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
6215 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
6216 | p = S.getAddress(); | ||||
6217 | r = get_pointer_64(p, offset, left, S, info); | ||||
6218 | if (r == nullptr) | ||||
6219 | return; | ||||
6220 | memset(&o, '\0', sizeof(struct objc_image_info64)); | ||||
6221 | if (left < sizeof(struct objc_image_info64)) { | ||||
6222 | memcpy(&o, r, left); | ||||
6223 | outs() << " (objc_image_info entends past the end of the section)\n"; | ||||
6224 | } else | ||||
6225 | memcpy(&o, r, sizeof(struct objc_image_info64)); | ||||
6226 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6227 | swapStruct(o); | ||||
6228 | outs() << " version " << o.version << "\n"; | ||||
6229 | outs() << " flags " << format("0x%" PRIx32"x", o.flags); | ||||
6230 | if (o.flags & OBJC_IMAGE_IS_REPLACEMENT(1 << 0)) | ||||
6231 | outs() << " OBJC_IMAGE_IS_REPLACEMENT"; | ||||
6232 | if (o.flags & OBJC_IMAGE_SUPPORTS_GC(1 << 1)) | ||||
6233 | outs() << " OBJC_IMAGE_SUPPORTS_GC"; | ||||
6234 | if (o.flags & OBJC_IMAGE_IS_SIMULATED(1 << 5)) | ||||
6235 | outs() << " OBJC_IMAGE_IS_SIMULATED"; | ||||
6236 | if (o.flags & OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES(1 << 6)) | ||||
6237 | outs() << " OBJC_IMAGE_HAS_CATEGORY_CLASS_PROPERTIES"; | ||||
6238 | swift_version = (o.flags >> 8) & 0xff; | ||||
6239 | if (swift_version != 0) { | ||||
6240 | if (swift_version == 1) | ||||
6241 | outs() << " Swift 1.0"; | ||||
6242 | else if (swift_version == 2) | ||||
6243 | outs() << " Swift 1.1"; | ||||
6244 | else if(swift_version == 3) | ||||
6245 | outs() << " Swift 2.0"; | ||||
6246 | else if(swift_version == 4) | ||||
6247 | outs() << " Swift 3.0"; | ||||
6248 | else if(swift_version == 5) | ||||
6249 | outs() << " Swift 4.0"; | ||||
6250 | else if(swift_version == 6) | ||||
6251 | outs() << " Swift 4.1/Swift 4.2"; | ||||
6252 | else if(swift_version == 7) | ||||
6253 | outs() << " Swift 5 or later"; | ||||
6254 | else | ||||
6255 | outs() << " unknown future Swift version (" << swift_version << ")"; | ||||
6256 | } | ||||
6257 | outs() << "\n"; | ||||
6258 | } | ||||
6259 | |||||
6260 | static void print_image_info32(SectionRef S, struct DisassembleInfo *info) { | ||||
6261 | uint32_t left, offset, swift_version, p; | ||||
6262 | struct objc_image_info32 o; | ||||
6263 | const char *r; | ||||
6264 | |||||
6265 | if (S == SectionRef()) | ||||
6266 | return; | ||||
6267 | |||||
6268 | StringRef SectName; | ||||
6269 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
6270 | if (SecNameOrErr) | ||||
6271 | SectName = *SecNameOrErr; | ||||
6272 | else | ||||
6273 | consumeError(SecNameOrErr.takeError()); | ||||
6274 | |||||
6275 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
6276 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
6277 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
6278 | p = S.getAddress(); | ||||
6279 | r = get_pointer_32(p, offset, left, S, info); | ||||
6280 | if (r == nullptr) | ||||
6281 | return; | ||||
6282 | memset(&o, '\0', sizeof(struct objc_image_info32)); | ||||
6283 | if (left < sizeof(struct objc_image_info32)) { | ||||
6284 | memcpy(&o, r, left); | ||||
6285 | outs() << " (objc_image_info entends past the end of the section)\n"; | ||||
6286 | } else | ||||
6287 | memcpy(&o, r, sizeof(struct objc_image_info32)); | ||||
6288 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6289 | swapStruct(o); | ||||
6290 | outs() << " version " << o.version << "\n"; | ||||
6291 | outs() << " flags " << format("0x%" PRIx32"x", o.flags); | ||||
6292 | if (o.flags & OBJC_IMAGE_IS_REPLACEMENT(1 << 0)) | ||||
6293 | outs() << " OBJC_IMAGE_IS_REPLACEMENT"; | ||||
6294 | if (o.flags & OBJC_IMAGE_SUPPORTS_GC(1 << 1)) | ||||
6295 | outs() << " OBJC_IMAGE_SUPPORTS_GC"; | ||||
6296 | swift_version = (o.flags >> 8) & 0xff; | ||||
6297 | if (swift_version != 0) { | ||||
6298 | if (swift_version == 1) | ||||
6299 | outs() << " Swift 1.0"; | ||||
6300 | else if (swift_version == 2) | ||||
6301 | outs() << " Swift 1.1"; | ||||
6302 | else if(swift_version == 3) | ||||
6303 | outs() << " Swift 2.0"; | ||||
6304 | else if(swift_version == 4) | ||||
6305 | outs() << " Swift 3.0"; | ||||
6306 | else if(swift_version == 5) | ||||
6307 | outs() << " Swift 4.0"; | ||||
6308 | else if(swift_version == 6) | ||||
6309 | outs() << " Swift 4.1/Swift 4.2"; | ||||
6310 | else if(swift_version == 7) | ||||
6311 | outs() << " Swift 5 or later"; | ||||
6312 | else | ||||
6313 | outs() << " unknown future Swift version (" << swift_version << ")"; | ||||
6314 | } | ||||
6315 | outs() << "\n"; | ||||
6316 | } | ||||
6317 | |||||
6318 | static void print_image_info(SectionRef S, struct DisassembleInfo *info) { | ||||
6319 | uint32_t left, offset, p; | ||||
6320 | struct imageInfo_t o; | ||||
6321 | const char *r; | ||||
6322 | |||||
6323 | StringRef SectName; | ||||
6324 | Expected<StringRef> SecNameOrErr = S.getName(); | ||||
6325 | if (SecNameOrErr) | ||||
6326 | SectName = *SecNameOrErr; | ||||
6327 | else | ||||
6328 | consumeError(SecNameOrErr.takeError()); | ||||
6329 | |||||
6330 | DataRefImpl Ref = S.getRawDataRefImpl(); | ||||
6331 | StringRef SegName = info->O->getSectionFinalSegmentName(Ref); | ||||
6332 | outs() << "Contents of (" << SegName << "," << SectName << ") section\n"; | ||||
6333 | p = S.getAddress(); | ||||
6334 | r = get_pointer_32(p, offset, left, S, info); | ||||
6335 | if (r == nullptr) | ||||
6336 | return; | ||||
6337 | memset(&o, '\0', sizeof(struct imageInfo_t)); | ||||
6338 | if (left < sizeof(struct imageInfo_t)) { | ||||
6339 | memcpy(&o, r, left); | ||||
6340 | outs() << " (imageInfo entends past the end of the section)\n"; | ||||
6341 | } else | ||||
6342 | memcpy(&o, r, sizeof(struct imageInfo_t)); | ||||
6343 | if (info->O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6344 | swapStruct(o); | ||||
6345 | outs() << " version " << o.version << "\n"; | ||||
6346 | outs() << " flags " << format("0x%" PRIx32"x", o.flags); | ||||
6347 | if (o.flags & 0x1) | ||||
6348 | outs() << " F&C"; | ||||
6349 | if (o.flags & 0x2) | ||||
6350 | outs() << " GC"; | ||||
6351 | if (o.flags & 0x4) | ||||
6352 | outs() << " GC-only"; | ||||
6353 | else | ||||
6354 | outs() << " RR"; | ||||
6355 | outs() << "\n"; | ||||
6356 | } | ||||
6357 | |||||
6358 | static void printObjc2_64bit_MetaData(MachOObjectFile *O, bool verbose) { | ||||
6359 | SymbolAddressMap AddrMap; | ||||
6360 | if (verbose) | ||||
6361 | CreateSymbolAddressMap(O, &AddrMap); | ||||
6362 | |||||
6363 | std::vector<SectionRef> Sections; | ||||
6364 | append_range(Sections, O->sections()); | ||||
6365 | |||||
6366 | struct DisassembleInfo info(O, &AddrMap, &Sections, verbose); | ||||
6367 | |||||
6368 | SectionRef CL = get_section(O, "__OBJC2", "__class_list"); | ||||
6369 | if (CL == SectionRef()) | ||||
6370 | CL = get_section(O, "__DATA", "__objc_classlist"); | ||||
6371 | if (CL == SectionRef()) | ||||
6372 | CL = get_section(O, "__DATA_CONST", "__objc_classlist"); | ||||
6373 | if (CL == SectionRef()) | ||||
6374 | CL = get_section(O, "__DATA_DIRTY", "__objc_classlist"); | ||||
6375 | info.S = CL; | ||||
6376 | walk_pointer_list_64("class", CL, O, &info, print_class64_t); | ||||
6377 | |||||
6378 | SectionRef CR = get_section(O, "__OBJC2", "__class_refs"); | ||||
6379 | if (CR == SectionRef()) | ||||
6380 | CR = get_section(O, "__DATA", "__objc_classrefs"); | ||||
6381 | if (CR == SectionRef()) | ||||
6382 | CR = get_section(O, "__DATA_CONST", "__objc_classrefs"); | ||||
6383 | if (CR == SectionRef()) | ||||
6384 | CR = get_section(O, "__DATA_DIRTY", "__objc_classrefs"); | ||||
6385 | info.S = CR; | ||||
6386 | walk_pointer_list_64("class refs", CR, O, &info, nullptr); | ||||
6387 | |||||
6388 | SectionRef SR = get_section(O, "__OBJC2", "__super_refs"); | ||||
6389 | if (SR == SectionRef()) | ||||
6390 | SR = get_section(O, "__DATA", "__objc_superrefs"); | ||||
6391 | if (SR == SectionRef()) | ||||
6392 | SR = get_section(O, "__DATA_CONST", "__objc_superrefs"); | ||||
6393 | if (SR == SectionRef()) | ||||
6394 | SR = get_section(O, "__DATA_DIRTY", "__objc_superrefs"); | ||||
6395 | info.S = SR; | ||||
6396 | walk_pointer_list_64("super refs", SR, O, &info, nullptr); | ||||
6397 | |||||
6398 | SectionRef CA = get_section(O, "__OBJC2", "__category_list"); | ||||
6399 | if (CA == SectionRef()) | ||||
6400 | CA = get_section(O, "__DATA", "__objc_catlist"); | ||||
6401 | if (CA == SectionRef()) | ||||
6402 | CA = get_section(O, "__DATA_CONST", "__objc_catlist"); | ||||
6403 | if (CA == SectionRef()) | ||||
6404 | CA = get_section(O, "__DATA_DIRTY", "__objc_catlist"); | ||||
6405 | info.S = CA; | ||||
6406 | walk_pointer_list_64("category", CA, O, &info, print_category64_t); | ||||
6407 | |||||
6408 | SectionRef PL = get_section(O, "__OBJC2", "__protocol_list"); | ||||
6409 | if (PL == SectionRef()) | ||||
6410 | PL = get_section(O, "__DATA", "__objc_protolist"); | ||||
6411 | if (PL == SectionRef()) | ||||
6412 | PL = get_section(O, "__DATA_CONST", "__objc_protolist"); | ||||
6413 | if (PL == SectionRef()) | ||||
6414 | PL = get_section(O, "__DATA_DIRTY", "__objc_protolist"); | ||||
6415 | info.S = PL; | ||||
6416 | walk_pointer_list_64("protocol", PL, O, &info, nullptr); | ||||
6417 | |||||
6418 | SectionRef MR = get_section(O, "__OBJC2", "__message_refs"); | ||||
6419 | if (MR == SectionRef()) | ||||
6420 | MR = get_section(O, "__DATA", "__objc_msgrefs"); | ||||
6421 | if (MR == SectionRef()) | ||||
6422 | MR = get_section(O, "__DATA_CONST", "__objc_msgrefs"); | ||||
6423 | if (MR == SectionRef()) | ||||
6424 | MR = get_section(O, "__DATA_DIRTY", "__objc_msgrefs"); | ||||
6425 | info.S = MR; | ||||
6426 | print_message_refs64(MR, &info); | ||||
6427 | |||||
6428 | SectionRef II = get_section(O, "__OBJC2", "__image_info"); | ||||
6429 | if (II == SectionRef()) | ||||
6430 | II = get_section(O, "__DATA", "__objc_imageinfo"); | ||||
6431 | if (II == SectionRef()) | ||||
6432 | II = get_section(O, "__DATA_CONST", "__objc_imageinfo"); | ||||
6433 | if (II == SectionRef()) | ||||
6434 | II = get_section(O, "__DATA_DIRTY", "__objc_imageinfo"); | ||||
6435 | info.S = II; | ||||
6436 | print_image_info64(II, &info); | ||||
6437 | } | ||||
6438 | |||||
6439 | static void printObjc2_32bit_MetaData(MachOObjectFile *O, bool verbose) { | ||||
6440 | SymbolAddressMap AddrMap; | ||||
6441 | if (verbose) | ||||
6442 | CreateSymbolAddressMap(O, &AddrMap); | ||||
6443 | |||||
6444 | std::vector<SectionRef> Sections; | ||||
6445 | append_range(Sections, O->sections()); | ||||
6446 | |||||
6447 | struct DisassembleInfo info(O, &AddrMap, &Sections, verbose); | ||||
6448 | |||||
6449 | SectionRef CL = get_section(O, "__OBJC2", "__class_list"); | ||||
6450 | if (CL == SectionRef()) | ||||
6451 | CL = get_section(O, "__DATA", "__objc_classlist"); | ||||
6452 | if (CL == SectionRef()) | ||||
6453 | CL = get_section(O, "__DATA_CONST", "__objc_classlist"); | ||||
6454 | if (CL == SectionRef()) | ||||
6455 | CL = get_section(O, "__DATA_DIRTY", "__objc_classlist"); | ||||
6456 | info.S = CL; | ||||
6457 | walk_pointer_list_32("class", CL, O, &info, print_class32_t); | ||||
6458 | |||||
6459 | SectionRef CR = get_section(O, "__OBJC2", "__class_refs"); | ||||
6460 | if (CR == SectionRef()) | ||||
6461 | CR = get_section(O, "__DATA", "__objc_classrefs"); | ||||
6462 | if (CR == SectionRef()) | ||||
6463 | CR = get_section(O, "__DATA_CONST", "__objc_classrefs"); | ||||
6464 | if (CR == SectionRef()) | ||||
6465 | CR = get_section(O, "__DATA_DIRTY", "__objc_classrefs"); | ||||
6466 | info.S = CR; | ||||
6467 | walk_pointer_list_32("class refs", CR, O, &info, nullptr); | ||||
6468 | |||||
6469 | SectionRef SR = get_section(O, "__OBJC2", "__super_refs"); | ||||
6470 | if (SR == SectionRef()) | ||||
6471 | SR = get_section(O, "__DATA", "__objc_superrefs"); | ||||
6472 | if (SR == SectionRef()) | ||||
6473 | SR = get_section(O, "__DATA_CONST", "__objc_superrefs"); | ||||
6474 | if (SR == SectionRef()) | ||||
6475 | SR = get_section(O, "__DATA_DIRTY", "__objc_superrefs"); | ||||
6476 | info.S = SR; | ||||
6477 | walk_pointer_list_32("super refs", SR, O, &info, nullptr); | ||||
6478 | |||||
6479 | SectionRef CA = get_section(O, "__OBJC2", "__category_list"); | ||||
6480 | if (CA == SectionRef()) | ||||
6481 | CA = get_section(O, "__DATA", "__objc_catlist"); | ||||
6482 | if (CA == SectionRef()) | ||||
6483 | CA = get_section(O, "__DATA_CONST", "__objc_catlist"); | ||||
6484 | if (CA == SectionRef()) | ||||
6485 | CA = get_section(O, "__DATA_DIRTY", "__objc_catlist"); | ||||
6486 | info.S = CA; | ||||
6487 | walk_pointer_list_32("category", CA, O, &info, print_category32_t); | ||||
6488 | |||||
6489 | SectionRef PL = get_section(O, "__OBJC2", "__protocol_list"); | ||||
6490 | if (PL == SectionRef()) | ||||
6491 | PL = get_section(O, "__DATA", "__objc_protolist"); | ||||
6492 | if (PL == SectionRef()) | ||||
6493 | PL = get_section(O, "__DATA_CONST", "__objc_protolist"); | ||||
6494 | if (PL == SectionRef()) | ||||
6495 | PL = get_section(O, "__DATA_DIRTY", "__objc_protolist"); | ||||
6496 | info.S = PL; | ||||
6497 | walk_pointer_list_32("protocol", PL, O, &info, nullptr); | ||||
6498 | |||||
6499 | SectionRef MR = get_section(O, "__OBJC2", "__message_refs"); | ||||
6500 | if (MR == SectionRef()) | ||||
6501 | MR = get_section(O, "__DATA", "__objc_msgrefs"); | ||||
6502 | if (MR == SectionRef()) | ||||
6503 | MR = get_section(O, "__DATA_CONST", "__objc_msgrefs"); | ||||
6504 | if (MR == SectionRef()) | ||||
6505 | MR = get_section(O, "__DATA_DIRTY", "__objc_msgrefs"); | ||||
6506 | info.S = MR; | ||||
6507 | print_message_refs32(MR, &info); | ||||
6508 | |||||
6509 | SectionRef II = get_section(O, "__OBJC2", "__image_info"); | ||||
6510 | if (II == SectionRef()) | ||||
6511 | II = get_section(O, "__DATA", "__objc_imageinfo"); | ||||
6512 | if (II == SectionRef()) | ||||
6513 | II = get_section(O, "__DATA_CONST", "__objc_imageinfo"); | ||||
6514 | if (II == SectionRef()) | ||||
6515 | II = get_section(O, "__DATA_DIRTY", "__objc_imageinfo"); | ||||
6516 | info.S = II; | ||||
6517 | print_image_info32(II, &info); | ||||
6518 | } | ||||
6519 | |||||
6520 | static bool printObjc1_32bit_MetaData(MachOObjectFile *O, bool verbose) { | ||||
6521 | uint32_t i, j, p, offset, xoffset, left, defs_left, def; | ||||
6522 | const char *r, *name, *defs; | ||||
6523 | struct objc_module_t module; | ||||
6524 | SectionRef S, xS; | ||||
6525 | struct objc_symtab_t symtab; | ||||
6526 | struct objc_class_t objc_class; | ||||
6527 | struct objc_category_t objc_category; | ||||
6528 | |||||
6529 | outs() << "Objective-C segment\n"; | ||||
6530 | S = get_section(O, "__OBJC", "__module_info"); | ||||
6531 | if (S == SectionRef()) | ||||
6532 | return false; | ||||
6533 | |||||
6534 | SymbolAddressMap AddrMap; | ||||
6535 | if (verbose) | ||||
6536 | CreateSymbolAddressMap(O, &AddrMap); | ||||
6537 | |||||
6538 | std::vector<SectionRef> Sections; | ||||
6539 | append_range(Sections, O->sections()); | ||||
6540 | |||||
6541 | struct DisassembleInfo info(O, &AddrMap, &Sections, verbose); | ||||
6542 | |||||
6543 | for (i = 0; i < S.getSize(); i += sizeof(struct objc_module_t)) { | ||||
6544 | p = S.getAddress() + i; | ||||
6545 | r = get_pointer_32(p, offset, left, S, &info, true); | ||||
6546 | if (r == nullptr) | ||||
6547 | return true; | ||||
6548 | memset(&module, '\0', sizeof(struct objc_module_t)); | ||||
6549 | if (left < sizeof(struct objc_module_t)) { | ||||
6550 | memcpy(&module, r, left); | ||||
6551 | outs() << " (module extends past end of __module_info section)\n"; | ||||
6552 | } else | ||||
6553 | memcpy(&module, r, sizeof(struct objc_module_t)); | ||||
6554 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6555 | swapStruct(module); | ||||
6556 | |||||
6557 | outs() << "Module " << format("0x%" PRIx32"x", p) << "\n"; | ||||
6558 | outs() << " version " << module.version << "\n"; | ||||
6559 | outs() << " size " << module.size << "\n"; | ||||
6560 | outs() << " name "; | ||||
6561 | name = get_pointer_32(module.name, xoffset, left, xS, &info, true); | ||||
6562 | if (name != nullptr) | ||||
6563 | outs() << format("%.*s", left, name); | ||||
6564 | else | ||||
6565 | outs() << format("0x%08" PRIx32"x", module.name) | ||||
6566 | << "(not in an __OBJC section)"; | ||||
6567 | outs() << "\n"; | ||||
6568 | |||||
6569 | r = get_pointer_32(module.symtab, xoffset, left, xS, &info, true); | ||||
6570 | if (module.symtab == 0 || r == nullptr) { | ||||
6571 | outs() << " symtab " << format("0x%08" PRIx32"x", module.symtab) | ||||
6572 | << " (not in an __OBJC section)\n"; | ||||
6573 | continue; | ||||
6574 | } | ||||
6575 | outs() << " symtab " << format("0x%08" PRIx32"x", module.symtab) << "\n"; | ||||
6576 | memset(&symtab, '\0', sizeof(struct objc_symtab_t)); | ||||
6577 | defs_left = 0; | ||||
6578 | defs = nullptr; | ||||
6579 | if (left < sizeof(struct objc_symtab_t)) { | ||||
6580 | memcpy(&symtab, r, left); | ||||
6581 | outs() << "\tsymtab extends past end of an __OBJC section)\n"; | ||||
6582 | } else { | ||||
6583 | memcpy(&symtab, r, sizeof(struct objc_symtab_t)); | ||||
6584 | if (left > sizeof(struct objc_symtab_t)) { | ||||
6585 | defs_left = left - sizeof(struct objc_symtab_t); | ||||
6586 | defs = r + sizeof(struct objc_symtab_t); | ||||
6587 | } | ||||
6588 | } | ||||
6589 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6590 | swapStruct(symtab); | ||||
6591 | |||||
6592 | outs() << "\tsel_ref_cnt " << symtab.sel_ref_cnt << "\n"; | ||||
6593 | r = get_pointer_32(symtab.refs, xoffset, left, xS, &info, true); | ||||
6594 | outs() << "\trefs " << format("0x%08" PRIx32"x", symtab.refs); | ||||
6595 | if (r == nullptr) | ||||
6596 | outs() << " (not in an __OBJC section)"; | ||||
6597 | outs() << "\n"; | ||||
6598 | outs() << "\tcls_def_cnt " << symtab.cls_def_cnt << "\n"; | ||||
6599 | outs() << "\tcat_def_cnt " << symtab.cat_def_cnt << "\n"; | ||||
6600 | if (symtab.cls_def_cnt > 0) | ||||
6601 | outs() << "\tClass Definitions\n"; | ||||
6602 | for (j = 0; j < symtab.cls_def_cnt; j++) { | ||||
6603 | if ((j + 1) * sizeof(uint32_t) > defs_left) { | ||||
6604 | outs() << "\t(remaining class defs entries entends past the end of the " | ||||
6605 | << "section)\n"; | ||||
6606 | break; | ||||
6607 | } | ||||
6608 | memcpy(&def, defs + j * sizeof(uint32_t), sizeof(uint32_t)); | ||||
6609 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6610 | sys::swapByteOrder(def); | ||||
6611 | |||||
6612 | r = get_pointer_32(def, xoffset, left, xS, &info, true); | ||||
6613 | outs() << "\tdefs[" << j << "] " << format("0x%08" PRIx32"x", def); | ||||
6614 | if (r != nullptr) { | ||||
6615 | if (left > sizeof(struct objc_class_t)) { | ||||
6616 | outs() << "\n"; | ||||
6617 | memcpy(&objc_class, r, sizeof(struct objc_class_t)); | ||||
6618 | } else { | ||||
6619 | outs() << " (entends past the end of the section)\n"; | ||||
6620 | memset(&objc_class, '\0', sizeof(struct objc_class_t)); | ||||
6621 | memcpy(&objc_class, r, left); | ||||
6622 | } | ||||
6623 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6624 | swapStruct(objc_class); | ||||
6625 | print_objc_class_t(&objc_class, &info); | ||||
6626 | } else { | ||||
6627 | outs() << "(not in an __OBJC section)\n"; | ||||
6628 | } | ||||
6629 | |||||
6630 | if (CLS_GETINFO(&objc_class, CLS_CLASS)((&objc_class)->info & (0x1))) { | ||||
6631 | outs() << "\tMeta Class"; | ||||
6632 | r = get_pointer_32(objc_class.isa, xoffset, left, xS, &info, true); | ||||
6633 | if (r != nullptr) { | ||||
6634 | if (left > sizeof(struct objc_class_t)) { | ||||
6635 | outs() << "\n"; | ||||
6636 | memcpy(&objc_class, r, sizeof(struct objc_class_t)); | ||||
6637 | } else { | ||||
6638 | outs() << " (entends past the end of the section)\n"; | ||||
6639 | memset(&objc_class, '\0', sizeof(struct objc_class_t)); | ||||
6640 | memcpy(&objc_class, r, left); | ||||
6641 | } | ||||
6642 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6643 | swapStruct(objc_class); | ||||
6644 | print_objc_class_t(&objc_class, &info); | ||||
6645 | } else { | ||||
6646 | outs() << "(not in an __OBJC section)\n"; | ||||
6647 | } | ||||
6648 | } | ||||
6649 | } | ||||
6650 | if (symtab.cat_def_cnt > 0) | ||||
6651 | outs() << "\tCategory Definitions\n"; | ||||
6652 | for (j = 0; j < symtab.cat_def_cnt; j++) { | ||||
6653 | if ((j + symtab.cls_def_cnt + 1) * sizeof(uint32_t) > defs_left) { | ||||
6654 | outs() << "\t(remaining category defs entries entends past the end of " | ||||
6655 | << "the section)\n"; | ||||
6656 | break; | ||||
6657 | } | ||||
6658 | memcpy(&def, defs + (j + symtab.cls_def_cnt) * sizeof(uint32_t), | ||||
6659 | sizeof(uint32_t)); | ||||
6660 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6661 | sys::swapByteOrder(def); | ||||
6662 | |||||
6663 | r = get_pointer_32(def, xoffset, left, xS, &info, true); | ||||
6664 | outs() << "\tdefs[" << j + symtab.cls_def_cnt << "] " | ||||
6665 | << format("0x%08" PRIx32"x", def); | ||||
6666 | if (r != nullptr) { | ||||
6667 | if (left > sizeof(struct objc_category_t)) { | ||||
6668 | outs() << "\n"; | ||||
6669 | memcpy(&objc_category, r, sizeof(struct objc_category_t)); | ||||
6670 | } else { | ||||
6671 | outs() << " (entends past the end of the section)\n"; | ||||
6672 | memset(&objc_category, '\0', sizeof(struct objc_category_t)); | ||||
6673 | memcpy(&objc_category, r, left); | ||||
6674 | } | ||||
6675 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6676 | swapStruct(objc_category); | ||||
6677 | print_objc_objc_category_t(&objc_category, &info); | ||||
6678 | } else { | ||||
6679 | outs() << "(not in an __OBJC section)\n"; | ||||
6680 | } | ||||
6681 | } | ||||
6682 | } | ||||
6683 | const SectionRef II = get_section(O, "__OBJC", "__image_info"); | ||||
6684 | if (II != SectionRef()) | ||||
6685 | print_image_info(II, &info); | ||||
6686 | |||||
6687 | return true; | ||||
6688 | } | ||||
6689 | |||||
6690 | static void DumpProtocolSection(MachOObjectFile *O, const char *sect, | ||||
6691 | uint32_t size, uint32_t addr) { | ||||
6692 | SymbolAddressMap AddrMap; | ||||
6693 | CreateSymbolAddressMap(O, &AddrMap); | ||||
6694 | |||||
6695 | std::vector<SectionRef> Sections; | ||||
6696 | append_range(Sections, O->sections()); | ||||
6697 | |||||
6698 | struct DisassembleInfo info(O, &AddrMap, &Sections, true); | ||||
6699 | |||||
6700 | const char *p; | ||||
6701 | struct objc_protocol_t protocol; | ||||
6702 | uint32_t left, paddr; | ||||
6703 | for (p = sect; p < sect + size; p += sizeof(struct objc_protocol_t)) { | ||||
6704 | memset(&protocol, '\0', sizeof(struct objc_protocol_t)); | ||||
6705 | left = size - (p - sect); | ||||
6706 | if (left < sizeof(struct objc_protocol_t)) { | ||||
6707 | outs() << "Protocol extends past end of __protocol section\n"; | ||||
6708 | memcpy(&protocol, p, left); | ||||
6709 | } else | ||||
6710 | memcpy(&protocol, p, sizeof(struct objc_protocol_t)); | ||||
6711 | if (O->isLittleEndian() != sys::IsLittleEndianHost) | ||||
6712 | swapStruct(protocol); | ||||
6713 | paddr = addr + (p - sect); | ||||
6714 | outs() << "Protocol " << format("0x%" PRIx32"x", paddr); | ||||
6715 | if (print_protocol(paddr, 0, &info)) | ||||
6716 | outs() << "(not in an __OBJC section)\n"; | ||||
6717 | } | ||||
6718 | } | ||||
6719 | |||||
6720 | #ifdef LLVM_HAVE_LIBXAR | ||||
6721 | static inline void swapStruct(struct xar_header &xar) { | ||||
6722 | sys::swapByteOrder(xar.magic); | ||||
6723 | sys::swapByteOrder(xar.size); | ||||
6724 | sys::swapByteOrder(xar.version); | ||||
6725 | sys::swapByteOrder(xar.toc_length_compressed); | ||||
6726 | sys::swapByteOrder(xar.toc_length_uncompressed); | ||||
6727 | sys::swapByteOrder(xar.cksum_alg); | ||||
6728 | } | ||||
6729 | |||||
6730 | static void PrintModeVerbose(uint32_t mode) { | ||||
6731 | switch(mode & S_IFMT){ | ||||
6732 | case S_IFDIR: | ||||
6733 | outs() << "d"; | ||||
6734 | break; | ||||
6735 | case S_IFCHR: | ||||
6736 | outs() << "c"; | ||||
6737 | break; | ||||
6738 | case S_IFBLK: | ||||
6739 | outs() << "b"; | ||||
6740 | break; | ||||
6741 | case S_IFREG: | ||||
6742 | outs() << "-"; | ||||
6743 | break; | ||||
6744 | case S_IFLNK: | ||||
6745 | outs() << "l"; | ||||
6746 | break; | ||||
6747 | case S_IFSOCK: | ||||
6748 | outs() << "s"; | ||||
6749 | break; | ||||
6750 | default: | ||||
6751 | outs() << "?"; | ||||
6752 | break; | ||||
6753 | } | ||||
6754 | |||||
6755 | /* owner permissions */ | ||||
6756 | if(mode & S_IREAD) | ||||
6757 | outs() << "r"; | ||||
6758 | else | ||||
6759 | outs() << "-"; | ||||
6760 | if(mode & S_IWRITE) | ||||
6761 | outs() << "w"; | ||||
6762 | else | ||||
6763 | outs() << "-"; | ||||
6764 | if(mode & S_ISUID) | ||||
6765 | outs() << "s"; | ||||
6766 | else if(mode & S_IEXEC) | ||||
6767 | outs() << "x"; | ||||
6768 | else | ||||
6769 | outs() << "-"; | ||||
6770 | |||||
6771 | /* group permissions */ | ||||
6772 | if(mode & (S_IREAD >> 3)) | ||||
6773 | outs() << "r"; | ||||
6774 | else | ||||
6775 | outs() << "-"; | ||||
6776 | if(mode & (S_IWRITE >> 3)) | ||||
6777 | outs() << "w"; | ||||
6778 | else | ||||
6779 | outs() << "-"; | ||||
6780 | if(mode & S_ISGID) | ||||
6781 | outs() << "s"; | ||||
6782 | else if(mode & (S_IEXEC >> 3)) | ||||
6783 | outs() << "x"; | ||||
6784 | else | ||||
6785 | outs() << "-"; | ||||
6786 | |||||
6787 | /* other permissions */ | ||||
6788 | if(mode & (S_IREAD >> 6)) | ||||
6789 | outs() << "r"; | ||||
6790 | else | ||||
6791 | outs() << "-"; | ||||
6792 | if(mode & (S_IWRITE >> 6)) | ||||
6793 | outs() << "w"; | ||||
6794 | else | ||||
6795 | outs() << "-"; | ||||
6796 | if(mode & S_ISVTX) | ||||
6797 | outs() << "t"; | ||||
6798 | else if(mode & (S_IEXEC >> 6)) | ||||
6799 | outs() << "x"; | ||||
6800 | else | ||||
6801 | outs() << "-"; | ||||
6802 | } | ||||
6803 | |||||
6804 | static void PrintXarFilesSummary(const char *XarFilename, xar_t xar) { | ||||
6805 | xar_file_t xf; | ||||
6806 | const char *key, *type, *mode, *user, *group, *size, *mtime, *name, *m; | ||||
6807 | char *endp; | ||||
6808 | uint32_t mode_value; | ||||
6809 | |||||
6810 | ScopedXarIter xi; | ||||
6811 | if (!xi) { | ||||
6812 | WithColor::error(errs(), "llvm-objdump") | ||||
6813 | << "can't obtain an xar iterator for xar archive " << XarFilename | ||||
6814 | << "\n"; | ||||
6815 | return; | ||||
6816 | } | ||||
6817 | |||||
6818 | // Go through the xar's files. | ||||
6819 | for (xf = xar_file_first(xar, xi); xf; xf = xar_file_next(xi)) { | ||||
6820 | ScopedXarIter xp; | ||||
6821 | if(!xp){ | ||||
6822 | WithColor::error(errs(), "llvm-objdump") | ||||
6823 | << "can't obtain an xar iterator for xar archive " << XarFilename | ||||
6824 | << "\n"; | ||||
6825 | return; | ||||
6826 | } | ||||
6827 | type = nullptr; | ||||
6828 | mode = nullptr; | ||||
6829 | user = nullptr; | ||||
6830 | group = nullptr; | ||||
6831 | size = nullptr; | ||||
6832 | mtime = nullptr; | ||||
6833 | name = nullptr; | ||||
6834 | for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){ | ||||
6835 | const char *val = nullptr; | ||||
6836 | xar_prop_get(xf, key, &val); | ||||
6837 | #if 0 // Useful for debugging. | ||||
6838 | outs() << "key: " << key << " value: " << val << "\n"; | ||||
6839 | #endif | ||||
6840 | if(strcmp(key, "type") == 0) | ||||
6841 | type = val; | ||||
6842 | if(strcmp(key, "mode") == 0) | ||||
6843 | mode = val; | ||||
6844 | if(strcmp(key, "user") == 0) | ||||
6845 | user = val; | ||||
6846 | if(strcmp(key, "group") == 0) | ||||
6847 | group = val; | ||||
6848 | if(strcmp(key, "data/size") == 0) | ||||
6849 | size = val; | ||||
6850 | if(strcmp(key, "mtime") == 0) | ||||
6851 | mtime = val; | ||||
6852 | if(strcmp(key, "name") == 0) | ||||
6853 | name = val; | ||||
6854 | } | ||||
6855 | if(mode != nullptr){ | ||||
6856 | mode_value = strtoul(mode, &endp, 8); | ||||
6857 | if(*endp != '\0') | ||||
6858 | outs() << "(mode: \"" << mode << "\" contains non-octal chars) "; | ||||
6859 | if(strcmp(type, "file") == 0) | ||||
6860 | mode_value |= S_IFREG; | ||||
6861 | PrintModeVerbose(mode_value); | ||||
6862 | outs() << " "; | ||||
6863 | } | ||||
6864 | if(user != nullptr) | ||||
6865 | outs() << format("%10s/", user); | ||||
6866 | if(group != nullptr) | ||||
6867 | outs() << format("%-10s ", group); | ||||
6868 | if(size != nullptr) | ||||
6869 | outs() << format("%7s ", size); | ||||
6870 | if(mtime != nullptr){ | ||||
6871 | for(m = mtime; *m != 'T' && *m != '\0'; m++) | ||||
6872 | outs() << *m; | ||||
6873 | if(*m == 'T') | ||||
6874 | m++; | ||||
6875 | outs() << " "; | ||||
6876 | for( ; *m != 'Z' && *m != '\0'; m++) | ||||
6877 | outs() << *m; | ||||
6878 | outs() << " "; | ||||
6879 | } | ||||
6880 | if(name != nullptr) | ||||
6881 | outs() << name; | ||||
6882 | outs() << "\n"; | ||||
6883 | } | ||||
6884 | } | ||||
6885 | |||||
6886 | static void DumpBitcodeSection(MachOObjectFile *O, const char *sect, | ||||
6887 | uint32_t size, bool verbose, | ||||
6888 | bool PrintXarHeader, bool PrintXarFileHeaders, | ||||
6889 | std::string XarMemberName) { | ||||
6890 | if(size < sizeof(struct xar_header)) { | ||||
6891 | outs() << "size of (__LLVM,__bundle) section too small (smaller than size " | ||||
6892 | "of struct xar_header)\n"; | ||||
6893 | return; | ||||
6894 | } | ||||
6895 | struct xar_header XarHeader; | ||||
6896 | memcpy(&XarHeader, sect, sizeof(struct xar_header)); | ||||
6897 | if (sys::IsLittleEndianHost) | ||||
6898 | swapStruct(XarHeader); | ||||
6899 | if (PrintXarHeader) { | ||||
6900 | if (!XarMemberName.empty()) | ||||
6901 | outs() << "In xar member " << XarMemberName << ": "; | ||||
6902 | else | ||||
6903 | outs() << "For (__LLVM,__bundle) section: "; | ||||
6904 | outs() << "xar header\n"; | ||||
6905 | if (XarHeader.magic == XAR_HEADER_MAGIC) | ||||
6906 | outs() << " magic XAR_HEADER_MAGIC\n"; | ||||
6907 | else | ||||
6908 | outs() << " magic " | ||||
6909 | << format_hex(XarHeader.magic, 10, true) | ||||
6910 | << " (not XAR_HEADER_MAGIC)\n"; | ||||
6911 | outs() << " size " << XarHeader.size << "\n"; | ||||
6912 | outs() << " version " << XarHeader.version << "\n"; | ||||
6913 | outs() << " toc_length_compressed " << XarHeader.toc_length_compressed | ||||
6914 | << "\n"; | ||||
6915 | outs() << "toc_length_uncompressed " << XarHeader.toc_length_uncompressed | ||||
6916 | << "\n"; | ||||
6917 | outs() << " cksum_alg "; | ||||
6918 | switch (XarHeader.cksum_alg) { | ||||
6919 | case XAR_CKSUM_NONE: | ||||
6920 | outs() << "XAR_CKSUM_NONE\n"; | ||||
6921 | break; | ||||
6922 | case XAR_CKSUM_SHA1: | ||||
6923 | outs() << "XAR_CKSUM_SHA1\n"; | ||||
6924 | break; | ||||
6925 | case XAR_CKSUM_MD5: | ||||
6926 | outs() << "XAR_CKSUM_MD5\n"; | ||||
6927 | break; | ||||
6928 | #ifdef XAR_CKSUM_SHA256 | ||||
6929 | case XAR_CKSUM_SHA256: | ||||
6930 | outs() << "XAR_CKSUM_SHA256\n"; | ||||
6931 | break; | ||||
6932 | #endif | ||||
6933 | #ifdef XAR_CKSUM_SHA512 | ||||
6934 | case XAR_CKSUM_SHA512: | ||||
6935 | outs() << "XAR_CKSUM_SHA512\n"; | ||||
6936 | break; | ||||
6937 | #endif | ||||
6938 | default: | ||||
6939 | outs() << XarHeader.cksum_alg << "\n"; | ||||
6940 | } | ||||
6941 | } | ||||
6942 | |||||
6943 | SmallString<128> XarFilename; | ||||
6944 | int FD; | ||||
6945 | std::error_code XarEC = | ||||
6946 | sys::fs::createTemporaryFile("llvm-objdump", "xar", FD, XarFilename); | ||||
6947 | if (XarEC) { | ||||
6948 | WithColor::error(errs(), "llvm-objdump") << XarEC.message() << "\n"; | ||||
6949 | return; | ||||
6950 | } | ||||
6951 | ToolOutputFile XarFile(XarFilename, FD); | ||||
6952 | raw_fd_ostream &XarOut = XarFile.os(); | ||||
6953 | StringRef XarContents(sect, size); | ||||
6954 | XarOut << XarContents; | ||||
6955 | XarOut.close(); | ||||
6956 | if (XarOut.has_error()) | ||||
6957 | return; | ||||
6958 | |||||
6959 | ScopedXarFile xar(XarFilename.c_str(), READ); | ||||
6960 | if (!xar) { | ||||
6961 | WithColor::error(errs(), "llvm-objdump") | ||||
6962 | << "can't create temporary xar archive " << XarFilename << "\n"; | ||||
6963 | return; | ||||
6964 | } | ||||
6965 | |||||
6966 | SmallString<128> TocFilename; | ||||
6967 | std::error_code TocEC = | ||||
6968 | sys::fs::createTemporaryFile("llvm-objdump", "toc", TocFilename); | ||||
6969 | if (TocEC) { | ||||
6970 | WithColor::error(errs(), "llvm-objdump") << TocEC.message() << "\n"; | ||||
6971 | return; | ||||
6972 | } | ||||
6973 | xar_serialize(xar, TocFilename.c_str()); | ||||
6974 | |||||
6975 | if (PrintXarFileHeaders) { | ||||
6976 | if (!XarMemberName.empty()) | ||||
6977 | outs() << "In xar member " << XarMemberName << ": "; | ||||
6978 | else | ||||
6979 | outs() << "For (__LLVM,__bundle) section: "; | ||||
6980 | outs() << "xar archive files:\n"; | ||||
6981 | PrintXarFilesSummary(XarFilename.c_str(), xar); | ||||
6982 | } | ||||
6983 | |||||
6984 | ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr = | ||||
6985 | MemoryBuffer::getFileOrSTDIN(TocFilename.c_str()); | ||||
6986 | if (std::error_code EC = FileOrErr.getError()) { | ||||
6987 | WithColor::error(errs(), "llvm-objdump") << EC.message() << "\n"; | ||||
6988 | return; | ||||
6989 | } | ||||
6990 | std::unique_ptr<MemoryBuffer> &Buffer = FileOrErr.get(); | ||||
6991 | |||||
6992 | if (!XarMemberName.empty()) | ||||
6993 | outs() << "In xar member " << XarMemberName << ": "; | ||||
6994 | else | ||||
6995 | outs() << "For (__LLVM,__bundle) section: "; | ||||
6996 | outs() << "xar table of contents:\n"; | ||||
6997 | outs() << Buffer->getBuffer() << "\n"; | ||||
6998 | |||||
6999 | // TODO: Go through the xar's files. | ||||
7000 | ScopedXarIter xi; | ||||
7001 | if(!xi){ | ||||
7002 | WithColor::error(errs(), "llvm-objdump") | ||||
7003 | << "can't obtain an xar iterator for xar archive " | ||||
7004 | << XarFilename.c_str() << "\n"; | ||||
7005 | return; | ||||
7006 | } | ||||
7007 | for(xar_file_t xf = xar_file_first(xar, xi); xf; xf = xar_file_next(xi)){ | ||||
7008 | const char *key; | ||||
7009 | const char *member_name, *member_type, *member_size_string; | ||||
7010 | size_t member_size; | ||||
7011 | |||||
7012 | ScopedXarIter xp; | ||||
7013 | if(!xp){ | ||||
7014 | WithColor::error(errs(), "llvm-objdump") | ||||
7015 | << "can't obtain an xar iterator for xar archive " | ||||
7016 | << XarFilename.c_str() << "\n"; | ||||
7017 | return; | ||||
7018 | } | ||||
7019 | member_name = NULL__null; | ||||
7020 | member_type = NULL__null; | ||||
7021 | member_size_string = NULL__null; | ||||
7022 | for(key = xar_prop_first(xf, xp); key; key = xar_prop_next(xp)){ | ||||
7023 | const char *val = nullptr; | ||||
7024 | xar_prop_get(xf, key, &val); | ||||
7025 | #if 0 // Useful for debugging. | ||||
7026 | outs() << "key: " << key << " value: " << val << "\n"; | ||||
7027 | #endif | ||||
7028 | if (strcmp(key, "name") == 0) | ||||
7029 | member_name = val; | ||||
7030 | if (strcmp(key, "type") == 0) | ||||
7031 | member_type = val; | ||||
7032 | if (strcmp(key, "data/size") == 0) | ||||
7033 | member_size_string = val; | ||||
7034 | } | ||||
7035 | /* | ||||
7036 | * If we find a file with a name, date/size and type properties | ||||
7037 | * and with the type being "file" see if that is a xar file. | ||||
7038 | */ | ||||
7039 | if (member_name != NULL__null && member_type != NULL__null && | ||||
7040 | strcmp(member_type, "file") == 0 && | ||||
7041 | member_size_string != NULL__null){ | ||||
7042 | // Extract the file into a buffer. | ||||
7043 | char *endptr; | ||||
7044 | member_size = strtoul(member_size_string, &endptr, 10); | ||||
7045 | if (*endptr == '\0' && member_size != 0) { | ||||
7046 | char *buffer; | ||||
7047 | if (xar_extract_tobuffersz(xar, xf, &buffer, &member_size) == 0) { | ||||
7048 | #if 0 // Useful for debugging. | ||||
7049 | outs() << "xar member: " << member_name << " extracted\n"; | ||||
7050 | #endif | ||||
7051 | // Set the XarMemberName we want to see printed in the header. | ||||
7052 | std::string OldXarMemberName; | ||||
7053 | // If XarMemberName is already set this is nested. So | ||||
7054 | // save the old name and create the nested name. | ||||
7055 | if (!XarMemberName.empty()) { | ||||
7056 | OldXarMemberName = XarMemberName; | ||||
7057 | XarMemberName = | ||||
7058 | (Twine("[") + XarMemberName + "]" + member_name).str(); | ||||
7059 | } else { | ||||
7060 | OldXarMemberName = ""; | ||||
7061 | XarMemberName = member_name; | ||||
7062 | } | ||||
7063 | // See if this is could be a xar file (nested). | ||||
7064 | if (member_size >= sizeof(struct xar_header)) { | ||||
7065 | #if 0 // Useful for debugging. | ||||
7066 | outs() << "could be a xar file: " << member_name << "\n"; | ||||
7067 | #endif | ||||
7068 | memcpy((char *)&XarHeader, buffer, sizeof(struct xar_header)); | ||||
7069 | if (sys::IsLittleEndianHost) | ||||
7070 | swapStruct(XarHeader); | ||||
7071 | if (XarHeader.magic == XAR_HEADER_MAGIC) | ||||
7072 | DumpBitcodeSection(O, buffer, member_size, verbose, | ||||
7073 | PrintXarHeader, PrintXarFileHeaders, | ||||
7074 | XarMemberName); | ||||
7075 | } | ||||
7076 | XarMemberName = OldXarMemberName; | ||||
7077 | delete buffer; | ||||
7078 | } | ||||
7079 | } | ||||
7080 | } | ||||
7081 | } | ||||
7082 | } | ||||
7083 | #endif // defined(LLVM_HAVE_LIBXAR) | ||||
7084 | |||||
7085 | static void printObjcMetaData(MachOObjectFile *O, bool verbose) { | ||||
7086 | if (O->is64Bit()) | ||||
7087 | printObjc2_64bit_MetaData(O, verbose); | ||||
7088 | else { | ||||
7089 | MachO::mach_header H; | ||||
7090 | H = O->getHeader(); | ||||
7091 | if (H.cputype == MachO::CPU_TYPE_ARM) | ||||
7092 | printObjc2_32bit_MetaData(O, verbose); | ||||
7093 | else { | ||||
7094 | // This is the 32-bit non-arm cputype case. Which is normally | ||||
7095 | // the first Objective-C ABI. But it may be the case of a | ||||
7096 | // binary for the iOS simulator which is the second Objective-C | ||||
7097 | // ABI. In that case printObjc1_32bit_MetaData() will determine that | ||||
7098 | // and return false. | ||||
7099 | if (!printObjc1_32bit_MetaData(O, verbose)) | ||||
7100 | printObjc2_32bit_MetaData(O, verbose); | ||||
7101 | } | ||||
7102 | } | ||||
7103 | } | ||||
7104 | |||||
7105 | // GuessLiteralPointer returns a string which for the item in the Mach-O file | ||||
7106 | // for the address passed in as ReferenceValue for printing as a comment with | ||||
7107 | // the instruction and also returns the corresponding type of that item | ||||
7108 | // indirectly through ReferenceType. | ||||
7109 | // | ||||
7110 | // If ReferenceValue is an address of literal cstring then a pointer to the | ||||
7111 | // cstring is returned and ReferenceType is set to | ||||
7112 | // LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr . | ||||
7113 | // | ||||
7114 | // If ReferenceValue is an address of an Objective-C CFString, Selector ref or | ||||
7115 | // Class ref that name is returned and the ReferenceType is set accordingly. | ||||
7116 | // | ||||
7117 | // Lastly, literals which are Symbol address in a literal pool are looked for | ||||
7118 | // and if found the symbol name is returned and ReferenceType is set to | ||||
7119 | // LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr . | ||||
7120 | // | ||||
7121 | // If there is no item in the Mach-O file for the address passed in as | ||||
7122 | // ReferenceValue nullptr is returned and ReferenceType is unchanged. | ||||
7123 | static const char *GuessLiteralPointer(uint64_t ReferenceValue, | ||||
7124 | uint64_t ReferencePC, | ||||
7125 | uint64_t *ReferenceType, | ||||
7126 | struct DisassembleInfo *info) { | ||||
7127 | // First see if there is an external relocation entry at the ReferencePC. | ||||
7128 | if (info->O->getHeader().filetype == MachO::MH_OBJECT) { | ||||
7129 | uint64_t sect_addr = info->S.getAddress(); | ||||
7130 | uint64_t sect_offset = ReferencePC - sect_addr; | ||||
7131 | bool reloc_found = false; | ||||
7132 | DataRefImpl Rel; | ||||
7133 | MachO::any_relocation_info RE; | ||||
7134 | bool isExtern = false; | ||||
7135 | SymbolRef Symbol; | ||||
7136 | for (const RelocationRef &Reloc : info->S.relocations()) { | ||||
7137 | uint64_t RelocOffset = Reloc.getOffset(); | ||||
7138 | if (RelocOffset == sect_offset) { | ||||
7139 | Rel = Reloc.getRawDataRefImpl(); | ||||
7140 | RE = info->O->getRelocation(Rel); | ||||
7141 | if (info->O->isRelocationScattered(RE)) | ||||
7142 | continue; | ||||
7143 | isExtern = info->O->getPlainRelocationExternal(RE); | ||||
7144 | if (isExtern) { | ||||
7145 | symbol_iterator RelocSym = Reloc.getSymbol(); | ||||
7146 | Symbol = *RelocSym; | ||||
7147 | } | ||||
7148 | reloc_found = true; | ||||
7149 | break; | ||||
7150 | } | ||||
7151 | } | ||||
7152 | // If there is an external relocation entry for a symbol in a section | ||||
7153 | // then used that symbol's value for the value of the reference. | ||||
7154 | if (reloc_found && isExtern) { | ||||
7155 | if (info->O->getAnyRelocationPCRel(RE)) { | ||||
7156 | unsigned Type = info->O->getAnyRelocationType(RE); | ||||
7157 | if (Type == MachO::X86_64_RELOC_SIGNED) { | ||||
7158 | ReferenceValue = cantFail(Symbol.getValue()); | ||||
7159 | } | ||||
7160 | } | ||||
7161 | } | ||||
7162 | } | ||||
7163 | |||||
7164 | // Look for literals such as Objective-C CFStrings refs, Selector refs, | ||||
7165 | // Message refs and Class refs. | ||||
7166 | bool classref, selref, msgref, cfstring; | ||||
7167 | uint64_t pointer_value = GuessPointerPointer(ReferenceValue, info, classref, | ||||
7168 | selref, msgref, cfstring); | ||||
7169 | if (classref && pointer_value == 0) { | ||||
7170 | // Note the ReferenceValue is a pointer into the __objc_classrefs section. | ||||
7171 | // And the pointer_value in that section is typically zero as it will be | ||||
7172 | // set by dyld as part of the "bind information". | ||||
7173 | const char *name = get_dyld_bind_info_symbolname(ReferenceValue, info); | ||||
7174 | if (name != nullptr) { | ||||
7175 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref8; | ||||
7176 | const char *class_name = strrchr(name, '$'); | ||||
7177 | if (class_name != nullptr && class_name[1] == '_' && | ||||
7178 | class_name[2] != '\0') { | ||||
7179 | info->class_name = class_name + 2; | ||||
7180 | return name; | ||||
7181 | } | ||||
7182 | } | ||||
7183 | } | ||||
7184 | |||||
7185 | if (classref) { | ||||
7186 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref8; | ||||
7187 | const char *name = | ||||
7188 | get_objc2_64bit_class_name(pointer_value, ReferenceValue, info); | ||||
7189 | if (name != nullptr) | ||||
7190 | info->class_name = name; | ||||
7191 | else | ||||
7192 | name = "bad class ref"; | ||||
7193 | return name; | ||||
7194 | } | ||||
7195 | |||||
7196 | if (cfstring) { | ||||
7197 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref4; | ||||
7198 | const char *name = get_objc2_64bit_cfstring_name(ReferenceValue, info); | ||||
7199 | return name; | ||||
7200 | } | ||||
7201 | |||||
7202 | if (selref && pointer_value == 0) | ||||
7203 | pointer_value = get_objc2_64bit_selref(ReferenceValue, info); | ||||
7204 | |||||
7205 | if (pointer_value != 0) | ||||
7206 | ReferenceValue = pointer_value; | ||||
7207 | |||||
7208 | const char *name = GuessCstringPointer(ReferenceValue, info); | ||||
7209 | if (name) { | ||||
7210 | if (pointer_value != 0 && selref) { | ||||
7211 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref7; | ||||
7212 | info->selector_name = name; | ||||
7213 | } else if (pointer_value != 0 && msgref) { | ||||
7214 | info->class_name = nullptr; | ||||
7215 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref6; | ||||
7216 | info->selector_name = name; | ||||
7217 | } else | ||||
7218 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr3; | ||||
7219 | return name; | ||||
7220 | } | ||||
7221 | |||||
7222 | // Lastly look for an indirect symbol with this ReferenceValue which is in | ||||
7223 | // a literal pool. If found return that symbol name. | ||||
7224 | name = GuessIndirectSymbol(ReferenceValue, info); | ||||
7225 | if (name) { | ||||
7226 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr2; | ||||
7227 | return name; | ||||
7228 | } | ||||
7229 | |||||
7230 | return nullptr; | ||||
7231 | } | ||||
7232 | |||||
7233 | // SymbolizerSymbolLookUp is the symbol lookup function passed when creating | ||||
7234 | // the Symbolizer. It looks up the ReferenceValue using the info passed via the | ||||
7235 | // pointer to the struct DisassembleInfo that was passed when MCSymbolizer | ||||
7236 | // is created and returns the symbol name that matches the ReferenceValue or | ||||
7237 | // nullptr if none. The ReferenceType is passed in for the IN type of | ||||
7238 | // reference the instruction is making from the values in defined in the header | ||||
7239 | // "llvm-c/Disassembler.h". On return the ReferenceType can set to a specific | ||||
7240 | // Out type and the ReferenceName will also be set which is added as a comment | ||||
7241 | // to the disassembled instruction. | ||||
7242 | // | ||||
7243 | // If the symbol name is a C++ mangled name then the demangled name is | ||||
7244 | // returned through ReferenceName and ReferenceType is set to | ||||
7245 | // LLVMDisassembler_ReferenceType_DeMangled_Name . | ||||
7246 | // | ||||
7247 | // When this is called to get a symbol name for a branch target then the | ||||
7248 | // ReferenceType will be LLVMDisassembler_ReferenceType_In_Branch and then | ||||
7249 | // SymbolValue will be looked for in the indirect symbol table to determine if | ||||
7250 | // it is an address for a symbol stub. If so then the symbol name for that | ||||
7251 | // stub is returned indirectly through ReferenceName and then ReferenceType is | ||||
7252 | // set to LLVMDisassembler_ReferenceType_Out_SymbolStub. | ||||
7253 | // | ||||
7254 | // When this is called with an value loaded via a PC relative load then | ||||
7255 | // ReferenceType will be LLVMDisassembler_ReferenceType_In_PCrel_Load then the | ||||
7256 | // SymbolValue is checked to be an address of literal pointer, symbol pointer, | ||||
7257 | // or an Objective-C meta data reference. If so the output ReferenceType is | ||||
7258 | // set to correspond to that as well as setting the ReferenceName. | ||||
7259 | static const char *SymbolizerSymbolLookUp(void *DisInfo, | ||||
7260 | uint64_t ReferenceValue, | ||||
7261 | uint64_t *ReferenceType, | ||||
7262 | uint64_t ReferencePC, | ||||
7263 | const char **ReferenceName) { | ||||
7264 | struct DisassembleInfo *info = (struct DisassembleInfo *)DisInfo; | ||||
7265 | // If no verbose symbolic information is wanted then just return nullptr. | ||||
7266 | if (!info->verbose) { | ||||
7267 | *ReferenceName = nullptr; | ||||
7268 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7269 | return nullptr; | ||||
7270 | } | ||||
7271 | |||||
7272 | const char *SymbolName = GuessSymbolName(ReferenceValue, info->AddrMap); | ||||
7273 | |||||
7274 | if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch1) { | ||||
7275 | *ReferenceName = GuessIndirectSymbol(ReferenceValue, info); | ||||
7276 | if (*ReferenceName != nullptr) { | ||||
7277 | method_reference(info, ReferenceType, ReferenceName); | ||||
7278 | if (*ReferenceType != LLVMDisassembler_ReferenceType_Out_Objc_Message5) | ||||
7279 | *ReferenceType = LLVMDisassembler_ReferenceType_Out_SymbolStub1; | ||||
7280 | } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) { | ||||
7281 | if (info->demangled_name != nullptr) | ||||
7282 | free(info->demangled_name); | ||||
7283 | info->demangled_name = itaniumDemangle(SymbolName + 1); | ||||
7284 | if (info->demangled_name != nullptr) { | ||||
7285 | *ReferenceName = info->demangled_name; | ||||
7286 | *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name9; | ||||
7287 | } else | ||||
7288 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7289 | } else | ||||
7290 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7291 | } else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load2) { | ||||
7292 | *ReferenceName = | ||||
7293 | GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info); | ||||
7294 | if (*ReferenceName) | ||||
7295 | method_reference(info, ReferenceType, ReferenceName); | ||||
7296 | else | ||||
7297 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7298 | // If this is arm64 and the reference is an adrp instruction save the | ||||
7299 | // instruction, passed in ReferenceValue and the address of the instruction | ||||
7300 | // for use later if we see and add immediate instruction. | ||||
7301 | } else if (info->O->getArch() == Triple::aarch64 && | ||||
7302 | *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADRP0x100000001) { | ||||
7303 | info->adrp_inst = ReferenceValue; | ||||
7304 | info->adrp_addr = ReferencePC; | ||||
7305 | SymbolName = nullptr; | ||||
7306 | *ReferenceName = nullptr; | ||||
7307 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7308 | // If this is arm64 and reference is an add immediate instruction and we | ||||
7309 | // have | ||||
7310 | // seen an adrp instruction just before it and the adrp's Xd register | ||||
7311 | // matches | ||||
7312 | // this add's Xn register reconstruct the value being referenced and look to | ||||
7313 | // see if it is a literal pointer. Note the add immediate instruction is | ||||
7314 | // passed in ReferenceValue. | ||||
7315 | } else if (info->O->getArch() == Triple::aarch64 && | ||||
7316 | *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADDXri0x100000002 && | ||||
7317 | ReferencePC - 4 == info->adrp_addr && | ||||
7318 | (info->adrp_inst & 0x9f000000) == 0x90000000 && | ||||
7319 | (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) { | ||||
7320 | uint32_t addxri_inst; | ||||
7321 | uint64_t adrp_imm, addxri_imm; | ||||
7322 | |||||
7323 | adrp_imm = | ||||
7324 | ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3); | ||||
7325 | if (info->adrp_inst & 0x0200000) | ||||
7326 | adrp_imm |= 0xfffffffffc000000LL; | ||||
7327 | |||||
7328 | addxri_inst = ReferenceValue; | ||||
7329 | addxri_imm = (addxri_inst >> 10) & 0xfff; | ||||
7330 | if (((addxri_inst >> 22) & 0x3) == 1) | ||||
7331 | addxri_imm <<= 12; | ||||
7332 | |||||
7333 | ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) + | ||||
7334 | (adrp_imm << 12) + addxri_imm; | ||||
7335 | |||||
7336 | *ReferenceName = | ||||
7337 | GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info); | ||||
7338 | if (*ReferenceName == nullptr) | ||||
7339 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7340 | // If this is arm64 and the reference is a load register instruction and we | ||||
7341 | // have seen an adrp instruction just before it and the adrp's Xd register | ||||
7342 | // matches this add's Xn register reconstruct the value being referenced and | ||||
7343 | // look to see if it is a literal pointer. Note the load register | ||||
7344 | // instruction is passed in ReferenceValue. | ||||
7345 | } else if (info->O->getArch() == Triple::aarch64 && | ||||
7346 | *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXui0x100000003 && | ||||
7347 | ReferencePC - 4 == info->adrp_addr && | ||||
7348 | (info->adrp_inst & 0x9f000000) == 0x90000000 && | ||||
7349 | (info->adrp_inst & 0x1f) == ((ReferenceValue >> 5) & 0x1f)) { | ||||
7350 | uint32_t ldrxui_inst; | ||||
7351 | uint64_t adrp_imm, ldrxui_imm; | ||||
7352 | |||||
7353 | adrp_imm = | ||||
7354 | ((info->adrp_inst & 0x00ffffe0) >> 3) | ((info->adrp_inst >> 29) & 0x3); | ||||
7355 | if (info->adrp_inst & 0x0200000) | ||||
7356 | adrp_imm |= 0xfffffffffc000000LL; | ||||
7357 | |||||
7358 | ldrxui_inst = ReferenceValue; | ||||
7359 | ldrxui_imm = (ldrxui_inst >> 10) & 0xfff; | ||||
7360 | |||||
7361 | ReferenceValue = (info->adrp_addr & 0xfffffffffffff000LL) + | ||||
7362 | (adrp_imm << 12) + (ldrxui_imm << 3); | ||||
7363 | |||||
7364 | *ReferenceName = | ||||
7365 | GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info); | ||||
7366 | if (*ReferenceName == nullptr) | ||||
7367 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7368 | } | ||||
7369 | // If this arm64 and is an load register (PC-relative) instruction the | ||||
7370 | // ReferenceValue is the PC plus the immediate value. | ||||
7371 | else if (info->O->getArch() == Triple::aarch64 && | ||||
7372 | (*ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_LDRXl0x100000004 || | ||||
7373 | *ReferenceType == LLVMDisassembler_ReferenceType_In_ARM64_ADR0x100000005)) { | ||||
7374 | *ReferenceName = | ||||
7375 | GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info); | ||||
7376 | if (*ReferenceName == nullptr) | ||||
7377 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7378 | } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) { | ||||
7379 | if (info->demangled_name != nullptr) | ||||
7380 | free(info->demangled_name); | ||||
7381 | info->demangled_name = itaniumDemangle(SymbolName + 1); | ||||
7382 | if (info->demangled_name != nullptr) { | ||||
7383 | *ReferenceName = info->demangled_name; | ||||
7384 | *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name9; | ||||
7385 | } | ||||
7386 | } | ||||
7387 | else { | ||||
7388 | *ReferenceName = nullptr; | ||||
7389 | *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None0; | ||||
7390 | } | ||||
7391 | |||||
7392 | return SymbolName; | ||||
7393 | } | ||||
7394 | |||||
7395 | /// Emits the comments that are stored in the CommentStream. | ||||
7396 | /// Each comment in the CommentStream must end with a newline. | ||||
7397 | static void emitComments(raw_svector_ostream &CommentStream, | ||||
7398 | SmallString<128> &CommentsToEmit, | ||||
7399 | formatted_raw_ostream &FormattedOS, | ||||
7400 | const MCAsmInfo &MAI) { | ||||
7401 | // Flush the stream before taking its content. | ||||
7402 | StringRef Comments = CommentsToEmit.str(); | ||||
7403 | // Get the default information for printing a comment. | ||||
7404 | StringRef CommentBegin = MAI.getCommentString(); | ||||
7405 | unsigned CommentColumn = MAI.getCommentColumn(); | ||||
7406 | ListSeparator LS("\n"); | ||||
7407 | while (!Comments.empty()) { | ||||
7408 | FormattedOS << LS; | ||||
7409 | // Emit a line of comments. | ||||
7410 | FormattedOS.PadToColumn(CommentColumn); | ||||
7411 | size_t Position = Comments.find('\n'); | ||||
7412 | FormattedOS << CommentBegin << ' ' << Comments.substr(0, Position); | ||||
7413 | // Move after the newline character. | ||||
7414 | Comments = Comments.substr(Position + 1); | ||||
7415 | } | ||||
7416 | FormattedOS.flush(); | ||||
7417 | |||||
7418 | // Tell the comment stream that the vector changed underneath it. | ||||
7419 | CommentsToEmit.clear(); | ||||
7420 | } | ||||
7421 | |||||
7422 | const MachOObjectFile * | ||||
7423 | objdump::getMachODSymObject(const MachOObjectFile *MachOOF, StringRef Filename, | ||||
7424 | std::unique_ptr<Binary> &DSYMBinary, | ||||
7425 | std::unique_ptr<MemoryBuffer> &DSYMBuf) { | ||||
7426 | const MachOObjectFile *DbgObj = MachOOF; | ||||
7427 | std::string DSYMPath; | ||||
7428 | |||||
7429 | // Auto-detect w/o --dsym. | ||||
7430 | if (DSYMFile.empty()) { | ||||
7431 | sys::fs::file_status DSYMStatus; | ||||
7432 | Twine FilenameDSYM = Filename + ".dSYM"; | ||||
7433 | if (!status(FilenameDSYM, DSYMStatus)) { | ||||
7434 | if (sys::fs::is_directory(DSYMStatus)) { | ||||
7435 | SmallString<1024> Path; | ||||
7436 | FilenameDSYM.toVector(Path); | ||||
7437 | sys::path::append(Path, "Contents", "Resources", "DWARF", | ||||
7438 | sys::path::filename(Filename)); | ||||
7439 | DSYMPath = std::string(Path); | ||||
7440 | } else if (sys::fs::is_regular_file(DSYMStatus)) { | ||||
7441 | DSYMPath = FilenameDSYM.str(); | ||||
7442 | } | ||||
7443 | } | ||||
7444 | } | ||||
7445 | |||||
7446 | if (DSYMPath.empty() && !DSYMFile.empty()) { | ||||
7447 | // If DSYMPath is a .dSYM directory, append the Mach-O file. | ||||
7448 | if (sys::fs::is_directory(DSYMFile) && | ||||
7449 | sys::path::extension(DSYMFile) == ".dSYM") { | ||||
7450 | SmallString<128> ShortName(sys::path::filename(DSYMFile)); | ||||
7451 | sys::path::replace_extension(ShortName, ""); | ||||
7452 | SmallString<1024> FullPath(DSYMFile); | ||||
7453 | sys::path::append(FullPath, "Contents", "Resources", "DWARF", ShortName); | ||||
7454 | DSYMPath = FullPath.str(); | ||||
7455 | } else { | ||||
7456 | DSYMPath = DSYMFile; | ||||
7457 | } | ||||
7458 | } | ||||
7459 | |||||
7460 | if (!DSYMPath.empty()) { | ||||
7461 | // Load the file. | ||||
7462 | ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr = | ||||
7463 | MemoryBuffer::getFileOrSTDIN(DSYMPath); | ||||
7464 | if (std::error_code EC = BufOrErr.getError()) { | ||||
7465 | reportError(errorCodeToError(EC), DSYMPath); | ||||
7466 | return nullptr; | ||||
7467 | } | ||||
7468 | |||||
7469 | // We need to keep the file alive, because we're replacing DbgObj with it. | ||||
7470 | DSYMBuf = std::move(BufOrErr.get()); | ||||
7471 | |||||
7472 | Expected<std::unique_ptr<Binary>> BinaryOrErr = | ||||
7473 | createBinary(DSYMBuf.get()->getMemBufferRef()); | ||||
7474 | if (!BinaryOrErr) { | ||||
7475 | reportError(BinaryOrErr.takeError(), DSYMPath); | ||||
7476 | return nullptr; | ||||
7477 | } | ||||
7478 | |||||
7479 | // We need to keep the Binary alive with the buffer | ||||
7480 | DSYMBinary = std::move(BinaryOrErr.get()); | ||||
7481 | if (ObjectFile *O = dyn_cast<ObjectFile>(DSYMBinary.get())) { | ||||
7482 | // this is a Mach-O object file, use it | ||||
7483 | if (MachOObjectFile *MachDSYM = dyn_cast<MachOObjectFile>(&*O)) { | ||||
7484 | DbgObj = MachDSYM; | ||||
7485 | } else { | ||||
7486 | WithColor::error(errs(), "llvm-objdump") | ||||
7487 | << DSYMPath << " is not a Mach-O file type.\n"; | ||||
7488 | return nullptr; | ||||
7489 | } | ||||
7490 | } else if (auto *UB = dyn_cast<MachOUniversalBinary>(DSYMBinary.get())) { | ||||
7491 | // this is a Universal Binary, find a Mach-O for this architecture | ||||
7492 | uint32_t CPUType, CPUSubType; | ||||
7493 | const char *ArchFlag; | ||||
7494 | if (MachOOF->is64Bit()) { | ||||
7495 | const MachO::mach_header_64 H_64 = MachOOF->getHeader64(); | ||||
7496 | CPUType = H_64.cputype; | ||||
7497 | CPUSubType = H_64.cpusubtype; | ||||
7498 | } else { | ||||
7499 | const MachO::mach_header H = MachOOF->getHeader(); | ||||
7500 | CPUType = H.cputype; | ||||
7501 | CPUSubType = H.cpusubtype; | ||||
7502 | } | ||||
7503 | Triple T = MachOObjectFile::getArchTriple(CPUType, CPUSubType, nullptr, | ||||
7504 | &ArchFlag); | ||||
7505 | Expected<std::unique_ptr<MachOObjectFile>> MachDSYM = | ||||
7506 | UB->getMachOObjectForArch(ArchFlag); | ||||
7507 | if (!MachDSYM) { | ||||
7508 | reportError(MachDSYM.takeError(), DSYMPath); | ||||
7509 | return nullptr; | ||||
7510 | } | ||||
7511 | |||||
7512 | // We need to keep the Binary alive with the buffer | ||||
7513 | DbgObj = &*MachDSYM.get(); | ||||
7514 | DSYMBinary = std::move(*MachDSYM); | ||||
7515 | } else { | ||||
7516 | WithColor::error(errs(), "llvm-objdump") | ||||
7517 | << DSYMPath << " is not a Mach-O or Universal file type.\n"; | ||||
7518 | return nullptr; | ||||
7519 | } | ||||
7520 | } | ||||
7521 | return DbgObj; | ||||
7522 | } | ||||
7523 | |||||
7524 | static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF, | ||||
7525 | StringRef DisSegName, StringRef DisSectName) { | ||||
7526 | const char *McpuDefault = nullptr; | ||||
7527 | const Target *ThumbTarget = nullptr; | ||||
7528 | const Target *TheTarget = GetTarget(MachOOF, &McpuDefault, &ThumbTarget); | ||||
7529 | if (!TheTarget) { | ||||
7530 | // GetTarget prints out stuff. | ||||
7531 | return; | ||||
7532 | } | ||||
7533 | std::string MachOMCPU; | ||||
7534 | if (MCPU.empty() && McpuDefault) | ||||
7535 | MachOMCPU = McpuDefault; | ||||
7536 | else | ||||
7537 | MachOMCPU = MCPU; | ||||
7538 | |||||
7539 | #define CHECK_TARGET_INFO_CREATION(NAME) \ | ||||
7540 | do { \ | ||||
7541 | if (!NAME) { \ | ||||
7542 | WithColor::error(errs(), "llvm-objdump") \ | ||||
7543 | << "couldn't initialize disassembler for target " << TripleName \ | ||||
7544 | << '\n'; \ | ||||
7545 | return; \ | ||||
7546 | } \ | ||||
7547 | } while (false) | ||||
7548 | #define CHECK_THUMB_TARGET_INFO_CREATION(NAME) \ | ||||
7549 | do { \ | ||||
7550 | if (!NAME) { \ | ||||
7551 | WithColor::error(errs(), "llvm-objdump") \ | ||||
7552 | << "couldn't initialize disassembler for target " << ThumbTripleName \ | ||||
7553 | << '\n'; \ | ||||
7554 | return; \ | ||||
7555 | } \ | ||||
7556 | } while (false) | ||||
7557 | |||||
7558 | std::unique_ptr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo()); | ||||
7559 | CHECK_TARGET_INFO_CREATION(InstrInfo); | ||||
7560 | std::unique_ptr<const MCInstrInfo> ThumbInstrInfo; | ||||
7561 | if (ThumbTarget) { | ||||
7562 | ThumbInstrInfo.reset(ThumbTarget->createMCInstrInfo()); | ||||
7563 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbInstrInfo); | ||||
7564 | } | ||||
7565 | |||||
7566 | // Package up features to be passed to target/subtarget | ||||
7567 | std::string FeaturesStr; | ||||
7568 | if (!MAttrs.empty()) { | ||||
7569 | SubtargetFeatures Features; | ||||
7570 | for (unsigned i = 0; i != MAttrs.size(); ++i) | ||||
7571 | Features.AddFeature(MAttrs[i]); | ||||
7572 | FeaturesStr = Features.getString(); | ||||
7573 | } | ||||
7574 | |||||
7575 | MCTargetOptions MCOptions; | ||||
7576 | // Set up disassembler. | ||||
7577 | std::unique_ptr<const MCRegisterInfo> MRI( | ||||
7578 | TheTarget->createMCRegInfo(TripleName)); | ||||
7579 | CHECK_TARGET_INFO_CREATION(MRI); | ||||
7580 | std::unique_ptr<const MCAsmInfo> AsmInfo( | ||||
7581 | TheTarget->createMCAsmInfo(*MRI, TripleName, MCOptions)); | ||||
7582 | CHECK_TARGET_INFO_CREATION(AsmInfo); | ||||
7583 | std::unique_ptr<const MCSubtargetInfo> STI( | ||||
7584 | TheTarget->createMCSubtargetInfo(TripleName, MachOMCPU, FeaturesStr)); | ||||
7585 | CHECK_TARGET_INFO_CREATION(STI); | ||||
7586 | MCContext Ctx(Triple(TripleName), AsmInfo.get(), MRI.get(), STI.get()); | ||||
7587 | std::unique_ptr<MCDisassembler> DisAsm( | ||||
7588 | TheTarget->createMCDisassembler(*STI, Ctx)); | ||||
7589 | CHECK_TARGET_INFO_CREATION(DisAsm); | ||||
7590 | std::unique_ptr<MCSymbolizer> Symbolizer; | ||||
7591 | struct DisassembleInfo SymbolizerInfo(nullptr, nullptr, nullptr, false); | ||||
7592 | std::unique_ptr<MCRelocationInfo> RelInfo( | ||||
7593 | TheTarget->createMCRelocationInfo(TripleName, Ctx)); | ||||
7594 | if (RelInfo) { | ||||
7595 | Symbolizer.reset(TheTarget->createMCSymbolizer( | ||||
7596 | TripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp, | ||||
7597 | &SymbolizerInfo, &Ctx, std::move(RelInfo))); | ||||
7598 | DisAsm->setSymbolizer(std::move(Symbolizer)); | ||||
7599 | } | ||||
7600 | int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); | ||||
7601 | std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter( | ||||
7602 | Triple(TripleName), AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI)); | ||||
7603 | CHECK_TARGET_INFO_CREATION(IP); | ||||
7604 | // Set the display preference for hex vs. decimal immediates. | ||||
7605 | IP->setPrintImmHex(PrintImmHex); | ||||
7606 | // Comment stream and backing vector. | ||||
7607 | SmallString<128> CommentsToEmit; | ||||
7608 | raw_svector_ostream CommentStream(CommentsToEmit); | ||||
7609 | // FIXME: Setting the CommentStream in the InstPrinter is problematic in that | ||||
7610 | // if it is done then arm64 comments for string literals don't get printed | ||||
7611 | // and some constant get printed instead and not setting it causes intel | ||||
7612 | // (32-bit and 64-bit) comments printed with different spacing before the | ||||
7613 | // comment causing different diffs with the 'C' disassembler library API. | ||||
7614 | // IP->setCommentStream(CommentStream); | ||||
7615 | |||||
7616 | // Set up separate thumb disassembler if needed. | ||||
7617 | std::unique_ptr<const MCRegisterInfo> ThumbMRI; | ||||
7618 | std::unique_ptr<const MCAsmInfo> ThumbAsmInfo; | ||||
7619 | std::unique_ptr<const MCSubtargetInfo> ThumbSTI; | ||||
7620 | std::unique_ptr<MCDisassembler> ThumbDisAsm; | ||||
7621 | std::unique_ptr<MCInstPrinter> ThumbIP; | ||||
7622 | std::unique_ptr<MCContext> ThumbCtx; | ||||
7623 | std::unique_ptr<MCSymbolizer> ThumbSymbolizer; | ||||
7624 | struct DisassembleInfo ThumbSymbolizerInfo(nullptr, nullptr, nullptr, false); | ||||
7625 | std::unique_ptr<MCRelocationInfo> ThumbRelInfo; | ||||
7626 | if (ThumbTarget) { | ||||
7627 | ThumbMRI.reset(ThumbTarget->createMCRegInfo(ThumbTripleName)); | ||||
7628 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbMRI); | ||||
7629 | ThumbAsmInfo.reset( | ||||
7630 | ThumbTarget->createMCAsmInfo(*ThumbMRI, ThumbTripleName, MCOptions)); | ||||
7631 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbAsmInfo); | ||||
7632 | ThumbSTI.reset( | ||||
7633 | ThumbTarget->createMCSubtargetInfo(ThumbTripleName, MachOMCPU, | ||||
7634 | FeaturesStr)); | ||||
7635 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbSTI); | ||||
7636 | ThumbCtx.reset(new MCContext(Triple(ThumbTripleName), ThumbAsmInfo.get(), | ||||
7637 | ThumbMRI.get(), ThumbSTI.get())); | ||||
7638 | ThumbDisAsm.reset(ThumbTarget->createMCDisassembler(*ThumbSTI, *ThumbCtx)); | ||||
7639 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbDisAsm); | ||||
7640 | MCContext *PtrThumbCtx = ThumbCtx.get(); | ||||
7641 | ThumbRelInfo.reset( | ||||
7642 | ThumbTarget->createMCRelocationInfo(ThumbTripleName, *PtrThumbCtx)); | ||||
7643 | if (ThumbRelInfo) { | ||||
7644 | ThumbSymbolizer.reset(ThumbTarget->createMCSymbolizer( | ||||
7645 | ThumbTripleName, SymbolizerGetOpInfo, SymbolizerSymbolLookUp, | ||||
7646 | &ThumbSymbolizerInfo, PtrThumbCtx, std::move(ThumbRelInfo))); | ||||
7647 | ThumbDisAsm->setSymbolizer(std::move(ThumbSymbolizer)); | ||||
7648 | } | ||||
7649 | int ThumbAsmPrinterVariant = ThumbAsmInfo->getAssemblerDialect(); | ||||
7650 | ThumbIP.reset(ThumbTarget->createMCInstPrinter( | ||||
7651 | Triple(ThumbTripleName), ThumbAsmPrinterVariant, *ThumbAsmInfo, | ||||
7652 | *ThumbInstrInfo, *ThumbMRI)); | ||||
7653 | CHECK_THUMB_TARGET_INFO_CREATION(ThumbIP); | ||||
7654 | // Set the display preference for hex vs. decimal immediates. | ||||
7655 | ThumbIP->setPrintImmHex(PrintImmHex); | ||||
7656 | } | ||||
7657 | |||||
7658 | #undef CHECK_TARGET_INFO_CREATION | ||||
7659 | #undef CHECK_THUMB_TARGET_INFO_CREATION | ||||
7660 | |||||
7661 | MachO::mach_header Header = MachOOF->getHeader(); | ||||
7662 | |||||
7663 | // FIXME: Using the -cfg command line option, this code used to be able to | ||||
7664 | // annotate relocations with the referenced symbol's name, and if this was | ||||
7665 | // inside a __[cf]string section, the data it points to. This is now replaced | ||||
7666 | // by the upcoming MCSymbolizer, which needs the appropriate setup done above. | ||||
7667 | std::vector<SectionRef> Sections; | ||||
7668 | std::vector<SymbolRef> Symbols; | ||||
7669 | SmallVector<uint64_t, 8> FoundFns; | ||||
7670 | uint64_t BaseSegmentAddress = 0; | ||||
7671 | |||||
7672 | getSectionsAndSymbols(MachOOF, Sections, Symbols, FoundFns, | ||||
7673 | BaseSegmentAddress); | ||||
7674 | |||||
7675 | // Sort the symbols by address, just in case they didn't come in that way. | ||||
7676 | llvm::stable_sort(Symbols, SymbolSorter()); | ||||
7677 | |||||
7678 | // Build a data in code table that is sorted on by the address of each entry. | ||||
7679 | uint64_t BaseAddress = 0; | ||||
7680 | if (Header.filetype == MachO::MH_OBJECT) | ||||
7681 | BaseAddress = Sections[0].getAddress(); | ||||
7682 | else | ||||
7683 | BaseAddress = BaseSegmentAddress; | ||||
7684 | DiceTable Dices; | ||||
7685 | for (dice_iterator DI = MachOOF->begin_dices(), DE = MachOOF->end_dices(); | ||||
7686 | DI != DE; ++DI) { | ||||
7687 | uint32_t Offset; | ||||
7688 | DI->getOffset(Offset); | ||||
7689 | Dices.push_back(std::make_pair(BaseAddress + Offset, *DI)); | ||||
7690 | } | ||||
7691 | array_pod_sort(Dices.begin(), Dices.end()); | ||||
7692 | |||||
7693 | // Try to find debug info and set up the DIContext for it. | ||||
7694 | std::unique_ptr<DIContext> diContext; | ||||
7695 | std::unique_ptr<Binary> DSYMBinary; | ||||
7696 | std::unique_ptr<MemoryBuffer> DSYMBuf; | ||||
7697 | if (UseDbg) { | ||||
7698 | // If separate DSym file path was specified, parse it as a macho file, | ||||
7699 | // get the sections and supply it to the section name parsing machinery. | ||||
7700 | if (const ObjectFile *DbgObj = | ||||
7701 | getMachODSymObject(MachOOF, Filename, DSYMBinary, DSYMBuf)) { | ||||
7702 | // Setup the DIContext | ||||
7703 | diContext = DWARFContext::create(*DbgObj); | ||||
7704 | } else { | ||||
7705 | return; | ||||
7706 | } | ||||
7707 | } | ||||
7708 | |||||
7709 | if (FilterSections.empty()) | ||||
7710 | outs() << "(" << DisSegName << "," << DisSectName << ") section\n"; | ||||
7711 | |||||
7712 | for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) { | ||||
7713 | Expected<StringRef> SecNameOrErr = Sections[SectIdx].getName(); | ||||
7714 | if (!SecNameOrErr) { | ||||
7715 | consumeError(SecNameOrErr.takeError()); | ||||
7716 | continue; | ||||
7717 | } | ||||
7718 | if (*SecNameOrErr != DisSectName) | ||||
7719 | continue; | ||||
7720 | |||||
7721 | DataRefImpl DR = Sections[SectIdx].getRawDataRefImpl(); | ||||
7722 | |||||
7723 | StringRef SegmentName = MachOOF->getSectionFinalSegmentName(DR); | ||||
7724 | if (SegmentName != DisSegName) | ||||
7725 | continue; | ||||
7726 | |||||
7727 | StringRef BytesStr = | ||||
7728 | unwrapOrError(Sections[SectIdx].getContents(), Filename); | ||||
7729 | ArrayRef<uint8_t> Bytes = arrayRefFromStringRef(BytesStr); | ||||
7730 | uint64_t SectAddress = Sections[SectIdx].getAddress(); | ||||
7731 | |||||
7732 | bool symbolTableWorked = false; | ||||
7733 | |||||
7734 | // Create a map of symbol addresses to symbol names for use by | ||||
7735 | // the SymbolizerSymbolLookUp() routine. | ||||
7736 | SymbolAddressMap AddrMap; | ||||
7737 | bool DisSymNameFound = false; | ||||
7738 | for (const SymbolRef &Symbol : MachOOF->symbols()) { | ||||
7739 | SymbolRef::Type ST = | ||||
7740 | unwrapOrError(Symbol.getType(), MachOOF->getFileName()); | ||||
7741 | if (ST == SymbolRef::ST_Function || ST == SymbolRef::ST_Data || | ||||
7742 | ST == SymbolRef::ST_Other) { | ||||
7743 | uint64_t Address = cantFail(Symbol.getValue()); | ||||
7744 | StringRef SymName = | ||||
7745 | unwrapOrError(Symbol.getName(), MachOOF->getFileName()); | ||||
7746 | AddrMap[Address] = SymName; | ||||
7747 | if (!DisSymName.empty() && DisSymName == SymName) | ||||
7748 | DisSymNameFound = true; | ||||
7749 | } | ||||
7750 | } | ||||
7751 | if (!DisSymName.empty() && !DisSymNameFound) { | ||||
7752 | outs() << "Can't find -dis-symname: " << DisSymName << "\n"; | ||||
7753 | return; | ||||
7754 | } | ||||
7755 | // Set up the block of info used by the Symbolizer call backs. | ||||
7756 | SymbolizerInfo.verbose = SymbolicOperands; | ||||
7757 | SymbolizerInfo.O = MachOOF; | ||||
7758 | SymbolizerInfo.S = Sections[SectIdx]; | ||||
7759 | SymbolizerInfo.AddrMap = &AddrMap; | ||||
7760 | SymbolizerInfo.Sections = &Sections; | ||||
7761 | // Same for the ThumbSymbolizer | ||||
7762 | ThumbSymbolizerInfo.verbose = SymbolicOperands; | ||||
7763 | ThumbSymbolizerInfo.O = MachOOF; | ||||
7764 | ThumbSymbolizerInfo.S = Sections[SectIdx]; | ||||
7765 | ThumbSymbolizerInfo.AddrMap = &AddrMap; | ||||
7766 | ThumbSymbolizerInfo.Sections = &Sections; | ||||
7767 | |||||
7768 | unsigned int Arch = MachOOF->getArch(); | ||||
7769 | |||||
7770 | // Skip all symbols if this is a stubs file. | ||||
7771 | if (Bytes.empty()) | ||||
7772 | return; | ||||
7773 | |||||
7774 | // If the section has symbols but no symbol at the start of the section | ||||
7775 | // these are used to make sure the bytes before the first symbol are | ||||
7776 | // disassembled. | ||||
7777 | bool FirstSymbol = true; | ||||
7778 | bool FirstSymbolAtSectionStart = true; | ||||
7779 | |||||
7780 | // Disassemble symbol by symbol. | ||||
7781 | for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) { | ||||
7782 | StringRef SymName = | ||||
7783 | unwrapOrError(Symbols[SymIdx].getName(), MachOOF->getFileName()); | ||||
7784 | SymbolRef::Type ST = | ||||
7785 | unwrapOrError(Symbols[SymIdx].getType(), MachOOF->getFileName()); | ||||
7786 | if (ST != SymbolRef::ST_Function && ST != SymbolRef::ST_Data) | ||||
7787 | continue; | ||||
7788 | |||||
7789 | // Make sure the symbol is defined in this section. | ||||
7790 | bool containsSym = Sections[SectIdx].containsSymbol(Symbols[SymIdx]); | ||||
7791 | if (!containsSym) { | ||||
7792 | if (!DisSymName.empty() && DisSymName == SymName) { | ||||
7793 | outs() << "-dis-symname: " << DisSymName << " not in the section\n"; | ||||
7794 | return; | ||||
7795 | } | ||||
7796 | continue; | ||||
7797 | } | ||||
7798 | // The __mh_execute_header is special and we need to deal with that fact | ||||
7799 | // this symbol is before the start of the (__TEXT,__text) section and at the | ||||
7800 | // address of the start of the __TEXT segment. This is because this symbol | ||||
7801 | // is an N_SECT symbol in the (__TEXT,__text) but its address is before the | ||||
7802 | // start of the section in a standard MH_EXECUTE filetype. | ||||
7803 | if (!DisSymName.empty() && DisSymName == "__mh_execute_header") { | ||||
7804 | outs() << "-dis-symname: __mh_execute_header not in any section\n"; | ||||
7805 | return; | ||||
7806 | } | ||||
7807 | // When this code is trying to disassemble a symbol at a time and in the | ||||
7808 | // case there is only the __mh_execute_header symbol left as in a stripped | ||||
7809 | // executable, we need to deal with this by ignoring this symbol so the | ||||
7810 | // whole section is disassembled and this symbol is then not displayed. | ||||
7811 | if (SymName == "__mh_execute_header" || SymName == "__mh_dylib_header" || | ||||
7812 | SymName == "__mh_bundle_header" || SymName == "__mh_object_header" || | ||||
7813 | SymName == "__mh_preload_header" || SymName == "__mh_dylinker_header") | ||||
7814 | continue; | ||||
7815 | |||||
7816 | // If we are only disassembling one symbol see if this is that symbol. | ||||
7817 | if (!DisSymName.empty() && DisSymName != SymName) | ||||
7818 | continue; | ||||
7819 | |||||
7820 | // Start at the address of the symbol relative to the section's address. | ||||
7821 | uint64_t SectSize = Sections[SectIdx].getSize(); | ||||
7822 | uint64_t Start = cantFail(Symbols[SymIdx].getValue()); | ||||
7823 | uint64_t SectionAddress = Sections[SectIdx].getAddress(); | ||||
7824 | Start -= SectionAddress; | ||||
7825 | |||||
7826 | if (Start > SectSize) { | ||||
7827 | outs() << "section data ends, " << SymName | ||||
7828 | << " lies outside valid range\n"; | ||||
7829 | return; | ||||
7830 | } | ||||
7831 | |||||
7832 | // Stop disassembling either at the beginning of the next symbol or at | ||||
7833 | // the end of the section. | ||||
7834 | bool containsNextSym = false; | ||||
7835 | uint64_t NextSym = 0; | ||||
7836 | uint64_t NextSymIdx = SymIdx + 1; | ||||
7837 | while (Symbols.size() > NextSymIdx) { | ||||
7838 | SymbolRef::Type NextSymType = unwrapOrError( | ||||
7839 | Symbols[NextSymIdx].getType(), MachOOF->getFileName()); | ||||
7840 | if (NextSymType == SymbolRef::ST_Function) { | ||||
7841 | containsNextSym = | ||||
7842 | Sections[SectIdx].containsSymbol(Symbols[NextSymIdx]); | ||||
7843 | NextSym = cantFail(Symbols[NextSymIdx].getValue()); | ||||
7844 | NextSym -= SectionAddress; | ||||
7845 | break; | ||||
7846 | } | ||||
7847 | ++NextSymIdx; | ||||
7848 | } | ||||
7849 | |||||
7850 | uint64_t End = containsNextSym ? std::min(NextSym, SectSize) : SectSize; | ||||
7851 | uint64_t Size; | ||||
7852 | |||||
7853 | symbolTableWorked = true; | ||||
7854 | |||||
7855 | DataRefImpl Symb = Symbols[SymIdx].getRawDataRefImpl(); | ||||
7856 | uint32_t SymbolFlags = cantFail(MachOOF->getSymbolFlags(Symb)); | ||||
7857 | bool IsThumb = SymbolFlags & SymbolRef::SF_Thumb; | ||||
7858 | |||||
7859 | // We only need the dedicated Thumb target if there's a real choice | ||||
7860 | // (i.e. we're not targeting M-class) and the function is Thumb. | ||||
7861 | bool UseThumbTarget = IsThumb && ThumbTarget; | ||||
7862 | |||||
7863 | // If we are not specifying a symbol to start disassembly with and this | ||||
7864 | // is the first symbol in the section but not at the start of the section | ||||
7865 | // then move the disassembly index to the start of the section and | ||||
7866 | // don't print the symbol name just yet. This is so the bytes before the | ||||
7867 | // first symbol are disassembled. | ||||
7868 | uint64_t SymbolStart = Start; | ||||
7869 | if (DisSymName.empty() && FirstSymbol && Start != 0) { | ||||
7870 | FirstSymbolAtSectionStart = false; | ||||
7871 | Start = 0; | ||||
7872 | } | ||||
7873 | else | ||||
7874 | outs() << SymName << ":\n"; | ||||
7875 | |||||
7876 | DILineInfo lastLine; | ||||
7877 | for (uint64_t Index = Start; Index < End; Index += Size) { | ||||
7878 | MCInst Inst; | ||||
7879 | |||||
7880 | // If this is the first symbol in the section and it was not at the | ||||
7881 | // start of the section, see if we are at its Index now and if so print | ||||
7882 | // the symbol name. | ||||
7883 | if (FirstSymbol && !FirstSymbolAtSectionStart && Index == SymbolStart) | ||||
7884 | outs() << SymName << ":\n"; | ||||
7885 | |||||
7886 | uint64_t PC = SectAddress + Index; | ||||
7887 | if (LeadingAddr) { | ||||
7888 | if (FullLeadingAddr) { | ||||
7889 | if (MachOOF->is64Bit()) | ||||
7890 | outs() << format("%016" PRIx64"l" "x", PC); | ||||
7891 | else | ||||
7892 | outs() << format("%08" PRIx64"l" "x", PC); | ||||
7893 | } else { | ||||
7894 | outs() << format("%8" PRIx64"l" "x" ":", PC); | ||||
7895 | } | ||||
7896 | } | ||||
7897 | if (ShowRawInsn || Arch == Triple::arm) | ||||
7898 | outs() << "\t"; | ||||
7899 | |||||
7900 | if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, Size)) | ||||
7901 | continue; | ||||
7902 | |||||
7903 | SmallVector<char, 64> AnnotationsBytes; | ||||
7904 | raw_svector_ostream Annotations(AnnotationsBytes); | ||||
7905 | |||||
7906 | bool gotInst; | ||||
7907 | if (UseThumbTarget) | ||||
7908 | gotInst = ThumbDisAsm->getInstruction(Inst, Size, Bytes.slice(Index), | ||||
7909 | PC, Annotations); | ||||
7910 | else | ||||
7911 | gotInst = DisAsm->getInstruction(Inst, Size, Bytes.slice(Index), PC, | ||||
7912 | Annotations); | ||||
7913 | if (gotInst) { | ||||
7914 | if (ShowRawInsn || Arch == Triple::arm) { | ||||
7915 | dumpBytes(ArrayRef(Bytes.data() + Index, Size), outs()); | ||||
7916 | } | ||||
7917 | formatted_raw_ostream FormattedOS(outs()); | ||||
7918 | StringRef AnnotationsStr = Annotations.str(); | ||||
7919 | if (UseThumbTarget) | ||||
7920 | ThumbIP->printInst(&Inst, PC, AnnotationsStr, *ThumbSTI, | ||||
7921 | FormattedOS); | ||||
7922 | else | ||||
7923 | IP->printInst(&Inst, PC, AnnotationsStr, *STI, FormattedOS); | ||||
7924 | emitComments(CommentStream, CommentsToEmit, FormattedOS, *AsmInfo); | ||||
7925 | |||||
7926 | // Print debug info. | ||||
7927 | if (diContext) { | ||||
7928 | DILineInfo dli = diContext->getLineInfoForAddress({PC, SectIdx}); | ||||
7929 | // Print valid line info if it changed. | ||||
7930 | if (dli != lastLine && dli.Line != 0) | ||||
7931 | outs() << "\t## " << dli.FileName << ':' << dli.Line << ':' | ||||
7932 | << dli.Column; | ||||
7933 | lastLine = dli; | ||||
7934 | } | ||||
7935 | outs() << "\n"; | ||||
7936 | } else { | ||||
7937 | if (MachOOF->getArchTriple().isX86()) { | ||||
7938 | outs() << format("\t.byte 0x%02x #bad opcode\n", | ||||
7939 | *(Bytes.data() + Index) & 0xff); | ||||
7940 | Size = 1; // skip exactly one illegible byte and move on. | ||||
7941 | } else if (Arch == Triple::aarch64 || | ||||
7942 | (Arch == Triple::arm && !IsThumb)) { | ||||
7943 | uint32_t opcode = (*(Bytes.data() + Index) & 0xff) | | ||||
7944 | (*(Bytes.data() + Index + 1) & 0xff) << 8 | | ||||
7945 | (*(Bytes.data() + Index + 2) & 0xff) << 16 | | ||||
7946 | (*(Bytes.data() + Index + 3) & 0xff) << 24; | ||||
7947 | outs() << format("\t.long\t0x%08x\n", opcode); | ||||
7948 | Size = 4; | ||||
7949 | } else if (Arch == Triple::arm) { | ||||
7950 | assert(IsThumb && "ARM mode should have been dealt with above")(static_cast <bool> (IsThumb && "ARM mode should have been dealt with above" ) ? void (0) : __assert_fail ("IsThumb && \"ARM mode should have been dealt with above\"" , "llvm/tools/llvm-objdump/MachODump.cpp", 7950, __extension__ __PRETTY_FUNCTION__)); | ||||
7951 | uint32_t opcode = (*(Bytes.data() + Index) & 0xff) | | ||||
7952 | (*(Bytes.data() + Index + 1) & 0xff) << 8; | ||||
7953 | outs() << format("\t.short\t0x%04x\n", opcode); | ||||
7954 | Size = 2; | ||||
7955 | } else{ | ||||
7956 | WithColor::warning(errs(), "llvm-objdump") | ||||
7957 | << "invalid instruction encoding\n"; | ||||
7958 | if (Size == 0) | ||||
7959 | Size = 1; // skip illegible bytes | ||||
7960 | } | ||||
7961 | } | ||||
7962 | } | ||||
7963 | // Now that we are done disassembled the first symbol set the bool that | ||||
7964 | // were doing this to false. | ||||
7965 | FirstSymbol = false; | ||||
7966 | } | ||||
7967 | if (!symbolTableWorked) { | ||||
7968 | // Reading the symbol table didn't work, disassemble the whole section. | ||||
7969 | uint64_t SectAddress = Sections[SectIdx].getAddress(); | ||||
7970 | uint64_t SectSize = Sections[SectIdx].getSize(); | ||||
7971 | uint64_t InstSize; | ||||
7972 | for (uint64_t Index = 0; Index < SectSize; Index += InstSize) { | ||||
7973 | MCInst Inst; | ||||
7974 | |||||
7975 | uint64_t PC = SectAddress + Index; | ||||
7976 | |||||
7977 | if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, InstSize)) | ||||
7978 | continue; | ||||
7979 | |||||
7980 | SmallVector<char, 64> AnnotationsBytes; | ||||
7981 | raw_svector_ostream Annotations(AnnotationsBytes); | ||||
7982 | if (DisAsm->getInstruction(Inst, InstSize, Bytes.slice(Index), PC, | ||||
7983 | Annotations)) { | ||||
7984 | if (LeadingAddr) { | ||||
7985 | if (FullLeadingAddr) { | ||||
7986 | if (MachOOF->is64Bit()) | ||||
7987 | outs() << format("%016" PRIx64"l" "x", PC); | ||||
7988 | else | ||||
7989 | outs() << format("%08" PRIx64"l" "x", PC); | ||||
7990 | } else { | ||||
7991 | outs() << format("%8" PRIx64"l" "x" ":", PC); | ||||
7992 | } | ||||
7993 | } | ||||
7994 | if (ShowRawInsn || Arch == Triple::arm) { | ||||
7995 | outs() << "\t"; | ||||
7996 | dumpBytes(ArrayRef(Bytes.data() + Index, InstSize), outs()); | ||||
7997 | } | ||||
7998 | StringRef AnnotationsStr = Annotations.str(); | ||||
7999 | IP->printInst(&Inst, PC, AnnotationsStr, *STI, outs()); | ||||
8000 | outs() << "\n"; | ||||
8001 | } else { | ||||
8002 | if (MachOOF->getArchTriple().isX86()) { | ||||
8003 | outs() << format("\t.byte 0x%02x #bad opcode\n", | ||||
8004 | *(Bytes.data() + Index) & 0xff); | ||||
8005 | InstSize = 1; // skip exactly one illegible byte and move on. | ||||
8006 | } else { | ||||
8007 | WithColor::warning(errs(), "llvm-objdump") | ||||
8008 | << "invalid instruction encoding\n"; | ||||
8009 | if (InstSize == 0) | ||||
8010 | InstSize = 1; // skip illegible bytes | ||||
8011 | } | ||||
8012 | } | ||||
8013 | } | ||||
8014 | } | ||||
8015 | // The TripleName's need to be reset if we are called again for a different | ||||
8016 | // architecture. | ||||
8017 | TripleName = ""; | ||||
8018 | ThumbTripleName = ""; | ||||
8019 | |||||
8020 | if (SymbolizerInfo.demangled_name != nullptr) | ||||
8021 | free(SymbolizerInfo.demangled_name); | ||||
8022 | if (ThumbSymbolizerInfo.demangled_name != nullptr) | ||||
8023 | free(ThumbSymbolizerInfo.demangled_name); | ||||
8024 | } | ||||
8025 | } | ||||
8026 | |||||
8027 | //===----------------------------------------------------------------------===// | ||||
8028 | // __compact_unwind section dumping | ||||
8029 | //===----------------------------------------------------------------------===// | ||||
8030 | |||||
8031 | namespace { | ||||
8032 | |||||
8033 | template <typename T> | ||||
8034 | static uint64_t read(StringRef Contents, ptrdiff_t Offset) { | ||||
8035 | using llvm::support::little; | ||||
8036 | using llvm::support::unaligned; | ||||
8037 | |||||
8038 | if (Offset + sizeof(T) > Contents.size()) { | ||||
8039 | outs() << "warning: attempt to read past end of buffer\n"; | ||||
8040 | return T(); | ||||
8041 | } | ||||
8042 | |||||
8043 | uint64_t Val = | ||||
8044 | support::endian::read<T, little, unaligned>(Contents.data() + Offset); | ||||
8045 | return Val; | ||||
8046 | } | ||||
8047 | |||||
8048 | template <typename T> | ||||
8049 | static uint64_t readNext(StringRef Contents, ptrdiff_t &Offset) { | ||||
8050 | T Val = read<T>(Contents, Offset); | ||||
8051 | Offset += sizeof(T); | ||||
8052 | return Val; | ||||
8053 | } | ||||
8054 | |||||
8055 | struct CompactUnwindEntry { | ||||
8056 | uint32_t OffsetInSection; | ||||
8057 | |||||
8058 | uint64_t FunctionAddr; | ||||
8059 | uint32_t Length; | ||||
8060 | uint32_t CompactEncoding; | ||||
8061 | uint64_t PersonalityAddr; | ||||
8062 | uint64_t LSDAAddr; | ||||
8063 | |||||
8064 | RelocationRef FunctionReloc; | ||||
8065 | RelocationRef PersonalityReloc; | ||||
8066 | RelocationRef LSDAReloc; | ||||
8067 | |||||
8068 | CompactUnwindEntry(StringRef Contents, unsigned Offset, bool Is64) | ||||
8069 | : OffsetInSection(Offset) { | ||||
8070 | if (Is64) | ||||
8071 | read<uint64_t>(Contents, Offset); | ||||
8072 | else | ||||
8073 | read<uint32_t>(Contents, Offset); | ||||
8074 | } | ||||
8075 | |||||
8076 | private: | ||||
8077 | template <typename UIntPtr> void read(StringRef Contents, ptrdiff_t Offset) { | ||||
8078 | FunctionAddr = readNext<UIntPtr>(Contents, Offset); | ||||
8079 | Length = readNext<uint32_t>(Contents, Offset); | ||||
8080 | CompactEncoding = readNext<uint32_t>(Contents, Offset); | ||||
8081 | PersonalityAddr = readNext<UIntPtr>(Contents, Offset); | ||||
8082 | LSDAAddr = readNext<UIntPtr>(Contents, Offset); | ||||
8083 | } | ||||
8084 | }; | ||||
8085 | } | ||||
8086 | |||||
8087 | /// Given a relocation from __compact_unwind, consisting of the RelocationRef | ||||
8088 | /// and data being relocated, determine the best base Name and Addend to use for | ||||
8089 | /// display purposes. | ||||
8090 | /// | ||||
8091 | /// 1. An Extern relocation will directly reference a symbol (and the data is | ||||
8092 | /// then already an addend), so use that. | ||||
8093 | /// 2. Otherwise the data is an offset in the object file's layout; try to find | ||||
8094 | // a symbol before it in the same section, and use the offset from there. | ||||
8095 | /// 3. Finally, if all that fails, fall back to an offset from the start of the | ||||
8096 | /// referenced section. | ||||
8097 | static void findUnwindRelocNameAddend(const MachOObjectFile *Obj, | ||||
8098 | std::map<uint64_t, SymbolRef> &Symbols, | ||||
8099 | const RelocationRef &Reloc, uint64_t Addr, | ||||
8100 | StringRef &Name, uint64_t &Addend) { | ||||
8101 | if (Reloc.getSymbol() != Obj->symbol_end()) { | ||||
8102 | Name = unwrapOrError(Reloc.getSymbol()->getName(), Obj->getFileName()); | ||||
8103 | Addend = Addr; | ||||
8104 | return; | ||||
8105 | } | ||||
8106 | |||||
8107 | auto RE = Obj->getRelocation(Reloc.getRawDataRefImpl()); | ||||
8108 | SectionRef RelocSection = Obj->getAnyRelocationSection(RE); | ||||
8109 | |||||
8110 | uint64_t SectionAddr = RelocSection.getAddress(); | ||||
8111 | |||||
8112 | auto Sym = Symbols.upper_bound(Addr); | ||||
8113 | if (Sym == Symbols.begin()) { | ||||
8114 | // The first symbol in the object is after this reference, the best we can | ||||
8115 | // do is section-relative notation. | ||||
8116 | if (Expected<StringRef> NameOrErr = RelocSection.getName()) | ||||
8117 | Name = *NameOrErr; | ||||
8118 | else | ||||
8119 | consumeError(NameOrErr.takeError()); | ||||
8120 | |||||
8121 | Addend = Addr - SectionAddr; | ||||
8122 | return; | ||||
8123 | } | ||||
8124 | |||||
8125 | // Go back one so that SymbolAddress <= Addr. | ||||
8126 | --Sym; | ||||
8127 | |||||
8128 | section_iterator SymSection = | ||||
8129 | unwrapOrError(Sym->second.getSection(), Obj->getFileName()); | ||||
8130 | if (RelocSection == *SymSection) { | ||||
8131 | // There's a valid symbol in the same section before this reference. | ||||
8132 | Name = unwrapOrError(Sym->second.getName(), Obj->getFileName()); | ||||
8133 | Addend = Addr - Sym->first; | ||||
8134 | return; | ||||
8135 | } | ||||
8136 | |||||
8137 | // There is a symbol before this reference, but it's in a different | ||||
8138 | // section. Probably not helpful to mention it, so use the section name. | ||||
8139 | if (Expected<StringRef> NameOrErr = RelocSection.getName()) | ||||
8140 | Name = *NameOrErr; | ||||
8141 | else | ||||
8142 | consumeError(NameOrErr.takeError()); | ||||
8143 | |||||
8144 | Addend = Addr - SectionAddr; | ||||
8145 | } | ||||
8146 | |||||
8147 | static void printUnwindRelocDest(const MachOObjectFile *Obj, | ||||
8148 | std::map<uint64_t, SymbolRef> &Symbols, | ||||
8149 | const RelocationRef &Reloc, uint64_t Addr) { | ||||
8150 | StringRef Name; | ||||
8151 | uint64_t Addend; | ||||
8152 | |||||
8153 | if (!Reloc.getObject()) | ||||
8154 | return; | ||||
8155 | |||||
8156 | findUnwindRelocNameAddend(Obj, Symbols, Reloc, Addr, Name, Addend); | ||||
8157 | |||||
8158 | outs() << Name; | ||||
8159 | if (Addend) | ||||
8160 | outs() << " + " << format("0x%" PRIx64"l" "x", Addend); | ||||
8161 | } | ||||
8162 | |||||
8163 | static void | ||||
8164 | printMachOCompactUnwindSection(const MachOObjectFile *Obj, | ||||
8165 | std::map<uint64_t, SymbolRef> &Symbols, | ||||
8166 | const SectionRef &CompactUnwind) { | ||||
8167 | |||||
8168 | if (!Obj->isLittleEndian()) { | ||||
8169 | outs() << "Skipping big-endian __compact_unwind section\n"; | ||||
8170 | return; | ||||
8171 | } | ||||
8172 | |||||
8173 | bool Is64 = Obj->is64Bit(); | ||||
8174 | uint32_t PointerSize = Is64 ? sizeof(uint64_t) : sizeof(uint32_t); | ||||
8175 | uint32_t EntrySize = 3 * PointerSize + 2 * sizeof(uint32_t); | ||||
8176 | |||||
8177 | StringRef Contents = | ||||
8178 | unwrapOrError(CompactUnwind.getContents(), Obj->getFileName()); | ||||
8179 | SmallVector<CompactUnwindEntry, 4> CompactUnwinds; | ||||
8180 | |||||
8181 | // First populate the initial raw offsets, encodings and so on from the entry. | ||||
8182 | for (unsigned Offset = 0; Offset < Contents.size(); Offset += EntrySize) { | ||||
8183 | CompactUnwindEntry Entry(Contents, Offset, Is64); | ||||
8184 | CompactUnwinds.push_back(Entry); | ||||
8185 | } | ||||
8186 | |||||
8187 | // Next we need to look at the relocations to find out what objects are | ||||
8188 | // actually being referred to. | ||||
8189 | for (const RelocationRef &Reloc : CompactUnwind.relocations()) { | ||||
8190 | uint64_t RelocAddress = Reloc.getOffset(); | ||||
8191 | |||||
8192 | uint32_t EntryIdx = RelocAddress / EntrySize; | ||||
8193 | uint32_t OffsetInEntry = RelocAddress - EntryIdx * EntrySize; | ||||
8194 | CompactUnwindEntry &Entry = CompactUnwinds[EntryIdx]; | ||||
8195 | |||||
8196 | if (OffsetInEntry == 0) | ||||
8197 | Entry.FunctionReloc = Reloc; | ||||
8198 | else if (OffsetInEntry == PointerSize + 2 * sizeof(uint32_t)) | ||||
8199 | Entry.PersonalityReloc = Reloc; | ||||
8200 | else if (OffsetInEntry == 2 * PointerSize + 2 * sizeof(uint32_t)) | ||||
8201 | Entry.LSDAReloc = Reloc; | ||||
8202 | else { | ||||
8203 | outs() << "Invalid relocation in __compact_unwind section\n"; | ||||
8204 | return; | ||||
8205 | } | ||||
8206 | } | ||||
8207 | |||||
8208 | // Finally, we're ready to print the data we've gathered. | ||||
8209 | outs() << "Contents of __compact_unwind section:\n"; | ||||
8210 | for (auto &Entry : CompactUnwinds) { | ||||
8211 | outs() << " Entry at offset " | ||||
8212 | << format("0x%" PRIx32"x", Entry.OffsetInSection) << ":\n"; | ||||
8213 | |||||
8214 | // 1. Start of the region this entry applies to. | ||||
8215 | outs() << " start: " << format("0x%" PRIx64"l" "x", | ||||
8216 | Entry.FunctionAddr) << ' '; | ||||
8217 | printUnwindRelocDest(Obj, Symbols, Entry.FunctionReloc, Entry.FunctionAddr); | ||||
8218 | outs() << '\n'; | ||||
8219 | |||||
8220 | // 2. Length of the region this entry applies to. | ||||
8221 | outs() << " length: " << format("0x%" PRIx32"x", Entry.Length) | ||||
8222 | << '\n'; | ||||
8223 | // 3. The 32-bit compact encoding. | ||||
8224 | outs() << " compact encoding: " | ||||
8225 | << format("0x%08" PRIx32"x", Entry.CompactEncoding) << '\n'; | ||||
8226 | |||||
8227 | // 4. The personality function, if present. | ||||
8228 | if (Entry.PersonalityReloc.getObject()) { | ||||
8229 | outs() << " personality function: " | ||||
8230 | << format("0x%" PRIx64"l" "x", Entry.PersonalityAddr) << ' '; | ||||
8231 | printUnwindRelocDest(Obj, Symbols, Entry.PersonalityReloc, | ||||
8232 | Entry.PersonalityAddr); | ||||
8233 | outs() << '\n'; | ||||
8234 | } | ||||
8235 | |||||
8236 | // 5. This entry's language-specific data area. | ||||
8237 | if (Entry.LSDAReloc.getObject()) { | ||||
8238 | outs() << " LSDA: " << format("0x%" PRIx64"l" "x", | ||||
8239 | Entry.LSDAAddr) << ' '; | ||||
8240 | printUnwindRelocDest(Obj, Symbols, Entry.LSDAReloc, Entry.LSDAAddr); | ||||
8241 | outs() << '\n'; | ||||
8242 | } | ||||
8243 | } | ||||
8244 | } | ||||
8245 | |||||
8246 | //===----------------------------------------------------------------------===// | ||||
8247 | // __unwind_info section dumping | ||||
8248 | //===----------------------------------------------------------------------===// | ||||
8249 | |||||
8250 | static void printRegularSecondLevelUnwindPage(StringRef PageData) { | ||||
8251 | ptrdiff_t Pos = 0; | ||||
8252 | uint32_t Kind = readNext<uint32_t>(PageData, Pos); | ||||
8253 | (void)Kind; | ||||
8254 | assert(Kind == 2 && "kind for a regular 2nd level index should be 2")(static_cast <bool> (Kind == 2 && "kind for a regular 2nd level index should be 2" ) ? void (0) : __assert_fail ("Kind == 2 && \"kind for a regular 2nd level index should be 2\"" , "llvm/tools/llvm-objdump/MachODump.cpp", 8254, __extension__ __PRETTY_FUNCTION__)); | ||||
8255 | |||||
8256 | uint16_t EntriesStart = readNext<uint16_t>(PageData, Pos); | ||||
8257 | uint16_t NumEntries = readNext<uint16_t>(PageData, Pos); | ||||
8258 | |||||
8259 | Pos = EntriesStart; | ||||
8260 | for (unsigned i = 0; i < NumEntries; ++i) { | ||||
8261 | uint32_t FunctionOffset = readNext<uint32_t>(PageData, Pos); | ||||
8262 | uint32_t Encoding = readNext<uint32_t>(PageData, Pos); | ||||
8263 | |||||
8264 | outs() << " [" << i << "]: " | ||||
8265 | << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset) | ||||
8266 | << ", " | ||||
8267 | << "encoding=" << format("0x%08" PRIx32"x", Encoding) << '\n'; | ||||
8268 | } | ||||
8269 | } | ||||
8270 | |||||
8271 | static void printCompressedSecondLevelUnwindPage( | ||||
8272 | StringRef PageData, uint32_t FunctionBase, | ||||
8273 | const SmallVectorImpl<uint32_t> &CommonEncodings) { | ||||
8274 | ptrdiff_t Pos = 0; | ||||
8275 | uint32_t Kind = readNext<uint32_t>(PageData, Pos); | ||||
8276 | (void)Kind; | ||||
8277 | assert(Kind == 3 && "kind for a compressed 2nd level index should be 3")(static_cast <bool> (Kind == 3 && "kind for a compressed 2nd level index should be 3" ) ? void (0) : __assert_fail ("Kind == 3 && \"kind for a compressed 2nd level index should be 3\"" , "llvm/tools/llvm-objdump/MachODump.cpp", 8277, __extension__ __PRETTY_FUNCTION__)); | ||||
8278 | |||||
8279 | uint32_t NumCommonEncodings = CommonEncodings.size(); | ||||
8280 | uint16_t EntriesStart = readNext<uint16_t>(PageData, Pos); | ||||
8281 | uint16_t NumEntries = readNext<uint16_t>(PageData, Pos); | ||||
8282 | |||||
8283 | uint16_t PageEncodingsStart = readNext<uint16_t>(PageData, Pos); | ||||
8284 | uint16_t NumPageEncodings = readNext<uint16_t>(PageData, Pos); | ||||
8285 | SmallVector<uint32_t, 64> PageEncodings; | ||||
8286 | if (NumPageEncodings) { | ||||
8287 | outs() << " Page encodings: (count = " << NumPageEncodings << ")\n"; | ||||
8288 | Pos = PageEncodingsStart; | ||||
8289 | for (unsigned i = 0; i < NumPageEncodings; ++i) { | ||||
8290 | uint32_t Encoding = readNext<uint32_t>(PageData, Pos); | ||||
8291 | PageEncodings.push_back(Encoding); | ||||
8292 | outs() << " encoding[" << (i + NumCommonEncodings) | ||||
8293 | << "]: " << format("0x%08" PRIx32"x", Encoding) << '\n'; | ||||
8294 | } | ||||
8295 | } | ||||
8296 | |||||
8297 | Pos = EntriesStart; | ||||
8298 | for (unsigned i = 0; i < NumEntries; ++i) { | ||||
8299 | uint32_t Entry = readNext<uint32_t>(PageData, Pos); | ||||
8300 | uint32_t FunctionOffset = FunctionBase + (Entry & 0xffffff); | ||||
8301 | uint32_t EncodingIdx = Entry >> 24; | ||||
8302 | |||||
8303 | uint32_t Encoding; | ||||
8304 | if (EncodingIdx < NumCommonEncodings) | ||||
8305 | Encoding = CommonEncodings[EncodingIdx]; | ||||
8306 | else | ||||
8307 | Encoding = PageEncodings[EncodingIdx - NumCommonEncodings]; | ||||
8308 | |||||
8309 | outs() << " [" << i << "]: " | ||||
8310 | << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset) | ||||
8311 | << ", " | ||||
8312 | << "encoding[" << EncodingIdx | ||||
8313 | << "]=" << format("0x%08" PRIx32"x", Encoding) << '\n'; | ||||
8314 | } | ||||
8315 | } | ||||
8316 | |||||
8317 | static void printMachOUnwindInfoSection(const MachOObjectFile *Obj, | ||||
8318 | std::map<uint64_t, SymbolRef> &Symbols, | ||||
8319 | const SectionRef &UnwindInfo) { | ||||
8320 | |||||
8321 | if (!Obj->isLittleEndian()) { | ||||
8322 | outs() << "Skipping big-endian __unwind_info section\n"; | ||||
8323 | return; | ||||
8324 | } | ||||
8325 | |||||
8326 | outs() << "Contents of __unwind_info section:\n"; | ||||
8327 | |||||
8328 | StringRef Contents = | ||||
8329 | unwrapOrError(UnwindInfo.getContents(), Obj->getFileName()); | ||||
8330 | ptrdiff_t Pos = 0; | ||||
8331 | |||||
8332 | //===---------------------------------- | ||||
8333 | // Section header | ||||
8334 | //===---------------------------------- | ||||
8335 | |||||
8336 | uint32_t Version = readNext<uint32_t>(Contents, Pos); | ||||
8337 | outs() << " Version: " | ||||
8338 | << format("0x%" PRIx32"x", Version) << '\n'; | ||||
8339 | if (Version != 1) { | ||||
8340 | outs() << " Skipping section with unknown version\n"; | ||||
8341 | return; | ||||
8342 | } | ||||
8343 | |||||
8344 | uint32_t CommonEncodingsStart = readNext<uint32_t>(Contents, Pos); | ||||
8345 | outs() << " Common encodings array section offset: " | ||||
8346 | << format("0x%" PRIx32"x", CommonEncodingsStart) << '\n'; | ||||
8347 | uint32_t NumCommonEncodings = readNext<uint32_t>(Contents, Pos); | ||||
8348 | outs() << " Number of common encodings in array: " | ||||
8349 | << format("0x%" PRIx32"x", NumCommonEncodings) << '\n'; | ||||
8350 | |||||
8351 | uint32_t PersonalitiesStart = readNext<uint32_t>(Contents, Pos); | ||||
8352 | outs() << " Personality function array section offset: " | ||||
8353 | << format("0x%" PRIx32"x", PersonalitiesStart) << '\n'; | ||||
8354 | uint32_t NumPersonalities = readNext<uint32_t>(Contents, Pos); | ||||
8355 | outs() << " Number of personality functions in array: " | ||||
8356 | << format("0x%" PRIx32"x", NumPersonalities) << '\n'; | ||||
8357 | |||||
8358 | uint32_t IndicesStart = readNext<uint32_t>(Contents, Pos); | ||||
8359 | outs() << " Index array section offset: " | ||||
8360 | << format("0x%" PRIx32"x", IndicesStart) << '\n'; | ||||
8361 | uint32_t NumIndices = readNext<uint32_t>(Contents, Pos); | ||||
8362 | outs() << " Number of indices in array: " | ||||
8363 | << format("0x%" PRIx32"x", NumIndices) << '\n'; | ||||
8364 | |||||
8365 | //===---------------------------------- | ||||
8366 | // A shared list of common encodings | ||||
8367 | //===---------------------------------- | ||||
8368 | |||||
8369 | // These occupy indices in the range [0, N] whenever an encoding is referenced | ||||
8370 | // from a compressed 2nd level index table. In practice the linker only | ||||
8371 | // creates ~128 of these, so that indices are available to embed encodings in | ||||
8372 | // the 2nd level index. | ||||
8373 | |||||
8374 | SmallVector<uint32_t, 64> CommonEncodings; | ||||
8375 | outs() << " Common encodings: (count = " << NumCommonEncodings << ")\n"; | ||||
8376 | Pos = CommonEncodingsStart; | ||||
8377 | for (unsigned i = 0; i < NumCommonEncodings; ++i) { | ||||
8378 | uint32_t Encoding = readNext<uint32_t>(Contents, Pos); | ||||
8379 | CommonEncodings.push_back(Encoding); | ||||
8380 | |||||
8381 | outs() << " encoding[" << i << "]: " << format("0x%08" PRIx32"x", Encoding) | ||||
8382 | << '\n'; | ||||
8383 | } | ||||
8384 | |||||
8385 | //===---------------------------------- | ||||
8386 | // Personality functions used in this executable | ||||
8387 | //===---------------------------------- | ||||
8388 | |||||
8389 | // There should be only a handful of these (one per source language, | ||||
8390 | // roughly). Particularly since they only get 2 bits in the compact encoding. | ||||
8391 | |||||
8392 | outs() << " Personality functions: (count = " << NumPersonalities << ")\n"; | ||||
8393 | Pos = PersonalitiesStart; | ||||
8394 | for (unsigned i = 0; i < NumPersonalities; ++i) { | ||||
8395 | uint32_t PersonalityFn = readNext<uint32_t>(Contents, Pos); | ||||
8396 | outs() << " personality[" << i + 1 | ||||
8397 | << "]: " << format("0x%08" PRIx32"x", PersonalityFn) << '\n'; | ||||
8398 | } | ||||
8399 | |||||
8400 | //===---------------------------------- | ||||
8401 | // The level 1 index entries | ||||
8402 | //===---------------------------------- | ||||
8403 | |||||
8404 | // These specify an approximate place to start searching for the more detailed | ||||
8405 | // information, sorted by PC. | ||||
8406 | |||||
8407 | struct IndexEntry { | ||||
8408 | uint32_t FunctionOffset; | ||||
8409 | uint32_t SecondLevelPageStart; | ||||
8410 | uint32_t LSDAStart; | ||||
8411 | }; | ||||
8412 | |||||
8413 | SmallVector<IndexEntry, 4> IndexEntries; | ||||
8414 | |||||
8415 | outs() << " Top level indices: (count = " << NumIndices << ")\n"; | ||||
8416 | Pos = IndicesStart; | ||||
8417 | for (unsigned i = 0; i < NumIndices; ++i) { | ||||
8418 | IndexEntry Entry; | ||||
8419 | |||||
8420 | Entry.FunctionOffset = readNext<uint32_t>(Contents, Pos); | ||||
8421 | Entry.SecondLevelPageStart = readNext<uint32_t>(Contents, Pos); | ||||
8422 | Entry.LSDAStart = readNext<uint32_t>(Contents, Pos); | ||||
8423 | IndexEntries.push_back(Entry); | ||||
8424 | |||||
8425 | outs() << " [" << i << "]: " | ||||
8426 | << "function offset=" << format("0x%08" PRIx32"x", Entry.FunctionOffset) | ||||
8427 | << ", " | ||||
8428 | << "2nd level page offset=" | ||||
8429 | << format("0x%08" PRIx32"x", Entry.SecondLevelPageStart) << ", " | ||||
8430 | << "LSDA offset=" << format("0x%08" PRIx32"x", Entry.LSDAStart) << '\n'; | ||||
8431 | } | ||||
8432 | |||||
8433 | //===---------------------------------- | ||||
8434 | // Next come the LSDA tables | ||||
8435 | //===---------------------------------- | ||||
8436 | |||||
8437 | // The LSDA layout is rather implicit: it's a contiguous array of entries from | ||||
8438 | // the first top-level index's LSDAOffset to the last (sentinel). | ||||
8439 | |||||
8440 | outs() << " LSDA descriptors:\n"; | ||||
8441 | Pos = IndexEntries[0].LSDAStart; | ||||
8442 | const uint32_t LSDASize = 2 * sizeof(uint32_t); | ||||
8443 | int NumLSDAs = | ||||
8444 | (IndexEntries.back().LSDAStart - IndexEntries[0].LSDAStart) / LSDASize; | ||||
8445 | |||||
8446 | for (int i = 0; i < NumLSDAs; ++i) { | ||||
8447 | uint32_t FunctionOffset = readNext<uint32_t>(Contents, Pos); | ||||
8448 | uint32_t LSDAOffset = readNext<uint32_t>(Contents, Pos); | ||||
8449 | outs() << " [" << i << "]: " | ||||
8450 | << "function offset=" << format("0x%08" PRIx32"x", FunctionOffset) | ||||
8451 | << ", " | ||||
8452 | << "LSDA offset=" << format("0x%08" PRIx32"x", LSDAOffset) << '\n'; | ||||
8453 | } | ||||
8454 | |||||
8455 | //===---------------------------------- | ||||
8456 | // Finally, the 2nd level indices | ||||
8457 | //===---------------------------------- | ||||
8458 | |||||
8459 | // Generally these are 4K in size, and have 2 possible forms: | ||||
8460 | // + Regular stores up to 511 entries with disparate encodings | ||||
8461 | // + Compressed stores up to 1021 entries if few enough compact encoding | ||||
8462 | // values are used. | ||||
8463 | outs() << " Second level indices:\n"; | ||||
8464 | for (unsigned i = 0; i < IndexEntries.size() - 1; ++i) { | ||||
8465 | // The final sentinel top-level index has no associated 2nd level page | ||||
8466 | if (IndexEntries[i].SecondLevelPageStart == 0) | ||||
8467 | break; | ||||
8468 | |||||
8469 | outs() << " Second level index[" << i << "]: " | ||||
8470 | << "offset in section=" | ||||
8471 | << format("0x%08" PRIx32"x", IndexEntries[i].SecondLevelPageStart) | ||||
8472 | << ", " | ||||
8473 | << "base function offset=" | ||||
8474 | << format("0x%08" PRIx32"x", IndexEntries[i].FunctionOffset) << '\n'; | ||||
8475 | |||||
8476 | Pos = IndexEntries[i].SecondLevelPageStart; | ||||
8477 | if (Pos + sizeof(uint32_t) > Contents.size()) { | ||||
8478 | outs() << "warning: invalid offset for second level page: " << Pos << '\n'; | ||||
8479 | continue; | ||||
8480 | } | ||||
8481 | |||||
8482 | uint32_t Kind = | ||||
8483 | *reinterpret_cast<const support::ulittle32_t *>(Contents.data() + Pos); | ||||
8484 | if (Kind == 2) | ||||
8485 | printRegularSecondLevelUnwindPage(Contents.substr(Pos, 4096)); | ||||
8486 | else if (Kind == 3) | ||||
8487 | printCompressedSecondLevelUnwindPage(Contents.substr(Pos, 4096), | ||||
8488 | IndexEntries[i].FunctionOffset, | ||||
8489 | CommonEncodings); | ||||
8490 | else | ||||
8491 | outs() << " Skipping 2nd level page with unknown kind " << Kind | ||||
8492 | << '\n'; | ||||
8493 | } | ||||
8494 | } | ||||
8495 | |||||
8496 | void objdump::printMachOUnwindInfo(const MachOObjectFile *Obj) { | ||||
8497 | std::map<uint64_t, SymbolRef> Symbols; | ||||
8498 | for (const SymbolRef &SymRef : Obj->symbols()) { | ||||
8499 | // Discard any undefined or absolute symbols. They're not going to take part | ||||
8500 | // in the convenience lookup for unwind info and just take up resources. | ||||
8501 | auto SectOrErr = SymRef.getSection(); | ||||
8502 | if (!SectOrErr) { | ||||
8503 | // TODO: Actually report errors helpfully. | ||||
8504 | consumeError(SectOrErr.takeError()); | ||||
8505 | continue; | ||||
8506 | } | ||||
8507 | section_iterator Section = *SectOrErr; | ||||
8508 | if (Section == Obj->section_end()) | ||||
8509 | continue; | ||||
8510 | |||||
8511 | uint64_t Addr = cantFail(SymRef.getValue()); | ||||
8512 | Symbols.insert(std::make_pair(Addr, SymRef)); | ||||
8513 | } | ||||
8514 | |||||
8515 | for (const SectionRef &Section : Obj->sections()) { | ||||
8516 | StringRef SectName; | ||||
8517 | if (Expected<StringRef> NameOrErr = Section.getName()) | ||||
8518 | SectName = *NameOrErr; | ||||
8519 | else | ||||
8520 | consumeError(NameOrErr.takeError()); | ||||
8521 | |||||
8522 | if (SectName == "__compact_unwind") | ||||
8523 | printMachOCompactUnwindSection(Obj, Symbols, Section); | ||||
8524 | else if (SectName == "__unwind_info") | ||||
8525 | printMachOUnwindInfoSection(Obj, Symbols, Section); | ||||
8526 | } | ||||
8527 | } | ||||
8528 | |||||
8529 | static void PrintMachHeader(uint32_t magic, uint32_t cputype, | ||||
8530 | uint32_t cpusubtype, uint32_t filetype, | ||||
8531 | uint32_t ncmds, uint32_t sizeofcmds, uint32_t flags, | ||||
8532 | bool verbose) { | ||||
8533 | outs() << "Mach header\n"; | ||||
8534 | outs() << " magic cputype cpusubtype caps filetype ncmds " | ||||
8535 | "sizeofcmds flags\n"; | ||||
8536 | if (verbose) { | ||||
8537 | if (magic == MachO::MH_MAGIC) | ||||
8538 | outs() << " MH_MAGIC"; | ||||
8539 | else if (magic == MachO::MH_MAGIC_64) | ||||
8540 | outs() << "MH_MAGIC_64"; | ||||
8541 | else | ||||
8542 | outs() << format(" 0x%08" PRIx32"x", magic); | ||||
8543 | switch (cputype) { | ||||
8544 | case MachO::CPU_TYPE_I386: | ||||
8545 | outs() << " I386"; | ||||
8546 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8547 | case MachO::CPU_SUBTYPE_I386_ALL: | ||||
8548 | outs() << " ALL"; | ||||
8549 | break; | ||||
8550 | default: | ||||
8551 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8552 | break; | ||||
8553 | } | ||||
8554 | break; | ||||
8555 | case MachO::CPU_TYPE_X86_64: | ||||
8556 | outs() << " X86_64"; | ||||
8557 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8558 | case MachO::CPU_SUBTYPE_X86_64_ALL: | ||||
8559 | outs() << " ALL"; | ||||
8560 | break; | ||||
8561 | case MachO::CPU_SUBTYPE_X86_64_H: | ||||
8562 | outs() << " Haswell"; | ||||
8563 | break; | ||||
8564 | default: | ||||
8565 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8566 | break; | ||||
8567 | } | ||||
8568 | break; | ||||
8569 | case MachO::CPU_TYPE_ARM: | ||||
8570 | outs() << " ARM"; | ||||
8571 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8572 | case MachO::CPU_SUBTYPE_ARM_ALL: | ||||
8573 | outs() << " ALL"; | ||||
8574 | break; | ||||
8575 | case MachO::CPU_SUBTYPE_ARM_V4T: | ||||
8576 | outs() << " V4T"; | ||||
8577 | break; | ||||
8578 | case MachO::CPU_SUBTYPE_ARM_V5TEJ: | ||||
8579 | outs() << " V5TEJ"; | ||||
8580 | break; | ||||
8581 | case MachO::CPU_SUBTYPE_ARM_XSCALE: | ||||
8582 | outs() << " XSCALE"; | ||||
8583 | break; | ||||
8584 | case MachO::CPU_SUBTYPE_ARM_V6: | ||||
8585 | outs() << " V6"; | ||||
8586 | break; | ||||
8587 | case MachO::CPU_SUBTYPE_ARM_V6M: | ||||
8588 | outs() << " V6M"; | ||||
8589 | break; | ||||
8590 | case MachO::CPU_SUBTYPE_ARM_V7: | ||||
8591 | outs() << " V7"; | ||||
8592 | break; | ||||
8593 | case MachO::CPU_SUBTYPE_ARM_V7EM: | ||||
8594 | outs() << " V7EM"; | ||||
8595 | break; | ||||
8596 | case MachO::CPU_SUBTYPE_ARM_V7K: | ||||
8597 | outs() << " V7K"; | ||||
8598 | break; | ||||
8599 | case MachO::CPU_SUBTYPE_ARM_V7M: | ||||
8600 | outs() << " V7M"; | ||||
8601 | break; | ||||
8602 | case MachO::CPU_SUBTYPE_ARM_V7S: | ||||
8603 | outs() << " V7S"; | ||||
8604 | break; | ||||
8605 | default: | ||||
8606 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8607 | break; | ||||
8608 | } | ||||
8609 | break; | ||||
8610 | case MachO::CPU_TYPE_ARM64: | ||||
8611 | outs() << " ARM64"; | ||||
8612 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8613 | case MachO::CPU_SUBTYPE_ARM64_ALL: | ||||
8614 | outs() << " ALL"; | ||||
8615 | break; | ||||
8616 | case MachO::CPU_SUBTYPE_ARM64_V8: | ||||
8617 | outs() << " V8"; | ||||
8618 | break; | ||||
8619 | case MachO::CPU_SUBTYPE_ARM64E: | ||||
8620 | outs() << " E"; | ||||
8621 | break; | ||||
8622 | default: | ||||
8623 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8624 | break; | ||||
8625 | } | ||||
8626 | break; | ||||
8627 | case MachO::CPU_TYPE_ARM64_32: | ||||
8628 | outs() << " ARM64_32"; | ||||
8629 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8630 | case MachO::CPU_SUBTYPE_ARM64_32_V8: | ||||
8631 | outs() << " V8"; | ||||
8632 | break; | ||||
8633 | default: | ||||
8634 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8635 | break; | ||||
8636 | } | ||||
8637 | break; | ||||
8638 | case MachO::CPU_TYPE_POWERPC: | ||||
8639 | outs() << " PPC"; | ||||
8640 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8641 | case MachO::CPU_SUBTYPE_POWERPC_ALL: | ||||
8642 | outs() << " ALL"; | ||||
8643 | break; | ||||
8644 | default: | ||||
8645 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8646 | break; | ||||
8647 | } | ||||
8648 | break; | ||||
8649 | case MachO::CPU_TYPE_POWERPC64: | ||||
8650 | outs() << " PPC64"; | ||||
8651 | switch (cpusubtype & ~MachO::CPU_SUBTYPE_MASK) { | ||||
8652 | case MachO::CPU_SUBTYPE_POWERPC_ALL: | ||||
8653 | outs() << " ALL"; | ||||
8654 | break; | ||||
8655 | default: | ||||
8656 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8657 | break; | ||||
8658 | } | ||||
8659 | break; | ||||
8660 | default: | ||||
8661 | outs() << format(" %7d", cputype); | ||||
8662 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8663 | break; | ||||
8664 | } | ||||
8665 | if ((cpusubtype & MachO::CPU_SUBTYPE_MASK) == MachO::CPU_SUBTYPE_LIB64) { | ||||
8666 | outs() << " LIB64"; | ||||
8667 | } else { | ||||
8668 | outs() << format(" 0x%02" PRIx32"x", | ||||
8669 | (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24); | ||||
8670 | } | ||||
8671 | switch (filetype) { | ||||
8672 | case MachO::MH_OBJECT: | ||||
8673 | outs() << " OBJECT"; | ||||
8674 | break; | ||||
8675 | case MachO::MH_EXECUTE: | ||||
8676 | outs() << " EXECUTE"; | ||||
8677 | break; | ||||
8678 | case MachO::MH_FVMLIB: | ||||
8679 | outs() << " FVMLIB"; | ||||
8680 | break; | ||||
8681 | case MachO::MH_CORE: | ||||
8682 | outs() << " CORE"; | ||||
8683 | break; | ||||
8684 | case MachO::MH_PRELOAD: | ||||
8685 | outs() << " PRELOAD"; | ||||
8686 | break; | ||||
8687 | case MachO::MH_DYLIB: | ||||
8688 | outs() << " DYLIB"; | ||||
8689 | break; | ||||
8690 | case MachO::MH_DYLIB_STUB: | ||||
8691 | outs() << " DYLIB_STUB"; | ||||
8692 | break; | ||||
8693 | case MachO::MH_DYLINKER: | ||||
8694 | outs() << " DYLINKER"; | ||||
8695 | break; | ||||
8696 | case MachO::MH_BUNDLE: | ||||
8697 | outs() << " BUNDLE"; | ||||
8698 | break; | ||||
8699 | case MachO::MH_DSYM: | ||||
8700 | outs() << " DSYM"; | ||||
8701 | break; | ||||
8702 | case MachO::MH_KEXT_BUNDLE: | ||||
8703 | outs() << " KEXTBUNDLE"; | ||||
8704 | break; | ||||
8705 | case MachO::MH_FILESET: | ||||
8706 | outs() << " FILESET"; | ||||
8707 | break; | ||||
8708 | default: | ||||
8709 | outs() << format(" %10u", filetype); | ||||
8710 | break; | ||||
8711 | } | ||||
8712 | outs() << format(" %5u", ncmds); | ||||
8713 | outs() << format(" %10u", sizeofcmds); | ||||
8714 | uint32_t f = flags; | ||||
8715 | if (f & MachO::MH_NOUNDEFS) { | ||||
8716 | outs() << " NOUNDEFS"; | ||||
8717 | f &= ~MachO::MH_NOUNDEFS; | ||||
8718 | } | ||||
8719 | if (f & MachO::MH_INCRLINK) { | ||||
8720 | outs() << " INCRLINK"; | ||||
8721 | f &= ~MachO::MH_INCRLINK; | ||||
8722 | } | ||||
8723 | if (f & MachO::MH_DYLDLINK) { | ||||
8724 | outs() << " DYLDLINK"; | ||||
8725 | f &= ~MachO::MH_DYLDLINK; | ||||
8726 | } | ||||
8727 | if (f & MachO::MH_BINDATLOAD) { | ||||
8728 | outs() << " BINDATLOAD"; | ||||
8729 | f &= ~MachO::MH_BINDATLOAD; | ||||
8730 | } | ||||
8731 | if (f & MachO::MH_PREBOUND) { | ||||
8732 | outs() << " PREBOUND"; | ||||
8733 | f &= ~MachO::MH_PREBOUND; | ||||
8734 | } | ||||
8735 | if (f & MachO::MH_SPLIT_SEGS) { | ||||
8736 | outs() << " SPLIT_SEGS"; | ||||
8737 | f &= ~MachO::MH_SPLIT_SEGS; | ||||
8738 | } | ||||
8739 | if (f & MachO::MH_LAZY_INIT) { | ||||
8740 | outs() << " LAZY_INIT"; | ||||
8741 | f &= ~MachO::MH_LAZY_INIT; | ||||
8742 | } | ||||
8743 | if (f & MachO::MH_TWOLEVEL) { | ||||
8744 | outs() << " TWOLEVEL"; | ||||
8745 | f &= ~MachO::MH_TWOLEVEL; | ||||
8746 | } | ||||
8747 | if (f & MachO::MH_FORCE_FLAT) { | ||||
8748 | outs() << " FORCE_FLAT"; | ||||
8749 | f &= ~MachO::MH_FORCE_FLAT; | ||||
8750 | } | ||||
8751 | if (f & MachO::MH_NOMULTIDEFS) { | ||||
8752 | outs() << " NOMULTIDEFS"; | ||||
8753 | f &= ~MachO::MH_NOMULTIDEFS; | ||||
8754 | } | ||||
8755 | if (f & MachO::MH_NOFIXPREBINDING) { | ||||
8756 | outs() << " NOFIXPREBINDING"; | ||||
8757 | f &= ~MachO::MH_NOFIXPREBINDING; | ||||
8758 | } | ||||
8759 | if (f & MachO::MH_PREBINDABLE) { | ||||
8760 | outs() << " PREBINDABLE"; | ||||
8761 | f &= ~MachO::MH_PREBINDABLE; | ||||
8762 | } | ||||
8763 | if (f & MachO::MH_ALLMODSBOUND) { | ||||
8764 | outs() << " ALLMODSBOUND"; | ||||
8765 | f &= ~MachO::MH_ALLMODSBOUND; | ||||
8766 | } | ||||
8767 | if (f & MachO::MH_SUBSECTIONS_VIA_SYMBOLS) { | ||||
8768 | outs() << " SUBSECTIONS_VIA_SYMBOLS"; | ||||
8769 | f &= ~MachO::MH_SUBSECTIONS_VIA_SYMBOLS; | ||||
8770 | } | ||||
8771 | if (f & MachO::MH_CANONICAL) { | ||||
8772 | outs() << " CANONICAL"; | ||||
8773 | f &= ~MachO::MH_CANONICAL; | ||||
8774 | } | ||||
8775 | if (f & MachO::MH_WEAK_DEFINES) { | ||||
8776 | outs() << " WEAK_DEFINES"; | ||||
8777 | f &= ~MachO::MH_WEAK_DEFINES; | ||||
8778 | } | ||||
8779 | if (f & MachO::MH_BINDS_TO_WEAK) { | ||||
8780 | outs() << " BINDS_TO_WEAK"; | ||||
8781 | f &= ~MachO::MH_BINDS_TO_WEAK; | ||||
8782 | } | ||||
8783 | if (f & MachO::MH_ALLOW_STACK_EXECUTION) { | ||||
8784 | outs() << " ALLOW_STACK_EXECUTION"; | ||||
8785 | f &= ~MachO::MH_ALLOW_STACK_EXECUTION; | ||||
8786 | } | ||||
8787 | if (f & MachO::MH_DEAD_STRIPPABLE_DYLIB) { | ||||
8788 | outs() << " DEAD_STRIPPABLE_DYLIB"; | ||||
8789 | f &= ~MachO::MH_DEAD_STRIPPABLE_DYLIB; | ||||
8790 | } | ||||
8791 | if (f & MachO::MH_PIE) { | ||||
8792 | outs() << " PIE"; | ||||
8793 | f &= ~MachO::MH_PIE; | ||||
8794 | } | ||||
8795 | if (f & MachO::MH_NO_REEXPORTED_DYLIBS) { | ||||
8796 | outs() << " NO_REEXPORTED_DYLIBS"; | ||||
8797 | f &= ~MachO::MH_NO_REEXPORTED_DYLIBS; | ||||
8798 | } | ||||
8799 | if (f & MachO::MH_HAS_TLV_DESCRIPTORS) { | ||||
8800 | outs() << " MH_HAS_TLV_DESCRIPTORS"; | ||||
8801 | f &= ~MachO::MH_HAS_TLV_DESCRIPTORS; | ||||
8802 | } | ||||
8803 | if (f & MachO::MH_NO_HEAP_EXECUTION) { | ||||
8804 | outs() << " MH_NO_HEAP_EXECUTION"; | ||||
8805 | f &= ~MachO::MH_NO_HEAP_EXECUTION; | ||||
8806 | } | ||||
8807 | if (f & MachO::MH_APP_EXTENSION_SAFE) { | ||||
8808 | outs() << " APP_EXTENSION_SAFE"; | ||||
8809 | f &= ~MachO::MH_APP_EXTENSION_SAFE; | ||||
8810 | } | ||||
8811 | if (f & MachO::MH_NLIST_OUTOFSYNC_WITH_DYLDINFO) { | ||||
8812 | outs() << " NLIST_OUTOFSYNC_WITH_DYLDINFO"; | ||||
8813 | f &= ~MachO::MH_NLIST_OUTOFSYNC_WITH_DYLDINFO; | ||||
8814 | } | ||||
8815 | if (f != 0 || flags == 0) | ||||
8816 | outs() << format(" 0x%08" PRIx32"x", f); | ||||
8817 | } else { | ||||
8818 | outs() << format(" 0x%08" PRIx32"x", magic); | ||||
8819 | outs() << format(" %7d", cputype); | ||||
8820 | outs() << format(" %10d", cpusubtype & ~MachO::CPU_SUBTYPE_MASK); | ||||
8821 | outs() << format(" 0x%02" PRIx32"x", | ||||
8822 | (cpusubtype & MachO::CPU_SUBTYPE_MASK) >> 24); | ||||
8823 | outs() << format(" %10u", filetype); | ||||
8824 | outs() << format(" %5u", ncmds); | ||||
8825 | outs() << format(" %10u", sizeofcmds); | ||||
8826 | outs() << format(" 0x%08" PRIx32"x", flags); | ||||
8827 | } | ||||
8828 | outs() << "\n"; | ||||
8829 | } | ||||
8830 | |||||
8831 | static void PrintSegmentCommand(uint32_t cmd, uint32_t cmdsize, | ||||
8832 | StringRef SegName, uint64_t vmaddr, | ||||
8833 | uint64_t vmsize, uint64_t fileoff, | ||||
8834 | uint64_t filesize, uint32_t maxprot, | ||||
8835 | uint32_t initprot, uint32_t nsects, | ||||
8836 | uint32_t flags, uint32_t object_size, | ||||
8837 | bool verbose) { | ||||
8838 | uint64_t expected_cmdsize; | ||||
8839 | if (cmd == MachO::LC_SEGMENT) { | ||||
8840 | outs() << " cmd LC_SEGMENT\n"; | ||||
8841 | expected_cmdsize = nsects; | ||||
8842 | expected_cmdsize *= sizeof(struct MachO::section); | ||||
8843 | expected_cmdsize += sizeof(struct MachO::segment_command); | ||||
8844 | } else { | ||||
8845 | outs() << " cmd LC_SEGMENT_64\n"; | ||||
8846 | expected_cmdsize = nsects; | ||||
8847 | expected_cmdsize *= sizeof(struct MachO::section_64); | ||||
8848 | expected_cmdsize += sizeof(struct MachO::segment_command_64); | ||||
8849 | } | ||||
8850 | outs() << " cmdsize " << cmdsize; | ||||
8851 | if (cmdsize != expected_cmdsize) | ||||
8852 | outs() << " Inconsistent size\n"; | ||||
8853 | else | ||||
8854 | outs() << "\n"; | ||||
8855 | outs() << " segname " << SegName << "\n"; | ||||
8856 | if (cmd == MachO::LC_SEGMENT_64) { | ||||
8857 | outs() << " vmaddr " << format("0x%016" PRIx64"l" "x", vmaddr) << "\n"; | ||||
8858 | outs() << " vmsize " << format("0x%016" PRIx64"l" "x", vmsize) << "\n"; | ||||
8859 | } else { | ||||
8860 | outs() << " vmaddr " << format("0x%08" PRIx64"l" "x", vmaddr) << "\n"; | ||||
8861 | outs() << " vmsize " << format("0x%08" PRIx64"l" "x", vmsize) << "\n"; | ||||
8862 | } | ||||
8863 | outs() << " fileoff " << fileoff; | ||||
8864 | if (fileoff > object_size) | ||||
8865 | outs() << " (past end of file)\n"; | ||||
8866 | else | ||||
8867 | outs() << "\n"; | ||||
8868 | outs() << " filesize " << filesize; | ||||
8869 | if (fileoff + filesize > object_size) | ||||
8870 | outs() << " (past end of file)\n"; | ||||
8871 | else | ||||
8872 | outs() << "\n"; | ||||
8873 | if (verbose) { | ||||
8874 | if ((maxprot & | ||||
8875 | ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | | ||||
8876 | MachO::VM_PROT_EXECUTE)) != 0) | ||||
8877 | outs() << " maxprot ?" << format("0x%08" PRIx32"x", maxprot) << "\n"; | ||||
8878 | else { | ||||
8879 | outs() << " maxprot "; | ||||
8880 | outs() << ((maxprot & MachO::VM_PROT_READ) ? "r" : "-"); | ||||
8881 | outs() << ((maxprot & MachO::VM_PROT_WRITE) ? "w" : "-"); | ||||
8882 | outs() << ((maxprot & MachO::VM_PROT_EXECUTE) ? "x\n" : "-\n"); | ||||
8883 | } | ||||
8884 | if ((initprot & | ||||
8885 | ~(MachO::VM_PROT_READ | MachO::VM_PROT_WRITE | | ||||
8886 | MachO::VM_PROT_EXECUTE)) != 0) | ||||
8887 | outs() << " initprot ?" << format("0x%08" PRIx32"x", initprot) << "\n"; | ||||
8888 | else { | ||||
8889 | outs() << " initprot "; | ||||
8890 | outs() << ((initprot & MachO::VM_PROT_READ) ? "r" : "-"); | ||||
8891 | outs() << ((initprot & MachO::VM_PROT_WRITE) ? "w" : "-"); | ||||
8892 | outs() << ((initprot & MachO::VM_PROT_EXECUTE) ? "x\n" : "-\n"); | ||||
8893 | } | ||||
8894 | } else { | ||||
8895 | outs() << " maxprot " << format("0x%08" PRIx32"x", maxprot) << "\n"; | ||||
8896 | outs() << " initprot " << format("0x%08" PRIx32"x", initprot) << "\n"; | ||||
8897 | } | ||||
8898 | outs() << " nsects " << nsects << "\n"; | ||||
8899 | if (verbose) { | ||||
8900 | outs() << " flags"; | ||||
8901 | if (flags == 0) | ||||
8902 | outs() << " (none)\n"; | ||||
8903 | else { | ||||
8904 | if (flags & MachO::SG_HIGHVM) { | ||||
8905 | outs() << " HIGHVM"; | ||||
8906 | flags &= ~MachO::SG_HIGHVM; | ||||
8907 | } | ||||
8908 | if (flags & MachO::SG_FVMLIB) { | ||||
8909 | outs() << " FVMLIB"; | ||||
8910 | flags &= ~MachO::SG_FVMLIB; | ||||
8911 | } | ||||
8912 | if (flags & MachO::SG_NORELOC) { | ||||
8913 | outs() << " NORELOC"; | ||||
8914 | flags &= ~MachO::SG_NORELOC; | ||||
8915 | } | ||||
8916 | if (flags & MachO::SG_PROTECTED_VERSION_1) { | ||||
8917 | outs() << " PROTECTED_VERSION_1"; | ||||
8918 | flags &= ~MachO::SG_PROTECTED_VERSION_1; | ||||
8919 | } | ||||
8920 | if (flags & MachO::SG_READ_ONLY) { | ||||
8921 | // Apple's otool prints the SG_ prefix for this flag, but not for the | ||||
8922 | // others. | ||||
8923 | outs() << " SG_READ_ONLY"; | ||||
8924 | flags &= ~MachO::SG_READ_ONLY; | ||||
8925 | } | ||||
8926 | if (flags) | ||||
8927 | outs() << format(" 0x%08" PRIx32"x", flags) << " (unknown flags)\n"; | ||||
8928 | else | ||||
8929 | outs() << "\n"; | ||||
8930 | } | ||||
8931 | } else { | ||||
8932 | outs() << " flags " << format("0x%" PRIx32"x", flags) << "\n"; | ||||
8933 | } | ||||
8934 | } | ||||
8935 | |||||
8936 | static void PrintSection(const char *sectname, const char *segname, | ||||
8937 | uint64_t addr, uint64_t size, uint32_t offset, | ||||
8938 | uint32_t align, uint32_t reloff, uint32_t nreloc, | ||||
8939 | uint32_t flags, uint32_t reserved1, uint32_t reserved2, | ||||
8940 | uint32_t cmd, const char *sg_segname, | ||||
8941 | uint32_t filetype, uint32_t object_size, | ||||
8942 | bool verbose) { | ||||
8943 | outs() << "Section\n"; | ||||
8944 | outs() << " sectname " << format("%.16s\n", sectname); | ||||
8945 | outs() << " segname " << format("%.16s", segname); | ||||
8946 | if (filetype != MachO::MH_OBJECT && strncmp(sg_segname, segname, 16) != 0) | ||||
8947 | outs() << " (does not match segment)\n"; | ||||
8948 | else | ||||
8949 | outs() << "\n"; | ||||
8950 | if (cmd == MachO::LC_SEGMENT_64) { | ||||
8951 | outs() << " addr " << format("0x%016" PRIx64"l" "x", addr) << "\n"; | ||||
8952 | outs() << " size " << format("0x%016" PRIx64"l" "x", size); | ||||
8953 | } else { | ||||
8954 | outs() << " addr " << format("0x%08" PRIx64"l" "x", addr) << "\n"; | ||||
8955 | outs() << " size " << format("0x%08" PRIx64"l" "x", size); | ||||
8956 | } | ||||
8957 | if ((flags & MachO::S_ZEROFILL) != 0 && offset + size > object_size) | ||||
8958 | outs() << " (past end of file)\n"; | ||||
8959 | else | ||||
8960 | outs() << "\n"; | ||||
8961 | outs() << " offset " << offset; | ||||
8962 | if (offset > object_size) | ||||
8963 | outs() << " (past end of file)\n"; | ||||
8964 | else | ||||
8965 | outs() << "\n"; | ||||
8966 | uint32_t align_shifted = 1 << align; | ||||
8967 | outs() << " align 2^" << align << " (" << align_shifted << ")\n"; | ||||
8968 | outs() << " reloff " << reloff; | ||||
8969 | if (reloff > object_size) | ||||
8970 | outs() << " (past end of file)\n"; | ||||
8971 | else | ||||
8972 | outs() << "\n"; | ||||
8973 | outs() << " nreloc " << nreloc; | ||||
8974 | if (reloff + nreloc * sizeof(struct MachO::relocation_info) > object_size) | ||||
8975 | outs() << " (past end of file)\n"; | ||||
8976 | else | ||||
8977 | outs() << "\n"; | ||||
8978 | uint32_t section_type = flags & MachO::SECTION_TYPE; | ||||
8979 | if (verbose) { | ||||
8980 | outs() << " type"; | ||||
8981 | if (section_type == MachO::S_REGULAR) | ||||
8982 | outs() << " S_REGULAR\n"; | ||||
8983 | else if (section_type == MachO::S_ZEROFILL) | ||||
8984 | outs() << " S_ZEROFILL\n"; | ||||
8985 | else if (section_type == MachO::S_CSTRING_LITERALS) | ||||
8986 | outs() << " S_CSTRING_LITERALS\n"; | ||||
8987 | else if (section_type == MachO::S_4BYTE_LITERALS) | ||||
8988 | outs() << " S_4BYTE_LITERALS\n"; | ||||
8989 | else if (section_type == MachO::S_8BYTE_LITERALS) | ||||
8990 | outs() << " S_8BYTE_LITERALS\n"; | ||||
8991 | else if (section_type == MachO::S_16BYTE_LITERALS) | ||||
8992 | outs() << " S_16BYTE_LITERALS\n"; | ||||
8993 | else if (section_type == MachO::S_LITERAL_POINTERS) | ||||
8994 | outs() << " S_LITERAL_POINTERS\n"; | ||||
8995 | else if (section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS) | ||||
8996 | outs() << " S_NON_LAZY_SYMBOL_POINTERS\n"; | ||||
8997 | else if (section_type == MachO::S_LAZY_SYMBOL_POINTERS) | ||||
8998 | outs() << " S_LAZY_SYMBOL_POINTERS\n"; | ||||
8999 | else if (section_type == MachO::S_SYMBOL_STUBS) | ||||
9000 | outs() << " S_SYMBOL_STUBS\n"; | ||||
9001 | else if (section_type == MachO::S_MOD_INIT_FUNC_POINTERS) | ||||
9002 | outs() << " S_MOD_INIT_FUNC_POINTERS\n"; | ||||
9003 | else if (section_type == MachO::S_MOD_TERM_FUNC_POINTERS) | ||||
9004 | outs() << " S_MOD_TERM_FUNC_POINTERS\n"; | ||||
9005 | else if (section_type == MachO::S_COALESCED) | ||||
9006 | outs() << " S_COALESCED\n"; | ||||
9007 | else if (section_type == MachO::S_INTERPOSING) | ||||
9008 | outs() << " S_INTERPOSING\n"; | ||||
9009 | else if (section_type == MachO::S_DTRACE_DOF) | ||||
9010 | outs() << " S_DTRACE_DOF\n"; | ||||
9011 | else if (section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS) | ||||
9012 | outs() << " S_LAZY_DYLIB_SYMBOL_POINTERS\n"; | ||||
9013 | else if (section_type == MachO::S_THREAD_LOCAL_REGULAR) | ||||
9014 | outs() << " S_THREAD_LOCAL_REGULAR\n"; | ||||
9015 | else if (section_type == MachO::S_THREAD_LOCAL_ZEROFILL) | ||||
9016 | outs() << " S_THREAD_LOCAL_ZEROFILL\n"; | ||||
9017 | else if (section_type == MachO::S_THREAD_LOCAL_VARIABLES) | ||||
9018 | outs() << " S_THREAD_LOCAL_VARIABLES\n"; | ||||
9019 | else if (section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS) | ||||
9020 | outs() << " S_THREAD_LOCAL_VARIABLE_POINTERS\n"; | ||||
9021 | else if (section_type == MachO::S_THREAD_LOCAL_INIT_FUNCTION_POINTERS) | ||||
9022 | outs() << " S_THREAD_LOCAL_INIT_FUNCTION_POINTERS\n"; | ||||
9023 | else if (section_type == MachO::S_INIT_FUNC_OFFSETS) | ||||
9024 | outs() << " S_INIT_FUNC_OFFSETS\n"; | ||||
9025 | else | ||||
9026 | outs() << format("0x%08" PRIx32"x", section_type) << "\n"; | ||||
9027 | outs() << "attributes"; | ||||
9028 | uint32_t section_attributes = flags & MachO::SECTION_ATTRIBUTES; | ||||
9029 | if (section_attributes & MachO::S_ATTR_PURE_INSTRUCTIONS) | ||||
9030 | outs() << " PURE_INSTRUCTIONS"; | ||||
9031 | if (section_attributes & MachO::S_ATTR_NO_TOC) | ||||
9032 | outs() << " NO_TOC"; | ||||
9033 | if (section_attributes & MachO::S_ATTR_STRIP_STATIC_SYMS) | ||||
9034 | outs() << " STRIP_STATIC_SYMS"; | ||||
9035 | if (section_attributes & MachO::S_ATTR_NO_DEAD_STRIP) | ||||
9036 | outs() << " NO_DEAD_STRIP"; | ||||
9037 | if (section_attributes & MachO::S_ATTR_LIVE_SUPPORT) | ||||
9038 | outs() << " LIVE_SUPPORT"; | ||||
9039 | if (section_attributes & MachO::S_ATTR_SELF_MODIFYING_CODE) | ||||
9040 | outs() << " SELF_MODIFYING_CODE"; | ||||
9041 | if (section_attributes & MachO::S_ATTR_DEBUG) | ||||
9042 | outs() << " DEBUG"; | ||||
9043 | if (section_attributes & MachO::S_ATTR_SOME_INSTRUCTIONS) | ||||
9044 | outs() << " SOME_INSTRUCTIONS"; | ||||
9045 | if (section_attributes & MachO::S_ATTR_EXT_RELOC) | ||||
9046 | outs() << " EXT_RELOC"; | ||||
9047 | if (section_attributes & MachO::S_ATTR_LOC_RELOC) | ||||
9048 | outs() << " LOC_RELOC"; | ||||
9049 | if (section_attributes == 0) | ||||
9050 | outs() << " (none)"; | ||||
9051 | outs() << "\n"; | ||||
9052 | } else | ||||
9053 | outs() << " flags " << format("0x%08" PRIx32"x", flags) << "\n"; | ||||
9054 | outs() << " reserved1 " << reserved1; | ||||
9055 | if (section_type == MachO::S_SYMBOL_STUBS || | ||||
9056 | section_type == MachO::S_LAZY_SYMBOL_POINTERS || | ||||
9057 | section_type == MachO::S_LAZY_DYLIB_SYMBOL_POINTERS || | ||||
9058 | section_type == MachO::S_NON_LAZY_SYMBOL_POINTERS || | ||||
9059 | section_type == MachO::S_THREAD_LOCAL_VARIABLE_POINTERS) | ||||
9060 | outs() << " (index into indirect symbol table)\n"; | ||||
9061 | else | ||||
9062 | outs() << "\n"; | ||||
9063 | outs() << " reserved2 " << reserved2; | ||||
9064 | if (section_type == MachO::S_SYMBOL_STUBS) | ||||
9065 | outs() << " (size of stubs)\n"; | ||||
9066 | else | ||||
9067 | outs() << "\n"; | ||||
9068 | } | ||||
9069 | |||||
9070 | static void PrintSymtabLoadCommand(MachO::symtab_command st, bool Is64Bit, | ||||
9071 | uint32_t object_size) { | ||||
9072 | outs() << " cmd LC_SYMTAB\n"; | ||||
9073 | outs() << " cmdsize " << st.cmdsize; | ||||
9074 | if (st.cmdsize != sizeof(struct MachO::symtab_command)) | ||||
9075 | outs() << " Incorrect size\n"; | ||||
9076 | else | ||||
9077 | outs() << "\n"; | ||||
9078 | outs() << " symoff " << st.symoff; | ||||
9079 | if (st.symoff > object_size) | ||||
9080 | outs() << " (past end of file)\n"; | ||||
9081 | else | ||||
9082 | outs() << "\n"; | ||||
9083 | outs() << " nsyms " << st.nsyms; | ||||
9084 | uint64_t big_size; | ||||
9085 | if (Is64Bit) { | ||||
9086 | big_size = st.nsyms; | ||||
9087 | big_size *= sizeof(struct MachO::nlist_64); | ||||
9088 | big_size += st.symoff; | ||||
9089 | if (big_size > object_size) | ||||
9090 | outs() << " (past end of file)\n"; | ||||
9091 | else | ||||
9092 | outs() << "\n"; | ||||
9093 | } else { | ||||
9094 | big_size = st.nsyms; | ||||
9095 | big_size *= sizeof(struct MachO::nlist); | ||||
9096 | big_size += st.symoff; | ||||
9097 | if (big_size > object_size) | ||||
9098 | outs() << " (past end of file)\n"; | ||||
9099 | else | ||||
9100 | outs() << "\n"; | ||||
9101 | } | ||||
9102 | outs() << " stroff " << st.stroff; | ||||
9103 | if (st.stroff > object_size) | ||||
9104 | outs() << " (past end of file)\n"; | ||||
9105 | else | ||||
9106 | outs() << "\n"; | ||||
9107 | outs() << " strsize " << st.strsize; | ||||
9108 | big_size = st.stroff; | ||||
9109 | big_size += st.strsize; | ||||
9110 | if (big_size > object_size) | ||||
9111 | outs() << " (past end of file)\n"; | ||||
9112 | else | ||||
9113 | outs() << "\n"; | ||||
9114 | } | ||||
9115 | |||||
9116 | static void PrintDysymtabLoadCommand(MachO::dysymtab_command dyst, | ||||
9117 | uint32_t nsyms, uint32_t object_size, | ||||
9118 | bool Is64Bit) { | ||||
9119 | outs() << " cmd LC_DYSYMTAB\n"; | ||||
9120 | outs() << " cmdsize " << dyst.cmdsize; | ||||
9121 | if (dyst.cmdsize != sizeof(struct MachO::dysymtab_command)) | ||||
9122 | outs() << " Incorrect size\n"; | ||||
9123 | else | ||||
9124 | outs() << "\n"; | ||||
9125 | outs() << " ilocalsym " << dyst.ilocalsym; | ||||
9126 | if (dyst.ilocalsym > nsyms) | ||||
9127 | outs() << " (greater than the number of symbols)\n"; | ||||
9128 | else | ||||
9129 | outs() << "\n"; | ||||
9130 | outs() << " nlocalsym " << dyst.nlocalsym; | ||||
9131 | uint64_t big_size; | ||||
9132 | big_size = dyst.ilocalsym; | ||||
9133 | big_size += dyst.nlocalsym; | ||||
9134 | if (big_size > nsyms) | ||||
9135 | outs() << " (past the end of the symbol table)\n"; | ||||
9136 | else | ||||
9137 | outs() << "\n"; | ||||
9138 | outs() << " iextdefsym " << dyst.iextdefsym; | ||||
9139 | if (dyst.iextdefsym > nsyms) | ||||
9140 | outs() << " (greater than the number of symbols)\n"; | ||||
9141 | else | ||||
9142 | outs() << "\n"; | ||||
9143 | outs() << " nextdefsym " << dyst.nextdefsym; | ||||
9144 | big_size = dyst.iextdefsym; | ||||
9145 | big_size += dyst.nextdefsym; | ||||
9146 | if (big_size > nsyms) | ||||
9147 | outs() << " (past the end of the symbol table)\n"; | ||||
9148 | else | ||||
9149 | outs() << "\n"; | ||||
9150 | outs() << " iundefsym " << dyst.iundefsym; | ||||
9151 | if (dyst.iundefsym > nsyms) | ||||
9152 | outs() << " (greater than the number of symbols)\n"; | ||||
9153 | else | ||||
9154 | outs() << "\n"; | ||||
9155 | outs() << " nundefsym " << dyst.nundefsym; | ||||
9156 | big_size = dyst.iundefsym; | ||||
9157 | big_size += dyst.nundefsym; | ||||
9158 | if (big_size > nsyms) | ||||
9159 | outs() << " (past the end of the symbol table)\n"; | ||||
9160 | else | ||||
9161 | outs() << "\n"; | ||||
9162 | outs() << " tocoff " << dyst.tocoff; | ||||
9163 | if (dyst.tocoff > object_size) | ||||
9164 | outs() << " (past end of file)\n"; | ||||
9165 | else | ||||
9166 | outs() << "\n"; | ||||
9167 | outs() << " ntoc " << dyst.ntoc; | ||||
9168 | big_size = dyst.ntoc; | ||||
9169 | big_size *= sizeof(struct MachO::dylib_table_of_contents); | ||||
9170 | big_size += dyst.tocoff; | ||||
9171 | if (big_size > object_size) | ||||
9172 | outs() << " (past end of file)\n"; | ||||
9173 | else | ||||
9174 | outs() << "\n"; | ||||
9175 | outs() << " modtaboff " << dyst.modtaboff; | ||||
9176 | if (dyst.modtaboff > object_size) | ||||
9177 | outs() << " (past end of file)\n"; | ||||
9178 | else | ||||
9179 | outs() << "\n"; | ||||
9180 | outs() << " nmodtab " << dyst.nmodtab; | ||||
9181 | uint64_t modtabend; | ||||
9182 | if (Is64Bit) { | ||||
9183 | modtabend = dyst.nmodtab; | ||||
9184 | modtabend *= sizeof(struct MachO::dylib_module_64); | ||||
9185 | modtabend += dyst.modtaboff; | ||||
9186 | } else { | ||||
9187 | modtabend = dyst.nmodtab; | ||||
9188 | modtabend *= sizeof(struct MachO::dylib_module); | ||||
9189 | modtabend += dyst.modtaboff; | ||||
9190 | } | ||||
9191 | if (modtabend > object_size) | ||||
9192 | outs() << " (past end of file)\n"; | ||||
9193 | else | ||||
9194 | outs() << "\n"; | ||||
9195 | outs() << " extrefsymoff " << dyst.extrefsymoff; | ||||
9196 | if (dyst.extrefsymoff > object_size) | ||||
9197 | outs() << " (past end of file)\n"; | ||||
9198 | else | ||||
9199 | outs() << "\n"; | ||||
9200 | outs() << " nextrefsyms " << dyst.nextrefsyms; | ||||
9201 | big_size = dyst.nextrefsyms; | ||||
9202 | big_size *= sizeof(struct MachO::dylib_reference); | ||||
9203 | big_size += dyst.extrefsymoff; | ||||
9204 | if (big_size > object_size) | ||||
9205 | outs() << " (past end of file)\n"; | ||||
9206 | else | ||||
9207 | outs() << "\n"; | ||||
9208 | outs() << " indirectsymoff " << dyst.indirectsymoff; | ||||
9209 | if (dyst.indirectsymoff > object_size) | ||||
9210 | outs() << " (past end of file)\n"; | ||||
9211 | else | ||||
9212 | outs() << "\n"; | ||||
9213 | outs() << " nindirectsyms " << dyst.nindirectsyms; | ||||
9214 | big_size = dyst.nindirectsyms; | ||||
9215 | big_size *= sizeof(uint32_t); | ||||
9216 | big_size += dyst.indirectsymoff; | ||||
9217 | if (big_size > object_size) | ||||
9218 | outs() << " (past end of file)\n"; | ||||
9219 | else | ||||
9220 | outs() << "\n"; | ||||
9221 | outs() << " extreloff " << dyst.extreloff; | ||||
9222 | if (dyst.extreloff > object_size) | ||||
9223 | outs() << " (past end of file)\n"; | ||||
9224 | else | ||||
9225 | outs() << "\n"; | ||||
9226 | outs() << " nextrel " << dyst.nextrel; | ||||
9227 | big_size = dyst.nextrel; | ||||
9228 | big_size *= sizeof(struct MachO::relocation_info); | ||||
9229 | big_size += dyst.extreloff; | ||||
9230 | if (big_size > object_size) | ||||
9231 | outs() << " (past end of file)\n"; | ||||
9232 | else | ||||
9233 | outs() << "\n"; | ||||
9234 | outs() << " locreloff " << dyst.locreloff; | ||||
9235 | if (dyst.locreloff > object_size) | ||||
9236 | outs() << " (past end of file)\n"; | ||||
9237 | else | ||||
9238 | outs() << "\n"; | ||||
9239 | outs() << " nlocrel " << dyst.nlocrel; | ||||
9240 | big_size = dyst.nlocrel; | ||||
9241 | big_size *= sizeof(struct MachO::relocation_info); | ||||
9242 | big_size += dyst.locreloff; | ||||
9243 | if (big_size > object_size) | ||||
9244 | outs() << " (past end of file)\n"; | ||||
9245 | else | ||||
9246 | outs() << "\n"; | ||||
9247 | } | ||||
9248 | |||||
9249 | static void PrintDyldInfoLoadCommand(MachO::dyld_info_command dc, | ||||
9250 | uint32_t object_size) { | ||||
9251 | if (dc.cmd == MachO::LC_DYLD_INFO) | ||||
9252 | outs() << " cmd LC_DYLD_INFO\n"; | ||||
9253 | else | ||||
9254 | outs() << " cmd LC_DYLD_INFO_ONLY\n"; | ||||
9255 | outs() << " cmdsize " << dc.cmdsize; | ||||
9256 | if (dc.cmdsize != sizeof(struct MachO::dyld_info_command)) | ||||
9257 | outs() << " Incorrect size\n"; | ||||
9258 | else | ||||
9259 | outs() << "\n"; | ||||
9260 | outs() << " rebase_off " << dc.rebase_off; | ||||
9261 | if (dc.rebase_off > object_size) | ||||
9262 | outs() << " (past end of file)\n"; | ||||
9263 | else | ||||
9264 | outs() << "\n"; | ||||
9265 | outs() << " rebase_size " << dc.rebase_size; | ||||
9266 | uint64_t big_size; | ||||
9267 | big_size = dc.rebase_off; | ||||
9268 | big_size += dc.rebase_size; | ||||
9269 | if (big_size > object_size) | ||||
9270 | outs() << " (past end of file)\n"; | ||||
9271 | else | ||||
9272 | outs() << "\n"; | ||||
9273 | outs() << " bind_off " << dc.bind_off; | ||||
9274 | if (dc.bind_off > object_size) | ||||
9275 | outs() << " (past end of file)\n"; | ||||
9276 | else | ||||
9277 | outs() << "\n"; | ||||
9278 | outs() << " bind_size " << dc.bind_size; | ||||
9279 | big_size = dc.bind_off; | ||||
9280 | big_size += dc.bind_size; | ||||
9281 | if (big_size > object_size) | ||||
9282 | outs() << " (past end of file)\n"; | ||||
9283 | else | ||||
9284 | outs() << "\n"; | ||||
9285 | outs() << " weak_bind_off " << dc.weak_bind_off; | ||||
9286 | if (dc.weak_bind_off > object_size) | ||||
9287 | outs() << " (past end of file)\n"; | ||||
9288 | else | ||||
9289 | outs() << "\n"; | ||||
9290 | outs() << " weak_bind_size " << dc.weak_bind_size; | ||||
9291 | big_size = dc.weak_bind_off; | ||||
9292 | big_size += dc.weak_bind_size; | ||||
9293 | if (big_size > object_size) | ||||
9294 | outs() << " (past end of file)\n"; | ||||
9295 | else | ||||
9296 | outs() << "\n"; | ||||
9297 | outs() << " lazy_bind_off " << dc.lazy_bind_off; | ||||
9298 | if (dc.lazy_bind_off > object_size) | ||||
9299 | outs() << " (past end of file)\n"; | ||||
9300 | else | ||||
9301 | outs() << "\n"; | ||||
9302 | outs() << " lazy_bind_size " << dc.lazy_bind_size; | ||||
9303 | big_size = dc.lazy_bind_off; | ||||
9304 | big_size += dc.lazy_bind_size; | ||||
9305 | if (big_size > object_size) | ||||
9306 | outs() << " (past end of file)\n"; | ||||
9307 | else | ||||
9308 | outs() << "\n"; | ||||
9309 | outs() << " export_off " << dc.export_off; | ||||
9310 | if (dc.export_off > object_size) | ||||
9311 | outs() << " (past end of file)\n"; | ||||
9312 | else | ||||
9313 | outs() << "\n"; | ||||
9314 | outs() << " export_size " << dc.export_size; | ||||
9315 | big_size = dc.export_off; | ||||
9316 | big_size += dc.export_size; | ||||
9317 | if (big_size > object_size) | ||||
9318 | outs() << " (past end of file)\n"; | ||||
9319 | else | ||||
9320 | outs() << "\n"; | ||||
9321 | } | ||||
9322 | |||||
9323 | static void PrintDyldLoadCommand(MachO::dylinker_command dyld, | ||||
9324 | const char *Ptr) { | ||||
9325 | if (dyld.cmd == MachO::LC_ID_DYLINKER) | ||||
9326 | outs() << " cmd LC_ID_DYLINKER\n"; | ||||
9327 | else if (dyld.cmd == MachO::LC_LOAD_DYLINKER) | ||||
9328 | outs() << " cmd LC_LOAD_DYLINKER\n"; | ||||
9329 | else if (dyld.cmd == MachO::LC_DYLD_ENVIRONMENT) | ||||
9330 | outs() << " cmd LC_DYLD_ENVIRONMENT\n"; | ||||
9331 | else | ||||
9332 | outs() << " cmd ?(" << dyld.cmd << ")\n"; | ||||
9333 | outs() << " cmdsize " << dyld.cmdsize; | ||||
9334 | if (dyld.cmdsize < sizeof(struct MachO::dylinker_command)) | ||||
9335 | outs() << " Incorrect size\n"; | ||||
9336 | else | ||||
9337 | outs() << "\n"; | ||||
9338 | if (dyld.name >= dyld.cmdsize) | ||||
9339 | outs() << " name ?(bad offset " << dyld.name << ")\n"; | ||||
9340 | else { | ||||
9341 | const char *P = (const char *)(Ptr) + dyld.name; | ||||
9342 | outs() << " name " << P << " (offset " << dyld.name << ")\n"; | ||||
9343 | } | ||||
9344 | } | ||||
9345 | |||||
9346 | static void PrintUuidLoadCommand(MachO::uuid_command uuid) { | ||||
9347 | outs() << " cmd LC_UUID\n"; | ||||
9348 | outs() << " cmdsize " << uuid.cmdsize; | ||||
9349 | if (uuid.cmdsize != sizeof(struct MachO::uuid_command)) | ||||
9350 | outs() << " Incorrect size\n"; | ||||
9351 | else | ||||
9352 | outs() << "\n"; | ||||
9353 | outs() << " uuid "; | ||||
9354 | for (int i = 0; i < 16; ++i) { | ||||
9355 | outs() << format("%02" PRIX32"X", uuid.uuid[i]); | ||||
9356 | if (i == 3 || i == 5 || i == 7 || i == 9) | ||||
9357 | outs() << "-"; | ||||
9358 | } | ||||
9359 | outs() << "\n"; | ||||
9360 | } | ||||
9361 | |||||
9362 | static void PrintRpathLoadCommand(MachO::rpath_command rpath, const char *Ptr) { | ||||
9363 | outs() << " cmd LC_RPATH\n"; | ||||
9364 | outs() << " cmdsize " << rpath.cmdsize; | ||||
9365 | if (rpath.cmdsize < sizeof(struct MachO::rpath_command)) | ||||
9366 | outs() << " Incorrect size\n"; | ||||
9367 | else | ||||
9368 | outs() << "\n"; | ||||
9369 | if (rpath.path >= rpath.cmdsize) | ||||
9370 | outs() << " path ?(bad offset " << rpath.path << ")\n"; | ||||
9371 | else { | ||||
9372 | const char *P = (const char *)(Ptr) + rpath.path; | ||||
9373 | outs() << " path " << P << " (offset " << rpath.path << ")\n"; | ||||
9374 | } | ||||
9375 | } | ||||
9376 | |||||
9377 | static void PrintVersionMinLoadCommand(MachO::version_min_command vd) { | ||||
9378 | StringRef LoadCmdName; | ||||
9379 | switch (vd.cmd) { | ||||
9380 | case MachO::LC_VERSION_MIN_MACOSX: | ||||
9381 | LoadCmdName = "LC_VERSION_MIN_MACOSX"; | ||||
9382 | break; | ||||
9383 | case MachO::LC_VERSION_MIN_IPHONEOS: | ||||
9384 | LoadCmdName = "LC_VERSION_MIN_IPHONEOS"; | ||||
9385 | break; | ||||
9386 | case MachO::LC_VERSION_MIN_TVOS: | ||||
9387 | LoadCmdName = "LC_VERSION_MIN_TVOS"; | ||||
9388 | break; | ||||
9389 | case MachO::LC_VERSION_MIN_WATCHOS: | ||||
9390 | LoadCmdName = "LC_VERSION_MIN_WATCHOS"; | ||||
9391 | break; | ||||
9392 | default: | ||||
9393 | llvm_unreachable("Unknown version min load command")::llvm::llvm_unreachable_internal("Unknown version min load command" , "llvm/tools/llvm-objdump/MachODump.cpp", 9393); | ||||
9394 | } | ||||
9395 | |||||
9396 | outs() << " cmd " << LoadCmdName << '\n'; | ||||
9397 | outs() << " cmdsize " << vd.cmdsize; | ||||
9398 | if (vd.cmdsize != sizeof(struct MachO::version_min_command)) | ||||
9399 | outs() << " Incorrect size\n"; | ||||
9400 | else | ||||
9401 | outs() << "\n"; | ||||
9402 | outs() << " version " | ||||
9403 | << MachOObjectFile::getVersionMinMajor(vd, false) << "." | ||||
9404 | << MachOObjectFile::getVersionMinMinor(vd, false); | ||||
9405 | uint32_t Update = MachOObjectFile::getVersionMinUpdate(vd, false); | ||||
9406 | if (Update != 0) | ||||
9407 | outs() << "." << Update; | ||||
9408 | outs() << "\n"; | ||||
9409 | if (vd.sdk == 0) | ||||
9410 | outs() << " sdk n/a"; | ||||
9411 | else { | ||||
9412 | outs() << " sdk " | ||||
9413 | << MachOObjectFile::getVersionMinMajor(vd, true) << "." | ||||
9414 | << MachOObjectFile::getVersionMinMinor(vd, true); | ||||
9415 | } | ||||
9416 | Update = MachOObjectFile::getVersionMinUpdate(vd, true); | ||||
9417 | if (Update != 0) | ||||
9418 | outs() << "." << Update; | ||||
9419 | outs() << "\n"; | ||||
9420 | } | ||||
9421 | |||||
9422 | static void PrintNoteLoadCommand(MachO::note_command Nt) { | ||||
9423 | outs() << " cmd LC_NOTE\n"; | ||||
9424 | outs() << " cmdsize " << Nt.cmdsize; | ||||
9425 | if (Nt.cmdsize != sizeof(struct MachO::note_command)) | ||||
9426 | outs() << " Incorrect size\n"; | ||||
9427 | else | ||||
9428 | outs() << "\n"; | ||||
9429 | const char *d = Nt.data_owner; | ||||
9430 | outs() << "data_owner " << format("%.16s\n", d); | ||||
9431 | outs() << " offset " << Nt.offset << "\n"; | ||||
9432 | outs() << " size " << Nt.size << "\n"; | ||||
9433 | } | ||||
9434 | |||||
9435 | static void PrintBuildToolVersion(MachO::build_tool_version bv, bool verbose) { | ||||
9436 | outs() << " tool "; | ||||
9437 | if (verbose) | ||||
9438 | outs() << MachOObjectFile::getBuildTool(bv.tool); | ||||
9439 | else | ||||
9440 | outs() << bv.tool; | ||||
9441 | outs() << "\n"; | ||||
9442 | outs() << " version " << MachOObjectFile::getVersionString(bv.version) | ||||
9443 | << "\n"; | ||||
9444 | } | ||||
9445 | |||||
9446 | static void PrintBuildVersionLoadCommand(const MachOObjectFile *obj, | ||||
9447 | MachO::build_version_command bd, | ||||
9448 | bool verbose) { | ||||
9449 | outs() << " cmd LC_BUILD_VERSION\n"; | ||||
9450 | outs() << " cmdsize " << bd.cmdsize; | ||||
9451 | if (bd.cmdsize != | ||||
9452 | sizeof(struct MachO::build_version_command) + | ||||
9453 | bd.ntools * sizeof(struct MachO::build_tool_version)) | ||||
9454 | outs() << " Incorrect size\n"; | ||||
9455 | else | ||||
9456 | outs() << "\n"; | ||||
9457 | outs() << " platform "; | ||||
9458 | if (verbose) | ||||
9459 | outs() << MachOObjectFile::getBuildPlatform(bd.platform); | ||||
9460 | else | ||||
9461 | outs() << bd.platform; | ||||
9462 | outs() << "\n"; | ||||
9463 | if (bd.sdk) | ||||
9464 | outs() << " sdk " << MachOObjectFile::getVersionString(bd.sdk) | ||||
9465 | << "\n"; | ||||
9466 | else | ||||
9467 | outs() << " sdk n/a\n"; | ||||
9468 | outs() << " minos " << MachOObjectFile::getVersionString(bd.minos) | ||||
9469 | << "\n"; | ||||
9470 | outs() << " ntools " << bd.ntools << "\n"; | ||||
9471 | for (unsigned i = 0; i < bd.ntools; ++i) { | ||||
9472 | MachO::build_tool_version bv = obj->getBuildToolVersion(i); | ||||
9473 | PrintBuildToolVersion(bv, verbose); | ||||
9474 | } | ||||
9475 | } | ||||
9476 | |||||
9477 | static void PrintSourceVersionCommand(MachO::source_version_command sd) { | ||||
9478 | outs() << " cmd LC_SOURCE_VERSION\n"; | ||||
9479 | outs() << " cmdsize " << sd.cmdsize; | ||||
9480 | if (sd.cmdsize != sizeof(struct MachO::source_version_command)) | ||||
9481 | outs() << " Incorrect size\n"; | ||||
9482 | else | ||||
9483 | outs() << "\n"; | ||||
9484 | uint64_t a = (sd.version >> 40) & 0xffffff; | ||||
9485 | uint64_t b = (sd.version >> 30) & 0x3ff; | ||||
9486 | uint64_t c = (sd.version >> 20) & 0x3ff; | ||||
9487 | uint64_t d = (sd.version >> 10) & 0x3ff; | ||||
9488 | uint64_t e = sd.version & 0x3ff; | ||||
9489 | outs() << " version " << a << "." << b; | ||||
9490 | if (e != 0) | ||||
9491 | outs() << "." << c << "." << d << "." << e; | ||||
9492 | else if (d != 0) | ||||
9493 | outs() << "." << c << "." << d; | ||||
9494 | else if (c != 0) | ||||
9495 | outs() << "." << c; | ||||
9496 | outs() << "\n"; | ||||
9497 | } | ||||
9498 | |||||
9499 | static void PrintEntryPointCommand(MachO::entry_point_command ep) { | ||||
9500 | outs() << " cmd LC_MAIN\n"; | ||||
9501 | outs() << " cmdsize " << ep.cmdsize; | ||||
9502 | if (ep.cmdsize != sizeof(struct MachO::entry_point_command)) | ||||
9503 | outs() << " Incorrect size\n"; | ||||
9504 | else | ||||
9505 | outs() << "\n"; | ||||
9506 | outs() << " entryoff " << ep.entryoff << "\n"; | ||||
9507 | outs() << " stacksize " << ep.stacksize << "\n"; | ||||
9508 | } | ||||
9509 | |||||
9510 | static void PrintEncryptionInfoCommand(MachO::encryption_info_command ec, | ||||
9511 | uint32_t object_size) { | ||||
9512 | outs() << " cmd LC_ENCRYPTION_INFO\n"; | ||||
9513 | outs() << " cmdsize " << ec.cmdsize; | ||||
9514 | if (ec.cmdsize != sizeof(struct MachO::encryption_info_command)) | ||||
9515 | outs() << " Incorrect size\n"; | ||||
9516 | else | ||||
9517 | outs() << "\n"; | ||||
9518 | outs() << " cryptoff " << ec.cryptoff; | ||||
9519 | if (ec.cryptoff > object_size) | ||||
9520 | outs() << " (past end of file)\n"; | ||||
9521 | else | ||||
9522 | outs() << "\n"; | ||||
9523 | outs() << " cryptsize " << ec.cryptsize; | ||||
9524 | if (ec.cryptsize > object_size) | ||||
9525 | outs() << " (past end of file)\n"; | ||||
9526 | else | ||||
9527 | outs() << "\n"; | ||||
9528 | outs() << " cryptid " << ec.cryptid << "\n"; | ||||
9529 | } | ||||
9530 | |||||
9531 | static void PrintEncryptionInfoCommand64(MachO::encryption_info_command_64 ec, | ||||
9532 | uint32_t object_size) { | ||||
9533 | outs() << " cmd LC_ENCRYPTION_INFO_64\n"; | ||||
9534 | outs() << " cmdsize " << ec.cmdsize; | ||||
9535 | if (ec.cmdsize != sizeof(struct MachO::encryption_info_command_64)) | ||||
9536 | outs() << " Incorrect size\n"; | ||||
9537 | else | ||||
9538 | outs() << "\n"; | ||||
9539 | outs() << " cryptoff " << ec.cryptoff; | ||||
9540 | if (ec.cryptoff > object_size) | ||||
9541 | outs() << " (past end of file)\n"; | ||||
9542 | else | ||||
9543 | outs() << "\n"; | ||||
9544 | outs() << " cryptsize " << ec.cryptsize; | ||||
9545 | if (ec.cryptsize > object_size) | ||||
9546 | outs() << " (past end of file)\n"; | ||||
9547 | else | ||||
9548 | outs() << "\n"; | ||||
9549 | outs() << " cryptid " << ec.cryptid << "\n"; | ||||
9550 | outs() << " pad " << ec.pad << "\n"; | ||||
9551 | } | ||||
9552 | |||||
9553 | static void PrintLinkerOptionCommand(MachO::linker_option_command lo, | ||||
9554 | const char *Ptr) { | ||||
9555 | outs() << " cmd LC_LINKER_OPTION\n"; | ||||
9556 | outs() << " cmdsize " << lo.cmdsize; | ||||
9557 | if (lo.cmdsize < sizeof(struct MachO::linker_option_command)) | ||||
9558 | outs() << " Incorrect size\n"; | ||||
9559 | else | ||||
9560 | outs() << "\n"; | ||||
9561 | outs() << " count " << lo.count << "\n"; | ||||
9562 | const char *string = Ptr + sizeof(struct MachO::linker_option_command); | ||||
9563 | uint32_t left = lo.cmdsize - sizeof(struct MachO::linker_option_command); | ||||
9564 | uint32_t i = 0; | ||||
9565 | while (left > 0) { | ||||
9566 | while (*string == '\0' && left > 0) { | ||||
9567 | string++; | ||||
9568 | left--; | ||||
9569 | } | ||||
9570 | if (left > 0) { | ||||
9571 | i++; | ||||
9572 | outs() << " string #" << i << " " << format("%.*s\n", left, string); | ||||
9573 | uint32_t NullPos = StringRef(string, left).find('\0'); | ||||
9574 | uint32_t len = std::min(NullPos, left) + 1; | ||||
9575 | string += len; | ||||
9576 | left -= len; | ||||
9577 | } | ||||
9578 | } | ||||
9579 | if (lo.count != i) | ||||
9580 | outs() << " count " << lo.count << " does not match number of strings " | ||||
9581 | << i << "\n"; | ||||
9582 | } | ||||
9583 | |||||
9584 | static void PrintSubFrameworkCommand(MachO::sub_framework_command sub, | ||||
9585 | const char *Ptr) { | ||||
9586 | outs() << " cmd LC_SUB_FRAMEWORK\n"; | ||||
9587 | outs() << " cmdsize " << sub.cmdsize; | ||||
9588 | if (sub.cmdsize < sizeof(struct MachO::sub_framework_command)) | ||||
9589 | outs() << " Incorrect size\n"; | ||||
9590 | else | ||||
9591 | outs() << "\n"; | ||||
9592 | if (sub.umbrella < sub.cmdsize) { | ||||
9593 | const char *P = Ptr + sub.umbrella; | ||||
9594 | outs() << " umbrella " << P << " (offset " << sub.umbrella << ")\n"; | ||||
9595 | } else { | ||||
9596 | outs() << " umbrella ?(bad offset " << sub.umbrella << ")\n"; | ||||
9597 | } | ||||
9598 | } | ||||
9599 | |||||
9600 | static void PrintSubUmbrellaCommand(MachO::sub_umbrella_command sub, | ||||
9601 | const char *Ptr) { | ||||
9602 | outs() << " cmd LC_SUB_UMBRELLA\n"; | ||||
9603 | outs() << " cmdsize " << sub.cmdsize; | ||||
9604 | if (sub.cmdsize < sizeof(struct MachO::sub_umbrella_command)) | ||||
9605 | outs() << " Incorrect size\n"; | ||||
9606 | else | ||||
9607 | outs() << "\n"; | ||||
9608 | if (sub.sub_umbrella < sub.cmdsize) { | ||||
9609 | const char *P = Ptr + sub.sub_umbrella; | ||||
9610 | outs() << " sub_umbrella " << P << " (offset " << sub.sub_umbrella << ")\n"; | ||||
9611 | } else { | ||||
9612 | outs() << " sub_umbrella ?(bad offset " << sub.sub_umbrella << ")\n"; | ||||
9613 | } | ||||
9614 | } | ||||
9615 | |||||
9616 | static void PrintSubLibraryCommand(MachO::sub_library_command sub, | ||||
9617 | const char *Ptr) { | ||||
9618 | outs() << " cmd LC_SUB_LIBRARY\n"; | ||||
9619 | outs() << " cmdsize " << sub.cmdsize; | ||||
9620 | if (sub.cmdsize < sizeof(struct MachO::sub_library_command)) | ||||
9621 | outs() << " Incorrect size\n"; | ||||
9622 | else | ||||
9623 | outs() << "\n"; | ||||
9624 | if (sub.sub_library < sub.cmdsize) { | ||||
9625 | const char *P = Ptr + sub.sub_library; | ||||
9626 | outs() << " sub_library " << P << " (offset " << sub.sub_library << ")\n"; | ||||
9627 | } else { | ||||
9628 | outs() << " sub_library ?(bad offset " << sub.sub_library << ")\n"; | ||||
9629 | } | ||||
9630 | } | ||||
9631 | |||||
9632 | static void PrintSubClientCommand(MachO::sub_client_command sub, | ||||
9633 | const char *Ptr) { | ||||
9634 | outs() << " cmd LC_SUB_CLIENT\n"; | ||||
9635 | outs() << " cmdsize " << sub.cmdsize; | ||||
9636 | if (sub.cmdsize < sizeof(struct MachO::sub_client_command)) | ||||
9637 | outs() << " Incorrect size\n"; | ||||
9638 | else | ||||
9639 | outs() << "\n"; | ||||
9640 | if (sub.client < sub.cmdsize) { | ||||
9641 | const char *P = Ptr + sub.client; | ||||
9642 | outs() << " client " << P << " (offset " << sub.client << ")\n"; | ||||
9643 | } else { | ||||
9644 | outs() << " client ?(bad offset " << sub.client << ")\n"; | ||||
9645 | } | ||||
9646 | } | ||||
9647 | |||||
9648 | static void PrintRoutinesCommand(MachO::routines_command r) { | ||||
9649 | outs() << " cmd LC_ROUTINES\n"; | ||||
9650 | outs() << " cmdsize " << r.cmdsize; | ||||
9651 | if (r.cmdsize != sizeof(struct MachO::routines_command)) | ||||
9652 | outs() << " Incorrect size\n"; | ||||
9653 | else | ||||
9654 | outs() << "\n"; | ||||
9655 | outs() << " init_address " << format("0x%08" PRIx32"x", r.init_address) << "\n"; | ||||
9656 | outs() << " init_module " << r.init_module << "\n"; | ||||
9657 | outs() << " reserved1 " << r.reserved1 << "\n"; | ||||
9658 | outs() << " reserved2 " << r.reserved2 << "\n"; | ||||
9659 | outs() << " reserved3 " << r.reserved3 << "\n"; | ||||
9660 | outs() << " reserved4 " << r.reserved4 << "\n"; | ||||
9661 | outs() << " reserved5 " << r.reserved5 << "\n"; | ||||
9662 | outs() << " reserved6 " << r.reserved6 << "\n"; | ||||
9663 | } | ||||
9664 | |||||
9665 | static void PrintRoutinesCommand64(MachO::routines_command_64 r) { | ||||
9666 | outs() << " cmd LC_ROUTINES_64\n"; | ||||
9667 | outs() << " cmdsize " << r.cmdsize; | ||||
9668 | if (r.cmdsize != sizeof(struct MachO::routines_command_64)) | ||||
9669 | outs() << " Incorrect size\n"; | ||||
9670 | else | ||||
9671 | outs() << "\n"; | ||||
9672 | outs() << " init_address " << format("0x%016" PRIx64"l" "x", r.init_address) << "\n"; | ||||
9673 | outs() << " init_module " << r.init_module << "\n"; | ||||
9674 | outs() << " reserved1 " << r.reserved1 << "\n"; | ||||
9675 | outs() << " reserved2 " << r.reserved2 << "\n"; | ||||
9676 | outs() << " reserved3 " << r.reserved3 << "\n"; | ||||
9677 | outs() << " reserved4 " << r.reserved4 << "\n"; | ||||
9678 | outs() << " reserved5 " << r.reserved5 << "\n"; | ||||
9679 | outs() << " reserved6 " << r.reserved6 << "\n"; | ||||
9680 | } | ||||
9681 | |||||
9682 | static void Print_x86_thread_state32_t(MachO::x86_thread_state32_t &cpu32) { | ||||
9683 | outs() << "\t eax " << format("0x%08" PRIx32"x", cpu32.eax); | ||||
9684 | outs() << " ebx " << format("0x%08" PRIx32"x", cpu32.ebx); | ||||
9685 | outs() << " ecx " << format("0x%08" PRIx32"x", cpu32.ecx); | ||||
9686 | outs() << " edx " << format("0x%08" PRIx32"x", cpu32.edx) << "\n"; | ||||
9687 | outs() << "\t edi " << format("0x%08" PRIx32"x", cpu32.edi); | ||||
9688 | outs() << " esi " << format("0x%08" PRIx32"x", cpu32.esi); | ||||
9689 | outs() << " ebp " << format("0x%08" PRIx32"x", cpu32.ebp); | ||||
9690 | outs() << " esp " << format("0x%08" PRIx32"x", cpu32.esp) << "\n"; | ||||
9691 | outs() << "\t ss " << format("0x%08" PRIx32"x", cpu32.ss); | ||||
9692 | outs() << " eflags " << format("0x%08" PRIx32"x", cpu32.eflags); | ||||
9693 | outs() << " eip " << format("0x%08" PRIx32"x", cpu32.eip); | ||||
9694 | outs() << " cs " << format("0x%08" PRIx32"x", cpu32.cs) << "\n"; | ||||
9695 | outs() << "\t ds " << format("0x%08" PRIx32"x", cpu32.ds); | ||||
9696 | outs() << " es " << format("0x%08" PRIx32"x", cpu32.es); | ||||
9697 | outs() << " fs " << format("0x%08" PRIx32"x", cpu32.fs); | ||||
9698 | outs() << " gs " << format("0x%08" PRIx32"x", cpu32.gs) << "\n"; | ||||
9699 | } | ||||
9700 | |||||
9701 | static void Print_x86_thread_state64_t(MachO::x86_thread_state64_t &cpu64) { | ||||
9702 | outs() << " rax " << format("0x%016" PRIx64"l" "x", cpu64.rax); | ||||
9703 | outs() << " rbx " << format("0x%016" PRIx64"l" "x", cpu64.rbx); | ||||
9704 | outs() << " rcx " << format("0x%016" PRIx64"l" "x", cpu64.rcx) << "\n"; | ||||
9705 | outs() << " rdx " << format("0x%016" PRIx64"l" "x", cpu64.rdx); | ||||
9706 | outs() << " rdi " << format("0x%016" PRIx64"l" "x", cpu64.rdi); | ||||
9707 | outs() << " rsi " << format("0x%016" PRIx64"l" "x", cpu64.rsi) << "\n"; | ||||
9708 | outs() << " rbp " << format("0x%016" PRIx64"l" "x", cpu64.rbp); | ||||
9709 | outs() << " rsp " << format("0x%016" PRIx64"l" "x", cpu64.rsp); | ||||
9710 | outs() << " r8 " << format("0x%016" PRIx64"l" "x", cpu64.r8) << "\n"; | ||||
9711 | outs() << " r9 " << format("0x%016" PRIx64"l" "x", cpu64.r9); | ||||
9712 | outs() << " r10 " << format("0x%016" PRIx64"l" "x", cpu64.r10); | ||||
9713 | outs() << " r11 " << format("0x%016" PRIx64"l" "x", cpu64.r11) << "\n"; | ||||
9714 | outs() << " r12 " << format("0x%016" PRIx64"l" "x", cpu64.r12); | ||||
9715 | outs() << " r13 " << format("0x%016" PRIx64"l" "x", cpu64.r13); | ||||
9716 | outs() << " r14 " << format("0x%016" PRIx64"l" "x", cpu64.r14) << "\n"; | ||||
9717 | outs() << " r15 " << format("0x%016" PRIx64"l" "x", cpu64.r15); | ||||
9718 | outs() << " rip " << format("0x%016" PRIx64"l" "x", cpu64.rip) << "\n"; | ||||
9719 | outs() << "rflags " << format("0x%016" PRIx64"l" "x", cpu64.rflags); | ||||
9720 | outs() << " cs " << format("0x%016" PRIx64"l" "x", cpu64.cs); | ||||
9721 | outs() << " fs " << format("0x%016" PRIx64"l" "x", cpu64.fs) << "\n"; | ||||
9722 | outs() << " gs " << format("0x%016" PRIx64"l" "x", cpu64.gs) << "\n"; | ||||
9723 | } | ||||
9724 | |||||
9725 | static void Print_mmst_reg(MachO::mmst_reg_t &r) { | ||||
9726 | uint32_t f; | ||||
9727 | outs() << "\t mmst_reg "; | ||||
9728 | for (f = 0; f < 10; f++) | ||||
9729 | outs() << format("%02" PRIx32"x", (r.mmst_reg[f] & 0xff)) << " "; | ||||
9730 | outs() << "\n"; | ||||
9731 | outs() << "\t mmst_rsrv "; | ||||
9732 | for (f = 0; f < 6; f++) | ||||
9733 | outs() << format("%02" PRIx32"x", (r.mmst_rsrv[f] & 0xff)) << " "; | ||||
9734 | outs() << "\n"; | ||||
9735 | } | ||||
9736 | |||||
9737 | static void Print_xmm_reg(MachO::xmm_reg_t &r) { | ||||
9738 | uint32_t f; | ||||
9739 | outs() << "\t xmm_reg "; | ||||
9740 | for (f = 0; f < 16; f++) | ||||
9741 | outs() << format("%02" PRIx32"x", (r.xmm_reg[f] & 0xff)) << " "; | ||||
9742 | outs() << "\n"; | ||||
9743 | } | ||||
9744 | |||||
9745 | static void Print_x86_float_state_t(MachO::x86_float_state64_t &fpu) { | ||||
9746 | outs() << "\t fpu_reserved[0] " << fpu.fpu_reserved[0]; | ||||
9747 | outs() << " fpu_reserved[1] " << fpu.fpu_reserved[1] << "\n"; | ||||
9748 | outs() << "\t control: invalid " << fpu.fpu_fcw.invalid; | ||||
9749 | outs() << " denorm " << fpu.fpu_fcw.denorm; | ||||
9750 | outs() << " zdiv " << fpu.fpu_fcw.zdiv; | ||||
9751 | outs() << " ovrfl " << fpu.fpu_fcw.ovrfl; | ||||
9752 | outs() << " undfl " << fpu.fpu_fcw.undfl; | ||||
9753 | outs() << " precis " << fpu.fpu_fcw.precis << "\n"; | ||||
9754 | outs() << "\t\t pc "; | ||||
9755 | if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_24B) | ||||
9756 | outs() << "FP_PREC_24B "; | ||||
9757 | else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_53B) | ||||
9758 | outs() << "FP_PREC_53B "; | ||||
9759 | else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_64B) | ||||
9760 | outs() << "FP_PREC_64B "; | ||||
9761 | else | ||||
9762 | outs() << fpu.fpu_fcw.pc << " "; | ||||
9763 | outs() << "rc "; | ||||
9764 | if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_NEAR) | ||||
9765 | outs() << "FP_RND_NEAR "; | ||||
9766 | else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_DOWN) | ||||
9767 | outs() << "FP_RND_DOWN "; | ||||
9768 | else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_UP) | ||||
9769 | outs() << "FP_RND_UP "; | ||||
9770 | else if (fpu.fpu_fcw.rc == MachO::x86_FP_CHOP) | ||||
9771 | outs() << "FP_CHOP "; | ||||
9772 | outs() << "\n"; | ||||
9773 | outs() << "\t status: invalid " << fpu.fpu_fsw.invalid; | ||||
9774 | outs() << " denorm " << fpu.fpu_fsw.denorm; | ||||
9775 | outs() << " zdiv " << fpu.fpu_fsw.zdiv; | ||||
9776 | outs() << " ovrfl " << fpu.fpu_fsw.ovrfl; | ||||
9777 | outs() << " undfl " << fpu.fpu_fsw.undfl; | ||||
9778 | outs() << " precis " << fpu.fpu_fsw.precis; | ||||
9779 | outs() << " stkflt " << fpu.fpu_fsw.stkflt << "\n"; | ||||
9780 | outs() << "\t errsumm " << fpu.fpu_fsw.errsumm; | ||||
9781 | outs() << " c0 " << fpu.fpu_fsw.c0; | ||||
9782 | outs() << " c1 " << fpu.fpu_fsw.c1; | ||||
9783 | outs() << " c2 " << fpu.fpu_fsw.c2; | ||||
9784 | outs() << " tos " << fpu.fpu_fsw.tos; | ||||
9785 | outs() << " c3 " << fpu.fpu_fsw.c3; | ||||
9786 | outs() << " busy " << fpu.fpu_fsw.busy << "\n"; | ||||
9787 | outs() << "\t fpu_ftw " << format("0x%02" PRIx32"x", fpu.fpu_ftw); | ||||
9788 | outs() << " fpu_rsrv1 " << format("0x%02" PRIx32"x", fpu.fpu_rsrv1); | ||||
9789 | outs() << " fpu_fop " << format("0x%04" PRIx32"x", fpu.fpu_fop); | ||||
9790 | outs() << " fpu_ip " << format("0x%08" PRIx32"x", fpu.fpu_ip) << "\n"; | ||||
9791 | outs() << "\t fpu_cs " << format("0x%04" PRIx32"x", fpu.fpu_cs); | ||||
9792 | outs() << " fpu_rsrv2 " << format("0x%04" PRIx32"x", fpu.fpu_rsrv2); | ||||
9793 | outs() << " fpu_dp " << format("0x%08" PRIx32"x", fpu.fpu_dp); | ||||
9794 | outs() << " fpu_ds " << format("0x%04" PRIx32"x", fpu.fpu_ds) << "\n"; | ||||
9795 | outs() << "\t fpu_rsrv3 " << format("0x%04" PRIx32"x", fpu.fpu_rsrv3); | ||||
9796 | outs() << " fpu_mxcsr " << format("0x%08" PRIx32"x", fpu.fpu_mxcsr); | ||||
9797 | outs() << " fpu_mxcsrmask " << format("0x%08" PRIx32"x", fpu.fpu_mxcsrmask); | ||||
9798 | outs() << "\n"; | ||||
9799 | outs() << "\t fpu_stmm0:\n"; | ||||
9800 | Print_mmst_reg(fpu.fpu_stmm0); | ||||
9801 | outs() << "\t fpu_stmm1:\n"; | ||||
9802 | Print_mmst_reg(fpu.fpu_stmm1); | ||||
9803 | outs() << "\t fpu_stmm2:\n"; | ||||
9804 | Print_mmst_reg(fpu.fpu_stmm2); | ||||
9805 | outs() << "\t fpu_stmm3:\n"; | ||||
9806 | Print_mmst_reg(fpu.fpu_stmm3); | ||||
9807 | outs() << "\t fpu_stmm4:\n"; | ||||
9808 | Print_mmst_reg(fpu.fpu_stmm4); | ||||
9809 | outs() << "\t fpu_stmm5:\n"; | ||||
9810 | Print_mmst_reg(fpu.fpu_stmm5); | ||||
9811 | outs() << "\t fpu_stmm6:\n"; | ||||
9812 | Print_mmst_reg(fpu.fpu_stmm6); | ||||
9813 | outs() << "\t fpu_stmm7:\n"; | ||||
9814 | Print_mmst_reg(fpu.fpu_stmm7); | ||||
9815 | outs() << "\t fpu_xmm0:\n"; | ||||
9816 | Print_xmm_reg(fpu.fpu_xmm0); | ||||
9817 | outs() << "\t fpu_xmm1:\n"; | ||||
9818 | Print_xmm_reg(fpu.fpu_xmm1); | ||||
9819 | outs() << "\t fpu_xmm2:\n"; | ||||
9820 | Print_xmm_reg(fpu.fpu_xmm2); | ||||
9821 | outs() << "\t fpu_xmm3:\n"; | ||||
9822 | Print_xmm_reg(fpu.fpu_xmm3); | ||||
9823 | outs() << "\t fpu_xmm4:\n"; | ||||
9824 | Print_xmm_reg(fpu.fpu_xmm4); | ||||
9825 | outs() << "\t fpu_xmm5:\n"; | ||||
9826 | Print_xmm_reg(fpu.fpu_xmm5); | ||||
9827 | outs() << "\t fpu_xmm6:\n"; | ||||
9828 | Print_xmm_reg(fpu.fpu_xmm6); | ||||
9829 | outs() << "\t fpu_xmm7:\n"; | ||||
9830 | Print_xmm_reg(fpu.fpu_xmm7); | ||||
9831 | outs() << "\t fpu_xmm8:\n"; | ||||
9832 | Print_xmm_reg(fpu.fpu_xmm8); | ||||
9833 | outs() << "\t fpu_xmm9:\n"; | ||||
9834 | Print_xmm_reg(fpu.fpu_xmm9); | ||||
9835 | outs() << "\t fpu_xmm10:\n"; | ||||
9836 | Print_xmm_reg(fpu.fpu_xmm10); | ||||
9837 | outs() << "\t fpu_xmm11:\n"; | ||||
9838 | Print_xmm_reg(fpu.fpu_xmm11); | ||||
9839 | outs() << "\t fpu_xmm12:\n"; | ||||
9840 | Print_xmm_reg(fpu.fpu_xmm12); | ||||
9841 | outs() << "\t fpu_xmm13:\n"; | ||||
9842 | Print_xmm_reg(fpu.fpu_xmm13); | ||||
9843 | outs() << "\t fpu_xmm14:\n"; | ||||
9844 | Print_xmm_reg(fpu.fpu_xmm14); | ||||
9845 | outs() << "\t fpu_xmm15:\n"; | ||||
9846 | Print_xmm_reg(fpu.fpu_xmm15); | ||||
9847 | outs() << "\t fpu_rsrv4:\n"; | ||||
9848 | for (uint32_t f = 0; f < 6; f++) { | ||||
9849 | outs() << "\t "; | ||||
9850 | for (uint32_t g = 0; g < 16; g++) | ||||
9851 | outs() << format("%02" PRIx32"x", fpu.fpu_rsrv4[f * g]) << " "; | ||||
9852 | outs() << "\n"; | ||||
9853 | } | ||||
9854 | outs() << "\t fpu_reserved1 " << format("0x%08" PRIx32"x", fpu.fpu_reserved1); | ||||
9855 | outs() << "\n"; | ||||
9856 | } | ||||
9857 | |||||
9858 | static void Print_x86_exception_state_t(MachO::x86_exception_state64_t &exc64) { | ||||
9859 | outs() << "\t trapno " << format("0x%08" PRIx32"x", exc64.trapno); | ||||
9860 | outs() << " err " << format("0x%08" PRIx32"x", exc64.err); | ||||
9861 | outs() << " faultvaddr " << format("0x%016" PRIx64"l" "x", exc64.faultvaddr) << "\n"; | ||||
9862 | } | ||||
9863 | |||||
9864 | static void Print_arm_thread_state32_t(MachO::arm_thread_state32_t &cpu32) { | ||||
9865 | outs() << "\t r0 " << format("0x%08" PRIx32"x", cpu32.r[0]); | ||||
9866 | outs() << " r1 " << format("0x%08" PRIx32"x", cpu32.r[1]); | ||||
9867 | outs() << " r2 " << format("0x%08" PRIx32"x", cpu32.r[2]); | ||||
9868 | outs() << " r3 " << format("0x%08" PRIx32"x", cpu32.r[3]) << "\n"; | ||||
9869 | outs() << "\t r4 " << format("0x%08" PRIx32"x", cpu32.r[4]); | ||||
9870 | outs() << " r5 " << format("0x%08" PRIx32"x", cpu32.r[5]); | ||||
9871 | outs() << " r6 " << format("0x%08" PRIx32"x", cpu32.r[6]); | ||||
9872 | outs() << " r7 " << format("0x%08" PRIx32"x", cpu32.r[7]) << "\n"; | ||||
9873 | outs() << "\t r8 " << format("0x%08" PRIx32"x", cpu32.r[8]); | ||||
9874 | outs() << " r9 " << format("0x%08" PRIx32"x", cpu32.r[9]); | ||||
9875 | outs() << " r10 " << format("0x%08" PRIx32"x", cpu32.r[10]); | ||||
9876 | outs() << " r11 " << format("0x%08" PRIx32"x", cpu32.r[11]) << "\n"; | ||||
9877 | outs() << "\t r12 " << format("0x%08" PRIx32"x", cpu32.r[12]); | ||||
9878 | outs() << " sp " << format("0x%08" PRIx32"x", cpu32.sp); | ||||
9879 | outs() << " lr " << format("0x%08" PRIx32"x", cpu32.lr); | ||||
9880 | outs() << " pc " << format("0x%08" PRIx32"x", cpu32.pc) << "\n"; | ||||
9881 | outs() << "\t cpsr " << format("0x%08" PRIx32"x", cpu32.cpsr) << "\n"; | ||||
9882 | } | ||||
9883 | |||||
9884 | static void Print_arm_thread_state64_t(MachO::arm_thread_state64_t &cpu64) { | ||||
9885 | outs() << "\t x0 " << format("0x%016" PRIx64"l" "x", cpu64.x[0]); | ||||
9886 | outs() << " x1 " << format("0x%016" PRIx64"l" "x", cpu64.x[1]); | ||||
9887 | outs() << " x2 " << format("0x%016" PRIx64"l" "x", cpu64.x[2]) << "\n"; | ||||
9888 | outs() << "\t x3 " << format("0x%016" PRIx64"l" "x", cpu64.x[3]); | ||||
9889 | outs() << " x4 " << format("0x%016" PRIx64"l" "x", cpu64.x[4]); | ||||
9890 | outs() << " x5 " << format("0x%016" PRIx64"l" "x", cpu64.x[5]) << "\n"; | ||||
9891 | outs() << "\t x6 " << format("0x%016" PRIx64"l" "x", cpu64.x[6]); | ||||
9892 | outs() << " x7 " << format("0x%016" PRIx64"l" "x", cpu64.x[7]); | ||||
9893 | outs() << " x8 " << format("0x%016" PRIx64"l" "x", cpu64.x[8]) << "\n"; | ||||
9894 | outs() << "\t x9 " << format("0x%016" PRIx64"l" "x", cpu64.x[9]); | ||||
9895 | outs() << " x10 " << format("0x%016" PRIx64"l" "x", cpu64.x[10]); | ||||
9896 | outs() << " x11 " << format("0x%016" PRIx64"l" "x", cpu64.x[11]) << "\n"; | ||||
9897 | outs() << "\t x12 " << format("0x%016" PRIx64"l" "x", cpu64.x[12]); | ||||
9898 | outs() << " x13 " << format("0x%016" PRIx64"l" "x", cpu64.x[13]); | ||||
9899 | outs() << " x14 " << format("0x%016" PRIx64"l" "x", cpu64.x[14]) << "\n"; | ||||
9900 | outs() << "\t x15 " << format("0x%016" PRIx64"l" "x", cpu64.x[15]); | ||||
9901 | outs() << " x16 " << format("0x%016" PRIx64"l" "x", cpu64.x[16]); | ||||
9902 | outs() << " x17 " << format("0x%016" PRIx64"l" "x", cpu64.x[17]) << "\n"; | ||||
9903 | outs() << "\t x18 " << format("0x%016" PRIx64"l" "x", cpu64.x[18]); | ||||
9904 | outs() << " x19 " << format("0x%016" PRIx64"l" "x", cpu64.x[19]); | ||||
9905 | outs() << " x20 " << format("0x%016" PRIx64"l" "x", cpu64.x[20]) << "\n"; | ||||
9906 | outs() << "\t x21 " << format("0x%016" PRIx64"l" "x", cpu64.x[21]); | ||||
9907 | outs() << " x22 " << format("0x%016" PRIx64"l" "x", cpu64.x[22]); | ||||
9908 | outs() << " x23 " << format("0x%016" PRIx64"l" "x", cpu64.x[23]) << "\n"; | ||||
9909 | outs() << "\t x24 " << format("0x%016" PRIx64"l" "x", cpu64.x[24]); | ||||
9910 | outs() << " x25 " << format("0x%016" PRIx64"l" "x", cpu64.x[25]); | ||||
9911 | outs() << " x26 " << format("0x%016" PRIx64"l" "x", cpu64.x[26]) << "\n"; | ||||
9912 | outs() << "\t x27 " << format("0x%016" PRIx64"l" "x", cpu64.x[27]); | ||||
9913 | outs() << " x28 " << format("0x%016" PRIx64"l" "x", cpu64.x[28]); | ||||
9914 | outs() << " fp " << format("0x%016" PRIx64"l" "x", cpu64.fp) << "\n"; | ||||
9915 | outs() << "\t lr " << format("0x%016" PRIx64"l" "x", cpu64.lr); | ||||
9916 | outs() << " sp " << format("0x%016" PRIx64"l" "x", cpu64.sp); | ||||
9917 | outs() << " pc " << format("0x%016" PRIx64"l" "x", cpu64.pc) << "\n"; | ||||
9918 | outs() << "\t cpsr " << format("0x%08" PRIx32"x", cpu64.cpsr) << "\n"; | ||||
9919 | } | ||||
9920 | |||||
9921 | static void PrintThreadCommand(MachO::thread_command t, const char *Ptr, | ||||
9922 | bool isLittleEndian, uint32_t cputype) { | ||||
9923 | if (t.cmd == MachO::LC_THREAD) | ||||
9924 | outs() << " cmd LC_THREAD\n"; | ||||
9925 | else if (t.cmd == MachO::LC_UNIXTHREAD) | ||||
9926 | outs() << " cmd LC_UNIXTHREAD\n"; | ||||
9927 | else | ||||
9928 | outs() << " cmd " << t.cmd << " (unknown)\n"; | ||||
9929 | outs() << " cmdsize " << t.cmdsize; | ||||
9930 | if (t.cmdsize < sizeof(struct MachO::thread_command) + 2 * sizeof(uint32_t)) | ||||
9931 | outs() << " Incorrect size\n"; | ||||
9932 | else | ||||
9933 | outs() << "\n"; | ||||
9934 | |||||
9935 | const char *begin = Ptr + sizeof(struct MachO::thread_command); | ||||
9936 | const char *end = Ptr + t.cmdsize; | ||||
9937 | uint32_t flavor, count, left; | ||||
9938 | if (cputype == MachO::CPU_TYPE_I386) { | ||||
9939 | while (begin < end) { | ||||
9940 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
9941 | memcpy((char *)&flavor, begin, sizeof(uint32_t)); | ||||
9942 | begin += sizeof(uint32_t); | ||||
9943 | } else { | ||||
9944 | flavor = 0; | ||||
9945 | begin = end; | ||||
9946 | } | ||||
9947 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
9948 | sys::swapByteOrder(flavor); | ||||
9949 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
9950 | memcpy((char *)&count, begin, sizeof(uint32_t)); | ||||
9951 | begin += sizeof(uint32_t); | ||||
9952 | } else { | ||||
9953 | count = 0; | ||||
9954 | begin = end; | ||||
9955 | } | ||||
9956 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
9957 | sys::swapByteOrder(count); | ||||
9958 | if (flavor == MachO::x86_THREAD_STATE32) { | ||||
9959 | outs() << " flavor i386_THREAD_STATE\n"; | ||||
9960 | if (count == MachO::x86_THREAD_STATE32_COUNT) | ||||
9961 | outs() << " count i386_THREAD_STATE_COUNT\n"; | ||||
9962 | else | ||||
9963 | outs() << " count " << count | ||||
9964 | << " (not x86_THREAD_STATE32_COUNT)\n"; | ||||
9965 | MachO::x86_thread_state32_t cpu32; | ||||
9966 | left = end - begin; | ||||
9967 | if (left >= sizeof(MachO::x86_thread_state32_t)) { | ||||
9968 | memcpy(&cpu32, begin, sizeof(MachO::x86_thread_state32_t)); | ||||
9969 | begin += sizeof(MachO::x86_thread_state32_t); | ||||
9970 | } else { | ||||
9971 | memset(&cpu32, '\0', sizeof(MachO::x86_thread_state32_t)); | ||||
9972 | memcpy(&cpu32, begin, left); | ||||
9973 | begin += left; | ||||
9974 | } | ||||
9975 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
9976 | swapStruct(cpu32); | ||||
9977 | Print_x86_thread_state32_t(cpu32); | ||||
9978 | } else if (flavor == MachO::x86_THREAD_STATE) { | ||||
9979 | outs() << " flavor x86_THREAD_STATE\n"; | ||||
9980 | if (count == MachO::x86_THREAD_STATE_COUNT) | ||||
9981 | outs() << " count x86_THREAD_STATE_COUNT\n"; | ||||
9982 | else | ||||
9983 | outs() << " count " << count | ||||
9984 | << " (not x86_THREAD_STATE_COUNT)\n"; | ||||
9985 | struct MachO::x86_thread_state_t ts; | ||||
9986 | left = end - begin; | ||||
9987 | if (left >= sizeof(MachO::x86_thread_state_t)) { | ||||
9988 | memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t)); | ||||
9989 | begin += sizeof(MachO::x86_thread_state_t); | ||||
9990 | } else { | ||||
9991 | memset(&ts, '\0', sizeof(MachO::x86_thread_state_t)); | ||||
9992 | memcpy(&ts, begin, left); | ||||
9993 | begin += left; | ||||
9994 | } | ||||
9995 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
9996 | swapStruct(ts); | ||||
9997 | if (ts.tsh.flavor == MachO::x86_THREAD_STATE32) { | ||||
9998 | outs() << "\t tsh.flavor x86_THREAD_STATE32 "; | ||||
9999 | if (ts.tsh.count == MachO::x86_THREAD_STATE32_COUNT) | ||||
10000 | outs() << "tsh.count x86_THREAD_STATE32_COUNT\n"; | ||||
10001 | else | ||||
10002 | outs() << "tsh.count " << ts.tsh.count | ||||
10003 | << " (not x86_THREAD_STATE32_COUNT\n"; | ||||
10004 | Print_x86_thread_state32_t(ts.uts.ts32); | ||||
10005 | } else { | ||||
10006 | outs() << "\t tsh.flavor " << ts.tsh.flavor << " tsh.count " | ||||
10007 | << ts.tsh.count << "\n"; | ||||
10008 | } | ||||
10009 | } else { | ||||
10010 | outs() << " flavor " << flavor << " (unknown)\n"; | ||||
10011 | outs() << " count " << count << "\n"; | ||||
10012 | outs() << " state (unknown)\n"; | ||||
10013 | begin += count * sizeof(uint32_t); | ||||
10014 | } | ||||
10015 | } | ||||
10016 | } else if (cputype == MachO::CPU_TYPE_X86_64) { | ||||
10017 | while (begin < end) { | ||||
10018 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10019 | memcpy((char *)&flavor, begin, sizeof(uint32_t)); | ||||
10020 | begin += sizeof(uint32_t); | ||||
10021 | } else { | ||||
10022 | flavor = 0; | ||||
10023 | begin = end; | ||||
10024 | } | ||||
10025 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10026 | sys::swapByteOrder(flavor); | ||||
10027 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10028 | memcpy((char *)&count, begin, sizeof(uint32_t)); | ||||
10029 | begin += sizeof(uint32_t); | ||||
10030 | } else { | ||||
10031 | count = 0; | ||||
10032 | begin = end; | ||||
10033 | } | ||||
10034 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10035 | sys::swapByteOrder(count); | ||||
10036 | if (flavor == MachO::x86_THREAD_STATE64) { | ||||
10037 | outs() << " flavor x86_THREAD_STATE64\n"; | ||||
10038 | if (count == MachO::x86_THREAD_STATE64_COUNT) | ||||
10039 | outs() << " count x86_THREAD_STATE64_COUNT\n"; | ||||
10040 | else | ||||
10041 | outs() << " count " << count | ||||
10042 | << " (not x86_THREAD_STATE64_COUNT)\n"; | ||||
10043 | MachO::x86_thread_state64_t cpu64; | ||||
10044 | left = end - begin; | ||||
10045 | if (left >= sizeof(MachO::x86_thread_state64_t)) { | ||||
10046 | memcpy(&cpu64, begin, sizeof(MachO::x86_thread_state64_t)); | ||||
10047 | begin += sizeof(MachO::x86_thread_state64_t); | ||||
10048 | } else { | ||||
10049 | memset(&cpu64, '\0', sizeof(MachO::x86_thread_state64_t)); | ||||
10050 | memcpy(&cpu64, begin, left); | ||||
10051 | begin += left; | ||||
10052 | } | ||||
10053 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10054 | swapStruct(cpu64); | ||||
10055 | Print_x86_thread_state64_t(cpu64); | ||||
10056 | } else if (flavor == MachO::x86_THREAD_STATE) { | ||||
10057 | outs() << " flavor x86_THREAD_STATE\n"; | ||||
10058 | if (count == MachO::x86_THREAD_STATE_COUNT) | ||||
10059 | outs() << " count x86_THREAD_STATE_COUNT\n"; | ||||
10060 | else | ||||
10061 | outs() << " count " << count | ||||
10062 | << " (not x86_THREAD_STATE_COUNT)\n"; | ||||
10063 | struct MachO::x86_thread_state_t ts; | ||||
10064 | left = end - begin; | ||||
10065 | if (left >= sizeof(MachO::x86_thread_state_t)) { | ||||
10066 | memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t)); | ||||
10067 | begin += sizeof(MachO::x86_thread_state_t); | ||||
10068 | } else { | ||||
10069 | memset(&ts, '\0', sizeof(MachO::x86_thread_state_t)); | ||||
10070 | memcpy(&ts, begin, left); | ||||
10071 | begin += left; | ||||
10072 | } | ||||
10073 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10074 | swapStruct(ts); | ||||
10075 | if (ts.tsh.flavor == MachO::x86_THREAD_STATE64) { | ||||
10076 | outs() << "\t tsh.flavor x86_THREAD_STATE64 "; | ||||
10077 | if (ts.tsh.count == MachO::x86_THREAD_STATE64_COUNT) | ||||
10078 | outs() << "tsh.count x86_THREAD_STATE64_COUNT\n"; | ||||
10079 | else | ||||
10080 | outs() << "tsh.count " << ts.tsh.count | ||||
10081 | << " (not x86_THREAD_STATE64_COUNT\n"; | ||||
10082 | Print_x86_thread_state64_t(ts.uts.ts64); | ||||
10083 | } else { | ||||
10084 | outs() << "\t tsh.flavor " << ts.tsh.flavor << " tsh.count " | ||||
10085 | << ts.tsh.count << "\n"; | ||||
10086 | } | ||||
10087 | } else if (flavor == MachO::x86_FLOAT_STATE) { | ||||
10088 | outs() << " flavor x86_FLOAT_STATE\n"; | ||||
10089 | if (count == MachO::x86_FLOAT_STATE_COUNT) | ||||
10090 | outs() << " count x86_FLOAT_STATE_COUNT\n"; | ||||
10091 | else | ||||
10092 | outs() << " count " << count << " (not x86_FLOAT_STATE_COUNT)\n"; | ||||
10093 | struct MachO::x86_float_state_t fs; | ||||
10094 | left = end - begin; | ||||
10095 | if (left >= sizeof(MachO::x86_float_state_t)) { | ||||
10096 | memcpy(&fs, begin, sizeof(MachO::x86_float_state_t)); | ||||
10097 | begin += sizeof(MachO::x86_float_state_t); | ||||
10098 | } else { | ||||
10099 | memset(&fs, '\0', sizeof(MachO::x86_float_state_t)); | ||||
10100 | memcpy(&fs, begin, left); | ||||
10101 | begin += left; | ||||
10102 | } | ||||
10103 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10104 | swapStruct(fs); | ||||
10105 | if (fs.fsh.flavor == MachO::x86_FLOAT_STATE64) { | ||||
10106 | outs() << "\t fsh.flavor x86_FLOAT_STATE64 "; | ||||
10107 | if (fs.fsh.count == MachO::x86_FLOAT_STATE64_COUNT) | ||||
10108 | outs() << "fsh.count x86_FLOAT_STATE64_COUNT\n"; | ||||
10109 | else | ||||
10110 | outs() << "fsh.count " << fs.fsh.count | ||||
10111 | << " (not x86_FLOAT_STATE64_COUNT\n"; | ||||
10112 | Print_x86_float_state_t(fs.ufs.fs64); | ||||
10113 | } else { | ||||
10114 | outs() << "\t fsh.flavor " << fs.fsh.flavor << " fsh.count " | ||||
10115 | << fs.fsh.count << "\n"; | ||||
10116 | } | ||||
10117 | } else if (flavor == MachO::x86_EXCEPTION_STATE) { | ||||
10118 | outs() << " flavor x86_EXCEPTION_STATE\n"; | ||||
10119 | if (count == MachO::x86_EXCEPTION_STATE_COUNT) | ||||
10120 | outs() << " count x86_EXCEPTION_STATE_COUNT\n"; | ||||
10121 | else | ||||
10122 | outs() << " count " << count | ||||
10123 | << " (not x86_EXCEPTION_STATE_COUNT)\n"; | ||||
10124 | struct MachO::x86_exception_state_t es; | ||||
10125 | left = end - begin; | ||||
10126 | if (left >= sizeof(MachO::x86_exception_state_t)) { | ||||
10127 | memcpy(&es, begin, sizeof(MachO::x86_exception_state_t)); | ||||
10128 | begin += sizeof(MachO::x86_exception_state_t); | ||||
10129 | } else { | ||||
10130 | memset(&es, '\0', sizeof(MachO::x86_exception_state_t)); | ||||
10131 | memcpy(&es, begin, left); | ||||
10132 | begin += left; | ||||
10133 | } | ||||
10134 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10135 | swapStruct(es); | ||||
10136 | if (es.esh.flavor == MachO::x86_EXCEPTION_STATE64) { | ||||
10137 | outs() << "\t esh.flavor x86_EXCEPTION_STATE64\n"; | ||||
10138 | if (es.esh.count == MachO::x86_EXCEPTION_STATE64_COUNT) | ||||
10139 | outs() << "\t esh.count x86_EXCEPTION_STATE64_COUNT\n"; | ||||
10140 | else | ||||
10141 | outs() << "\t esh.count " << es.esh.count | ||||
10142 | << " (not x86_EXCEPTION_STATE64_COUNT\n"; | ||||
10143 | Print_x86_exception_state_t(es.ues.es64); | ||||
10144 | } else { | ||||
10145 | outs() << "\t esh.flavor " << es.esh.flavor << " esh.count " | ||||
10146 | << es.esh.count << "\n"; | ||||
10147 | } | ||||
10148 | } else if (flavor == MachO::x86_EXCEPTION_STATE64) { | ||||
10149 | outs() << " flavor x86_EXCEPTION_STATE64\n"; | ||||
10150 | if (count == MachO::x86_EXCEPTION_STATE64_COUNT) | ||||
10151 | outs() << " count x86_EXCEPTION_STATE64_COUNT\n"; | ||||
10152 | else | ||||
10153 | outs() << " count " << count | ||||
10154 | << " (not x86_EXCEPTION_STATE64_COUNT)\n"; | ||||
10155 | struct MachO::x86_exception_state64_t es64; | ||||
10156 | left = end - begin; | ||||
10157 | if (left >= sizeof(MachO::x86_exception_state64_t)) { | ||||
10158 | memcpy(&es64, begin, sizeof(MachO::x86_exception_state64_t)); | ||||
10159 | begin += sizeof(MachO::x86_exception_state64_t); | ||||
10160 | } else { | ||||
10161 | memset(&es64, '\0', sizeof(MachO::x86_exception_state64_t)); | ||||
10162 | memcpy(&es64, begin, left); | ||||
10163 | begin += left; | ||||
10164 | } | ||||
10165 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10166 | swapStruct(es64); | ||||
10167 | Print_x86_exception_state_t(es64); | ||||
10168 | } else { | ||||
10169 | outs() << " flavor " << flavor << " (unknown)\n"; | ||||
10170 | outs() << " count " << count << "\n"; | ||||
10171 | outs() << " state (unknown)\n"; | ||||
10172 | begin += count * sizeof(uint32_t); | ||||
10173 | } | ||||
10174 | } | ||||
10175 | } else if (cputype == MachO::CPU_TYPE_ARM) { | ||||
10176 | while (begin < end) { | ||||
10177 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10178 | memcpy((char *)&flavor, begin, sizeof(uint32_t)); | ||||
10179 | begin += sizeof(uint32_t); | ||||
10180 | } else { | ||||
10181 | flavor = 0; | ||||
10182 | begin = end; | ||||
10183 | } | ||||
10184 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10185 | sys::swapByteOrder(flavor); | ||||
10186 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10187 | memcpy((char *)&count, begin, sizeof(uint32_t)); | ||||
10188 | begin += sizeof(uint32_t); | ||||
10189 | } else { | ||||
10190 | count = 0; | ||||
10191 | begin = end; | ||||
10192 | } | ||||
10193 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10194 | sys::swapByteOrder(count); | ||||
10195 | if (flavor == MachO::ARM_THREAD_STATE) { | ||||
10196 | outs() << " flavor ARM_THREAD_STATE\n"; | ||||
10197 | if (count == MachO::ARM_THREAD_STATE_COUNT) | ||||
10198 | outs() << " count ARM_THREAD_STATE_COUNT\n"; | ||||
10199 | else | ||||
10200 | outs() << " count " << count | ||||
10201 | << " (not ARM_THREAD_STATE_COUNT)\n"; | ||||
10202 | MachO::arm_thread_state32_t cpu32; | ||||
10203 | left = end - begin; | ||||
10204 | if (left >= sizeof(MachO::arm_thread_state32_t)) { | ||||
10205 | memcpy(&cpu32, begin, sizeof(MachO::arm_thread_state32_t)); | ||||
10206 | begin += sizeof(MachO::arm_thread_state32_t); | ||||
10207 | } else { | ||||
10208 | memset(&cpu32, '\0', sizeof(MachO::arm_thread_state32_t)); | ||||
10209 | memcpy(&cpu32, begin, left); | ||||
10210 | begin += left; | ||||
10211 | } | ||||
10212 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10213 | swapStruct(cpu32); | ||||
10214 | Print_arm_thread_state32_t(cpu32); | ||||
10215 | } else { | ||||
10216 | outs() << " flavor " << flavor << " (unknown)\n"; | ||||
10217 | outs() << " count " << count << "\n"; | ||||
10218 | outs() << " state (unknown)\n"; | ||||
10219 | begin += count * sizeof(uint32_t); | ||||
10220 | } | ||||
10221 | } | ||||
10222 | } else if (cputype == MachO::CPU_TYPE_ARM64 || | ||||
10223 | cputype == MachO::CPU_TYPE_ARM64_32) { | ||||
10224 | while (begin < end) { | ||||
10225 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10226 | memcpy((char *)&flavor, begin, sizeof(uint32_t)); | ||||
10227 | begin += sizeof(uint32_t); | ||||
10228 | } else { | ||||
10229 | flavor = 0; | ||||
10230 | begin = end; | ||||
10231 | } | ||||
10232 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10233 | sys::swapByteOrder(flavor); | ||||
10234 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10235 | memcpy((char *)&count, begin, sizeof(uint32_t)); | ||||
10236 | begin += sizeof(uint32_t); | ||||
10237 | } else { | ||||
10238 | count = 0; | ||||
10239 | begin = end; | ||||
10240 | } | ||||
10241 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10242 | sys::swapByteOrder(count); | ||||
10243 | if (flavor == MachO::ARM_THREAD_STATE64) { | ||||
10244 | outs() << " flavor ARM_THREAD_STATE64\n"; | ||||
10245 | if (count == MachO::ARM_THREAD_STATE64_COUNT) | ||||
10246 | outs() << " count ARM_THREAD_STATE64_COUNT\n"; | ||||
10247 | else | ||||
10248 | outs() << " count " << count | ||||
10249 | << " (not ARM_THREAD_STATE64_COUNT)\n"; | ||||
10250 | MachO::arm_thread_state64_t cpu64; | ||||
10251 | left = end - begin; | ||||
10252 | if (left >= sizeof(MachO::arm_thread_state64_t)) { | ||||
10253 | memcpy(&cpu64, begin, sizeof(MachO::arm_thread_state64_t)); | ||||
10254 | begin += sizeof(MachO::arm_thread_state64_t); | ||||
10255 | } else { | ||||
10256 | memset(&cpu64, '\0', sizeof(MachO::arm_thread_state64_t)); | ||||
10257 | memcpy(&cpu64, begin, left); | ||||
10258 | begin += left; | ||||
10259 | } | ||||
10260 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10261 | swapStruct(cpu64); | ||||
10262 | Print_arm_thread_state64_t(cpu64); | ||||
10263 | } else { | ||||
10264 | outs() << " flavor " << flavor << " (unknown)\n"; | ||||
10265 | outs() << " count " << count << "\n"; | ||||
10266 | outs() << " state (unknown)\n"; | ||||
10267 | begin += count * sizeof(uint32_t); | ||||
10268 | } | ||||
10269 | } | ||||
10270 | } else { | ||||
10271 | while (begin < end) { | ||||
10272 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10273 | memcpy((char *)&flavor, begin, sizeof(uint32_t)); | ||||
10274 | begin += sizeof(uint32_t); | ||||
10275 | } else { | ||||
10276 | flavor = 0; | ||||
10277 | begin = end; | ||||
10278 | } | ||||
10279 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10280 | sys::swapByteOrder(flavor); | ||||
10281 | if (end - begin > (ptrdiff_t)sizeof(uint32_t)) { | ||||
10282 | memcpy((char *)&count, begin, sizeof(uint32_t)); | ||||
10283 | begin += sizeof(uint32_t); | ||||
10284 | } else { | ||||
10285 | count = 0; | ||||
10286 | begin = end; | ||||
10287 | } | ||||
10288 | if (isLittleEndian != sys::IsLittleEndianHost) | ||||
10289 | sys::swapByteOrder(count); | ||||
10290 | outs() << " flavor " << flavor << "\n"; | ||||
10291 | outs() << " count " << count << "\n"; | ||||
10292 | outs() << " state (Unknown cputype/cpusubtype)\n"; | ||||
10293 | begin += count * sizeof(uint32_t); | ||||
10294 | } | ||||
10295 | } | ||||
10296 | } | ||||
10297 | |||||
10298 | static void PrintDylibCommand(MachO::dylib_command dl, const char *Ptr) { | ||||
10299 | if (dl.cmd == MachO::LC_ID_DYLIB) | ||||
10300 | outs() << " cmd LC_ID_DYLIB\n"; | ||||
10301 | else if (dl.cmd == MachO::LC_LOAD_DYLIB) | ||||
10302 | outs() << " cmd LC_LOAD_DYLIB\n"; | ||||
10303 | else if (dl.cmd == MachO::LC_LOAD_WEAK_DYLIB) | ||||
10304 | outs() << " cmd LC_LOAD_WEAK_DYLIB\n"; | ||||
10305 | else if (dl.cmd == MachO::LC_REEXPORT_DYLIB) | ||||
10306 | outs() << " cmd LC_REEXPORT_DYLIB\n"; | ||||
10307 | else if (dl.cmd == MachO::LC_LAZY_LOAD_DYLIB) | ||||
10308 | outs() << " cmd LC_LAZY_LOAD_DYLIB\n"; | ||||
10309 | else if (dl.cmd == MachO::LC_LOAD_UPWARD_DYLIB) | ||||
10310 | outs() << " cmd LC_LOAD_UPWARD_DYLIB\n"; | ||||
10311 | else | ||||
10312 | outs() << " cmd " << dl.cmd << " (unknown)\n"; | ||||
10313 | outs() << " cmdsize " << dl.cmdsize; | ||||
10314 | if (dl.cmdsize < sizeof(struct MachO::dylib_command)) | ||||
10315 | outs() << " Incorrect size\n"; | ||||
10316 | else | ||||
10317 | outs() << "\n"; | ||||
10318 | if (dl.dylib.name < dl.cmdsize) { | ||||
10319 | const char *P = (const char *)(Ptr) + dl.dylib.name; | ||||
10320 | outs() << " name " << P << " (offset " << dl.dylib.name << ")\n"; | ||||
10321 | } else { | ||||
10322 | outs() << " name ?(bad offset " << dl.dylib.name << ")\n"; | ||||
10323 | } | ||||
10324 | outs() << " time stamp " << dl.dylib.timestamp << " "; | ||||
10325 | time_t t = dl.dylib.timestamp; | ||||
10326 | outs() << ctime(&t); | ||||
10327 | outs() << " current version "; | ||||
10328 | if (dl.dylib.current_version == 0xffffffff) | ||||
10329 | outs() << "n/a\n"; | ||||
10330 | else | ||||
10331 | outs() << ((dl.dylib.current_version >> 16) & 0xffff) << "." | ||||
10332 | << ((dl.dylib.current_version >> 8) & 0xff) << "." | ||||
10333 | << (dl.dylib.current_version & 0xff) << "\n"; | ||||
10334 | outs() << "compatibility version "; | ||||
10335 | if (dl.dylib.compatibility_version == 0xffffffff) | ||||
10336 | outs() << "n/a\n"; | ||||
10337 | else | ||||
10338 | outs() << ((dl.dylib.compatibility_version >> 16) & 0xffff) << "." | ||||
10339 | << ((dl.dylib.compatibility_version >> 8) & 0xff) << "." | ||||
10340 | << (dl.dylib.compatibility_version & 0xff) << "\n"; | ||||
10341 | } | ||||
10342 | |||||
10343 | static void PrintLinkEditDataCommand(MachO::linkedit_data_command ld, | ||||
10344 | uint32_t object_size) { | ||||
10345 | if (ld.cmd == MachO::LC_CODE_SIGNATURE) | ||||
10346 | outs() << " cmd LC_CODE_SIGNATURE\n"; | ||||
10347 | else if (ld.cmd == MachO::LC_SEGMENT_SPLIT_INFO) | ||||
10348 | outs() << " cmd LC_SEGMENT_SPLIT_INFO\n"; | ||||
10349 | else if (ld.cmd == MachO::LC_FUNCTION_STARTS) | ||||
10350 | outs() << " cmd LC_FUNCTION_STARTS\n"; | ||||
10351 | else if (ld.cmd == MachO::LC_DATA_IN_CODE) | ||||
10352 | outs() << " cmd LC_DATA_IN_CODE\n"; | ||||
10353 | else if (ld.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS) | ||||
10354 | outs() << " cmd LC_DYLIB_CODE_SIGN_DRS\n"; | ||||
10355 | else if (ld.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT) | ||||
10356 | outs() << " cmd LC_LINKER_OPTIMIZATION_HINT\n"; | ||||
10357 | else if (ld.cmd == MachO::LC_DYLD_EXPORTS_TRIE) | ||||
10358 | outs() << " cmd LC_DYLD_EXPORTS_TRIE\n"; | ||||
10359 | else if (ld.cmd == MachO::LC_DYLD_CHAINED_FIXUPS) | ||||
10360 | outs() << " cmd LC_DYLD_CHAINED_FIXUPS\n"; | ||||
10361 | else | ||||
10362 | outs() << " cmd " << ld.cmd << " (?)\n"; | ||||
10363 | outs() << " cmdsize " << ld.cmdsize; | ||||
10364 | if (ld.cmdsize != sizeof(struct MachO::linkedit_data_command)) | ||||
10365 | outs() << " Incorrect size\n"; | ||||
10366 | else | ||||
10367 | outs() << "\n"; | ||||
10368 | outs() << " dataoff " << ld.dataoff; | ||||
10369 | if (ld.dataoff > object_size) | ||||
10370 | outs() << " (past end of file)\n"; | ||||
10371 | else | ||||
10372 | outs() << "\n"; | ||||
10373 | outs() << " datasize " << ld.datasize; | ||||
10374 | uint64_t big_size = ld.dataoff; | ||||
10375 | big_size += ld.datasize; | ||||
10376 | if (big_size > object_size) | ||||
10377 | outs() << " (past end of file)\n"; | ||||
10378 | else | ||||
10379 | outs() << "\n"; | ||||
10380 | } | ||||
10381 | |||||
10382 | static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t filetype, | ||||
10383 | uint32_t cputype, bool verbose) { | ||||
10384 | StringRef Buf = Obj->getData(); | ||||
10385 | unsigned Index = 0; | ||||
10386 | for (const auto &Command : Obj->load_commands()) { | ||||
10387 | outs() << "Load command " << Index++ << "\n"; | ||||
10388 | if (Command.C.cmd == MachO::LC_SEGMENT) { | ||||
10389 | MachO::segment_command SLC = Obj->getSegmentLoadCommand(Command); | ||||
10390 | const char *sg_segname = SLC.segname; | ||||
10391 | PrintSegmentCommand(SLC.cmd, SLC.cmdsize, SLC.segname, SLC.vmaddr, | ||||
10392 | SLC.vmsize, SLC.fileoff, SLC.filesize, SLC.maxprot, | ||||
10393 | SLC.initprot, SLC.nsects, SLC.flags, Buf.size(), | ||||
10394 | verbose); | ||||
10395 | for (unsigned j = 0; j < SLC.nsects; j++) { | ||||
10396 | MachO::section S = Obj->getSection(Command, j); | ||||
10397 | PrintSection(S.sectname, S.segname, S.addr, S.size, S.offset, S.align, | ||||
10398 | S.reloff, S.nreloc, S.flags, S.reserved1, S.reserved2, | ||||
10399 | SLC.cmd, sg_segname, filetype, Buf.size(), verbose); | ||||
10400 | } | ||||
10401 | } else if (Command.C.cmd == MachO::LC_SEGMENT_64) { | ||||
10402 | MachO::segment_command_64 SLC_64 = Obj->getSegment64LoadCommand(Command); | ||||
10403 | const char *sg_segname = SLC_64.segname; | ||||
10404 | PrintSegmentCommand(SLC_64.cmd, SLC_64.cmdsize, SLC_64.segname, | ||||
10405 | SLC_64.vmaddr, SLC_64.vmsize, SLC_64.fileoff, | ||||
10406 | SLC_64.filesize, SLC_64.maxprot, SLC_64.initprot, | ||||
10407 | SLC_64.nsects, SLC_64.flags, Buf.size(), verbose); | ||||
10408 | for (unsigned j = 0; j < SLC_64.nsects; j++) { | ||||
10409 | MachO::section_64 S_64 = Obj->getSection64(Command, j); | ||||
10410 | PrintSection(S_64.sectname, S_64.segname, S_64.addr, S_64.size, | ||||
10411 | S_64.offset, S_64.align, S_64.reloff, S_64.nreloc, | ||||
10412 | S_64.flags, S_64.reserved1, S_64.reserved2, SLC_64.cmd, | ||||
10413 | sg_segname, filetype, Buf.size(), verbose); | ||||
10414 | } | ||||
10415 | } else if (Command.C.cmd == MachO::LC_SYMTAB) { | ||||
10416 | MachO::symtab_command Symtab = Obj->getSymtabLoadCommand(); | ||||
10417 | PrintSymtabLoadCommand(Symtab, Obj->is64Bit(), Buf.size()); | ||||
10418 | } else if (Command.C.cmd == MachO::LC_DYSYMTAB) { | ||||
10419 | MachO::dysymtab_command Dysymtab = Obj->getDysymtabLoadCommand(); | ||||
10420 | MachO::symtab_command Symtab = Obj->getSymtabLoadCommand(); | ||||
10421 | PrintDysymtabLoadCommand(Dysymtab, Symtab.nsyms, Buf.size(), | ||||
10422 | Obj->is64Bit()); | ||||
10423 | } else if (Command.C.cmd == MachO::LC_DYLD_INFO || | ||||
10424 | Command.C.cmd == MachO::LC_DYLD_INFO_ONLY) { | ||||
10425 | MachO::dyld_info_command DyldInfo = Obj->getDyldInfoLoadCommand(Command); | ||||
10426 | PrintDyldInfoLoadCommand(DyldInfo, Buf.size()); | ||||
10427 | } else if (Command.C.cmd == MachO::LC_LOAD_DYLINKER || | ||||
10428 | Command.C.cmd == MachO::LC_ID_DYLINKER || | ||||
10429 | Command.C.cmd == MachO::LC_DYLD_ENVIRONMENT) { | ||||
10430 | MachO::dylinker_command Dyld = Obj->getDylinkerCommand(Command); | ||||
10431 | PrintDyldLoadCommand(Dyld, Command.Ptr); | ||||
10432 | } else if (Command.C.cmd == MachO::LC_UUID) { | ||||
10433 | MachO::uuid_command Uuid = Obj->getUuidCommand(Command); | ||||
10434 | PrintUuidLoadCommand(Uuid); | ||||
10435 | } else if (Command.C.cmd == MachO::LC_RPATH) { | ||||
10436 | MachO::rpath_command Rpath = Obj->getRpathCommand(Command); | ||||
10437 | PrintRpathLoadCommand(Rpath, Command.Ptr); | ||||
10438 | } else if (Command.C.cmd == MachO::LC_VERSION_MIN_MACOSX || | ||||
10439 | Command.C.cmd == MachO::LC_VERSION_MIN_IPHONEOS || | ||||
10440 | Command.C.cmd == MachO::LC_VERSION_MIN_TVOS || | ||||
10441 | Command.C.cmd == MachO::LC_VERSION_MIN_WATCHOS) { | ||||
10442 | MachO::version_min_command Vd = Obj->getVersionMinLoadCommand(Command); | ||||
10443 | PrintVersionMinLoadCommand(Vd); | ||||
10444 | } else if (Command.C.cmd == MachO::LC_NOTE) { | ||||
10445 | MachO::note_command Nt = Obj->getNoteLoadCommand(Command); | ||||
10446 | PrintNoteLoadCommand(Nt); | ||||
10447 | } else if (Command.C.cmd == MachO::LC_BUILD_VERSION) { | ||||
10448 | MachO::build_version_command Bv = | ||||
10449 | Obj->getBuildVersionLoadCommand(Command); | ||||
10450 | PrintBuildVersionLoadCommand(Obj, Bv, verbose); | ||||
10451 | } else if (Command.C.cmd == MachO::LC_SOURCE_VERSION) { | ||||
10452 | MachO::source_version_command Sd = Obj->getSourceVersionCommand(Command); | ||||
10453 | PrintSourceVersionCommand(Sd); | ||||
10454 | } else if (Command.C.cmd == MachO::LC_MAIN) { | ||||
10455 | MachO::entry_point_command Ep = Obj->getEntryPointCommand(Command); | ||||
10456 | PrintEntryPointCommand(Ep); | ||||
10457 | } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO) { | ||||
10458 | MachO::encryption_info_command Ei = | ||||
10459 | Obj->getEncryptionInfoCommand(Command); | ||||
10460 | PrintEncryptionInfoCommand(Ei, Buf.size()); | ||||
10461 | } else if (Command.C.cmd == MachO::LC_ENCRYPTION_INFO_64) { | ||||
10462 | MachO::encryption_info_command_64 Ei = | ||||
10463 | Obj->getEncryptionInfoCommand64(Command); | ||||
10464 | PrintEncryptionInfoCommand64(Ei, Buf.size()); | ||||
10465 | } else if (Command.C.cmd == MachO::LC_LINKER_OPTION) { | ||||
10466 | MachO::linker_option_command Lo = | ||||
10467 | Obj->getLinkerOptionLoadCommand(Command); | ||||
10468 | PrintLinkerOptionCommand(Lo, Command.Ptr); | ||||
10469 | } else if (Command.C.cmd == MachO::LC_SUB_FRAMEWORK) { | ||||
10470 | MachO::sub_framework_command Sf = Obj->getSubFrameworkCommand(Command); | ||||
10471 | PrintSubFrameworkCommand(Sf, Command.Ptr); | ||||
10472 | } else if (Command.C.cmd == MachO::LC_SUB_UMBRELLA) { | ||||
10473 | MachO::sub_umbrella_command Sf = Obj->getSubUmbrellaCommand(Command); | ||||
10474 | PrintSubUmbrellaCommand(Sf, Command.Ptr); | ||||
10475 | } else if (Command.C.cmd == MachO::LC_SUB_LIBRARY) { | ||||
10476 | MachO::sub_library_command Sl = Obj->getSubLibraryCommand(Command); | ||||
10477 | PrintSubLibraryCommand(Sl, Command.Ptr); | ||||
10478 | } else if (Command.C.cmd == MachO::LC_SUB_CLIENT) { | ||||
10479 | MachO::sub_client_command Sc = Obj->getSubClientCommand(Command); | ||||
10480 | PrintSubClientCommand(Sc, Command.Ptr); | ||||
10481 | } else if (Command.C.cmd == MachO::LC_ROUTINES) { | ||||
10482 | MachO::routines_command Rc = Obj->getRoutinesCommand(Command); | ||||
10483 | PrintRoutinesCommand(Rc); | ||||
10484 | } else if (Command.C.cmd == MachO::LC_ROUTINES_64) { | ||||
10485 | MachO::routines_command_64 Rc = Obj->getRoutinesCommand64(Command); | ||||
10486 | PrintRoutinesCommand64(Rc); | ||||
10487 | } else if (Command.C.cmd == MachO::LC_THREAD || | ||||
10488 | Command.C.cmd == MachO::LC_UNIXTHREAD) { | ||||
10489 | MachO::thread_command Tc = Obj->getThreadCommand(Command); | ||||
10490 | PrintThreadCommand(Tc, Command.Ptr, Obj->isLittleEndian(), cputype); | ||||
10491 | } else if (Command.C.cmd == MachO::LC_LOAD_DYLIB || | ||||
10492 | Command.C.cmd == MachO::LC_ID_DYLIB || | ||||
10493 | Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB || | ||||
10494 | Command.C.cmd == MachO::LC_REEXPORT_DYLIB || | ||||
10495 | Command.C.cmd == MachO::LC_LAZY_LOAD_DYLIB || | ||||
10496 | Command.C.cmd == MachO::LC_LOAD_UPWARD_DYLIB) { | ||||
10497 | MachO::dylib_command Dl = Obj->getDylibIDLoadCommand(Command); | ||||
10498 | PrintDylibCommand(Dl, Command.Ptr); | ||||
10499 | } else if (Command.C.cmd == MachO::LC_CODE_SIGNATURE || | ||||
10500 | Command.C.cmd == MachO::LC_SEGMENT_SPLIT_INFO || | ||||
10501 | Command.C.cmd == MachO::LC_FUNCTION_STARTS || | ||||
10502 | Command.C.cmd == MachO::LC_DATA_IN_CODE || | ||||
10503 | Command.C.cmd == MachO::LC_DYLIB_CODE_SIGN_DRS || | ||||
10504 | Command.C.cmd == MachO::LC_LINKER_OPTIMIZATION_HINT || | ||||
10505 | Command.C.cmd == MachO::LC_DYLD_EXPORTS_TRIE || | ||||
10506 | Command.C.cmd == MachO::LC_DYLD_CHAINED_FIXUPS) { | ||||
10507 | MachO::linkedit_data_command Ld = | ||||
10508 | Obj->getLinkeditDataLoadCommand(Command); | ||||
10509 | PrintLinkEditDataCommand(Ld, Buf.size()); | ||||
10510 | } else { | ||||
10511 | outs() << " cmd ?(" << format("0x%08" PRIx32"x", Command.C.cmd) | ||||
10512 | << ")\n"; | ||||
10513 | outs() << " cmdsize " << Command.C.cmdsize << "\n"; | ||||
10514 | // TODO: get and print the raw bytes of the load command. | ||||
10515 | } | ||||
10516 | // TODO: print all the other kinds of load commands. | ||||
10517 | } | ||||
10518 | } | ||||
10519 | |||||
10520 | static void PrintMachHeader(const MachOObjectFile *Obj, bool verbose) { | ||||
10521 | if (Obj->is64Bit()) { | ||||
10522 | MachO::mach_header_64 H_64; | ||||
10523 | H_64 = Obj->getHeader64(); | ||||
10524 | PrintMachHeader(H_64.magic, H_64.cputype, H_64.cpusubtype, H_64.filetype, | ||||
10525 | H_64.ncmds, H_64.sizeofcmds, H_64.flags, verbose); | ||||
10526 | } else { | ||||
10527 | MachO::mach_header H; | ||||
10528 | H = Obj->getHeader(); | ||||
10529 | PrintMachHeader(H.magic, H.cputype, H.cpusubtype, H.filetype, H.ncmds, | ||||
10530 | H.sizeofcmds, H.flags, verbose); | ||||
10531 | } | ||||
10532 | } | ||||
10533 | |||||
10534 | void objdump::printMachOFileHeader(const object::ObjectFile *Obj) { | ||||
10535 | const MachOObjectFile *file = cast<const MachOObjectFile>(Obj); | ||||
10536 | PrintMachHeader(file, Verbose); | ||||
10537 | } | ||||
10538 | |||||
10539 | void objdump::printMachOLoadCommands(const object::ObjectFile *Obj) { | ||||
10540 | const MachOObjectFile *file = cast<const MachOObjectFile>(Obj); | ||||
10541 | uint32_t filetype = 0; | ||||
10542 | uint32_t cputype = 0; | ||||
10543 | if (file->is64Bit()) { | ||||
10544 | MachO::mach_header_64 H_64; | ||||
10545 | H_64 = file->getHeader64(); | ||||
10546 | filetype = H_64.filetype; | ||||
10547 | cputype = H_64.cputype; | ||||
10548 | } else { | ||||
10549 | MachO::mach_header H; | ||||
10550 | H = file->getHeader(); | ||||
10551 | filetype = H.filetype; | ||||
10552 | cputype = H.cputype; | ||||
10553 | } | ||||
10554 | PrintLoadCommands(file, filetype, cputype, Verbose); | ||||
10555 | } | ||||
10556 | |||||
10557 | //===----------------------------------------------------------------------===// | ||||
10558 | // export trie dumping | ||||
10559 | //===----------------------------------------------------------------------===// | ||||
10560 | |||||
10561 | static void printMachOExportsTrie(const object::MachOObjectFile *Obj) { | ||||
10562 | uint64_t BaseSegmentAddress = 0; | ||||
10563 | for (const auto &Command : Obj->load_commands()) { | ||||
10564 | if (Command.C.cmd == MachO::LC_SEGMENT) { | ||||
10565 | MachO::segment_command Seg = Obj->getSegmentLoadCommand(Command); | ||||
10566 | if (Seg.fileoff == 0 && Seg.filesize != 0) { | ||||
10567 | BaseSegmentAddress = Seg.vmaddr; | ||||
10568 | break; | ||||
10569 | } | ||||
10570 | } else if (Command.C.cmd == MachO::LC_SEGMENT_64) { | ||||
10571 | MachO::segment_command_64 Seg = Obj->getSegment64LoadCommand(Command); | ||||
10572 | if (Seg.fileoff == 0 && Seg.filesize != 0) { | ||||
10573 | BaseSegmentAddress = Seg.vmaddr; | ||||
10574 | break; | ||||
10575 | } | ||||
10576 | } | ||||
10577 | } | ||||
10578 | Error Err = Error::success(); | ||||
10579 | for (const object::ExportEntry &Entry : Obj->exports(Err)) { | ||||
10580 | uint64_t Flags = Entry.flags(); | ||||
10581 | bool ReExport = (Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT); | ||||
10582 | bool WeakDef = (Flags & MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION); | ||||
10583 | bool ThreadLocal = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) == | ||||
10584 | MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL); | ||||
10585 | bool Abs = ((Flags & MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) == | ||||
10586 | MachO::EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE); | ||||
10587 | bool Resolver = (Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER); | ||||
10588 | if (ReExport) | ||||
10589 | outs() << "[re-export] "; | ||||
10590 | else | ||||
10591 | outs() << format("0x%08llX ", | ||||
10592 | Entry.address() + BaseSegmentAddress); | ||||
10593 | outs() << Entry.name(); | ||||
10594 | if (WeakDef || ThreadLocal || Resolver || Abs) { | ||||
10595 | ListSeparator LS; | ||||
10596 | outs() << " ["; | ||||
10597 | if (WeakDef) | ||||
10598 | outs() << LS << "weak_def"; | ||||
10599 | if (ThreadLocal) | ||||
10600 | outs() << LS << "per-thread"; | ||||
10601 | if (Abs) | ||||
10602 | outs() << LS << "absolute"; | ||||
10603 | if (Resolver) | ||||
10604 | outs() << LS << format("resolver=0x%08llX", Entry.other()); | ||||
10605 | outs() << "]"; | ||||
10606 | } | ||||
10607 | if (ReExport) { | ||||
10608 | StringRef DylibName = "unknown"; | ||||
10609 | int Ordinal = Entry.other() - 1; | ||||
10610 | Obj->getLibraryShortNameByIndex(Ordinal, DylibName); | ||||
10611 | if (Entry.otherName().empty()) | ||||
10612 | outs() << " (from " << DylibName << ")"; | ||||
10613 | else | ||||
10614 | outs() << " (" << Entry.otherName() << " from " << DylibName << ")"; | ||||
10615 | } | ||||
10616 | outs() << "\n"; | ||||
10617 | } | ||||
10618 | if (Err) | ||||
10619 | reportError(std::move(Err), Obj->getFileName()); | ||||
10620 | } | ||||
10621 | |||||
10622 | //===----------------------------------------------------------------------===// | ||||
10623 | // rebase table dumping | ||||
10624 | //===----------------------------------------------------------------------===// | ||||
10625 | |||||
10626 | static void printMachORebaseTable(object::MachOObjectFile *Obj) { | ||||
10627 | outs() << "segment section address type\n"; | ||||
10628 | Error Err = Error::success(); | ||||
10629 | for (const object::MachORebaseEntry &Entry : Obj->rebaseTable(Err)) { | ||||
10630 | StringRef SegmentName = Entry.segmentName(); | ||||
10631 | StringRef SectionName = Entry.sectionName(); | ||||
10632 | uint64_t Address = Entry.address(); | ||||
10633 | |||||
10634 | // Table lines look like: __DATA __nl_symbol_ptr 0x0000F00C pointer | ||||
10635 | outs() << format("%-8s %-18s 0x%08" PRIX64"l" "X" " %s\n", | ||||
10636 | SegmentName.str().c_str(), SectionName.str().c_str(), | ||||
10637 | Address, Entry.typeName().str().c_str()); | ||||
10638 | } | ||||
10639 | if (Err) | ||||
10640 | reportError(std::move(Err), Obj->getFileName()); | ||||
10641 | } | ||||
10642 | |||||
10643 | static StringRef ordinalName(const object::MachOObjectFile *Obj, int Ordinal) { | ||||
10644 | StringRef DylibName; | ||||
10645 | switch (Ordinal) { | ||||
10646 | case MachO::BIND_SPECIAL_DYLIB_SELF: | ||||
10647 | return "this-image"; | ||||
10648 | case MachO::BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE: | ||||
10649 | return "main-executable"; | ||||
10650 | case MachO::BIND_SPECIAL_DYLIB_FLAT_LOOKUP: | ||||
10651 | return "flat-namespace"; | ||||
10652 | case MachO::BIND_SPECIAL_DYLIB_WEAK_LOOKUP: | ||||
10653 | return "weak"; | ||||
10654 | default: | ||||
10655 | if (Ordinal > 0) { | ||||
10656 | std::error_code EC = | ||||
10657 | Obj->getLibraryShortNameByIndex(Ordinal - 1, DylibName); | ||||
10658 | if (EC) | ||||
10659 | return "<<bad library ordinal>>"; | ||||
10660 | return DylibName; | ||||
10661 | } | ||||
10662 | } | ||||
10663 | return "<<unknown special ordinal>>"; | ||||
10664 | } | ||||
10665 | |||||
10666 | //===----------------------------------------------------------------------===// | ||||
10667 | // bind table dumping | ||||
10668 | //===----------------------------------------------------------------------===// | ||||
10669 | |||||
10670 | static void printMachOBindTable(object::MachOObjectFile *Obj) { | ||||
10671 | // Build table of sections so names can used in final output. | ||||
10672 | outs() << "segment section address type " | ||||
10673 | "addend dylib symbol\n"; | ||||
10674 | Error Err = Error::success(); | ||||
10675 | for (const object::MachOBindEntry &Entry : Obj->bindTable(Err)) { | ||||
10676 | StringRef SegmentName = Entry.segmentName(); | ||||
10677 | StringRef SectionName = Entry.sectionName(); | ||||
10678 | uint64_t Address = Entry.address(); | ||||
10679 | |||||
10680 | // Table lines look like: | ||||
10681 | // __DATA __got 0x00012010 pointer 0 libSystem ___stack_chk_guard | ||||
10682 | StringRef Attr; | ||||
10683 | if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT) | ||||
10684 | Attr = " (weak_import)"; | ||||
10685 | outs() << left_justify(SegmentName, 8) << " " | ||||
10686 | << left_justify(SectionName, 18) << " " | ||||
10687 | << format_hex(Address, 10, true) << " " | ||||
10688 | << left_justify(Entry.typeName(), 8) << " " | ||||
10689 | << format_decimal(Entry.addend(), 8) << " " | ||||
10690 | << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " " | ||||
10691 | << Entry.symbolName() << Attr << "\n"; | ||||
10692 | } | ||||
10693 | if (Err) | ||||
10694 | reportError(std::move(Err), Obj->getFileName()); | ||||
10695 | } | ||||
10696 | |||||
10697 | //===----------------------------------------------------------------------===// | ||||
10698 | // lazy bind table dumping | ||||
10699 | //===----------------------------------------------------------------------===// | ||||
10700 | |||||
10701 | static void printMachOLazyBindTable(object::MachOObjectFile *Obj) { | ||||
10702 | outs() << "segment section address " | ||||
10703 | "dylib symbol\n"; | ||||
10704 | Error Err = Error::success(); | ||||
10705 | for (const object::MachOBindEntry &Entry : Obj->lazyBindTable(Err)) { | ||||
10706 | StringRef SegmentName = Entry.segmentName(); | ||||
10707 | StringRef SectionName = Entry.sectionName(); | ||||
10708 | uint64_t Address = Entry.address(); | ||||
10709 | |||||
10710 | // Table lines look like: | ||||
10711 | // __DATA __got 0x00012010 libSystem ___stack_chk_guard | ||||
10712 | outs() << left_justify(SegmentName, 8) << " " | ||||
10713 | << left_justify(SectionName, 18) << " " | ||||
10714 | << format_hex(Address, 10, true) << " " | ||||
10715 | << left_justify(ordinalName(Obj, Entry.ordinal()), 16) << " " | ||||
10716 | << Entry.symbolName() << "\n"; | ||||
10717 | } | ||||
10718 | if (Err) | ||||
10719 | reportError(std::move(Err), Obj->getFileName()); | ||||
10720 | } | ||||
10721 | |||||
10722 | //===----------------------------------------------------------------------===// | ||||
10723 | // weak bind table dumping | ||||
10724 | //===----------------------------------------------------------------------===// | ||||
10725 | |||||
10726 | static void printMachOWeakBindTable(object::MachOObjectFile *Obj) { | ||||
10727 | outs() << "segment section address " | ||||
10728 | "type addend symbol\n"; | ||||
10729 | Error Err = Error::success(); | ||||
10730 | for (const object::MachOBindEntry &Entry : Obj->weakBindTable(Err)) { | ||||
10731 | // Strong symbols don't have a location to update. | ||||
10732 | if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION) { | ||||
10733 | outs() << " strong " | ||||
10734 | << Entry.symbolName() << "\n"; | ||||
10735 | continue; | ||||
10736 | } | ||||
10737 | StringRef SegmentName = Entry.segmentName(); | ||||
10738 | StringRef SectionName = Entry.sectionName(); | ||||
10739 | uint64_t Address = Entry.address(); | ||||
10740 | |||||
10741 | // Table lines look like: | ||||
10742 | // __DATA __data 0x00001000 pointer 0 _foo | ||||
10743 | outs() << left_justify(SegmentName, 8) << " " | ||||
10744 | << left_justify(SectionName, 18) << " " | ||||
10745 | << format_hex(Address, 10, true) << " " | ||||
10746 | << left_justify(Entry.typeName(), 8) << " " | ||||
10747 | << format_decimal(Entry.addend(), 8) << " " << Entry.symbolName() | ||||
10748 | << "\n"; | ||||
10749 | } | ||||
10750 | if (Err) | ||||
10751 | reportError(std::move(Err), Obj->getFileName()); | ||||
10752 | } | ||||
10753 | |||||
10754 | // get_dyld_bind_info_symbolname() is used for disassembly and passed an | ||||
10755 | // address, ReferenceValue, in the Mach-O file and looks in the dyld bind | ||||
10756 | // information for that address. If the address is found its binding symbol | ||||
10757 | // name is returned. If not nullptr is returned. | ||||
10758 | static const char *get_dyld_bind_info_symbolname(uint64_t ReferenceValue, | ||||
10759 | struct DisassembleInfo *info) { | ||||
10760 | if (info->bindtable == nullptr) { | ||||
10761 | info->bindtable = std::make_unique<SymbolAddressMap>(); | ||||
10762 | Error Err = Error::success(); | ||||
10763 | for (const object::MachOBindEntry &Entry : info->O->bindTable(Err)) { | ||||
10764 | uint64_t Address = Entry.address(); | ||||
10765 | StringRef name = Entry.symbolName(); | ||||
10766 | if (!name.empty()) | ||||
10767 | (*info->bindtable)[Address] = name; | ||||
10768 | } | ||||
10769 | if (Err) | ||||
10770 | reportError(std::move(Err), info->O->getFileName()); | ||||
10771 | } | ||||
10772 | auto name = info->bindtable->lookup(ReferenceValue); | ||||
10773 | return !name.empty() ? name.data() : nullptr; | ||||
10774 | } | ||||
10775 | |||||
10776 | void objdump::printLazyBindTable(ObjectFile *o) { | ||||
10777 | outs() << "\nLazy bind table:\n"; | ||||
10778 | if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) | ||||
10779 | printMachOLazyBindTable(MachO); | ||||
10780 | else | ||||
10781 | WithColor::error() | ||||
10782 | << "This operation is only currently supported " | ||||
10783 | "for Mach-O executable files.\n"; | ||||
10784 | } | ||||
10785 | |||||
10786 | void objdump::printWeakBindTable(ObjectFile *o) { | ||||
10787 | outs() << "\nWeak bind table:\n"; | ||||
10788 | if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) | ||||
10789 | printMachOWeakBindTable(MachO); | ||||
10790 | else | ||||
10791 | WithColor::error() | ||||
10792 | << "This operation is only currently supported " | ||||
10793 | "for Mach-O executable files.\n"; | ||||
10794 | } | ||||
10795 | |||||
10796 | void objdump::printExportsTrie(const ObjectFile *o) { | ||||
10797 | outs() << "\nExports trie:\n"; | ||||
10798 | if (const MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) | ||||
10799 | printMachOExportsTrie(MachO); | ||||
10800 | else | ||||
10801 | WithColor::error() | ||||
10802 | << "This operation is only currently supported " | ||||
10803 | "for Mach-O executable files.\n"; | ||||
10804 | } | ||||
10805 | |||||
10806 | void objdump::printRebaseTable(ObjectFile *o) { | ||||
10807 | outs() << "\nRebase table:\n"; | ||||
10808 | if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) | ||||
10809 | printMachORebaseTable(MachO); | ||||
10810 | else | ||||
10811 | WithColor::error() | ||||
10812 | << "This operation is only currently supported " | ||||
10813 | "for Mach-O executable files.\n"; | ||||
10814 | } | ||||
10815 | |||||
10816 | void objdump::printBindTable(ObjectFile *o) { | ||||
10817 | outs() << "\nBind table:\n"; | ||||
10818 | if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(o)) | ||||
10819 | printMachOBindTable(MachO); | ||||
10820 | else | ||||
10821 | WithColor::error() | ||||
10822 | << "This operation is only currently supported " | ||||
10823 | "for Mach-O executable files.\n"; | ||||
10824 | } |
1 | //===- ObjectFile.h - File format independent object file -------*- C++ -*-===// | |||
2 | // | |||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
4 | // See https://llvm.org/LICENSE.txt for license information. | |||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
6 | // | |||
7 | //===----------------------------------------------------------------------===// | |||
8 | // | |||
9 | // This file declares a file format independent ObjectFile class. | |||
10 | // | |||
11 | //===----------------------------------------------------------------------===// | |||
12 | ||||
13 | #ifndef LLVM_OBJECT_OBJECTFILE_H | |||
14 | #define LLVM_OBJECT_OBJECTFILE_H | |||
15 | ||||
16 | #include "llvm/ADT/ArrayRef.h" | |||
17 | #include "llvm/ADT/Hashing.h" | |||
18 | #include "llvm/ADT/StringRef.h" | |||
19 | #include "llvm/ADT/iterator_range.h" | |||
20 | #include "llvm/BinaryFormat/Magic.h" | |||
21 | #include "llvm/BinaryFormat/Swift.h" | |||
22 | #include "llvm/Object/Binary.h" | |||
23 | #include "llvm/Object/Error.h" | |||
24 | #include "llvm/Object/SymbolicFile.h" | |||
25 | #include "llvm/Support/Casting.h" | |||
26 | #include "llvm/Support/Error.h" | |||
27 | #include "llvm/Support/MemoryBufferRef.h" | |||
28 | #include "llvm/TargetParser/Triple.h" | |||
29 | #include <cassert> | |||
30 | #include <cstdint> | |||
31 | #include <memory> | |||
32 | ||||
33 | namespace llvm { | |||
34 | ||||
35 | class SubtargetFeatures; | |||
36 | ||||
37 | namespace object { | |||
38 | ||||
39 | class COFFObjectFile; | |||
40 | class MachOObjectFile; | |||
41 | class ObjectFile; | |||
42 | class SectionRef; | |||
43 | class SymbolRef; | |||
44 | class symbol_iterator; | |||
45 | class WasmObjectFile; | |||
46 | ||||
47 | using section_iterator = content_iterator<SectionRef>; | |||
48 | ||||
49 | /// This is a value type class that represents a single relocation in the list | |||
50 | /// of relocations in the object file. | |||
51 | class RelocationRef { | |||
52 | DataRefImpl RelocationPimpl; | |||
53 | const ObjectFile *OwningObject = nullptr; | |||
54 | ||||
55 | public: | |||
56 | RelocationRef() = default; | |||
57 | RelocationRef(DataRefImpl RelocationP, const ObjectFile *Owner); | |||
58 | ||||
59 | bool operator==(const RelocationRef &Other) const; | |||
60 | ||||
61 | void moveNext(); | |||
62 | ||||
63 | uint64_t getOffset() const; | |||
64 | symbol_iterator getSymbol() const; | |||
65 | uint64_t getType() const; | |||
66 | ||||
67 | /// Get a string that represents the type of this relocation. | |||
68 | /// | |||
69 | /// This is for display purposes only. | |||
70 | void getTypeName(SmallVectorImpl<char> &Result) const; | |||
71 | ||||
72 | DataRefImpl getRawDataRefImpl() const; | |||
73 | const ObjectFile *getObject() const; | |||
74 | }; | |||
75 | ||||
76 | using relocation_iterator = content_iterator<RelocationRef>; | |||
77 | ||||
78 | /// This is a value type class that represents a single section in the list of | |||
79 | /// sections in the object file. | |||
80 | class SectionRef { | |||
81 | friend class SymbolRef; | |||
82 | ||||
83 | DataRefImpl SectionPimpl; | |||
84 | const ObjectFile *OwningObject = nullptr; | |||
85 | ||||
86 | public: | |||
87 | SectionRef() = default; | |||
88 | SectionRef(DataRefImpl SectionP, const ObjectFile *Owner); | |||
89 | ||||
90 | bool operator==(const SectionRef &Other) const; | |||
91 | bool operator!=(const SectionRef &Other) const; | |||
92 | bool operator<(const SectionRef &Other) const; | |||
93 | ||||
94 | void moveNext(); | |||
95 | ||||
96 | Expected<StringRef> getName() const; | |||
97 | uint64_t getAddress() const; | |||
98 | uint64_t getIndex() const; | |||
99 | uint64_t getSize() const; | |||
100 | Expected<StringRef> getContents() const; | |||
101 | ||||
102 | /// Get the alignment of this section. | |||
103 | Align getAlignment() const; | |||
104 | ||||
105 | bool isCompressed() const; | |||
106 | /// Whether this section contains instructions. | |||
107 | bool isText() const; | |||
108 | /// Whether this section contains data, not instructions. | |||
109 | bool isData() const; | |||
110 | /// Whether this section contains BSS uninitialized data. | |||
111 | bool isBSS() const; | |||
112 | bool isVirtual() const; | |||
113 | bool isBitcode() const; | |||
114 | bool isStripped() const; | |||
115 | ||||
116 | /// Whether this section will be placed in the text segment, according to the | |||
117 | /// Berkeley size format. This is true if the section is allocatable, and | |||
118 | /// contains either code or readonly data. | |||
119 | bool isBerkeleyText() const; | |||
120 | /// Whether this section will be placed in the data segment, according to the | |||
121 | /// Berkeley size format. This is true if the section is allocatable and | |||
122 | /// contains data (e.g. PROGBITS), but is not text. | |||
123 | bool isBerkeleyData() const; | |||
124 | ||||
125 | /// Whether this section is a debug section. | |||
126 | bool isDebugSection() const; | |||
127 | ||||
128 | bool containsSymbol(SymbolRef S) const; | |||
129 | ||||
130 | relocation_iterator relocation_begin() const; | |||
131 | relocation_iterator relocation_end() const; | |||
132 | iterator_range<relocation_iterator> relocations() const { | |||
133 | return make_range(relocation_begin(), relocation_end()); | |||
134 | } | |||
135 | ||||
136 | /// Returns the related section if this section contains relocations. The | |||
137 | /// returned section may or may not have applied its relocations. | |||
138 | Expected<section_iterator> getRelocatedSection() const; | |||
139 | ||||
140 | DataRefImpl getRawDataRefImpl() const; | |||
141 | const ObjectFile *getObject() const; | |||
142 | }; | |||
143 | ||||
144 | struct SectionedAddress { | |||
145 | const static uint64_t UndefSection = UINT64_MAX(18446744073709551615UL); | |||
146 | ||||
147 | uint64_t Address = 0; | |||
148 | uint64_t SectionIndex = UndefSection; | |||
149 | }; | |||
150 | ||||
151 | inline bool operator<(const SectionedAddress &LHS, | |||
152 | const SectionedAddress &RHS) { | |||
153 | return std::tie(LHS.SectionIndex, LHS.Address) < | |||
154 | std::tie(RHS.SectionIndex, RHS.Address); | |||
155 | } | |||
156 | ||||
157 | inline bool operator==(const SectionedAddress &LHS, | |||
158 | const SectionedAddress &RHS) { | |||
159 | return std::tie(LHS.SectionIndex, LHS.Address) == | |||
160 | std::tie(RHS.SectionIndex, RHS.Address); | |||
161 | } | |||
162 | ||||
163 | raw_ostream &operator<<(raw_ostream &OS, const SectionedAddress &Addr); | |||
164 | ||||
165 | /// This is a value type class that represents a single symbol in the list of | |||
166 | /// symbols in the object file. | |||
167 | class SymbolRef : public BasicSymbolRef { | |||
168 | friend class SectionRef; | |||
169 | ||||
170 | public: | |||
171 | enum Type { | |||
172 | ST_Unknown, // Type not specified | |||
173 | ST_Other, | |||
174 | ST_Data, | |||
175 | ST_Debug, | |||
176 | ST_File, | |||
177 | ST_Function, | |||
178 | }; | |||
179 | ||||
180 | SymbolRef() = default; | |||
181 | SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner); | |||
182 | SymbolRef(const BasicSymbolRef &B) : BasicSymbolRef(B) { | |||
183 | assert(isa<ObjectFile>(BasicSymbolRef::getObject()))(static_cast <bool> (isa<ObjectFile>(BasicSymbolRef ::getObject())) ? void (0) : __assert_fail ("isa<ObjectFile>(BasicSymbolRef::getObject())" , "llvm/include/llvm/Object/ObjectFile.h", 183, __extension__ __PRETTY_FUNCTION__)); | |||
184 | } | |||
185 | ||||
186 | Expected<StringRef> getName() const; | |||
187 | /// Returns the symbol virtual address (i.e. address at which it will be | |||
188 | /// mapped). | |||
189 | Expected<uint64_t> getAddress() const; | |||
190 | ||||
191 | /// Return the value of the symbol depending on the object this can be an | |||
192 | /// offset or a virtual address. | |||
193 | Expected<uint64_t> getValue() const; | |||
194 | ||||
195 | /// Get the alignment of this symbol as the actual value (not log 2). | |||
196 | uint32_t getAlignment() const; | |||
197 | uint64_t getCommonSize() const; | |||
198 | Expected<SymbolRef::Type> getType() const; | |||
199 | ||||
200 | /// Get section this symbol is defined in reference to. Result is | |||
201 | /// end_sections() if it is undefined or is an absolute symbol. | |||
202 | Expected<section_iterator> getSection() const; | |||
203 | ||||
204 | const ObjectFile *getObject() const; | |||
205 | }; | |||
206 | ||||
207 | class symbol_iterator : public basic_symbol_iterator { | |||
208 | public: | |||
209 | symbol_iterator(SymbolRef Sym) : basic_symbol_iterator(Sym) {} | |||
210 | symbol_iterator(const basic_symbol_iterator &B) | |||
211 | : basic_symbol_iterator(SymbolRef(B->getRawDataRefImpl(), | |||
212 | cast<ObjectFile>(B->getObject()))) {} | |||
213 | ||||
214 | const SymbolRef *operator->() const { | |||
215 | const BasicSymbolRef &P = basic_symbol_iterator::operator *(); | |||
216 | return static_cast<const SymbolRef*>(&P); | |||
217 | } | |||
218 | ||||
219 | const SymbolRef &operator*() const { | |||
220 | const BasicSymbolRef &P = basic_symbol_iterator::operator *(); | |||
221 | return static_cast<const SymbolRef&>(P); | |||
222 | } | |||
223 | }; | |||
224 | ||||
225 | /// This class is the base class for all object file types. Concrete instances | |||
226 | /// of this object are created by createObjectFile, which figures out which type | |||
227 | /// to create. | |||
228 | class ObjectFile : public SymbolicFile { | |||
229 | virtual void anchor(); | |||
230 | ||||
231 | protected: | |||
232 | ObjectFile(unsigned int Type, MemoryBufferRef Source); | |||
233 | ||||
234 | const uint8_t *base() const { | |||
235 | return reinterpret_cast<const uint8_t *>(Data.getBufferStart()); | |||
236 | } | |||
237 | ||||
238 | // These functions are for SymbolRef to call internally. The main goal of | |||
239 | // this is to allow SymbolRef::SymbolPimpl to point directly to the symbol | |||
240 | // entry in the memory mapped object file. SymbolPimpl cannot contain any | |||
241 | // virtual functions because then it could not point into the memory mapped | |||
242 | // file. | |||
243 | // | |||
244 | // Implementations assume that the DataRefImpl is valid and has not been | |||
245 | // modified externally. It's UB otherwise. | |||
246 | friend class SymbolRef; | |||
247 | ||||
248 | virtual Expected<StringRef> getSymbolName(DataRefImpl Symb) const = 0; | |||
249 | Error printSymbolName(raw_ostream &OS, | |||
250 | DataRefImpl Symb) const override; | |||
251 | virtual Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const = 0; | |||
252 | virtual uint64_t getSymbolValueImpl(DataRefImpl Symb) const = 0; | |||
253 | virtual uint32_t getSymbolAlignment(DataRefImpl Symb) const; | |||
254 | virtual uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const = 0; | |||
255 | virtual Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const = 0; | |||
256 | virtual Expected<section_iterator> | |||
257 | getSymbolSection(DataRefImpl Symb) const = 0; | |||
258 | ||||
259 | // Same as above for SectionRef. | |||
260 | friend class SectionRef; | |||
261 | ||||
262 | virtual void moveSectionNext(DataRefImpl &Sec) const = 0; | |||
263 | virtual Expected<StringRef> getSectionName(DataRefImpl Sec) const = 0; | |||
264 | virtual uint64_t getSectionAddress(DataRefImpl Sec) const = 0; | |||
265 | virtual uint64_t getSectionIndex(DataRefImpl Sec) const = 0; | |||
266 | virtual uint64_t getSectionSize(DataRefImpl Sec) const = 0; | |||
267 | virtual Expected<ArrayRef<uint8_t>> | |||
268 | getSectionContents(DataRefImpl Sec) const = 0; | |||
269 | virtual uint64_t getSectionAlignment(DataRefImpl Sec) const = 0; | |||
270 | virtual bool isSectionCompressed(DataRefImpl Sec) const = 0; | |||
271 | virtual bool isSectionText(DataRefImpl Sec) const = 0; | |||
272 | virtual bool isSectionData(DataRefImpl Sec) const = 0; | |||
273 | virtual bool isSectionBSS(DataRefImpl Sec) const = 0; | |||
274 | // A section is 'virtual' if its contents aren't present in the object image. | |||
275 | virtual bool isSectionVirtual(DataRefImpl Sec) const = 0; | |||
276 | virtual bool isSectionBitcode(DataRefImpl Sec) const; | |||
277 | virtual bool isSectionStripped(DataRefImpl Sec) const; | |||
278 | virtual bool isBerkeleyText(DataRefImpl Sec) const; | |||
279 | virtual bool isBerkeleyData(DataRefImpl Sec) const; | |||
280 | virtual bool isDebugSection(DataRefImpl Sec) const; | |||
281 | virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const = 0; | |||
282 | virtual relocation_iterator section_rel_end(DataRefImpl Sec) const = 0; | |||
283 | virtual Expected<section_iterator> getRelocatedSection(DataRefImpl Sec) const; | |||
284 | ||||
285 | // Same as above for RelocationRef. | |||
286 | friend class RelocationRef; | |||
287 | virtual void moveRelocationNext(DataRefImpl &Rel) const = 0; | |||
288 | virtual uint64_t getRelocationOffset(DataRefImpl Rel) const = 0; | |||
289 | virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const = 0; | |||
290 | virtual uint64_t getRelocationType(DataRefImpl Rel) const = 0; | |||
291 | virtual void getRelocationTypeName(DataRefImpl Rel, | |||
292 | SmallVectorImpl<char> &Result) const = 0; | |||
293 | ||||
294 | virtual llvm::binaryformat::Swift5ReflectionSectionKind | |||
295 | mapReflectionSectionNameToEnumValue(StringRef SectionName) const { | |||
296 | return llvm::binaryformat::Swift5ReflectionSectionKind::unknown; | |||
297 | }; | |||
298 | ||||
299 | Expected<uint64_t> getSymbolValue(DataRefImpl Symb) const; | |||
300 | ||||
301 | public: | |||
302 | ObjectFile() = delete; | |||
303 | ObjectFile(const ObjectFile &other) = delete; | |||
304 | ||||
305 | uint64_t getCommonSymbolSize(DataRefImpl Symb) const { | |||
306 | Expected<uint32_t> SymbolFlagsOrErr = getSymbolFlags(Symb); | |||
307 | if (!SymbolFlagsOrErr) | |||
308 | // TODO: Actually report errors helpfully. | |||
309 | report_fatal_error(SymbolFlagsOrErr.takeError()); | |||
310 | assert(*SymbolFlagsOrErr & SymbolRef::SF_Common)(static_cast <bool> (*SymbolFlagsOrErr & SymbolRef:: SF_Common) ? void (0) : __assert_fail ("*SymbolFlagsOrErr & SymbolRef::SF_Common" , "llvm/include/llvm/Object/ObjectFile.h", 310, __extension__ __PRETTY_FUNCTION__)); | |||
311 | return getCommonSymbolSizeImpl(Symb); | |||
312 | } | |||
313 | ||||
314 | virtual std::vector<SectionRef> dynamic_relocation_sections() const { | |||
315 | return std::vector<SectionRef>(); | |||
316 | } | |||
317 | ||||
318 | using symbol_iterator_range = iterator_range<symbol_iterator>; | |||
319 | symbol_iterator_range symbols() const { | |||
320 | return symbol_iterator_range(symbol_begin(), symbol_end()); | |||
321 | } | |||
322 | ||||
323 | virtual section_iterator section_begin() const = 0; | |||
324 | virtual section_iterator section_end() const = 0; | |||
325 | ||||
326 | using section_iterator_range = iterator_range<section_iterator>; | |||
327 | section_iterator_range sections() const { | |||
328 | return section_iterator_range(section_begin(), section_end()); | |||
329 | } | |||
330 | ||||
331 | virtual bool hasDebugInfo() const; | |||
332 | ||||
333 | /// The number of bytes used to represent an address in this object | |||
334 | /// file format. | |||
335 | virtual uint8_t getBytesInAddress() const = 0; | |||
336 | ||||
337 | virtual StringRef getFileFormatName() const = 0; | |||
338 | virtual Triple::ArchType getArch() const = 0; | |||
339 | virtual Expected<SubtargetFeatures> getFeatures() const = 0; | |||
340 | virtual std::optional<StringRef> tryGetCPUName() const { | |||
341 | return std::nullopt; | |||
342 | }; | |||
343 | virtual void setARMSubArch(Triple &TheTriple) const { } | |||
344 | virtual Expected<uint64_t> getStartAddress() const { | |||
345 | return errorCodeToError(object_error::parse_failed); | |||
346 | }; | |||
347 | ||||
348 | /// Create a triple from the data in this object file. | |||
349 | Triple makeTriple() const; | |||
350 | ||||
351 | /// Maps a debug section name to a standard DWARF section name. | |||
352 | virtual StringRef mapDebugSectionName(StringRef Name) const { return Name; } | |||
353 | ||||
354 | /// True if this is a relocatable object (.o/.obj). | |||
355 | virtual bool isRelocatableObject() const = 0; | |||
356 | ||||
357 | /// True if the reflection section can be stripped by the linker. | |||
358 | bool isReflectionSectionStrippable( | |||
359 | llvm::binaryformat::Swift5ReflectionSectionKind ReflectionSectionKind) | |||
360 | const; | |||
361 | ||||
362 | /// @returns Pointer to ObjectFile subclass to handle this type of object. | |||
363 | /// @param ObjectPath The path to the object file. ObjectPath.isObject must | |||
364 | /// return true. | |||
365 | /// Create ObjectFile from path. | |||
366 | static Expected<OwningBinary<ObjectFile>> | |||
367 | createObjectFile(StringRef ObjectPath); | |||
368 | ||||
369 | static Expected<std::unique_ptr<ObjectFile>> | |||
370 | createObjectFile(MemoryBufferRef Object, llvm::file_magic Type, | |||
371 | bool InitContent = true); | |||
372 | static Expected<std::unique_ptr<ObjectFile>> | |||
373 | createObjectFile(MemoryBufferRef Object) { | |||
374 | return createObjectFile(Object, llvm::file_magic::unknown); | |||
375 | } | |||
376 | ||||
377 | static bool classof(const Binary *v) { | |||
378 | return v->isObject(); | |||
379 | } | |||
380 | ||||
381 | static Expected<std::unique_ptr<COFFObjectFile>> | |||
382 | createCOFFObjectFile(MemoryBufferRef Object); | |||
383 | ||||
384 | static Expected<std::unique_ptr<ObjectFile>> | |||
385 | createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType); | |||
386 | ||||
387 | static Expected<std::unique_ptr<ObjectFile>> | |||
388 | createELFObjectFile(MemoryBufferRef Object, bool InitContent = true); | |||
389 | ||||
390 | static Expected<std::unique_ptr<MachOObjectFile>> | |||
391 | createMachOObjectFile(MemoryBufferRef Object, | |||
392 | uint32_t UniversalCputype = 0, | |||
393 | uint32_t UniversalIndex = 0); | |||
394 | ||||
395 | static Expected<std::unique_ptr<ObjectFile>> | |||
396 | createGOFFObjectFile(MemoryBufferRef Object); | |||
397 | ||||
398 | static Expected<std::unique_ptr<WasmObjectFile>> | |||
399 | createWasmObjectFile(MemoryBufferRef Object); | |||
400 | }; | |||
401 | ||||
402 | // Inline function definitions. | |||
403 | inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner) | |||
404 | : BasicSymbolRef(SymbolP, Owner) {} | |||
405 | ||||
406 | inline Expected<StringRef> SymbolRef::getName() const { | |||
407 | return getObject()->getSymbolName(getRawDataRefImpl()); | |||
408 | } | |||
409 | ||||
410 | inline Expected<uint64_t> SymbolRef::getAddress() const { | |||
411 | return getObject()->getSymbolAddress(getRawDataRefImpl()); | |||
412 | } | |||
413 | ||||
414 | inline Expected<uint64_t> SymbolRef::getValue() const { | |||
415 | return getObject()->getSymbolValue(getRawDataRefImpl()); | |||
416 | } | |||
417 | ||||
418 | inline uint32_t SymbolRef::getAlignment() const { | |||
419 | return getObject()->getSymbolAlignment(getRawDataRefImpl()); | |||
420 | } | |||
421 | ||||
422 | inline uint64_t SymbolRef::getCommonSize() const { | |||
423 | return getObject()->getCommonSymbolSize(getRawDataRefImpl()); | |||
424 | } | |||
425 | ||||
426 | inline Expected<section_iterator> SymbolRef::getSection() const { | |||
427 | return getObject()->getSymbolSection(getRawDataRefImpl()); | |||
428 | } | |||
429 | ||||
430 | inline Expected<SymbolRef::Type> SymbolRef::getType() const { | |||
431 | return getObject()->getSymbolType(getRawDataRefImpl()); | |||
432 | } | |||
433 | ||||
434 | inline const ObjectFile *SymbolRef::getObject() const { | |||
435 | const SymbolicFile *O = BasicSymbolRef::getObject(); | |||
436 | return cast<ObjectFile>(O); | |||
437 | } | |||
438 | ||||
439 | /// SectionRef | |||
440 | inline SectionRef::SectionRef(DataRefImpl SectionP, | |||
441 | const ObjectFile *Owner) | |||
442 | : SectionPimpl(SectionP) | |||
443 | , OwningObject(Owner) {} | |||
444 | ||||
445 | inline bool SectionRef::operator==(const SectionRef &Other) const { | |||
446 | return OwningObject == Other.OwningObject && | |||
447 | SectionPimpl == Other.SectionPimpl; | |||
448 | } | |||
449 | ||||
450 | inline bool SectionRef::operator!=(const SectionRef &Other) const { | |||
451 | return !(*this == Other); | |||
452 | } | |||
453 | ||||
454 | inline bool SectionRef::operator<(const SectionRef &Other) const { | |||
455 | assert(OwningObject == Other.OwningObject)(static_cast <bool> (OwningObject == Other.OwningObject ) ? void (0) : __assert_fail ("OwningObject == Other.OwningObject" , "llvm/include/llvm/Object/ObjectFile.h", 455, __extension__ __PRETTY_FUNCTION__)); | |||
456 | return SectionPimpl < Other.SectionPimpl; | |||
457 | } | |||
458 | ||||
459 | inline void SectionRef::moveNext() { | |||
460 | return OwningObject->moveSectionNext(SectionPimpl); | |||
461 | } | |||
462 | ||||
463 | inline Expected<StringRef> SectionRef::getName() const { | |||
464 | return OwningObject->getSectionName(SectionPimpl); | |||
| ||||
465 | } | |||
466 | ||||
467 | inline uint64_t SectionRef::getAddress() const { | |||
468 | return OwningObject->getSectionAddress(SectionPimpl); | |||
469 | } | |||
470 | ||||
471 | inline uint64_t SectionRef::getIndex() const { | |||
472 | return OwningObject->getSectionIndex(SectionPimpl); | |||
473 | } | |||
474 | ||||
475 | inline uint64_t SectionRef::getSize() const { | |||
476 | return OwningObject->getSectionSize(SectionPimpl); | |||
477 | } | |||
478 | ||||
479 | inline Expected<StringRef> SectionRef::getContents() const { | |||
480 | Expected<ArrayRef<uint8_t>> Res = | |||
481 | OwningObject->getSectionContents(SectionPimpl); | |||
482 | if (!Res) | |||
483 | return Res.takeError(); | |||
484 | return StringRef(reinterpret_cast<const char *>(Res->data()), Res->size()); | |||
485 | } | |||
486 | ||||
487 | inline Align SectionRef::getAlignment() const { | |||
488 | return MaybeAlign(OwningObject->getSectionAlignment(SectionPimpl)) | |||
489 | .valueOrOne(); | |||
490 | } | |||
491 | ||||
492 | inline bool SectionRef::isCompressed() const { | |||
493 | return OwningObject->isSectionCompressed(SectionPimpl); | |||
494 | } | |||
495 | ||||
496 | inline bool SectionRef::isText() const { | |||
497 | return OwningObject->isSectionText(SectionPimpl); | |||
498 | } | |||
499 | ||||
500 | inline bool SectionRef::isData() const { | |||
501 | return OwningObject->isSectionData(SectionPimpl); | |||
502 | } | |||
503 | ||||
504 | inline bool SectionRef::isBSS() const { | |||
505 | return OwningObject->isSectionBSS(SectionPimpl); | |||
506 | } | |||
507 | ||||
508 | inline bool SectionRef::isVirtual() const { | |||
509 | return OwningObject->isSectionVirtual(SectionPimpl); | |||
510 | } | |||
511 | ||||
512 | inline bool SectionRef::isBitcode() const { | |||
513 | return OwningObject->isSectionBitcode(SectionPimpl); | |||
514 | } | |||
515 | ||||
516 | inline bool SectionRef::isStripped() const { | |||
517 | return OwningObject->isSectionStripped(SectionPimpl); | |||
518 | } | |||
519 | ||||
520 | inline bool SectionRef::isBerkeleyText() const { | |||
521 | return OwningObject->isBerkeleyText(SectionPimpl); | |||
522 | } | |||
523 | ||||
524 | inline bool SectionRef::isBerkeleyData() const { | |||
525 | return OwningObject->isBerkeleyData(SectionPimpl); | |||
526 | } | |||
527 | ||||
528 | inline bool SectionRef::isDebugSection() const { | |||
529 | return OwningObject->isDebugSection(SectionPimpl); | |||
530 | } | |||
531 | ||||
532 | inline relocation_iterator SectionRef::relocation_begin() const { | |||
533 | return OwningObject->section_rel_begin(SectionPimpl); | |||
534 | } | |||
535 | ||||
536 | inline relocation_iterator SectionRef::relocation_end() const { | |||
537 | return OwningObject->section_rel_end(SectionPimpl); | |||
538 | } | |||
539 | ||||
540 | inline Expected<section_iterator> SectionRef::getRelocatedSection() const { | |||
541 | return OwningObject->getRelocatedSection(SectionPimpl); | |||
542 | } | |||
543 | ||||
544 | inline DataRefImpl SectionRef::getRawDataRefImpl() const { | |||
545 | return SectionPimpl; | |||
546 | } | |||
547 | ||||
548 | inline const ObjectFile *SectionRef::getObject() const { | |||
549 | return OwningObject; | |||
550 | } | |||
551 | ||||
552 | /// RelocationRef | |||
553 | inline RelocationRef::RelocationRef(DataRefImpl RelocationP, | |||
554 | const ObjectFile *Owner) | |||
555 | : RelocationPimpl(RelocationP) | |||
556 | , OwningObject(Owner) {} | |||
557 | ||||
558 | inline bool RelocationRef::operator==(const RelocationRef &Other) const { | |||
559 | return RelocationPimpl == Other.RelocationPimpl; | |||
560 | } | |||
561 | ||||
562 | inline void RelocationRef::moveNext() { | |||
563 | return OwningObject->moveRelocationNext(RelocationPimpl); | |||
564 | } | |||
565 | ||||
566 | inline uint64_t RelocationRef::getOffset() const { | |||
567 | return OwningObject->getRelocationOffset(RelocationPimpl); | |||
568 | } | |||
569 | ||||
570 | inline symbol_iterator RelocationRef::getSymbol() const { | |||
571 | return OwningObject->getRelocationSymbol(RelocationPimpl); | |||
572 | } | |||
573 | ||||
574 | inline uint64_t RelocationRef::getType() const { | |||
575 | return OwningObject->getRelocationType(RelocationPimpl); | |||
576 | } | |||
577 | ||||
578 | inline void RelocationRef::getTypeName(SmallVectorImpl<char> &Result) const { | |||
579 | return OwningObject->getRelocationTypeName(RelocationPimpl, Result); | |||
580 | } | |||
581 | ||||
582 | inline DataRefImpl RelocationRef::getRawDataRefImpl() const { | |||
583 | return RelocationPimpl; | |||
584 | } | |||
585 | ||||
586 | inline const ObjectFile *RelocationRef::getObject() const { | |||
587 | return OwningObject; | |||
588 | } | |||
589 | ||||
590 | } // end namespace object | |||
591 | ||||
592 | template <> struct DenseMapInfo<object::SectionRef> { | |||
593 | static bool isEqual(const object::SectionRef &A, | |||
594 | const object::SectionRef &B) { | |||
595 | return A == B; | |||
596 | } | |||
597 | static object::SectionRef getEmptyKey() { | |||
598 | return object::SectionRef({}, nullptr); | |||
599 | } | |||
600 | static object::SectionRef getTombstoneKey() { | |||
601 | object::DataRefImpl TS; | |||
602 | TS.p = (uintptr_t)-1; | |||
603 | return object::SectionRef(TS, nullptr); | |||
604 | } | |||
605 | static unsigned getHashValue(const object::SectionRef &Sec) { | |||
606 | object::DataRefImpl Raw = Sec.getRawDataRefImpl(); | |||
607 | return hash_combine(Raw.p, Raw.d.a, Raw.d.b); | |||
608 | } | |||
609 | }; | |||
610 | ||||
611 | } // end namespace llvm | |||
612 | ||||
613 | #endif // LLVM_OBJECT_OBJECTFILE_H |