Movatterモバイル変換

Go to the documentation of this file.

1//===- DylibReader.cpp -------------- TAPI MachO Dylib Reader --*- 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/// Implements the TAPI Reader for Mach-O dynamic libraries.

10///

11//===----------------------------------------------------------------------===//

13#include "llvm/TextAPI/DylibReader.h"

14#include "llvm/ADT/STLExtras.h"

15#include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"

16#include "llvm/DebugInfo/DWARF/DWARFContext.h"

17#include "llvm/Object/Binary.h"

18#include "llvm/Object/MachOUniversal.h"

19#include "llvm/Support/Endian.h"

20#include "llvm/TargetParser/Triple.h"

21#include "llvm/TextAPI/InterfaceFile.h"

22#include "llvm/TextAPI/RecordsSlice.h"

23#include "llvm/TextAPI/TextAPIError.h"

24#include <iomanip>

25#include <set>

26#include <sstream>

27#include <string>

28#include <tuple>

30using namespacellvm;

31using namespacellvm::object;

32using namespacellvm::MachO;

33using namespacellvm::MachO::DylibReader;

35usingTripleVec = std::vector<Triple>;

36statictypename TripleVec::iteratoremplace(TripleVec &Container,Triple &&T) {

37autoI =partition_point(Container, [=](constTriple &CT) {

38return std::forward_as_tuple(CT.getArch(), CT.getOS(),

39 CT.getEnvironment()) <

40 std::forward_as_tuple(T.getArch(),T.getOS(),T.getEnvironment());

41 });

43if (I != Container.end() && *I ==T)

44returnI;

45return Container.emplace(I,T);

46}

48staticTripleVec constructTriples(MachOObjectFile *Obj,

49constArchitecture ArchT) {

50auto getOSVersionStr = [](uint32_t V) {

51PackedVersion OSVersion(V);

52 std::string Vers;

53raw_string_ostream VStream(Vers);

54 VStream << OSVersion;

55return VStream.str();

56 };

57auto getOSVersion = [&](constMachOObjectFile::LoadCommandInfo &cmd) {

58auto Vers = Obj->getVersionMinLoadCommand(cmd);

59return getOSVersionStr(Vers.version);

60 };

62TripleVec Triples;

63bool IsIntel =ArchitectureSet(ArchT).hasX86();

64auto Arch =getArchitectureName(ArchT);

66for (constauto &cmd : Obj->load_commands()) {

67 std::string OSVersion;

68switch (cmd.C.cmd) {

69case MachO::LC_VERSION_MIN_MACOSX:

70 OSVersion = getOSVersion(cmd);

71emplace(Triples, {Arch,"apple","macos" + OSVersion});

72break;

73case MachO::LC_VERSION_MIN_IPHONEOS:

74 OSVersion = getOSVersion(cmd);

75if (IsIntel)

76emplace(Triples, {Arch,"apple","ios" + OSVersion,"simulator"});

77else

78emplace(Triples, {Arch,"apple","ios" + OSVersion});

79break;

80case MachO::LC_VERSION_MIN_TVOS:

81 OSVersion = getOSVersion(cmd);

82if (IsIntel)

83emplace(Triples, {Arch,"apple","tvos" + OSVersion,"simulator"});

84else

85emplace(Triples, {Arch,"apple","tvos" + OSVersion});

86break;

87case MachO::LC_VERSION_MIN_WATCHOS:

88 OSVersion = getOSVersion(cmd);

89if (IsIntel)

90emplace(Triples, {Arch,"apple","watchos" + OSVersion,"simulator"});

91else

92emplace(Triples, {Arch,"apple","watchos" + OSVersion});

93break;

94case MachO::LC_BUILD_VERSION: {

95 OSVersion = getOSVersionStr(Obj->getBuildVersionLoadCommand(cmd).minos);

96switch (Obj->getBuildVersionLoadCommand(cmd).platform) {

97case MachO::PLATFORM_MACOS:

98emplace(Triples, {Arch,"apple","macos" + OSVersion});

99break;

100case MachO::PLATFORM_IOS:

101emplace(Triples, {Arch,"apple","ios" + OSVersion});

102break;

103case MachO::PLATFORM_TVOS:

104emplace(Triples, {Arch,"apple","tvos" + OSVersion});

105break;

106case MachO::PLATFORM_WATCHOS:

107emplace(Triples, {Arch,"apple","watchos" + OSVersion});

108break;

109case MachO::PLATFORM_BRIDGEOS:

110emplace(Triples, {Arch,"apple","bridgeos" + OSVersion});

111break;

112case MachO::PLATFORM_MACCATALYST:

113emplace(Triples, {Arch,"apple","ios" + OSVersion,"macabi"});

114break;

115case MachO::PLATFORM_IOSSIMULATOR:

116emplace(Triples, {Arch,"apple","ios" + OSVersion,"simulator"});

117break;

118case MachO::PLATFORM_TVOSSIMULATOR:

119emplace(Triples, {Arch,"apple","tvos" + OSVersion,"simulator"});

120break;

121case MachO::PLATFORM_WATCHOSSIMULATOR:

122emplace(Triples, {Arch,"apple","watchos" + OSVersion,"simulator"});

123break;

124case MachO::PLATFORM_DRIVERKIT:

125emplace(Triples, {Arch,"apple","driverkit" + OSVersion});

126break;

127default:

128break;// Skip any others.

129 }

130break;

131 }

132default:

133break;

134 }

135 }

136

137// Record unknown platform for older binaries that don't enforce platform

138// load commands.

139if (Triples.empty())

140emplace(Triples, {Arch,"apple","unknown"});

141

142return Triples;

143}

