1 | //===- ObjectFile.h - File format independent object file -------*- 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 | // This file declares a file format independent ObjectFile class. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #ifndef LLVM_OBJECT_OBJECTFILE_H |
14 | #define LLVM_OBJECT_OBJECTFILE_H |
15 | |
16 | #include "llvm/ADT/ArrayRef.h" |
17 | #include "llvm/ADT/Hashing.h" |
18 | #include "llvm/ADT/StringRef.h" |
19 | #include "llvm/ADT/iterator_range.h" |
20 | #include "llvm/BinaryFormat/Magic.h" |
21 | #include "llvm/BinaryFormat/Swift.h" |
22 | #include "llvm/Object/Binary.h" |
23 | #include "llvm/Object/Error.h" |
24 | #include "llvm/Object/SymbolicFile.h" |
25 | #include "llvm/Support/Casting.h" |
26 | #include "llvm/Support/Error.h" |
27 | #include "llvm/Support/MemoryBufferRef.h" |
28 | #include "llvm/TargetParser/Triple.h" |
29 | #include <cassert> |
30 | #include <cstdint> |
31 | #include <memory> |
32 | |
33 | namespace llvm { |
34 | |
35 | class SubtargetFeatures; |
36 | |
37 | namespace object { |
38 | |
39 | class COFFObjectFile; |
40 | class MachOObjectFile; |
41 | class ObjectFile; |
42 | class SectionRef; |
43 | class SymbolRef; |
44 | class symbol_iterator; |
45 | class WasmObjectFile; |
46 | |
47 | using section_iterator = content_iterator<SectionRef>; |
48 | |
49 | typedef std::function<bool(const SectionRef &)> SectionFilterPredicate; |
50 | /// This is a value type class that represents a single relocation in the list |
51 | /// of relocations in the object file. |
52 | class RelocationRef { |
53 | DataRefImpl RelocationPimpl; |
54 | const ObjectFile *OwningObject = nullptr; |
55 | |
56 | public: |
57 | RelocationRef() = default; |
58 | RelocationRef(DataRefImpl RelocationP, const ObjectFile *Owner); |
59 | |
60 | bool operator==(const RelocationRef &Other) const; |
61 | |
62 | void moveNext(); |
63 | |
64 | uint64_t getOffset() const; |
65 | symbol_iterator getSymbol() const; |
66 | uint64_t getType() const; |
67 | |
68 | /// Get a string that represents the type of this relocation. |
69 | /// |
70 | /// This is for display purposes only. |
71 | void getTypeName(SmallVectorImpl<char> &Result) const; |
72 | |
73 | DataRefImpl getRawDataRefImpl() const; |
74 | const ObjectFile *getObject() const; |
75 | }; |
76 | |
77 | using relocation_iterator = content_iterator<RelocationRef>; |
78 | |
79 | /// This is a value type class that represents a single section in the list of |
80 | /// sections in the object file. |
81 | class SectionRef { |
82 | friend class SymbolRef; |
83 | |
84 | DataRefImpl SectionPimpl; |
85 | const ObjectFile *OwningObject = nullptr; |
86 | |
87 | public: |
88 | SectionRef() = default; |
89 | SectionRef(DataRefImpl SectionP, const ObjectFile *Owner); |
90 | |
91 | bool operator==(const SectionRef &Other) const; |
92 | bool operator!=(const SectionRef &Other) const; |
93 | bool operator<(const SectionRef &Other) const; |
94 | |
95 | void moveNext(); |
96 | |
97 | Expected<StringRef> getName() const; |
98 | uint64_t getAddress() const; |
99 | uint64_t getIndex() const; |
100 | uint64_t getSize() const; |
101 | Expected<StringRef> getContents() const; |
102 | |
103 | /// Get the alignment of this section. |
104 | Align getAlignment() const; |
105 | |
106 | bool isCompressed() const; |
107 | /// Whether this section contains instructions. |
108 | bool isText() const; |
109 | /// Whether this section contains data, not instructions. |
110 | bool isData() const; |
111 | /// Whether this section contains BSS uninitialized data. |
112 | bool isBSS() const; |
113 | bool isVirtual() const; |
114 | bool isBitcode() const; |
115 | bool isStripped() const; |
116 | |
117 | /// Whether this section will be placed in the text segment, according to the |
118 | /// Berkeley size format. This is true if the section is allocatable, and |
119 | /// contains either code or readonly data. |
120 | bool isBerkeleyText() const; |
121 | /// Whether this section will be placed in the data segment, according to the |
122 | /// Berkeley size format. This is true if the section is allocatable and |
123 | /// contains data (e.g. PROGBITS), but is not text. |
124 | bool isBerkeleyData() const; |
125 | |
126 | /// Whether this section is a debug section. |
127 | bool isDebugSection() const; |
128 | |
129 | bool containsSymbol(SymbolRef S) const; |
130 | |
131 | relocation_iterator relocation_begin() const; |
132 | relocation_iterator relocation_end() const; |
133 | iterator_range<relocation_iterator> relocations() const { |
134 | return make_range(x: relocation_begin(), y: relocation_end()); |
135 | } |
136 | |
137 | /// Returns the related section if this section contains relocations. The |
138 | /// returned section may or may not have applied its relocations. |
139 | Expected<section_iterator> getRelocatedSection() const; |
140 | |
141 | DataRefImpl getRawDataRefImpl() const; |
142 | const ObjectFile *getObject() const; |
143 | }; |
144 | |
145 | struct SectionedAddress { |
146 | const static uint64_t UndefSection = UINT64_MAX; |
147 | |
148 | uint64_t Address = 0; |
149 | uint64_t SectionIndex = UndefSection; |
150 | }; |
151 | |
152 | inline bool operator<(const SectionedAddress &LHS, |
153 | const SectionedAddress &RHS) { |
154 | return std::tie(args: LHS.SectionIndex, args: LHS.Address) < |
155 | std::tie(args: RHS.SectionIndex, args: RHS.Address); |
156 | } |
157 | |
158 | inline bool operator==(const SectionedAddress &LHS, |
159 | const SectionedAddress &RHS) { |
160 | return std::tie(args: LHS.SectionIndex, args: LHS.Address) == |
161 | std::tie(args: RHS.SectionIndex, args: RHS.Address); |
162 | } |
163 | |
164 | raw_ostream &operator<<(raw_ostream &OS, const SectionedAddress &Addr); |
165 | |
166 | /// This is a value type class that represents a single symbol in the list of |
167 | /// symbols in the object file. |
168 | class SymbolRef : public BasicSymbolRef { |
169 | friend class SectionRef; |
170 | |
171 | public: |
172 | enum Type { |
173 | ST_Unknown, // Type not specified |
174 | ST_Other, |
175 | ST_Data, |
176 | ST_Debug, |
177 | ST_File, |
178 | ST_Function, |
179 | }; |
180 | |
181 | SymbolRef() = default; |
182 | SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner); |
183 | SymbolRef(const BasicSymbolRef &B) : BasicSymbolRef(B) { |
184 | assert(isa<ObjectFile>(BasicSymbolRef::getObject())); |
185 | } |
186 | |
187 | Expected<StringRef> getName() const; |
188 | /// Returns the symbol virtual address (i.e. address at which it will be |
189 | /// mapped). |
190 | Expected<uint64_t> getAddress() const; |
191 | |
192 | /// Return the value of the symbol depending on the object this can be an |
193 | /// offset or a virtual address. |
194 | Expected<uint64_t> getValue() const; |
195 | |
196 | /// Get the alignment of this symbol as the actual value (not log 2). |
197 | uint32_t getAlignment() const; |
198 | uint64_t getCommonSize() const; |
199 | Expected<SymbolRef::Type> getType() const; |
200 | |
201 | /// Get section this symbol is defined in reference to. Result is |
202 | /// end_sections() if it is undefined or is an absolute symbol. |
203 | Expected<section_iterator> getSection() const; |
204 | |
205 | const ObjectFile *getObject() const; |
206 | }; |
207 | |
208 | class symbol_iterator : public basic_symbol_iterator { |
209 | public: |
210 | symbol_iterator(SymbolRef Sym) : basic_symbol_iterator(Sym) {} |
211 | symbol_iterator(const basic_symbol_iterator &B) |
212 | : basic_symbol_iterator(SymbolRef(B->getRawDataRefImpl(), |
213 | cast<ObjectFile>(Val: B->getObject()))) {} |
214 | |
215 | const SymbolRef *operator->() const { |
216 | const BasicSymbolRef &P = basic_symbol_iterator::operator *(); |
217 | return static_cast<const SymbolRef*>(&P); |
218 | } |
219 | |
220 | const SymbolRef &operator*() const { |
221 | const BasicSymbolRef &P = basic_symbol_iterator::operator *(); |
222 | return static_cast<const SymbolRef&>(P); |
223 | } |
224 | }; |
225 | |
226 | /// This class is the base class for all object file types. Concrete instances |
227 | /// of this object are created by createObjectFile, which figures out which type |
228 | /// to create. |
229 | class ObjectFile : public SymbolicFile { |
230 | virtual void anchor(); |
231 | |
232 | protected: |
233 | ObjectFile(unsigned int Type, MemoryBufferRef Source); |
234 | |
235 | const uint8_t *base() const { |
236 | return reinterpret_cast<const uint8_t *>(Data.getBufferStart()); |
237 | } |
238 | |
239 | // These functions are for SymbolRef to call internally. The main goal of |
240 | // this is to allow SymbolRef::SymbolPimpl to point directly to the symbol |
241 | // entry in the memory mapped object file. SymbolPimpl cannot contain any |
242 | // virtual functions because then it could not point into the memory mapped |
243 | // file. |
244 | // |
245 | // Implementations assume that the DataRefImpl is valid and has not been |
246 | // modified externally. It's UB otherwise. |
247 | friend class SymbolRef; |
248 | |
249 | virtual Expected<StringRef> getSymbolName(DataRefImpl Symb) const = 0; |
250 | Error printSymbolName(raw_ostream &OS, |
251 | DataRefImpl Symb) const override; |
252 | virtual Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const = 0; |
253 | virtual uint64_t getSymbolValueImpl(DataRefImpl Symb) const = 0; |
254 | virtual uint32_t getSymbolAlignment(DataRefImpl Symb) const; |
255 | virtual uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const = 0; |
256 | virtual Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const = 0; |
257 | virtual Expected<section_iterator> |
258 | getSymbolSection(DataRefImpl Symb) const = 0; |
259 | |
260 | // Same as above for SectionRef. |
261 | friend class SectionRef; |
262 | |
263 | virtual void moveSectionNext(DataRefImpl &Sec) const = 0; |
264 | virtual Expected<StringRef> getSectionName(DataRefImpl Sec) const = 0; |
265 | virtual uint64_t getSectionAddress(DataRefImpl Sec) const = 0; |
266 | virtual uint64_t getSectionIndex(DataRefImpl Sec) const = 0; |
267 | virtual uint64_t getSectionSize(DataRefImpl Sec) const = 0; |
268 | virtual Expected<ArrayRef<uint8_t>> |
269 | getSectionContents(DataRefImpl Sec) const = 0; |
270 | virtual uint64_t getSectionAlignment(DataRefImpl Sec) const = 0; |
271 | virtual bool isSectionCompressed(DataRefImpl Sec) const = 0; |
272 | virtual bool isSectionText(DataRefImpl Sec) const = 0; |
273 | virtual bool isSectionData(DataRefImpl Sec) const = 0; |
274 | virtual bool isSectionBSS(DataRefImpl Sec) const = 0; |
275 | // A section is 'virtual' if its contents aren't present in the object image. |
276 | virtual bool isSectionVirtual(DataRefImpl Sec) const = 0; |
277 | virtual bool isSectionBitcode(DataRefImpl Sec) const; |
278 | virtual bool isSectionStripped(DataRefImpl Sec) const; |
279 | virtual bool isBerkeleyText(DataRefImpl Sec) const; |
280 | virtual bool isBerkeleyData(DataRefImpl Sec) const; |
281 | virtual bool isDebugSection(DataRefImpl Sec) const; |
282 | virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const = 0; |
283 | virtual relocation_iterator section_rel_end(DataRefImpl Sec) const = 0; |
284 | virtual Expected<section_iterator> getRelocatedSection(DataRefImpl Sec) const; |
285 | |
286 | // Same as above for RelocationRef. |
287 | friend class RelocationRef; |
288 | virtual void moveRelocationNext(DataRefImpl &Rel) const = 0; |
289 | virtual uint64_t getRelocationOffset(DataRefImpl Rel) const = 0; |
290 | virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const = 0; |
291 | virtual uint64_t getRelocationType(DataRefImpl Rel) const = 0; |
292 | virtual void getRelocationTypeName(DataRefImpl Rel, |
293 | SmallVectorImpl<char> &Result) const = 0; |
294 | |
295 | virtual llvm::binaryformat::Swift5ReflectionSectionKind |
296 | mapReflectionSectionNameToEnumValue(StringRef SectionName) const { |
297 | return llvm::binaryformat::Swift5ReflectionSectionKind::unknown; |
298 | }; |
299 | |
300 | Expected<uint64_t> getSymbolValue(DataRefImpl Symb) const; |
301 | |
302 | public: |
303 | ObjectFile() = delete; |
304 | ObjectFile(const ObjectFile &other) = delete; |
305 | |
306 | uint64_t getCommonSymbolSize(DataRefImpl Symb) const { |
307 | Expected<uint32_t> SymbolFlagsOrErr = getSymbolFlags(Symb); |
308 | if (!SymbolFlagsOrErr) |
309 | // TODO: Actually report errors helpfully. |
310 | report_fatal_error(Err: SymbolFlagsOrErr.takeError()); |
311 | assert(*SymbolFlagsOrErr & SymbolRef::SF_Common); |
312 | return getCommonSymbolSizeImpl(Symb); |
313 | } |
314 | |
315 | virtual std::vector<SectionRef> dynamic_relocation_sections() const { |
316 | return std::vector<SectionRef>(); |
317 | } |
318 | |
319 | using symbol_iterator_range = iterator_range<symbol_iterator>; |
320 | symbol_iterator_range symbols() const { |
321 | return symbol_iterator_range(symbol_begin(), symbol_end()); |
322 | } |
323 | |
324 | virtual section_iterator section_begin() const = 0; |
325 | virtual section_iterator section_end() const = 0; |
326 | |
327 | using section_iterator_range = iterator_range<section_iterator>; |
328 | section_iterator_range sections() const { |
329 | return section_iterator_range(section_begin(), section_end()); |
330 | } |
331 | |
332 | virtual bool hasDebugInfo() const; |
333 | |
334 | /// The number of bytes used to represent an address in this object |
335 | /// file format. |
336 | virtual uint8_t getBytesInAddress() const = 0; |
337 | |
338 | virtual StringRef getFileFormatName() const = 0; |
339 | virtual Triple::ArchType getArch() const = 0; |
340 | virtual Triple::OSType getOS() const { return Triple::UnknownOS; } |
341 | virtual Expected<SubtargetFeatures> getFeatures() const = 0; |
342 | virtual std::optional<StringRef> tryGetCPUName() const { |
343 | return std::nullopt; |
344 | }; |
345 | virtual void setARMSubArch(Triple &TheTriple) const { } |
346 | virtual Expected<uint64_t> getStartAddress() const { |
347 | return errorCodeToError(EC: object_error::parse_failed); |
348 | }; |
349 | |
350 | /// Create a triple from the data in this object file. |
351 | Triple makeTriple() const; |
352 | |
353 | /// Maps a debug section name to a standard DWARF section name. |
354 | virtual StringRef mapDebugSectionName(StringRef Name) const { return Name; } |
355 | |
356 | /// True if this is a relocatable object (.o/.obj). |
357 | virtual bool isRelocatableObject() const = 0; |
358 | |
359 | /// True if the reflection section can be stripped by the linker. |
360 | bool isReflectionSectionStrippable( |
361 | llvm::binaryformat::Swift5ReflectionSectionKind ReflectionSectionKind) |
362 | const; |
363 | |
364 | /// @returns Pointer to ObjectFile subclass to handle this type of object. |
365 | /// @param ObjectPath The path to the object file. ObjectPath.isObject must |
366 | /// return true. |
367 | /// Create ObjectFile from path. |
368 | static Expected<OwningBinary<ObjectFile>> |
369 | createObjectFile(StringRef ObjectPath); |
370 | |
371 | static Expected<std::unique_ptr<ObjectFile>> |
372 | createObjectFile(MemoryBufferRef Object, llvm::file_magic Type, |
373 | bool InitContent = true); |
374 | static Expected<std::unique_ptr<ObjectFile>> |
375 | createObjectFile(MemoryBufferRef Object) { |
376 | return createObjectFile(Object, Type: llvm::file_magic::unknown); |
377 | } |
378 | |
379 | static bool classof(const Binary *v) { |
380 | return v->isObject(); |
381 | } |
382 | |
383 | static Expected<std::unique_ptr<COFFObjectFile>> |
384 | createCOFFObjectFile(MemoryBufferRef Object); |
385 | |
386 | static Expected<std::unique_ptr<ObjectFile>> |
387 | createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType); |
388 | |
389 | static Expected<std::unique_ptr<ObjectFile>> |
390 | createELFObjectFile(MemoryBufferRef Object, bool InitContent = true); |
391 | |
392 | static Expected<std::unique_ptr<MachOObjectFile>> |
393 | createMachOObjectFile(MemoryBufferRef Object, uint32_t UniversalCputype = 0, |
394 | uint32_t UniversalIndex = 0, |
395 | size_t MachOFilesetEntryOffset = 0); |
396 | |
397 | static Expected<std::unique_ptr<ObjectFile>> |
398 | createGOFFObjectFile(MemoryBufferRef Object); |
399 | |
400 | static Expected<std::unique_ptr<WasmObjectFile>> |
401 | createWasmObjectFile(MemoryBufferRef Object); |
402 | }; |
403 | |
404 | /// A filtered iterator for SectionRefs that skips sections based on some given |
405 | /// predicate. |
406 | class SectionFilterIterator { |
407 | public: |
408 | SectionFilterIterator(SectionFilterPredicate Pred, |
409 | const section_iterator &Begin, |
410 | const section_iterator &End) |
411 | : Predicate(std::move(Pred)), Iterator(Begin), End(End) { |
412 | scanPredicate(); |
413 | } |
414 | const SectionRef &operator*() const { return *Iterator; } |
415 | SectionFilterIterator &operator++() { |
416 | ++Iterator; |
417 | scanPredicate(); |
418 | return *this; |
419 | } |
420 | bool operator!=(const SectionFilterIterator &Other) const { |
421 | return Iterator != Other.Iterator; |
422 | } |
423 | |
424 | private: |
425 | void scanPredicate() { |
426 | while (Iterator != End && !Predicate(*Iterator)) { |
427 | ++Iterator; |
428 | } |
429 | } |
430 | SectionFilterPredicate Predicate; |
431 | section_iterator Iterator; |
432 | section_iterator End; |
433 | }; |
434 | |
435 | /// Creates an iterator range of SectionFilterIterators for a given Object and |
436 | /// predicate. |
437 | class SectionFilter { |
438 | public: |
439 | SectionFilter(SectionFilterPredicate Pred, const ObjectFile &Obj) |
440 | : Predicate(std::move(Pred)), Object(Obj) {} |
441 | SectionFilterIterator begin() { |
442 | return SectionFilterIterator(Predicate, Object.section_begin(), |
443 | Object.section_end()); |
444 | } |
445 | SectionFilterIterator end() { |
446 | return SectionFilterIterator(Predicate, Object.section_end(), |
447 | Object.section_end()); |
448 | } |
449 | |
450 | private: |
451 | SectionFilterPredicate Predicate; |
452 | const ObjectFile &Object; |
453 | }; |
454 | |
455 | // Inline function definitions. |
456 | inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner) |
457 | : BasicSymbolRef(SymbolP, Owner) {} |
458 | |
459 | inline Expected<StringRef> SymbolRef::getName() const { |
460 | return getObject()->getSymbolName(Symb: getRawDataRefImpl()); |
461 | } |
462 | |
463 | inline Expected<uint64_t> SymbolRef::getAddress() const { |
464 | return getObject()->getSymbolAddress(Symb: getRawDataRefImpl()); |
465 | } |
466 | |
467 | inline Expected<uint64_t> SymbolRef::getValue() const { |
468 | return getObject()->getSymbolValue(Symb: getRawDataRefImpl()); |
469 | } |
470 | |
471 | inline uint32_t SymbolRef::getAlignment() const { |
472 | return getObject()->getSymbolAlignment(Symb: getRawDataRefImpl()); |
473 | } |
474 | |
475 | inline uint64_t SymbolRef::getCommonSize() const { |
476 | return getObject()->getCommonSymbolSize(Symb: getRawDataRefImpl()); |
477 | } |
478 | |
479 | inline Expected<section_iterator> SymbolRef::getSection() const { |
480 | return getObject()->getSymbolSection(Symb: getRawDataRefImpl()); |
481 | } |
482 | |
483 | inline Expected<SymbolRef::Type> SymbolRef::getType() const { |
484 | return getObject()->getSymbolType(Symb: getRawDataRefImpl()); |
485 | } |
486 | |
487 | inline const ObjectFile *SymbolRef::getObject() const { |
488 | const SymbolicFile *O = BasicSymbolRef::getObject(); |
489 | return cast<ObjectFile>(Val: O); |
490 | } |
491 | |
492 | /// SectionRef |
493 | inline SectionRef::SectionRef(DataRefImpl SectionP, |
494 | const ObjectFile *Owner) |
495 | : SectionPimpl(SectionP) |
496 | , OwningObject(Owner) {} |
497 | |
498 | inline bool SectionRef::operator==(const SectionRef &Other) const { |
499 | return OwningObject == Other.OwningObject && |
500 | SectionPimpl == Other.SectionPimpl; |
501 | } |
502 | |
503 | inline bool SectionRef::operator!=(const SectionRef &Other) const { |
504 | return !(*this == Other); |
505 | } |
506 | |
507 | inline bool SectionRef::operator<(const SectionRef &Other) const { |
508 | assert(OwningObject == Other.OwningObject); |
509 | return SectionPimpl < Other.SectionPimpl; |
510 | } |
511 | |
512 | inline void SectionRef::moveNext() { |
513 | return OwningObject->moveSectionNext(Sec&: SectionPimpl); |
514 | } |
515 | |
516 | inline Expected<StringRef> SectionRef::getName() const { |
517 | return OwningObject->getSectionName(Sec: SectionPimpl); |
518 | } |
519 | |
520 | inline uint64_t SectionRef::getAddress() const { |
521 | return OwningObject->getSectionAddress(Sec: SectionPimpl); |
522 | } |
523 | |
524 | inline uint64_t SectionRef::getIndex() const { |
525 | return OwningObject->getSectionIndex(Sec: SectionPimpl); |
526 | } |
527 | |
528 | inline uint64_t SectionRef::getSize() const { |
529 | return OwningObject->getSectionSize(Sec: SectionPimpl); |
530 | } |
531 | |
532 | inline Expected<StringRef> SectionRef::getContents() const { |
533 | Expected<ArrayRef<uint8_t>> Res = |
534 | OwningObject->getSectionContents(Sec: SectionPimpl); |
535 | if (!Res) |
536 | return Res.takeError(); |
537 | return StringRef(reinterpret_cast<const char *>(Res->data()), Res->size()); |
538 | } |
539 | |
540 | inline Align SectionRef::getAlignment() const { |
541 | return MaybeAlign(OwningObject->getSectionAlignment(Sec: SectionPimpl)) |
542 | .valueOrOne(); |
543 | } |
544 | |
545 | inline bool SectionRef::isCompressed() const { |
546 | return OwningObject->isSectionCompressed(Sec: SectionPimpl); |
547 | } |
548 | |
549 | inline bool SectionRef::isText() const { |
550 | return OwningObject->isSectionText(Sec: SectionPimpl); |
551 | } |
552 | |
553 | inline bool SectionRef::isData() const { |
554 | return OwningObject->isSectionData(Sec: SectionPimpl); |
555 | } |
556 | |
557 | inline bool SectionRef::isBSS() const { |
558 | return OwningObject->isSectionBSS(Sec: SectionPimpl); |
559 | } |
560 | |
561 | inline bool SectionRef::isVirtual() const { |
562 | return OwningObject->isSectionVirtual(Sec: SectionPimpl); |
563 | } |
564 | |
565 | inline bool SectionRef::isBitcode() const { |
566 | return OwningObject->isSectionBitcode(Sec: SectionPimpl); |
567 | } |
568 | |
569 | inline bool SectionRef::isStripped() const { |
570 | return OwningObject->isSectionStripped(Sec: SectionPimpl); |
571 | } |
572 | |
573 | inline bool SectionRef::isBerkeleyText() const { |
574 | return OwningObject->isBerkeleyText(Sec: SectionPimpl); |
575 | } |
576 | |
577 | inline bool SectionRef::isBerkeleyData() const { |
578 | return OwningObject->isBerkeleyData(Sec: SectionPimpl); |
579 | } |
580 | |
581 | inline bool SectionRef::isDebugSection() const { |
582 | return OwningObject->isDebugSection(Sec: SectionPimpl); |
583 | } |
584 | |
585 | inline relocation_iterator SectionRef::relocation_begin() const { |
586 | return OwningObject->section_rel_begin(Sec: SectionPimpl); |
587 | } |
588 | |
589 | inline relocation_iterator SectionRef::relocation_end() const { |
590 | return OwningObject->section_rel_end(Sec: SectionPimpl); |
591 | } |
592 | |
593 | inline Expected<section_iterator> SectionRef::getRelocatedSection() const { |
594 | return OwningObject->getRelocatedSection(Sec: SectionPimpl); |
595 | } |
596 | |
597 | inline DataRefImpl SectionRef::getRawDataRefImpl() const { |
598 | return SectionPimpl; |
599 | } |
600 | |
601 | inline const ObjectFile *SectionRef::getObject() const { |
602 | return OwningObject; |
603 | } |
604 | |
605 | /// RelocationRef |
606 | inline RelocationRef::RelocationRef(DataRefImpl RelocationP, |
607 | const ObjectFile *Owner) |
608 | : RelocationPimpl(RelocationP) |
609 | , OwningObject(Owner) {} |
610 | |
611 | inline bool RelocationRef::operator==(const RelocationRef &Other) const { |
612 | return RelocationPimpl == Other.RelocationPimpl; |
613 | } |
614 | |
615 | inline void RelocationRef::moveNext() { |
616 | return OwningObject->moveRelocationNext(Rel&: RelocationPimpl); |
617 | } |
618 | |
619 | inline uint64_t RelocationRef::getOffset() const { |
620 | return OwningObject->getRelocationOffset(Rel: RelocationPimpl); |
621 | } |
622 | |
623 | inline symbol_iterator RelocationRef::getSymbol() const { |
624 | return OwningObject->getRelocationSymbol(Rel: RelocationPimpl); |
625 | } |
626 | |
627 | inline uint64_t RelocationRef::getType() const { |
628 | return OwningObject->getRelocationType(Rel: RelocationPimpl); |
629 | } |
630 | |
631 | inline void RelocationRef::getTypeName(SmallVectorImpl<char> &Result) const { |
632 | return OwningObject->getRelocationTypeName(Rel: RelocationPimpl, Result); |
633 | } |
634 | |
635 | inline DataRefImpl RelocationRef::getRawDataRefImpl() const { |
636 | return RelocationPimpl; |
637 | } |
638 | |
639 | inline const ObjectFile *RelocationRef::getObject() const { |
640 | return OwningObject; |
641 | } |
642 | |
643 | } // end namespace object |
644 | |
645 | template <> struct DenseMapInfo<object::SectionRef> { |
646 | static bool isEqual(const object::SectionRef &A, |
647 | const object::SectionRef &B) { |
648 | return A == B; |
649 | } |
650 | static object::SectionRef getEmptyKey() { |
651 | return object::SectionRef({}, nullptr); |
652 | } |
653 | static object::SectionRef getTombstoneKey() { |
654 | object::DataRefImpl TS; |
655 | TS.p = (uintptr_t)-1; |
656 | return object::SectionRef(TS, nullptr); |
657 | } |
658 | static unsigned getHashValue(const object::SectionRef &Sec) { |
659 | object::DataRefImpl Raw = Sec.getRawDataRefImpl(); |
660 | return hash_combine(args: Raw.p, args: Raw.d.a, args: Raw.d.b); |
661 | } |
662 | }; |
663 | |
664 | } // end namespace llvm |
665 | |
666 | #endif // LLVM_OBJECT_OBJECTFILE_H |
667 | |