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