144

145staticError readMachOHeader(MachOObjectFile *Obj,RecordsSlice &Slice) {

146autoH = Obj->getHeader();

147auto &BA =Slice.getBinaryAttrs();

148

149switch (H.filetype) {

150default:

151llvm_unreachable("unsupported binary type");

152caseMachO::MH_DYLIB:

153 BA.File = FileType::MachO_DynamicLibrary;

154break;

155caseMachO::MH_DYLIB_STUB:

156 BA.File = FileType::MachO_DynamicLibrary_Stub;

157break;

158caseMachO::MH_BUNDLE:

159 BA.File = FileType::MachO_Bundle;

160break;

161 }

162

163if (H.flags &MachO::MH_TWOLEVEL)

164 BA.TwoLevelNamespace =true;

165if (H.flags &MachO::MH_APP_EXTENSION_SAFE)

166 BA.AppExtensionSafe =true;

167

168for (constauto &LCI : Obj->load_commands()) {

169switch (LCI.C.cmd) {

170case MachO::LC_ID_DYLIB: {

171auto DLLC = Obj->getDylibIDLoadCommand(LCI);

172 BA.InstallName =Slice.copyString(LCI.Ptr + DLLC.dylib.name);

173 BA.CurrentVersion = DLLC.dylib.current_version;

174 BA.CompatVersion = DLLC.dylib.compatibility_version;

175break;

176 }

177case MachO::LC_REEXPORT_DYLIB: {

178auto DLLC = Obj->getDylibIDLoadCommand(LCI);

179 BA.RexportedLibraries.emplace_back(

180Slice.copyString(LCI.Ptr + DLLC.dylib.name));

181break;

182 }

183case MachO::LC_SUB_FRAMEWORK: {

184auto SFC = Obj->getSubFrameworkCommand(LCI);

185 BA.ParentUmbrella =Slice.copyString(LCI.Ptr + SFC.umbrella);

186break;

187 }

188case MachO::LC_SUB_CLIENT: {

189auto SCLC = Obj->getSubClientCommand(LCI);

190 BA.AllowableClients.emplace_back(Slice.copyString(LCI.Ptr + SCLC.client));

191break;

192 }

193case MachO::LC_UUID: {

194auto UUIDLC = Obj->getUuidCommand(LCI);

195 std::stringstream Stream;

196for (unsignedI = 0;I < 16; ++I) {

197if (I == 4 ||I == 6 ||I == 8 ||I == 10)

198 Stream <<'-';

199 Stream << std::setfill('0') << std::setw(2) << std::uppercase

200 << std::hex << static_cast<int>(UUIDLC.uuid[I]);

201 }

202 BA.UUID =Slice.copyString(Stream.str());

203break;

204 }

205case MachO::LC_RPATH: {

206auto RPLC = Obj->getRpathCommand(LCI);

207 BA.RPaths.emplace_back(Slice.copyString(LCI.Ptr + RPLC.path));

208break;

209 }

210case MachO::LC_SEGMENT_SPLIT_INFO: {

211auto SSILC = Obj->getLinkeditDataLoadCommand(LCI);

212if (SSILC.datasize == 0)

213 BA.OSLibNotForSharedCache =true;

214break;

215 }

216default:

217break;

218 }

219 }

220

221for (auto &Sect : Obj->sections()) {

222auto SectName = Sect.getName();

223if (!SectName)

224return SectName.takeError();

225if (*SectName !="__objc_imageinfo" && *SectName !="__image_info")

226continue;

227

228autoContent = Sect.getContents();

229if (!Content)

230returnContent.takeError();

231

232if ((Content->size() >= 8) && (Content->front() == 0)) {

233uint32_t Flags;

234if (Obj->isLittleEndian()) {

235auto *p =

236reinterpret_cast<constsupport::ulittle32_t *>(Content->data() + 4);

237 Flags = *p;

238 }else {

239auto *p =

240reinterpret_cast<constsupport::ubig32_t *>(Content->data() + 4);

241 Flags = *p;

242 }

243 BA.SwiftABI = (Flags >> 8) & 0xFF;

244 }

245 }

246returnError::success();

247}

