LLVM  8.0.0svn
RuntimeDyldMachOARM.h
Go to the documentation of this file.
1 //===----- RuntimeDyldMachOARM.h ---- MachO/ARM specific code. ----*- 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 #ifndef LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
11 #define LLVM_LIB_EXECUTIONENGINE_RUNTIMEDYLD_TARGETS_RUNTIMEDYLDMACHOARM_H
12 
13 #include "../RuntimeDyldMachO.h"
14 #include <string>
15 
16 #define DEBUG_TYPE "dyld"
17 
18 namespace llvm {
19 
21  : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
22 private:
24 
25 public:
26 
28 
31  : RuntimeDyldMachOCRTPBase(MM, Resolver) {}
32 
33  unsigned getMaxStubSize() override { return 8; }
34 
35  unsigned getStubAlignment() override { return 4; }
36 
38  auto Flags = RuntimeDyldImpl::getJITSymbolFlags(SR);
39  if (!Flags)
40  return Flags.takeError();
41  Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(SR);
42  return Flags;
43  }
44 
45  uint64_t modifyAddressBasedOnFlags(uint64_t Addr,
46  JITSymbolFlags Flags) const override {
48  Addr |= 0x1;
49  return Addr;
50  }
51 
52  bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset) {
53  auto TargetObjAddr = Sections[SectionID].getObjAddress() + Offset;
54  for (auto &KV : GlobalSymbolTable) {
55  auto &Entry = KV.second;
56  auto SymbolObjAddr =
57  Sections[Entry.getSectionID()].getObjAddress() + Entry.getOffset();
58  if (TargetObjAddr == SymbolObjAddr)
59  return (Entry.getFlags().getTargetFlags() & ARMJITSymbolFlags::Thumb);
60  }
61  return false;
62  }
63 
66  uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
67 
68  switch (RE.RelType) {
69  default:
70  return memcpyAddend(RE);
71  case MachO::ARM_RELOC_BR24: {
72  uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
73  Temp &= 0x00ffffff; // Mask out the opcode.
74  // Now we've got the shifted immediate, shift by 2, sign extend and ret.
75  return SignExtend32<26>(Temp << 2);
76  }
77 
79  // This is a pair of instructions whose operands combine to provide 22
80  // bits of displacement:
81  // Encoding for high bits 1111 0XXX XXXX XXXX
82  // Encoding for low bits 1111 1XXX XXXX XXXX
83  uint16_t HighInsn = readBytesUnaligned(LocalAddress, 2);
84  if ((HighInsn & 0xf800) != 0xf000)
85  return make_error<StringError>("Unrecognized thumb branch encoding "
86  "(BR22 high bits)",
88 
89  uint16_t LowInsn = readBytesUnaligned(LocalAddress + 2, 2);
90  if ((LowInsn & 0xf800) != 0xf800)
91  return make_error<StringError>("Unrecognized thumb branch encoding "
92  "(BR22 low bits)",
94 
95  return SignExtend64<23>(((HighInsn & 0x7ff) << 12) |
96  ((LowInsn & 0x7ff) << 1));
97  }
98  }
99  }
100 
102  processRelocationRef(unsigned SectionID, relocation_iterator RelI,
103  const ObjectFile &BaseObjT,
104  ObjSectionToIDMap &ObjSectionToID,
105  StubMap &Stubs) override {
106  const MachOObjectFile &Obj =
107  static_cast<const MachOObjectFile &>(BaseObjT);
109  Obj.getRelocation(RelI->getRawDataRefImpl());
110  uint32_t RelType = Obj.getAnyRelocationType(RelInfo);
111 
112  // Set to true for thumb functions in this (or previous) TUs.
113  // Will be used to set the TargetIsThumbFunc member on the relocation entry.
114  bool TargetIsLocalThumbFunc = false;
115  if (Obj.getPlainRelocationExternal(RelInfo)) {
116  auto Symbol = RelI->getSymbol();
117  StringRef TargetName;
118  if (auto TargetNameOrErr = Symbol->getName())
119  TargetName = *TargetNameOrErr;
120  else
121  return TargetNameOrErr.takeError();
122 
123  // If the target is external but the value doesn't have a name then we've
124  // converted the value to a section/offset pair, but we still need to set
125  // the IsTargetThumbFunc bit, so look the value up in the globla symbol table.
126  auto EntryItr = GlobalSymbolTable.find(TargetName);
127  if (EntryItr != GlobalSymbolTable.end()) {
128  TargetIsLocalThumbFunc =
129  EntryItr->second.getFlags().getTargetFlags() &
131  }
132  }
133 
134  if (Obj.isRelocationScattered(RelInfo)) {
135  if (RelType == MachO::ARM_RELOC_HALF_SECTDIFF)
136  return processHALFSECTDIFFRelocation(SectionID, RelI, Obj,
137  ObjSectionToID);
138  else if (RelType == MachO::GENERIC_RELOC_VANILLA)
139  return processScatteredVANILLA(SectionID, RelI, Obj, ObjSectionToID,
140  TargetIsLocalThumbFunc);
141  else
142  return ++RelI;
143  }
144 
145  // Sanity check relocation type.
146  switch (RelType) {
153  default:
154  if (RelType > MachO::ARM_RELOC_HALF_SECTDIFF)
155  return make_error<RuntimeDyldError>(("MachO ARM relocation type " +
156  Twine(RelType) +
157  " is out of range").str());
158  break;
159  }
160 
161  RelocationEntry RE(getRelocationEntry(SectionID, Obj, RelI));
162  if (auto AddendOrErr = decodeAddend(RE))
163  RE.Addend = *AddendOrErr;
164  else
165  return AddendOrErr.takeError();
166  RE.IsTargetThumbFunc = TargetIsLocalThumbFunc;
167 
169  if (auto ValueOrErr = getRelocationValueRef(Obj, RelI, RE, ObjSectionToID))
170  Value = *ValueOrErr;
171  else
172  return ValueOrErr.takeError();
173 
174  // If this is a branch from a thumb function (BR22) then make sure we mark
175  // the value as being a thumb stub: we don't want to mix it up with an ARM
176  // stub targeting the same function.
178  Value.IsStubThumb = true;
179 
180  if (RE.IsPCRel)
181  makeValueAddendPCRel(Value, RelI,
182  (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8);
183 
184  // If this is a non-external branch target check whether Value points to a
185  // thumb func.
186  if (!Value.SymbolName && (RelType == MachO::ARM_RELOC_BR24 ||
187  RelType == MachO::ARM_THUMB_RELOC_BR22))
189 
190  if (RE.RelType == MachO::ARM_RELOC_BR24 ||
192  processBranchRelocation(RE, Value, Stubs);
193  else {
194  RE.Addend = Value.Offset;
195  if (Value.SymbolName)
197  else
199  }
200 
201  return ++RelI;
202  }
203 
204  void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override {
206  const SectionEntry &Section = Sections[RE.SectionID];
207  uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
208 
209  // If the relocation is PC-relative, the value to be encoded is the
210  // pointer difference.
211  if (RE.IsPCRel) {
212  uint64_t FinalAddress = Section.getLoadAddressWithOffset(RE.Offset);
213  Value -= FinalAddress;
214  // ARM PCRel relocations have an effective-PC offset of two instructions
215  // (four bytes in Thumb mode, 8 bytes in ARM mode).
216  Value -= (RE.RelType == MachO::ARM_THUMB_RELOC_BR22) ? 4 : 8;
217  }
218 
219  switch (RE.RelType) {
221  Value += RE.Addend;
222  uint16_t HighInsn = readBytesUnaligned(LocalAddress, 2);
223  assert((HighInsn & 0xf800) == 0xf000 &&
224  "Unrecognized thumb branch encoding (BR22 high bits)");
225  HighInsn = (HighInsn & 0xf800) | ((Value >> 12) & 0x7ff);
226 
227  uint16_t LowInsn = readBytesUnaligned(LocalAddress + 2, 2);
228  assert((LowInsn & 0xf800) != 0xf8000 &&
229  "Unrecognized thumb branch encoding (BR22 low bits)");
230  LowInsn = (LowInsn & 0xf800) | ((Value >> 1) & 0x7ff);
231 
232  writeBytesUnaligned(HighInsn, LocalAddress, 2);
233  writeBytesUnaligned(LowInsn, LocalAddress + 2, 2);
234  break;
235  }
236 
238  if (RE.IsTargetThumbFunc)
239  Value |= 0x01;
240  writeBytesUnaligned(Value + RE.Addend, LocalAddress, 1 << RE.Size);
241  break;
242  case MachO::ARM_RELOC_BR24: {
243  // Mask the value into the target address. We know instructions are
244  // 32-bit aligned, so we can do it all at once.
245  Value += RE.Addend;
246  // The low two bits of the value are not encoded.
247  Value >>= 2;
248  // Mask the value to 24 bits.
249  uint64_t FinalValue = Value & 0xffffff;
250  // FIXME: If the destination is a Thumb function (and the instruction
251  // is a non-predicated BL instruction), we need to change it to a BLX
252  // instruction instead.
253 
254  // Insert the value into the instruction.
255  uint32_t Temp = readBytesUnaligned(LocalAddress, 4);
256  writeBytesUnaligned((Temp & ~0xffffff) | FinalValue, LocalAddress, 4);
257 
258  break;
259  }
261  uint64_t SectionABase = Sections[RE.Sections.SectionA].getLoadAddress();
262  uint64_t SectionBBase = Sections[RE.Sections.SectionB].getLoadAddress();
263  assert((Value == SectionABase || Value == SectionBBase) &&
264  "Unexpected HALFSECTDIFF relocation value.");
265  Value = SectionABase - SectionBBase + RE.Addend;
266  if (RE.Size & 0x1) // :upper16:
267  Value = (Value >> 16);
268 
269  bool IsThumb = RE.Size & 0x2;
270 
271  Value &= 0xffff;
272 
273  uint32_t Insn = readBytesUnaligned(LocalAddress, 4);
274 
275  if (IsThumb)
276  Insn = (Insn & 0x8f00fbf0) | ((Value & 0xf000) >> 12) |
277  ((Value & 0x0800) >> 1) | ((Value & 0x0700) << 20) |
278  ((Value & 0x00ff) << 16);
279  else
280  Insn = (Insn & 0xfff0f000) | ((Value & 0xf000) << 4) | (Value & 0x0fff);
281  writeBytesUnaligned(Insn, LocalAddress, 4);
282  break;
283  }
284 
285  default:
286  llvm_unreachable("Invalid relocation type");
287  }
288  }
289 
290  Error finalizeSection(const ObjectFile &Obj, unsigned SectionID,
291  const SectionRef &Section) {
292  StringRef Name;
293  Section.getName(Name);
294 
295  if (Name == "__nl_symbol_ptr")
296  return populateIndirectSymbolPointersSection(cast<MachOObjectFile>(Obj),
297  Section, SectionID);
298  return Error::success();
299  }
300 
301 private:
302 
303  void processBranchRelocation(const RelocationEntry &RE,
304  const RelocationValueRef &Value,
305  StubMap &Stubs) {
306  // This is an ARM branch relocation, need to use a stub function.
307  // Look up for existing stub.
309  RuntimeDyldMachO::StubMap::const_iterator i = Stubs.find(Value);
310  uint8_t *Addr;
311  if (i != Stubs.end()) {
312  Addr = Section.getAddressWithOffset(i->second);
313  } else {
314  // Create a new stub function.
315  assert(Section.getStubOffset() % 4 == 0 && "Misaligned stub");
316  Stubs[Value] = Section.getStubOffset();
317  uint32_t StubOpcode = 0;
318  if (RE.RelType == MachO::ARM_RELOC_BR24)
319  StubOpcode = 0xe51ff004; // ldr pc, [pc, #-4]
320  else if (RE.RelType == MachO::ARM_THUMB_RELOC_BR22)
321  StubOpcode = 0xf000f8df; // ldr pc, [pc]
322  else
323  llvm_unreachable("Unrecognized relocation");
324  Addr = Section.getAddressWithOffset(Section.getStubOffset());
325  writeBytesUnaligned(StubOpcode, Addr, 4);
326  uint8_t *StubTargetAddr = Addr + 4;
327  RelocationEntry StubRE(
328  RE.SectionID, StubTargetAddr - Section.getAddress(),
329  MachO::GENERIC_RELOC_VANILLA, Value.Offset, false, 2);
331  if (Value.SymbolName)
332  addRelocationForSymbol(StubRE, Value.SymbolName);
333  else
334  addRelocationForSection(StubRE, Value.SectionID);
336  }
337  RelocationEntry TargetRE(RE.SectionID, RE.Offset, RE.RelType, 0,
338  RE.IsPCRel, RE.Size);
339  resolveRelocation(TargetRE, (uint64_t)Addr);
340  }
341 
343  processHALFSECTDIFFRelocation(unsigned SectionID, relocation_iterator RelI,
344  const ObjectFile &BaseTObj,
345  ObjSectionToIDMap &ObjSectionToID) {
346  const MachOObjectFile &MachO =
347  static_cast<const MachOObjectFile&>(BaseTObj);
349  MachO.getRelocation(RelI->getRawDataRefImpl());
350 
351  // For a half-diff relocation the length bits actually record whether this
352  // is a movw/movt, and whether this is arm or thumb.
353  // Bit 0 indicates movw (b0 == 0) or movt (b0 == 1).
354  // Bit 1 indicates arm (b1 == 0) or thumb (b1 == 1).
355  unsigned HalfDiffKindBits = MachO.getAnyRelocationLength(RE);
356  bool IsThumb = HalfDiffKindBits & 0x2;
357 
358  SectionEntry &Section = Sections[SectionID];
359  uint32_t RelocType = MachO.getAnyRelocationType(RE);
360  bool IsPCRel = MachO.getAnyRelocationPCRel(RE);
361  uint64_t Offset = RelI->getOffset();
362  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
363  int64_t Immediate = readBytesUnaligned(LocalAddress, 4); // Copy the whole instruction out.
364 
365  if (IsThumb)
366  Immediate = ((Immediate & 0x0000000f) << 12) |
367  ((Immediate & 0x00000400) << 1) |
368  ((Immediate & 0x70000000) >> 20) |
369  ((Immediate & 0x00ff0000) >> 16);
370  else
371  Immediate = ((Immediate >> 4) & 0xf000) | (Immediate & 0xfff);
372 
373  ++RelI;
375  MachO.getRelocation(RelI->getRawDataRefImpl());
376  uint32_t AddrA = MachO.getScatteredRelocationValue(RE);
377  section_iterator SAI = getSectionByAddress(MachO, AddrA);
378  assert(SAI != MachO.section_end() && "Can't find section for address A");
379  uint64_t SectionABase = SAI->getAddress();
380  uint64_t SectionAOffset = AddrA - SectionABase;
381  SectionRef SectionA = *SAI;
382  bool IsCode = SectionA.isText();
383  uint32_t SectionAID = ~0U;
384  if (auto SectionAIDOrErr =
385  findOrEmitSection(MachO, SectionA, IsCode, ObjSectionToID))
386  SectionAID = *SectionAIDOrErr;
387  else
388  return SectionAIDOrErr.takeError();
389 
390  uint32_t AddrB = MachO.getScatteredRelocationValue(RE2);
391  section_iterator SBI = getSectionByAddress(MachO, AddrB);
392  assert(SBI != MachO.section_end() && "Can't find section for address B");
393  uint64_t SectionBBase = SBI->getAddress();
394  uint64_t SectionBOffset = AddrB - SectionBBase;
395  SectionRef SectionB = *SBI;
396  uint32_t SectionBID = ~0U;
397  if (auto SectionBIDOrErr =
398  findOrEmitSection(MachO, SectionB, IsCode, ObjSectionToID))
399  SectionBID = *SectionBIDOrErr;
400  else
401  return SectionBIDOrErr.takeError();
402 
403  uint32_t OtherHalf = MachO.getAnyRelocationAddress(RE2) & 0xffff;
404  unsigned Shift = (HalfDiffKindBits & 0x1) ? 16 : 0;
405  uint32_t FullImmVal = (Immediate << Shift) | (OtherHalf << (16 - Shift));
406  int64_t Addend = FullImmVal - (AddrA - AddrB);
407 
408  // addend = Encoded - Expected
409  // = Encoded - (AddrA - AddrB)
410 
411  LLVM_DEBUG(dbgs() << "Found SECTDIFF: AddrA: " << AddrA
412  << ", AddrB: " << AddrB << ", Addend: " << Addend
413  << ", SectionA ID: " << SectionAID << ", SectionAOffset: "
414  << SectionAOffset << ", SectionB ID: " << SectionBID
415  << ", SectionBOffset: " << SectionBOffset << "\n");
416  RelocationEntry R(SectionID, Offset, RelocType, Addend, SectionAID,
417  SectionAOffset, SectionBID, SectionBOffset, IsPCRel,
418  HalfDiffKindBits);
419 
420  addRelocationForSection(R, SectionAID);
421 
422  return ++RelI;
423  }
424 
425 };
426 }
427 
428 #undef DEBUG_TYPE
429 
430 #endif
unsigned getStubAlignment() override
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
uint64_t getLoadAddressWithOffset(unsigned OffsetBytes) const
Return the load address of this section with an offset.
bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const
iterator find(StringRef Key)
Definition: StringMap.h:333
void dumpRelocationToResolve(const RelocationEntry &RE, uint64_t Value) const
Dump information about the relocation entry (RE) and resolved value.
This class is the base class for all object file types.
Definition: ObjectFile.h:190
unsigned getMaxStubSize() override
uint8_t * getAddress() const
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
bool IsPCRel
True if this is a PCRel relocation (MachO specific).
unsigned SectionID
SectionID - the section this relocation points to.
amdgpu Simplify well known AMD library false Value Value const Twine & Name
uint64_t modifyAddressBasedOnFlags(uint64_t Addr, JITSymbolFlags Flags) const override
Modify the given target address based on the given symbol flags.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Expected< relocation_iterator > processRelocationRef(unsigned SectionID, relocation_iterator RelI, const ObjectFile &BaseObjT, ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) override
Parses one or more object file relocations (some object files use relocation pairs) and stores it to ...
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
int64_t memcpyAddend(const RelocationEntry &RE) const
This convenience method uses memcpy to extract a contiguous addend (the addend size and offset are ta...
virtual Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &Sym)
Generate JITSymbolFlags from a libObject symbol.
RuntimeDyldMachOARM(RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver)
unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const
RuntimeDyldMachOTarget - Templated base class for generic MachO linker algorithms and data structures...
Error finalizeSection(const ObjectFile &Obj, unsigned SectionID, const SectionRef &Section)
Expected< RelocationValueRef > getRelocationValueRef(const ObjectFile &BaseTObj, const relocation_iterator &RI, const RelocationEntry &RE, ObjSectionToIDMap &ObjSectionToID)
Construct a RelocationValueRef representing the relocation target.
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
RelocationEntry getRelocationEntry(unsigned SectionID, const ObjectFile &BaseTObj, const relocation_iterator &RI) const
Given a relocation_iterator for a non-scattered relocation, construct a RelocationEntry and fill in t...
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
MachO::any_relocation_info getRelocation(DataRefImpl Rel) const
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1774
Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &SR) override
Generate JITSymbolFlags from a libObject symbol.
Flags for symbols in the JIT.
Definition: JITSymbol.h:44
Symbol resolution interface.
Definition: JITSymbol.h:332
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
static section_iterator getSectionByAddress(const MachOObjectFile &Obj, uint64_t Addr)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isRelocationScattered(const MachO::any_relocation_info &RE) const
Expected< int64_t > decodeAddend(const RelocationEntry &RE) const
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
std::error_code getName(StringRef &Result) const
Definition: ObjectFile.h:400
uint32_t RelType
RelType - relocation type.
Expected< relocation_iterator > processScatteredVANILLA(unsigned SectionID, relocation_iterator RelI, const ObjectFile &BaseObjT, RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID, bool TargetIsLocalThumbFunc=false)
Process a scattered vanilla relocation.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
uintptr_t getStubOffset() const
bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset)
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:129
unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const
uint64_t Offset
Offset - offset into the section.
std::map< SectionRef, unsigned > ObjSectionToIDMap
uint8_t * getAddressWithOffset(unsigned OffsetBytes) const
Return the address of this section with an offset.
TargetFlagsType & getTargetFlags()
Return a reference to the target-specific flags.
Definition: JITSymbol.h:144
SectionEntry - represents a section emitted into memory by the dynamic linker.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override
A object file specific relocation resolver.
RTDyldSymbolTable GlobalSymbolTable
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
unsigned Size
The size of this relocation (MachO specific).
section_iterator section_end() const override
static ARMJITSymbolFlags fromObjectSymbol(const object::SymbolRef &Symbol)
Definition: JITSymbol.cpp:61
#define UNIMPLEMENTED_RELOC(RelType)
Error populateIndirectSymbolPointersSection(const MachOObjectFile &Obj, const SectionRef &PTSection, unsigned PTSectionID)
void advanceStubOffset(unsigned StubSize)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
void makeValueAddendPCRel(RelocationValueRef &Value, const relocation_iterator &RI, unsigned OffsetToNextPC)
Make the RelocationValueRef addend PC-relative.
#define LLVM_DEBUG(X)
Definition: Debug.h:123
uint32_t getScatteredRelocationValue(const MachO::any_relocation_info &RE) const
iterator end()
Definition: StringMap.h:318
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77