LLVM 19.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
16namespace llvm {
17
19 : public RuntimeDyldMachOCRTPBase<RuntimeDyldMachOARM> {
20private:
22
23public:
24
26
30
31 unsigned getMaxStubSize() const override { return 8; }
32
33 Align getStubAlignment() override { return Align(4); }
34
37 if (!Flags)
38 return Flags.takeError();
39 Flags->getTargetFlags() = ARMJITSymbolFlags::fromObjectSymbol(SR);
40 return Flags;
41 }
42
44 JITSymbolFlags Flags) const override {
45 if (Flags.getTargetFlags() & ARMJITSymbolFlags::Thumb)
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
63 const SectionEntry &Section = Sections[RE.SectionID];
64 uint8_t *LocalAddress = Section.getAddressWithOffset(RE.Offset);
65
66 switch (RE.RelType) {
67 default:
68 return memcpyAddend(RE);
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
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
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;
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) {
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
302private:
303
304 void processBranchRelocation(const RelocationEntry &RE,
306 StubMap &Stubs) {
307 // This is an ARM branch relocation, need to use a stub function.
308 // Look up for existing stub.
309 SectionEntry &Section = Sections[RE.SectionID];
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;
320 StubOpcode = 0xe51ff004; // ldr pc, [pc, #-4]
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
SmallVector< AArch64_IMM::ImmInsnModel, 4 > Insn
#define LLVM_DEBUG(X)
Definition: Debug.h:101
uint64_t Addr
std::string Name
#define UNIMPLEMENTED_RELOC(RelType)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static ARMJITSymbolFlags fromObjectSymbol(const object::SymbolRef &Symbol)
Definition: JITSymbol.cpp:94
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Flags for symbols in the JIT.
Definition: JITSymbol.h:74
Symbol resolution interface.
Definition: JITSymbol.h:371
RelocationEntry - used to represent relocations internally in the dynamic linker.
unsigned Size
The size of this relocation (MachO specific).
uint32_t RelType
RelType - relocation type.
uint64_t Offset
Offset - offset into the section.
bool IsPCRel
True if this is a PCRel relocation (MachO specific).
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
unsigned SectionID
SectionID - the section this relocation points to.
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2213
std::map< SectionRef, unsigned > ObjSectionToIDMap
std::map< RelocationValueRef, uintptr_t > StubMap
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
RTDyldSymbolTable GlobalSymbolTable
virtual Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &Sym)
Generate JITSymbolFlags from a libObject symbol.
uint64_t modifyAddressBasedOnFlags(uint64_t Addr, JITSymbolFlags Flags) const override
Modify the given target address based on the given symbol flags.
Error finalizeSection(const ObjectFile &Obj, unsigned SectionID, const SectionRef &Section)
RuntimeDyldMachOARM(RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver)
void resolveRelocation(const RelocationEntry &RE, uint64_t Value) override
A object file specific relocation resolver.
Expected< int64_t > decodeAddend(const RelocationEntry &RE) const
Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &SR) override
Generate JITSymbolFlags from a libObject symbol.
bool isAddrTargetThumb(unsigned SectionID, uint64_t Offset)
Align getStubAlignment() override
unsigned getMaxStubSize() const override
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 ...
RuntimeDyldMachOTarget - Templated base class for generic MachO linker algorithms and data structures...
static section_iterator getSectionByAddress(const MachOObjectFile &Obj, uint64_t Addr)
int64_t memcpyAddend(const RelocationEntry &RE) const
This convenience method uses memcpy to extract a contiguous addend (the addend size and offset are ta...
Error populateIndirectSymbolPointersSection(const MachOObjectFile &Obj, const SectionRef &PTSection, unsigned PTSectionID)
void makeValueAddendPCRel(RelocationValueRef &Value, const relocation_iterator &RI, unsigned OffsetToNextPC)
Make the RelocationValueRef addend PC-relative.
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...
Expected< RelocationValueRef > getRelocationValueRef(const ObjectFile &BaseTObj, const relocation_iterator &RI, const RelocationEntry &RE, ObjSectionToIDMap &ObjSectionToID)
Construct a RelocationValueRef representing the relocation target.
Expected< relocation_iterator > processScatteredVANILLA(unsigned SectionID, relocation_iterator RelI, const ObjectFile &BaseObjT, RuntimeDyldMachO::ObjSectionToIDMap &ObjSectionToID, bool TargetIsLocalThumbFunc=false)
Process a scattered vanilla relocation.
void dumpRelocationToResolve(const RelocationEntry &RE, uint64_t Value) const
Dump information about the relocation entry (RE) and resolved value.
SectionEntry - represents a section emitted into memory by the dynamic linker.
iterator end()
Definition: StringMap.h:221
iterator find(StringRef Key)
Definition: StringMap.h:234
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVM Value Representation.
Definition: Value.h:74
section_iterator section_end() const override
uint32_t getScatteredRelocationValue(const MachO::any_relocation_info &RE) const
unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const
bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const
unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const
unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const
MachO::any_relocation_info getRelocation(DataRefImpl Rel) const
bool isRelocationScattered(const MachO::any_relocation_info &RE) const
unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const
This class is the base class for all object file types.
Definition: ObjectFile.h:229
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
uint64_t getAddress() const
Definition: ObjectFile.h:520
bool isText() const
Whether this section contains instructions.
Definition: ObjectFile.h:549
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: ObjectFile.h:168
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ ARM_RELOC_PAIR
Definition: MachO.h:441
@ ARM_RELOC_BR24
Definition: MachO.h:445
@ ARM_THUMB_RELOC_BR22
Definition: MachO.h:446
@ ARM_RELOC_PB_LA_PTR
Definition: MachO.h:444
@ ARM_RELOC_LOCAL_SECTDIFF
Definition: MachO.h:443
@ GENERIC_RELOC_VANILLA
Definition: MachO.h:410
@ ARM_THUMB_32BIT_BRANCH
Definition: MachO.h:447
@ ARM_RELOC_HALF_SECTDIFF
Definition: MachO.h:449
@ ARM_RELOC_SECTDIFF
Definition: MachO.h:442
@ ARM_RELOC_HALF
Definition: MachO.h:448
@ ARM_RELOC_VANILLA
Definition: MachO.h:440
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:90
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1041
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39