248

249staticError readSymbols(MachOObjectFile *Obj,RecordsSlice &Slice,

250constParseOption &Opt) {

251

252auto parseExport = [](constauto ExportFlags,

253autoAddr) -> std::tuple<SymbolFlags, RecordLinkage> {

254SymbolFlags Flags = SymbolFlags::None;

255switch (ExportFlags &MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK) {

256caseMachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR:

257if (ExportFlags &MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION)

258 Flags |= SymbolFlags::WeakDefined;

259break;

260caseMachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL:

261 Flags |= SymbolFlags::ThreadLocalValue;

262break;

263 }

264

265RecordLinkage Linkage = (ExportFlags &MachO::EXPORT_SYMBOL_FLAGS_REEXPORT)

266 ? RecordLinkage::Rexported

267 : RecordLinkage::Exported;

268return {Flags, Linkage};

269 };

270

271Error Err =Error::success();

272

273StringMap<std::pair<SymbolFlags, RecordLinkage>> Exports;

274// Collect symbols from export trie first. Sometimes, there are more exports

275// in the trie than in n-list due to stripping. This is common for swift

276// mangled symbols.

277for (auto &Sym : Obj->exports(Err)) {

278auto [Flags, Linkage] = parseExport(Sym.flags(),Sym.address());

279Slice.addRecord(Sym.name(), Flags, GlobalRecord::Kind::Unknown, Linkage);

280 Exports[Sym.name()] = {Flags, Linkage};

281 }

282

283for (constauto &Sym : Obj->symbols()) {

284auto FlagsOrErr =Sym.getFlags();

285if (!FlagsOrErr)

286return FlagsOrErr.takeError();

287auto Flags = *FlagsOrErr;

288

289auto NameOrErr =Sym.getName();

290if (!NameOrErr)

291return NameOrErr.takeError();

292autoName = *NameOrErr;

293

294RecordLinkage Linkage = RecordLinkage::Unknown;

295SymbolFlags RecordFlags = SymbolFlags::None;

296

297if (Flags & SymbolRef::SF_Undefined) {

298if (Opt.Undefineds)

299 Linkage = RecordLinkage::Undefined;

300else

301continue;

302if (Flags & SymbolRef::SF_Weak)

303 RecordFlags |= SymbolFlags::WeakReferenced;

304 }elseif (Flags & SymbolRef::SF_Exported) {

305auto Exp = Exports.find(Name);

306// This should never be possible when binaries are produced with Apple

307// linkers. However it is possible to craft dylibs where the export trie

308// is either malformed or has conflicting symbols compared to n_list.

309if (Exp != Exports.end())

310 std::tie(RecordFlags, Linkage) = Exp->second;

311else

312 Linkage = RecordLinkage::Exported;

313 }elseif (Flags & SymbolRef::SF_Hidden) {

314 Linkage = RecordLinkage::Internal;

315 }else

316continue;

317

318auto TypeOrErr =Sym.getType();

319if (!TypeOrErr)

320return TypeOrErr.takeError();

321autoType = *TypeOrErr;

322

323GlobalRecord::Kind GV = (Type &SymbolRef::ST_Function)

324 ? GlobalRecord::Kind::Function

325 : GlobalRecord::Kind::Variable;

326

327if (GV == GlobalRecord::Kind::Function)

328 RecordFlags |= SymbolFlags::Text;

329else

330 RecordFlags |= SymbolFlags::Data;

331

332Slice.addRecord(Name, RecordFlags, GV, Linkage);

333 }

334return Err;

335}

