File: | tools/obj2yaml/macho2yaml.cpp |
Warning: | line 210, column 17 Value stored to 'EndPtr' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===------ macho2yaml.cpp - obj2yaml conversion tool -----------*- C++ -*-===// |
2 | // |
3 | // The LLVM Compiler Infrastructure |
4 | // |
5 | // This file is distributed under the University of Illinois Open Source |
6 | // License. See LICENSE.TXT for details. |
7 | // |
8 | //===----------------------------------------------------------------------===// |
9 | |
10 | #include "Error.h" |
11 | #include "obj2yaml.h" |
12 | #include "llvm/DebugInfo/DWARF/DWARFContext.h" |
13 | #include "llvm/Object/MachOUniversal.h" |
14 | #include "llvm/ObjectYAML/ObjectYAML.h" |
15 | #include "llvm/Support/ErrorHandling.h" |
16 | #include "llvm/Support/LEB128.h" |
17 | |
18 | #include <string.h> // for memcpy |
19 | |
20 | using namespace llvm; |
21 | |
22 | class MachODumper { |
23 | |
24 | template <typename StructType> |
25 | const char *processLoadCommandData( |
26 | MachOYAML::LoadCommand &LC, |
27 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd); |
28 | |
29 | const object::MachOObjectFile &Obj; |
30 | void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y); |
31 | void dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y); |
32 | void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y); |
33 | void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y); |
34 | void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes, |
35 | ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false); |
36 | void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y); |
37 | void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y); |
38 | void dumpDebugAbbrev(DWARFContext &DCtx, |
39 | std::unique_ptr<MachOYAML::Object> &Y); |
40 | void dumpDebugStrings(DWARFContext &DCtx, |
41 | std::unique_ptr<MachOYAML::Object> &Y); |
42 | |
43 | public: |
44 | MachODumper(const object::MachOObjectFile &O) : Obj(O) {} |
45 | Expected<std::unique_ptr<MachOYAML::Object>> dump(); |
46 | }; |
47 | |
48 | #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \ |
49 | case MachO::LCName: \ |
50 | memcpy((void *) & (LC.Data.LCStruct##_data), LoadCmd.Ptr, \ |
51 | sizeof(MachO::LCStruct)); \ |
52 | if (Obj.isLittleEndian() != sys::IsLittleEndianHost) \ |
53 | MachO::swapStruct(LC.Data.LCStruct##_data); \ |
54 | EndPtr = processLoadCommandData<MachO::LCStruct>(LC, LoadCmd); \ |
55 | break; |
56 | |
57 | template <typename SectionType> |
58 | MachOYAML::Section constructSectionCommon(SectionType Sec) { |
59 | MachOYAML::Section TempSec; |
60 | memcpy(reinterpret_cast<void *>(&TempSec.sectname[0]), &Sec.sectname[0], 16); |
61 | memcpy(reinterpret_cast<void *>(&TempSec.segname[0]), &Sec.segname[0], 16); |
62 | TempSec.addr = Sec.addr; |
63 | TempSec.size = Sec.size; |
64 | TempSec.offset = Sec.offset; |
65 | TempSec.align = Sec.align; |
66 | TempSec.reloff = Sec.reloff; |
67 | TempSec.nreloc = Sec.nreloc; |
68 | TempSec.flags = Sec.flags; |
69 | TempSec.reserved1 = Sec.reserved1; |
70 | TempSec.reserved2 = Sec.reserved2; |
71 | TempSec.reserved3 = 0; |
72 | return TempSec; |
73 | } |
74 | |
75 | template <typename SectionType> |
76 | MachOYAML::Section constructSection(SectionType Sec); |
77 | |
78 | template <> MachOYAML::Section constructSection(MachO::section Sec) { |
79 | MachOYAML::Section TempSec = constructSectionCommon(Sec); |
80 | TempSec.reserved3 = 0; |
81 | return TempSec; |
82 | } |
83 | |
84 | template <> MachOYAML::Section constructSection(MachO::section_64 Sec) { |
85 | MachOYAML::Section TempSec = constructSectionCommon(Sec); |
86 | TempSec.reserved3 = Sec.reserved3; |
87 | return TempSec; |
88 | } |
89 | |
90 | template <typename SectionType, typename SegmentType> |
91 | const char * |
92 | extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd, |
93 | std::vector<MachOYAML::Section> &Sections, |
94 | bool IsLittleEndian) { |
95 | auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize; |
96 | const SectionType *Curr = |
97 | reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType)); |
98 | for (; reinterpret_cast<const void *>(Curr) < End; Curr++) { |
99 | if (IsLittleEndian != sys::IsLittleEndianHost) { |
100 | SectionType Sec; |
101 | memcpy((void *)&Sec, Curr, sizeof(SectionType)); |
102 | MachO::swapStruct(Sec); |
103 | Sections.push_back(constructSection(Sec)); |
104 | } else { |
105 | Sections.push_back(constructSection(*Curr)); |
106 | } |
107 | } |
108 | return reinterpret_cast<const char *>(Curr); |
109 | } |
110 | |
111 | template <typename StructType> |
112 | const char *MachODumper::processLoadCommandData( |
113 | MachOYAML::LoadCommand &LC, |
114 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
115 | return LoadCmd.Ptr + sizeof(StructType); |
116 | } |
117 | |
118 | template <> |
119 | const char *MachODumper::processLoadCommandData<MachO::segment_command>( |
120 | MachOYAML::LoadCommand &LC, |
121 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
122 | return extractSections<MachO::section, MachO::segment_command>( |
123 | LoadCmd, LC.Sections, Obj.isLittleEndian()); |
124 | } |
125 | |
126 | template <> |
127 | const char *MachODumper::processLoadCommandData<MachO::segment_command_64>( |
128 | MachOYAML::LoadCommand &LC, |
129 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
130 | return extractSections<MachO::section_64, MachO::segment_command_64>( |
131 | LoadCmd, LC.Sections, Obj.isLittleEndian()); |
132 | } |
133 | |
134 | template <typename StructType> |
135 | const char * |
136 | readString(MachOYAML::LoadCommand &LC, |
137 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
138 | auto Start = LoadCmd.Ptr + sizeof(StructType); |
139 | auto MaxSize = LoadCmd.C.cmdsize - sizeof(StructType); |
140 | auto Size = strnlen(Start, MaxSize); |
141 | LC.PayloadString = StringRef(Start, Size).str(); |
142 | return Start + Size; |
143 | } |
144 | |
145 | template <> |
146 | const char *MachODumper::processLoadCommandData<MachO::dylib_command>( |
147 | MachOYAML::LoadCommand &LC, |
148 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
149 | return readString<MachO::dylib_command>(LC, LoadCmd); |
150 | } |
151 | |
152 | template <> |
153 | const char *MachODumper::processLoadCommandData<MachO::dylinker_command>( |
154 | MachOYAML::LoadCommand &LC, |
155 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
156 | return readString<MachO::dylinker_command>(LC, LoadCmd); |
157 | } |
158 | |
159 | template <> |
160 | const char *MachODumper::processLoadCommandData<MachO::rpath_command>( |
161 | MachOYAML::LoadCommand &LC, |
162 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
163 | return readString<MachO::rpath_command>(LC, LoadCmd); |
164 | } |
165 | |
166 | template <> |
167 | const char *MachODumper::processLoadCommandData<MachO::build_version_command>( |
168 | MachOYAML::LoadCommand &LC, |
169 | const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) { |
170 | auto Start = LoadCmd.Ptr + sizeof(MachO::build_version_command); |
171 | auto NTools = LC.Data.build_version_command_data.ntools; |
172 | for (unsigned i = 0; i < NTools; ++i) { |
173 | auto Curr = Start + i * sizeof(MachO::build_tool_version); |
174 | MachO::build_tool_version BV; |
175 | memcpy((void *)&BV, Curr, sizeof(MachO::build_tool_version)); |
176 | if (Obj.isLittleEndian() != sys::IsLittleEndianHost) |
177 | MachO::swapStruct(BV); |
178 | LC.Tools.push_back(BV); |
179 | } |
180 | return Start + NTools * sizeof(MachO::build_tool_version); |
181 | } |
182 | |
183 | Expected<std::unique_ptr<MachOYAML::Object>> MachODumper::dump() { |
184 | auto Y = make_unique<MachOYAML::Object>(); |
185 | Y->IsLittleEndian = Obj.isLittleEndian(); |
186 | dumpHeader(Y); |
187 | dumpLoadCommands(Y); |
188 | dumpLinkEdit(Y); |
189 | |
190 | std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj); |
191 | if (auto Err = dwarf2yaml(*DICtx, Y->DWARF)) |
192 | return errorCodeToError(Err); |
193 | return std::move(Y); |
194 | } |
195 | |
196 | void MachODumper::dumpHeader(std::unique_ptr<MachOYAML::Object> &Y) { |
197 | Y->Header.magic = Obj.getHeader().magic; |
198 | Y->Header.cputype = Obj.getHeader().cputype; |
199 | Y->Header.cpusubtype = Obj.getHeader().cpusubtype; |
200 | Y->Header.filetype = Obj.getHeader().filetype; |
201 | Y->Header.ncmds = Obj.getHeader().ncmds; |
202 | Y->Header.sizeofcmds = Obj.getHeader().sizeofcmds; |
203 | Y->Header.flags = Obj.getHeader().flags; |
204 | Y->Header.reserved = 0; |
205 | } |
206 | |
207 | void MachODumper::dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y) { |
208 | for (auto LoadCmd : Obj.load_commands()) { |
209 | MachOYAML::LoadCommand LC; |
210 | const char *EndPtr = LoadCmd.Ptr; |
Value stored to 'EndPtr' during its initialization is never read | |
211 | switch (LoadCmd.C.cmd) { |
212 | default: |
213 | memcpy((void *)&(LC.Data.load_command_data), LoadCmd.Ptr, |
214 | sizeof(MachO::load_command)); |
215 | if (Obj.isLittleEndian() != sys::IsLittleEndianHost) |
216 | MachO::swapStruct(LC.Data.load_command_data); |
217 | EndPtr = processLoadCommandData<MachO::load_command>(LC, LoadCmd); |
218 | break; |
219 | #include "llvm/BinaryFormat/MachO.def" |
220 | } |
221 | auto RemainingBytes = LoadCmd.C.cmdsize - (EndPtr - LoadCmd.Ptr); |
222 | if (!std::all_of(EndPtr, &EndPtr[RemainingBytes], |
223 | [](const char C) { return C == 0; })) { |
224 | LC.PayloadBytes.insert(LC.PayloadBytes.end(), EndPtr, |
225 | &EndPtr[RemainingBytes]); |
226 | RemainingBytes = 0; |
227 | } |
228 | LC.ZeroPadBytes = RemainingBytes; |
229 | Y->LoadCommands.push_back(std::move(LC)); |
230 | } |
231 | } |
232 | |
233 | void MachODumper::dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y) { |
234 | dumpRebaseOpcodes(Y); |
235 | dumpBindOpcodes(Y->LinkEdit.BindOpcodes, Obj.getDyldInfoBindOpcodes()); |
236 | dumpBindOpcodes(Y->LinkEdit.WeakBindOpcodes, |
237 | Obj.getDyldInfoWeakBindOpcodes()); |
238 | dumpBindOpcodes(Y->LinkEdit.LazyBindOpcodes, Obj.getDyldInfoLazyBindOpcodes(), |
239 | true); |
240 | dumpExportTrie(Y); |
241 | dumpSymbols(Y); |
242 | } |
243 | |
244 | void MachODumper::dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y) { |
245 | MachOYAML::LinkEditData &LEData = Y->LinkEdit; |
246 | |
247 | auto RebaseOpcodes = Obj.getDyldInfoRebaseOpcodes(); |
248 | for (auto OpCode = RebaseOpcodes.begin(); OpCode != RebaseOpcodes.end(); |
249 | ++OpCode) { |
250 | MachOYAML::RebaseOpcode RebaseOp; |
251 | RebaseOp.Opcode = |
252 | static_cast<MachO::RebaseOpcode>(*OpCode & MachO::REBASE_OPCODE_MASK); |
253 | RebaseOp.Imm = *OpCode & MachO::REBASE_IMMEDIATE_MASK; |
254 | |
255 | unsigned Count; |
256 | uint64_t ULEB = 0; |
257 | |
258 | switch (RebaseOp.Opcode) { |
259 | case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: |
260 | |
261 | ULEB = decodeULEB128(OpCode + 1, &Count); |
262 | RebaseOp.ExtraData.push_back(ULEB); |
263 | OpCode += Count; |
264 | LLVM_FALLTHROUGH[[clang::fallthrough]]; |
265 | // Intentionally no break here -- This opcode has two ULEB values |
266 | case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: |
267 | case MachO::REBASE_OPCODE_ADD_ADDR_ULEB: |
268 | case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES: |
269 | case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: |
270 | |
271 | ULEB = decodeULEB128(OpCode + 1, &Count); |
272 | RebaseOp.ExtraData.push_back(ULEB); |
273 | OpCode += Count; |
274 | break; |
275 | default: |
276 | break; |
277 | } |
278 | |
279 | LEData.RebaseOpcodes.push_back(RebaseOp); |
280 | |
281 | if (RebaseOp.Opcode == MachO::REBASE_OPCODE_DONE) |
282 | break; |
283 | } |
284 | } |
285 | |
286 | StringRef ReadStringRef(const uint8_t *Start) { |
287 | const uint8_t *Itr = Start; |
288 | for (; *Itr; ++Itr) |
289 | ; |
290 | return StringRef(reinterpret_cast<const char *>(Start), Itr - Start); |
291 | } |
292 | |
293 | void MachODumper::dumpBindOpcodes( |
294 | std::vector<MachOYAML::BindOpcode> &BindOpcodes, |
295 | ArrayRef<uint8_t> OpcodeBuffer, bool Lazy) { |
296 | for (auto OpCode = OpcodeBuffer.begin(); OpCode != OpcodeBuffer.end(); |
297 | ++OpCode) { |
298 | MachOYAML::BindOpcode BindOp; |
299 | BindOp.Opcode = |
300 | static_cast<MachO::BindOpcode>(*OpCode & MachO::BIND_OPCODE_MASK); |
301 | BindOp.Imm = *OpCode & MachO::BIND_IMMEDIATE_MASK; |
302 | |
303 | unsigned Count; |
304 | uint64_t ULEB = 0; |
305 | int64_t SLEB = 0; |
306 | |
307 | switch (BindOp.Opcode) { |
308 | case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: |
309 | ULEB = decodeULEB128(OpCode + 1, &Count); |
310 | BindOp.ULEBExtraData.push_back(ULEB); |
311 | OpCode += Count; |
312 | LLVM_FALLTHROUGH[[clang::fallthrough]]; |
313 | // Intentionally no break here -- this opcode has two ULEB values |
314 | |
315 | case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: |
316 | case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: |
317 | case MachO::BIND_OPCODE_ADD_ADDR_ULEB: |
318 | case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: |
319 | ULEB = decodeULEB128(OpCode + 1, &Count); |
320 | BindOp.ULEBExtraData.push_back(ULEB); |
321 | OpCode += Count; |
322 | break; |
323 | |
324 | case MachO::BIND_OPCODE_SET_ADDEND_SLEB: |
325 | SLEB = decodeSLEB128(OpCode + 1, &Count); |
326 | BindOp.SLEBExtraData.push_back(SLEB); |
327 | OpCode += Count; |
328 | break; |
329 | |
330 | case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: |
331 | BindOp.Symbol = ReadStringRef(OpCode + 1); |
332 | OpCode += BindOp.Symbol.size() + 1; |
333 | break; |
334 | default: |
335 | break; |
336 | } |
337 | |
338 | BindOpcodes.push_back(BindOp); |
339 | |
340 | // Lazy bindings have DONE opcodes between operations, so we need to keep |
341 | // processing after a DONE. |
342 | if (!Lazy && BindOp.Opcode == MachO::BIND_OPCODE_DONE) |
343 | break; |
344 | } |
345 | } |
346 | |
347 | /*! |
348 | * /brief processes a node from the export trie, and its children. |
349 | * |
350 | * To my knowledge there is no documentation of the encoded format of this data |
351 | * other than in the heads of the Apple linker engineers. To that end hopefully |
352 | * this comment and the implementation below can serve to light the way for |
353 | * anyone crazy enough to come down this path in the future. |
354 | * |
355 | * This function reads and preserves the trie structure of the export trie. To |
356 | * my knowledge there is no code anywhere else that reads the data and preserves |
357 | * the Trie. LD64 (sources available at opensource.apple.com) has a similar |
358 | * implementation that parses the export trie into a vector. That code as well |
359 | * as LLVM's libObject MachO implementation were the basis for this. |
360 | * |
361 | * The export trie is an encoded trie. The node serialization is a bit awkward. |
362 | * The below pseudo-code is the best description I've come up with for it. |
363 | * |
364 | * struct SerializedNode { |
365 | * ULEB128 TerminalSize; |
366 | * struct TerminalData { <-- This is only present if TerminalSize > 0 |
367 | * ULEB128 Flags; |
368 | * ULEB128 Address; <-- Present if (! Flags & REEXPORT ) |
369 | * ULEB128 Other; <-- Present if ( Flags & REEXPORT || |
370 | * Flags & STUB_AND_RESOLVER ) |
371 | * char[] ImportName; <-- Present if ( Flags & REEXPORT ) |
372 | * } |
373 | * uint8_t ChildrenCount; |
374 | * Pair<char[], ULEB128> ChildNameOffsetPair[ChildrenCount]; |
375 | * SerializedNode Children[ChildrenCount] |
376 | * } |
377 | * |
378 | * Terminal nodes are nodes that represent actual exports. They can appear |
379 | * anywhere in the tree other than at the root; they do not need to be leaf |
380 | * nodes. When reading the data out of the trie this routine reads it in-order, |
381 | * but it puts the child names and offsets directly into the child nodes. This |
382 | * results in looping over the children twice during serialization and |
383 | * de-serialization, but it makes the YAML representation more human readable. |
384 | * |
385 | * Below is an example of the graph from a "Hello World" executable: |
386 | * |
387 | * ------- |
388 | * | '' | |
389 | * ------- |
390 | * | |
391 | * ------- |
392 | * | '_' | |
393 | * ------- |
394 | * | |
395 | * |----------------------------------------| |
396 | * | | |
397 | * ------------------------ --------------------- |
398 | * | '_mh_execute_header' | | 'main' | |
399 | * | Flags: 0x00000000 | | Flags: 0x00000000 | |
400 | * | Addr: 0x00000000 | | Addr: 0x00001160 | |
401 | * ------------------------ --------------------- |
402 | * |
403 | * This graph represents the trie for the exports "__mh_execute_header" and |
404 | * "_main". In the graph only the "_main" and "__mh_execute_header" nodes are |
405 | * terminal. |
406 | */ |
407 | |
408 | const uint8_t *processExportNode(const uint8_t *CurrPtr, |
409 | const uint8_t *const End, |
410 | MachOYAML::ExportEntry &Entry) { |
411 | if (CurrPtr >= End) |
412 | return CurrPtr; |
413 | unsigned Count = 0; |
414 | Entry.TerminalSize = decodeULEB128(CurrPtr, &Count); |
415 | CurrPtr += Count; |
416 | if (Entry.TerminalSize != 0) { |
417 | Entry.Flags = decodeULEB128(CurrPtr, &Count); |
418 | CurrPtr += Count; |
419 | if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) { |
420 | Entry.Address = 0; |
421 | Entry.Other = decodeULEB128(CurrPtr, &Count); |
422 | CurrPtr += Count; |
423 | Entry.ImportName = std::string(reinterpret_cast<const char *>(CurrPtr)); |
424 | } else { |
425 | Entry.Address = decodeULEB128(CurrPtr, &Count); |
426 | CurrPtr += Count; |
427 | if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) { |
428 | Entry.Other = decodeULEB128(CurrPtr, &Count); |
429 | CurrPtr += Count; |
430 | } else |
431 | Entry.Other = 0; |
432 | } |
433 | } |
434 | uint8_t childrenCount = *CurrPtr++; |
435 | if (childrenCount == 0) |
436 | return CurrPtr; |
437 | |
438 | Entry.Children.insert(Entry.Children.begin(), (size_t)childrenCount, |
439 | MachOYAML::ExportEntry()); |
440 | for (auto &Child : Entry.Children) { |
441 | Child.Name = std::string(reinterpret_cast<const char *>(CurrPtr)); |
442 | CurrPtr += Child.Name.length() + 1; |
443 | Child.NodeOffset = decodeULEB128(CurrPtr, &Count); |
444 | CurrPtr += Count; |
445 | } |
446 | for (auto &Child : Entry.Children) { |
447 | CurrPtr = processExportNode(CurrPtr, End, Child); |
448 | } |
449 | return CurrPtr; |
450 | } |
451 | |
452 | void MachODumper::dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y) { |
453 | MachOYAML::LinkEditData &LEData = Y->LinkEdit; |
454 | auto ExportsTrie = Obj.getDyldInfoExportsTrie(); |
455 | processExportNode(ExportsTrie.begin(), ExportsTrie.end(), LEData.ExportTrie); |
456 | } |
457 | |
458 | template <typename nlist_t> |
459 | MachOYAML::NListEntry constructNameList(const nlist_t &nlist) { |
460 | MachOYAML::NListEntry NL; |
461 | NL.n_strx = nlist.n_strx; |
462 | NL.n_type = nlist.n_type; |
463 | NL.n_sect = nlist.n_sect; |
464 | NL.n_desc = nlist.n_desc; |
465 | NL.n_value = nlist.n_value; |
466 | return NL; |
467 | } |
468 | |
469 | void MachODumper::dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y) { |
470 | MachOYAML::LinkEditData &LEData = Y->LinkEdit; |
471 | |
472 | for (auto Symbol : Obj.symbols()) { |
473 | MachOYAML::NListEntry NLE = |
474 | Obj.is64Bit() |
475 | ? constructNameList<MachO::nlist_64>( |
476 | Obj.getSymbol64TableEntry(Symbol.getRawDataRefImpl())) |
477 | : constructNameList<MachO::nlist>( |
478 | Obj.getSymbolTableEntry(Symbol.getRawDataRefImpl())); |
479 | LEData.NameList.push_back(NLE); |
480 | } |
481 | |
482 | StringRef RemainingTable = Obj.getStringTableData(); |
483 | while (RemainingTable.size() > 0) { |
484 | auto SymbolPair = RemainingTable.split('\0'); |
485 | RemainingTable = SymbolPair.second; |
486 | LEData.StringTable.push_back(SymbolPair.first); |
487 | } |
488 | } |
489 | |
490 | Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj) { |
491 | MachODumper Dumper(Obj); |
492 | Expected<std::unique_ptr<MachOYAML::Object>> YAML = Dumper.dump(); |
493 | if (!YAML) |
494 | return YAML.takeError(); |
495 | |
496 | yaml::YamlObjectFile YAMLFile; |
497 | YAMLFile.MachO = std::move(YAML.get()); |
498 | |
499 | yaml::Output Yout(Out); |
500 | Yout << YAMLFile; |
501 | return Error::success(); |
502 | } |
503 | |
504 | Error macho2yaml(raw_ostream &Out, const object::MachOUniversalBinary &Obj) { |
505 | yaml::YamlObjectFile YAMLFile; |
506 | YAMLFile.FatMachO.reset(new MachOYAML::UniversalBinary()); |
507 | MachOYAML::UniversalBinary &YAML = *YAMLFile.FatMachO; |
508 | YAML.Header.magic = Obj.getMagic(); |
509 | YAML.Header.nfat_arch = Obj.getNumberOfObjects(); |
510 | |
511 | for (auto Slice : Obj.objects()) { |
512 | MachOYAML::FatArch arch; |
513 | arch.cputype = Slice.getCPUType(); |
514 | arch.cpusubtype = Slice.getCPUSubType(); |
515 | arch.offset = Slice.getOffset(); |
516 | arch.size = Slice.getSize(); |
517 | arch.align = Slice.getAlign(); |
518 | arch.reserved = Slice.getReserved(); |
519 | YAML.FatArchs.push_back(arch); |
520 | |
521 | auto SliceObj = Slice.getAsObjectFile(); |
522 | if (!SliceObj) |
523 | return SliceObj.takeError(); |
524 | |
525 | MachODumper Dumper(*SliceObj.get()); |
526 | Expected<std::unique_ptr<MachOYAML::Object>> YAMLObj = Dumper.dump(); |
527 | if (!YAMLObj) |
528 | return YAMLObj.takeError(); |
529 | YAML.Slices.push_back(*YAMLObj.get()); |
530 | } |
531 | |
532 | yaml::Output Yout(Out); |
533 | Yout << YAML; |
534 | return Error::success(); |
535 | } |
536 | |
537 | std::error_code macho2yaml(raw_ostream &Out, const object::Binary &Binary) { |
538 | if (const auto *MachOObj = dyn_cast<object::MachOUniversalBinary>(&Binary)) { |
539 | if (auto Err = macho2yaml(Out, *MachOObj)) { |
540 | return errorToErrorCode(std::move(Err)); |
541 | } |
542 | return obj2yaml_error::success; |
543 | } |
544 | |
545 | if (const auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Binary)) { |
546 | if (auto Err = macho2yaml(Out, *MachOObj)) { |
547 | return errorToErrorCode(std::move(Err)); |
548 | } |
549 | return obj2yaml_error::success; |
550 | } |
551 | |
552 | return obj2yaml_error::unsupported_obj_file_format; |
553 | } |