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