336

337staticError load(MachOObjectFile *Obj,RecordsSlice &Slice,

338constParseOption &Opt,constArchitecture Arch) {

339if (Arch ==AK_unknown)

340return make_error<TextAPIError>(TextAPIErrorCode::UnsupportedTarget);

341

342if (Opt.MachOHeader)

343if (auto Err =readMachOHeader(Obj,Slice))

344return Err;

345

346if (Opt.SymbolTable)

347if (auto Err =readSymbols(Obj,Slice, Opt))

348return Err;

349

350returnError::success();

351}

352

353Expected<Records>DylibReader::readFile(MemoryBufferRef Buffer,

354constParseOption &Opt) {

355Records Results;

356

357auto BinOrErr =createBinary(Buffer);

358if (!BinOrErr)

359return BinOrErr.takeError();

360

361Binary &Bin = *BinOrErr.get();

362if (auto *Obj = dyn_cast<MachOObjectFile>(&Bin)) {

363constauto Arch =getArchitectureFromCpuType(Obj->getHeader().cputype,

364 Obj->getHeader().cpusubtype);

365if (!Opt.Archs.has(Arch))

366return make_error<TextAPIError>(TextAPIErrorCode::NoSuchArchitecture);

367

368auto Triples =constructTriples(Obj, Arch);

369for (constauto &T : Triples) {

370if (mapToPlatformType(T) == PLATFORM_UNKNOWN)

371return make_error<TextAPIError>(TextAPIErrorCode::UnsupportedTarget);

372Results.emplace_back(std::make_shared<RecordsSlice>(RecordsSlice({T})));

373if (auto Err =load(Obj, *Results.back(), Opt, Arch))

374return std::move(Err);

375Results.back()->getBinaryAttrs().Path = Buffer.getBufferIdentifier();

376 }

377returnResults;

378 }

379

380// Only expect MachO universal binaries at this point.

381assert(isa<MachOUniversalBinary>(&Bin) &&

382"Expected a MachO universal binary.");

383auto *UB = cast<MachOUniversalBinary>(&Bin);

384

385for (auto OI = UB->begin_objects(), OE = UB->end_objects(); OI != OE; ++OI) {

386// Skip architecture if not requested.

387auto Arch =

388getArchitectureFromCpuType(OI->getCPUType(), OI->getCPUSubType());

389if (!Opt.Archs.has(Arch))

390continue;

391

392// Skip unknown architectures.

393if (Arch ==AK_unknown)

394continue;

395

396// This can fail if the object is an archive.

397auto ObjOrErr = OI->getAsObjectFile();

398

399// Skip the archive and consume the error.

400if (!ObjOrErr) {

401consumeError(ObjOrErr.takeError());

402continue;

403 }

404

405auto &Obj = *ObjOrErr.get();

406switch (Obj.getHeader().filetype) {

407default:

408break;

409caseMachO::MH_BUNDLE:

410caseMachO::MH_DYLIB:

411caseMachO::MH_DYLIB_STUB:

412for (constauto &T :constructTriples(&Obj, Arch)) {

413Results.emplace_back(std::make_shared<RecordsSlice>(RecordsSlice({T})));

414if (auto Err =load(&Obj, *Results.back(), Opt, Arch))

415return std::move(Err);

416Results.back()->getBinaryAttrs().Path = Buffer.getBufferIdentifier();

417 }

418break;

419 }

420 }

421

422if (Results.empty())

423return make_error<TextAPIError>(TextAPIErrorCode::EmptyResults);

424returnResults;

425}

426

427Expected<std::unique_ptr<InterfaceFile>>

428DylibReader::get(MemoryBufferRef Buffer) {

429ParseOption Options;

430auto SlicesOrErr =readFile(Buffer,Options);

431if (!SlicesOrErr)

432return SlicesOrErr.takeError();

433

434returnconvertToInterfaceFile(*SlicesOrErr);

435}

436

437staticvoidDWARFErrorHandler(Error Err) {/**/ }

438

439staticSymbolToSourceLocMap

