Bug Summary

File:llvm/tools/obj2yaml/macho2yaml.cpp
Warning:line 317, column 17
Value stored to 'EndPtr' during its initialization is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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