440accumulateLocs(MachOObjectFile &Obj,

441const std::unique_ptr<DWARFContext> &DiCtx) {

442SymbolToSourceLocMap LocMap;

443for (constauto &Symbol : Obj.symbols()) {

444Expected<uint32_t> FlagsOrErr =Symbol.getFlags();

445if (!FlagsOrErr) {

446consumeError(FlagsOrErr.takeError());

447continue;

448 }

449

450if (!(*FlagsOrErr & SymbolRef::SF_Exported))

451continue;

452

453Expected<uint64_t> AddressOrErr =Symbol.getAddress();

454if (!AddressOrErr) {

455consumeError(AddressOrErr.takeError());

456continue;

457 }

458constuint64_t Address = *AddressOrErr;

459

460auto TypeOrErr =Symbol.getType();

461if (!TypeOrErr) {

462consumeError(TypeOrErr.takeError());

463continue;

464 }

465constbool IsCode = (*TypeOrErr &SymbolRef::ST_Function);

466

467auto *DWARFCU = IsCode ? DiCtx->getCompileUnitForCodeAddress(Address)

468 : DiCtx->getCompileUnitForDataAddress(Address);

469if (!DWARFCU)

470continue;

471

472constDWARFDie &DIE = IsCode ? DWARFCU->getSubroutineForAddress(Address)

473 : DWARFCU->getVariableForAddress(Address);

474const std::string File =DIE.getDeclFile(

475 llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath);

476constuint64_t Line =DIE.getDeclLine();

477

478auto NameOrErr =Symbol.getName();

479if (!NameOrErr) {

480consumeError(NameOrErr.takeError());

481continue;

482 }

483autoName = *NameOrErr;

484autoSym =parseSymbol(Name);

485

486if (!File.empty() && Line != 0)

487LocMap.insert({Sym.Name,RecordLoc(File, Line)});

488 }

489

490returnLocMap;

491}

492

493SymbolToSourceLocMap

494DylibReader::accumulateSourceLocFromDSYM(constStringRef DSYM,

495constTarget &T) {

496// Find sidecar file.

497auto DSYMsOrErr =MachOObjectFile::findDsymObjectMembers(DSYM);

498if (!DSYMsOrErr) {

499consumeError(DSYMsOrErr.takeError());

500returnSymbolToSourceLocMap();

501 }

502if (DSYMsOrErr->empty())

503returnSymbolToSourceLocMap();

504

505constStringRef Path = DSYMsOrErr->front();

506auto BufOrErr =MemoryBuffer::getFile(Path);

507if (auto Err = BufOrErr.getError())

508returnSymbolToSourceLocMap();

509

510auto BinOrErr =createBinary(*BufOrErr.get());

511if (!BinOrErr) {

512consumeError(BinOrErr.takeError());

513returnSymbolToSourceLocMap();

514 }

515// Handle single arch.

516if (auto *Single = dyn_cast<MachOObjectFile>(BinOrErr->get())) {

517auto DiCtx =DWARFContext::create(

518 *Single, DWARFContext::ProcessDebugRelocations::Process,nullptr,"",

519DWARFErrorHandler,DWARFErrorHandler);

520

521returnaccumulateLocs(*Single, DiCtx);

522 }

523// Handle universal companion file.

524if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get())) {

525auto ObjForArch = Fat->getObjectForArch(getArchitectureName(T.Arch));

526if (!ObjForArch) {

527consumeError(ObjForArch.takeError());

528returnSymbolToSourceLocMap();

529 }

530auto MachOOrErr = ObjForArch->getAsObjectFile();

531if (!MachOOrErr) {

532consumeError(MachOOrErr.takeError());

533returnSymbolToSourceLocMap();

534 }

535auto &Obj = **MachOOrErr;

536auto DiCtx =DWARFContext::create(

537 Obj, DWARFContext::ProcessDebugRelocations::Process,nullptr,"",

538DWARFErrorHandler,DWARFErrorHandler);

539

540returnaccumulateLocs(Obj, DiCtx);

541 }

542returnSymbolToSourceLocMap();

543}

load

AMDGPU Mark last scratch load

Definition:AMDGPUMarkLastScratchLoad.cpp:142

Results

Function Alias Analysis Results

Definition:AliasAnalysis.cpp:731

static TripleVec::iterator emplace(TripleVec &Container, Triple &&T)

Definition:DylibReader.cpp:36

accumulateLocs

static SymbolToSourceLocMap accumulateLocs(MachOObjectFile &Obj, const std::unique_ptr< DWARFContext > &DiCtx)

Definition:DylibReader.cpp:440

readSymbols

static Error readSymbols(MachOObjectFile *Obj, RecordsSlice &Slice, const ParseOption &Opt)

Definition:DylibReader.cpp:249

readMachOHeader

static Error readMachOHeader(MachOObjectFile *Obj, RecordsSlice &Slice)

Definition:DylibReader.cpp:145

constructTriples

static TripleVec constructTriples(MachOObjectFile *Obj, const Architecture ArchT)

Definition:DylibReader.cpp:48

TripleVec

std::vector< Triple > TripleVec

Definition:DylibReader.cpp:35

DWARFErrorHandler

static void DWARFErrorHandler(Error Err)

Definition:DylibReader.cpp:437

DylibReader.h

Content

T Content

Definition:ELFObjHandler.cpp:89

Addr

uint64_t Addr

Definition:ELFObjHandler.cpp:79

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Sym

Symbol * Sym

Definition:ELF_riscv.cpp:479

Endian.h

InterfaceFile.h

Options

static LVOptions Options

Definition:LVOptions.cpp:25

LocMap

IntervalMap< SlotIndex, DbgVariableValue, 4 > LocMap

Map of where a user value is live to that value.

Definition:LiveDebugVariables.cpp:265

#define I(x, y, z)

Definition:MD5.cpp:58

#define H(x, y, z)

Definition:MD5.cpp:57

MachOUniversal.h

RecordsSlice.h

Implements the TAPI Record Collection Type.

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

Address

@ Address

Definition:SPIRVEmitNonSemanticDI.cpp:68

STLExtras.h

This file contains some templates that are useful if you are working with the STL at all.

TextAPIError.h

Define TAPI specific error codes.

Triple.h

llvm::DIE

A structured debug information entry.

Definition:DIE.h:819

llvm::DWARFContext::create

static std::unique_ptr< DWARFContext > create(const object::ObjectFile &Obj, ProcessDebugRelocations RelocAction=ProcessDebugRelocations::Process, const LoadedObjectInfo *L=nullptr, std::string DWPName="", std::function< void(Error)> RecoverableErrorHandler=WithColor::defaultErrorHandler, std::function< void(Error)> WarningHandler=WithColor::defaultWarningHandler, bool ThreadSafe=false)

Definition:DWARFContext.cpp:2442

llvm::DWARFDie

Utility class that carries the DWARF compile/type unit and the debug info entry in an object.

Definition:DWARFDie.h:42

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::Function::empty

bool empty() const

Definition:Function.h:859

llvm::Function::back

const BasicBlock & back() const

Definition:Function.h:862

llvm::IntervalMap

Definition:IntervalMap.h:936

llvm::IntervalMap::insert

void insert(KeyT a, KeyT b, ValT y)

insert - Add a mapping of [a;b] to y, coalesce with adjacent intervals.

Definition:IntervalMap.h:1129

llvm::MachO::ArchitectureSet

Definition:ArchitectureSet.h:29

llvm::MachO::ArchitectureSet::has

bool has(Architecture Arch) const

Definition:ArchitectureSet.h:56

llvm::MachO::ArchitectureSet::hasX86

bool hasX86() const

Definition:ArchitectureSet.h:70

llvm::MachO::GlobalRecord::Kind

Kind

Definition:Record.h:121

llvm::MachO::PackedVersion

Definition:PackedVersion.h:27

llvm::MachO::RecordsSlice

Definition:RecordsSlice.h:28

llvm::MachO::Symbol

Definition:Symbol.h:96

llvm::MachO::Symbol::getFlags

SymbolFlags getFlags() const

Definition:Symbol.h:107

llvm::MachO::Symbol::getName

StringRef getName() const

Definition:Symbol.h:103

llvm::MachO::Target

Definition:Target.h:28

llvm::MemoryBufferRef

Definition:MemoryBufferRef.h:22

llvm::MemoryBufferRef::getBufferIdentifier

StringRef getBufferIdentifier() const

Definition:MemoryBufferRef.h:33

llvm::MemoryBuffer::getFile

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

Definition:MemoryBuffer.cpp:260

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringMap

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

Definition:StringMap.h:128

llvm::StringMap::end

iterator end()

Definition:StringMap.h:220

llvm::StringMap::find

iterator find(StringRef Key)

Definition:StringMap.h:233

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition:Triple.h:44

llvm::Triple::getOS

OSType getOS() const

Get the parsed operating system type of this triple.

Definition:Triple.h:404

llvm::Triple::getArch

ArchType getArch() const

Get the parsed architecture type of this triple.

Definition:Triple.h:395

llvm::Triple::getEnvironment

EnvironmentType getEnvironment() const

Get the parsed environment type of this triple.

Definition:Triple.h:412

llvm::Type

The instances of the Type class are immutable: once they are created, they are never changed.

Definition:Type.h:45

llvm::object::Binary

Definition:Binary.h:32

llvm::object::Binary::isLittleEndian

bool isLittleEndian() const

Definition:Binary.h:155

llvm::object::MachOObjectFile

Definition:MachO.h:406

llvm::object::MachOObjectFile::getSubClientCommand

MachO::sub_client_command getSubClientCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4754

llvm::object::MachOObjectFile::exports

iterator_range< export_iterator > exports(Error &Err) const

For use iterating over all exported symbols.

Definition:MachOObjectFile.cpp:3240

llvm::object::MachOObjectFile::getBuildVersionLoadCommand

MachO::build_version_command getBuildVersionLoadCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4684

llvm::object::MachOObjectFile::findDsymObjectMembers

static Expected< std::vector< std::string > > findDsymObjectMembers(StringRef Path)

If the input path is a .dSYM bundle (as created by the dsymutil tool), return the paths to the object...

Definition:MachOObjectFile.cpp:5346

llvm::object::MachOObjectFile::getRpathCommand

MachO::rpath_command getRpathCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4714

llvm::object::MachOObjectFile::getSubFrameworkCommand

MachO::sub_framework_command getSubFrameworkCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4739

llvm::object::MachOObjectFile::getHeader

const MachO::mach_header & getHeader() const

Definition:MachOObjectFile.cpp:4811

llvm::object::MachOObjectFile::load_commands

iterator_range< load_command_iterator > load_commands() const

Definition:MachOObjectFile.cpp:4514

llvm::object::MachOObjectFile::getUuidCommand

MachO::uuid_command getUuidCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4709

llvm::object::MachOObjectFile::getVersionMinLoadCommand

MachO::version_min_command getVersionMinLoadCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4674

llvm::object::MachOObjectFile::getLinkeditDataLoadCommand

MachO::linkedit_data_command getLinkeditDataLoadCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4654

llvm::object::MachOObjectFile::getDylibIDLoadCommand

MachO::dylib_command getDylibIDLoadCommand(const LoadCommandInfo &L) const

Definition:MachOObjectFile.cpp:4694

llvm::object::ObjectFile::sections

section_iterator_range sections() const

Definition:ObjectFile.h:329

llvm::object::ObjectFile::symbols

symbol_iterator_range symbols() const

Definition:ObjectFile.h:321

llvm::object::Slice

Definition:MachOUniversalWriter.h:34

llvm::object::SymbolRef::ST_Function

@ ST_Function

Definition:ObjectFile.h:178

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition:raw_ostream.h:661

llvm::raw_string_ostream::str

std::string & str()

Returns the string's reference.

Definition:raw_ostream.h:679

uint32_t

uint64_t

llvm_unreachable

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

llvm::MachO::DylibReader

Defines the MachO Dynamic Library Reader.

Definition:DylibReader.h:22

llvm::MachO::DylibReader::readFile

Expected< Records > readFile(MemoryBufferRef Buffer, const ParseOption &Opt)

Parse Mach-O dynamic libraries to extract TAPI attributes.

Definition:DylibReader.cpp:353

llvm::MachO::DylibReader::accumulateSourceLocFromDSYM

SymbolToSourceLocMap accumulateSourceLocFromDSYM(const StringRef DSYM, const Target &T)

Get the source location for each symbol from dylib.

Definition:DylibReader.cpp:494

llvm::MachO::DylibReader::SymbolToSourceLocMap

llvm::StringMap< RecordLoc > SymbolToSourceLocMap

Definition:DylibReader.h:47

llvm::MachO::DylibReader::get

Expected< std::unique_ptr< InterfaceFile > > get(MemoryBufferRef Buffer)

Get TAPI file representation of binary dylib.

Definition:DylibReader.cpp:428

llvm::MachO

Definition:MachO.h:25

llvm::MachO::EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL

@ EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL

Definition:MachO.h:300

llvm::MachO::EXPORT_SYMBOL_FLAGS_KIND_REGULAR

@ EXPORT_SYMBOL_FLAGS_KIND_REGULAR

Definition:MachO.h:299

llvm::MachO::RecordLinkage

RecordLinkage

Definition:Record.h:48

llvm::MachO::getArchitectureName

StringRef getArchitectureName(Architecture Arch)

Convert an architecture slice to a string.

Definition:Architecture.cpp:42

llvm::MachO::MH_DYLIB

@ MH_DYLIB

Definition:MachO.h:48

llvm::MachO::MH_DYLIB_STUB

@ MH_DYLIB_STUB

Definition:MachO.h:51

llvm::MachO::MH_BUNDLE

@ MH_BUNDLE

Definition:MachO.h:50

llvm::MachO::Architecture

Architecture

Defines the architecture slices that are supported by Text-based Stub files.

Definition:Architecture.h:27

llvm::MachO::AK_unknown

@ AK_unknown

Definition:Architecture.h:31

llvm::MachO::mapToPlatformType

PlatformType mapToPlatformType(PlatformType Platform, bool WantSim)

Definition:Platform.cpp:21

llvm::MachO::EXPORT_SYMBOL_FLAGS_REEXPORT

@ EXPORT_SYMBOL_FLAGS_REEXPORT

Definition:MachO.h:294

llvm::MachO::EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION

@ EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION

Definition:MachO.h:293

llvm::MachO::EXPORT_SYMBOL_FLAGS_KIND_MASK

@ EXPORT_SYMBOL_FLAGS_KIND_MASK

Definition:MachO.h:292

llvm::MachO::convertToInterfaceFile

std::unique_ptr< InterfaceFile > convertToInterfaceFile(const Records &Slices)

Definition:RecordsSlice.cpp:339

llvm::MachO::parseSymbol

SimpleSymbol parseSymbol(StringRef SymName)

Get symbol classification by parsing the name of a symbol.

Definition:Symbol.cpp:75

llvm::MachO::SymbolFlags

SymbolFlags

Symbol flags.

Definition:Symbol.h:24

llvm::MachO::getArchitectureFromCpuType

Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType)

Convert a CPU Type and Subtype pair to an architecture slice.

Definition:Architecture.cpp:23

llvm::MachO::MH_APP_EXTENSION_SAFE

@ MH_APP_EXTENSION_SAFE

Definition:MachO.h:85

llvm::MachO::MH_TWOLEVEL

@ MH_TWOLEVEL

Definition:MachO.h:67

llvm::object

Definition:DWARFDebugLoc.h:24

llvm::object::createBinary

Expected< std::unique_ptr< Binary > > createBinary(MemoryBufferRef Source, LLVMContext *Context=nullptr, bool InitContent=true)

Create a Binary from Source, autodetecting the file type.

Definition:Binary.cpp:45

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::partition_point

auto partition_point(R &&Range, Predicate P)

Binary search for the first iterator in a range where a predicate is false.

Definition:STLExtras.h:2050

llvm::SubDirectoryType::Bin

@ Bin

llvm::consumeError

void consumeError(Error Err)

Consume a Error without doing anything.

Definition:Error.h:1069

llvm::MachO::DylibReader::ParseOption

Definition:DylibReader.h:24

llvm::MachO::DylibReader::ParseOption::Undefineds

bool Undefineds

Capture undefined symbols too.

Definition:DylibReader.h:32

llvm::MachO::DylibReader::ParseOption::MachOHeader

bool MachOHeader

Capture Mach-O header from binary, primarily load commands.

Definition:DylibReader.h:28

llvm::MachO::DylibReader::ParseOption::SymbolTable

bool SymbolTable

Capture defined symbols out of export trie and n-list.

Definition:DylibReader.h:30

llvm::MachO::DylibReader::ParseOption::Archs

ArchitectureSet Archs

Determines arch slice to parse.

Definition:DylibReader.h:26

llvm::MachO::RecordLoc

Definition:Record.h:31

llvm::MachO::build_version_command::minos

uint32_t minos

Definition:MachO.h:863

llvm::MachO::build_version_command::platform

uint32_t platform

Definition:MachO.h:862

llvm::object::MachOObjectFile::LoadCommandInfo

Definition:MachO.h:408

llvm::support::detail::packed_endian_specific_integral

Definition:Endian.h:217