]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===- ObjectFile.h - File format independent object file -------*- 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 | // This file declares a file format independent ObjectFile class. | |
11 | // | |
12 | //===----------------------------------------------------------------------===// | |
13 | ||
970d7e83 LB |
14 | #ifndef LLVM_OBJECT_OBJECTFILE_H |
15 | #define LLVM_OBJECT_OBJECTFILE_H | |
223e47cc | 16 | |
223e47cc | 17 | #include "llvm/ADT/StringRef.h" |
970d7e83 | 18 | #include "llvm/Object/Binary.h" |
223e47cc LB |
19 | #include "llvm/Support/DataTypes.h" |
20 | #include "llvm/Support/ErrorHandling.h" | |
21 | #include "llvm/Support/MemoryBuffer.h" | |
22 | #include <cstring> | |
23 | #include <vector> | |
24 | ||
25 | namespace llvm { | |
26 | namespace object { | |
27 | ||
28 | class ObjectFile; | |
29 | ||
30 | union DataRefImpl { | |
31 | struct { | |
32 | // ELF needs this for relocations. This entire union should probably be a | |
33 | // char[max(8, sizeof(uintptr_t))] and require the impl to cast. | |
34 | uint16_t a, b; | |
35 | uint32_t c; | |
36 | } w; | |
37 | struct { | |
38 | uint32_t a, b; | |
39 | } d; | |
40 | uintptr_t p; | |
41 | DataRefImpl() { | |
42 | std::memset(this, 0, sizeof(DataRefImpl)); | |
43 | } | |
44 | }; | |
45 | ||
46 | template<class content_type> | |
47 | class content_iterator { | |
48 | content_type Current; | |
49 | public: | |
50 | content_iterator(content_type symb) | |
51 | : Current(symb) {} | |
52 | ||
53 | const content_type* operator->() const { | |
54 | return &Current; | |
55 | } | |
56 | ||
57 | const content_type &operator*() const { | |
58 | return Current; | |
59 | } | |
60 | ||
61 | bool operator==(const content_iterator &other) const { | |
62 | return Current == other.Current; | |
63 | } | |
64 | ||
65 | bool operator!=(const content_iterator &other) const { | |
66 | return !(*this == other); | |
67 | } | |
68 | ||
69 | content_iterator& increment(error_code &err) { | |
70 | content_type next; | |
71 | if (error_code ec = Current.getNext(next)) | |
72 | err = ec; | |
73 | else | |
74 | Current = next; | |
75 | return *this; | |
76 | } | |
77 | }; | |
78 | ||
970d7e83 | 79 | inline bool operator==(const DataRefImpl &a, const DataRefImpl &b) { |
223e47cc LB |
80 | // Check bitwise identical. This is the only legal way to compare a union w/o |
81 | // knowing which member is in use. | |
82 | return std::memcmp(&a, &b, sizeof(DataRefImpl)) == 0; | |
83 | } | |
84 | ||
970d7e83 | 85 | inline bool operator<(const DataRefImpl &a, const DataRefImpl &b) { |
223e47cc LB |
86 | // Check bitwise identical. This is the only legal way to compare a union w/o |
87 | // knowing which member is in use. | |
88 | return std::memcmp(&a, &b, sizeof(DataRefImpl)) < 0; | |
89 | } | |
90 | ||
91 | class SymbolRef; | |
92 | ||
93 | /// RelocationRef - This is a value type class that represents a single | |
94 | /// relocation in the list of relocations in the object file. | |
95 | class RelocationRef { | |
96 | DataRefImpl RelocationPimpl; | |
97 | const ObjectFile *OwningObject; | |
98 | ||
99 | public: | |
100 | RelocationRef() : OwningObject(NULL) { } | |
101 | ||
102 | RelocationRef(DataRefImpl RelocationP, const ObjectFile *Owner); | |
103 | ||
104 | bool operator==(const RelocationRef &Other) const; | |
105 | ||
106 | error_code getNext(RelocationRef &Result) const; | |
107 | ||
108 | error_code getAddress(uint64_t &Result) const; | |
109 | error_code getOffset(uint64_t &Result) const; | |
110 | error_code getSymbol(SymbolRef &Result) const; | |
111 | error_code getType(uint64_t &Result) const; | |
112 | ||
113 | /// @brief Indicates whether this relocation should hidden when listing | |
114 | /// relocations, usually because it is the trailing part of a multipart | |
115 | /// relocation that will be printed as part of the leading relocation. | |
116 | error_code getHidden(bool &Result) const; | |
117 | ||
118 | /// @brief Get a string that represents the type of this relocation. | |
119 | /// | |
120 | /// This is for display purposes only. | |
121 | error_code getTypeName(SmallVectorImpl<char> &Result) const; | |
122 | error_code getAdditionalInfo(int64_t &Result) const; | |
123 | ||
124 | /// @brief Get a string that represents the calculation of the value of this | |
125 | /// relocation. | |
126 | /// | |
127 | /// This is for display purposes only. | |
128 | error_code getValueString(SmallVectorImpl<char> &Result) const; | |
129 | ||
130 | DataRefImpl getRawDataRefImpl() const; | |
131 | }; | |
132 | typedef content_iterator<RelocationRef> relocation_iterator; | |
133 | ||
134 | /// SectionRef - This is a value type class that represents a single section in | |
135 | /// the list of sections in the object file. | |
136 | class SectionRef { | |
137 | friend class SymbolRef; | |
138 | DataRefImpl SectionPimpl; | |
139 | const ObjectFile *OwningObject; | |
140 | ||
141 | public: | |
142 | SectionRef() : OwningObject(NULL) { } | |
143 | ||
144 | SectionRef(DataRefImpl SectionP, const ObjectFile *Owner); | |
145 | ||
146 | bool operator==(const SectionRef &Other) const; | |
970d7e83 | 147 | bool operator<(const SectionRef &Other) const; |
223e47cc LB |
148 | |
149 | error_code getNext(SectionRef &Result) const; | |
150 | ||
151 | error_code getName(StringRef &Result) const; | |
152 | error_code getAddress(uint64_t &Result) const; | |
153 | error_code getSize(uint64_t &Result) const; | |
154 | error_code getContents(StringRef &Result) const; | |
155 | ||
156 | /// @brief Get the alignment of this section as the actual value (not log 2). | |
157 | error_code getAlignment(uint64_t &Result) const; | |
158 | ||
159 | // FIXME: Move to the normalization layer when it's created. | |
160 | error_code isText(bool &Result) const; | |
161 | error_code isData(bool &Result) const; | |
162 | error_code isBSS(bool &Result) const; | |
163 | error_code isRequiredForExecution(bool &Result) const; | |
164 | error_code isVirtual(bool &Result) const; | |
165 | error_code isZeroInit(bool &Result) const; | |
970d7e83 | 166 | error_code isReadOnlyData(bool &Result) const; |
223e47cc LB |
167 | |
168 | error_code containsSymbol(SymbolRef S, bool &Result) const; | |
169 | ||
170 | relocation_iterator begin_relocations() const; | |
171 | relocation_iterator end_relocations() const; | |
172 | ||
173 | DataRefImpl getRawDataRefImpl() const; | |
174 | }; | |
175 | typedef content_iterator<SectionRef> section_iterator; | |
176 | ||
177 | /// SymbolRef - This is a value type class that represents a single symbol in | |
178 | /// the list of symbols in the object file. | |
179 | class SymbolRef { | |
180 | friend class SectionRef; | |
181 | DataRefImpl SymbolPimpl; | |
182 | const ObjectFile *OwningObject; | |
183 | ||
184 | public: | |
185 | SymbolRef() : OwningObject(NULL) { } | |
186 | ||
187 | enum Type { | |
188 | ST_Unknown, // Type not specified | |
189 | ST_Data, | |
190 | ST_Debug, | |
191 | ST_File, | |
192 | ST_Function, | |
193 | ST_Other | |
194 | }; | |
195 | ||
196 | enum Flags { | |
197 | SF_None = 0, | |
198 | SF_Undefined = 1U << 0, // Symbol is defined in another object file | |
199 | SF_Global = 1U << 1, // Global symbol | |
200 | SF_Weak = 1U << 2, // Weak symbol | |
201 | SF_Absolute = 1U << 3, // Absolute symbol | |
202 | SF_ThreadLocal = 1U << 4, // Thread local symbol | |
203 | SF_Common = 1U << 5, // Symbol has common linkage | |
204 | SF_FormatSpecific = 1U << 31 // Specific to the object file format | |
205 | // (e.g. section symbols) | |
206 | }; | |
207 | ||
208 | SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner); | |
209 | ||
210 | bool operator==(const SymbolRef &Other) const; | |
970d7e83 | 211 | bool operator<(const SymbolRef &Other) const; |
223e47cc LB |
212 | |
213 | error_code getNext(SymbolRef &Result) const; | |
214 | ||
215 | error_code getName(StringRef &Result) const; | |
216 | /// Returns the symbol virtual address (i.e. address at which it will be | |
217 | /// mapped). | |
218 | error_code getAddress(uint64_t &Result) const; | |
219 | error_code getFileOffset(uint64_t &Result) const; | |
220 | error_code getSize(uint64_t &Result) const; | |
221 | error_code getType(SymbolRef::Type &Result) const; | |
222 | ||
223 | /// Returns the ascii char that should be displayed in a symbol table dump via | |
224 | /// nm for this symbol. | |
225 | error_code getNMTypeChar(char &Result) const; | |
226 | ||
227 | /// Get symbol flags (bitwise OR of SymbolRef::Flags) | |
228 | error_code getFlags(uint32_t &Result) const; | |
229 | ||
230 | /// @brief Return true for common symbols such as uninitialized globals | |
231 | error_code isCommon(bool &Result) const; | |
232 | ||
233 | /// @brief Get section this symbol is defined in reference to. Result is | |
234 | /// end_sections() if it is undefined or is an absolute symbol. | |
235 | error_code getSection(section_iterator &Result) const; | |
236 | ||
970d7e83 LB |
237 | /// @brief Get value of the symbol in the symbol table. |
238 | error_code getValue(uint64_t &Val) const; | |
239 | ||
223e47cc LB |
240 | DataRefImpl getRawDataRefImpl() const; |
241 | }; | |
242 | typedef content_iterator<SymbolRef> symbol_iterator; | |
243 | ||
244 | /// LibraryRef - This is a value type class that represents a single library in | |
245 | /// the list of libraries needed by a shared or dynamic object. | |
246 | class LibraryRef { | |
247 | friend class SectionRef; | |
248 | DataRefImpl LibraryPimpl; | |
249 | const ObjectFile *OwningObject; | |
250 | ||
251 | public: | |
252 | LibraryRef() : OwningObject(NULL) { } | |
253 | ||
254 | LibraryRef(DataRefImpl LibraryP, const ObjectFile *Owner); | |
255 | ||
256 | bool operator==(const LibraryRef &Other) const; | |
970d7e83 | 257 | bool operator<(const LibraryRef &Other) const; |
223e47cc LB |
258 | |
259 | error_code getNext(LibraryRef &Result) const; | |
260 | ||
261 | // Get the path to this library, as stored in the object file. | |
262 | error_code getPath(StringRef &Result) const; | |
263 | ||
264 | DataRefImpl getRawDataRefImpl() const; | |
265 | }; | |
266 | typedef content_iterator<LibraryRef> library_iterator; | |
267 | ||
268 | const uint64_t UnknownAddressOrSize = ~0ULL; | |
269 | ||
270 | /// ObjectFile - This class is the base class for all object file types. | |
271 | /// Concrete instances of this object are created by createObjectFile, which | |
970d7e83 | 272 | /// figures out which type to create. |
223e47cc LB |
273 | class ObjectFile : public Binary { |
274 | virtual void anchor(); | |
275 | ObjectFile() LLVM_DELETED_FUNCTION; | |
276 | ObjectFile(const ObjectFile &other) LLVM_DELETED_FUNCTION; | |
277 | ||
278 | protected: | |
279 | ObjectFile(unsigned int Type, MemoryBuffer *source, error_code &ec); | |
280 | ||
281 | const uint8_t *base() const { | |
282 | return reinterpret_cast<const uint8_t *>(Data->getBufferStart()); | |
283 | } | |
284 | ||
285 | // These functions are for SymbolRef to call internally. The main goal of | |
286 | // this is to allow SymbolRef::SymbolPimpl to point directly to the symbol | |
287 | // entry in the memory mapped object file. SymbolPimpl cannot contain any | |
288 | // virtual functions because then it could not point into the memory mapped | |
289 | // file. | |
290 | // | |
291 | // Implementations assume that the DataRefImpl is valid and has not been | |
292 | // modified externally. It's UB otherwise. | |
293 | friend class SymbolRef; | |
294 | virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const = 0; | |
295 | virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const = 0; | |
970d7e83 LB |
296 | virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const = 0; |
297 | virtual error_code getSymbolFileOffset(DataRefImpl Symb, uint64_t &Res)const=0; | |
223e47cc LB |
298 | virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const = 0; |
299 | virtual error_code getSymbolType(DataRefImpl Symb, | |
300 | SymbolRef::Type &Res) const = 0; | |
301 | virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const = 0; | |
302 | virtual error_code getSymbolFlags(DataRefImpl Symb, | |
303 | uint32_t &Res) const = 0; | |
304 | virtual error_code getSymbolSection(DataRefImpl Symb, | |
305 | section_iterator &Res) const = 0; | |
970d7e83 | 306 | virtual error_code getSymbolValue(DataRefImpl Symb, uint64_t &Val) const = 0; |
223e47cc LB |
307 | |
308 | // Same as above for SectionRef. | |
309 | friend class SectionRef; | |
310 | virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const = 0; | |
311 | virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const = 0; | |
312 | virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const =0; | |
313 | virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const = 0; | |
314 | virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res)const=0; | |
315 | virtual error_code getSectionAlignment(DataRefImpl Sec, uint64_t &Res)const=0; | |
316 | virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const = 0; | |
317 | virtual error_code isSectionData(DataRefImpl Sec, bool &Res) const = 0; | |
318 | virtual error_code isSectionBSS(DataRefImpl Sec, bool &Res) const = 0; | |
319 | virtual error_code isSectionRequiredForExecution(DataRefImpl Sec, | |
320 | bool &Res) const = 0; | |
321 | // A section is 'virtual' if its contents aren't present in the object image. | |
322 | virtual error_code isSectionVirtual(DataRefImpl Sec, bool &Res) const = 0; | |
323 | virtual error_code isSectionZeroInit(DataRefImpl Sec, bool &Res) const = 0; | |
970d7e83 | 324 | virtual error_code isSectionReadOnlyData(DataRefImpl Sec, bool &Res) const =0; |
223e47cc LB |
325 | virtual error_code sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb, |
326 | bool &Result) const = 0; | |
327 | virtual relocation_iterator getSectionRelBegin(DataRefImpl Sec) const = 0; | |
328 | virtual relocation_iterator getSectionRelEnd(DataRefImpl Sec) const = 0; | |
329 | ||
330 | ||
331 | // Same as above for RelocationRef. | |
332 | friend class RelocationRef; | |
333 | virtual error_code getRelocationNext(DataRefImpl Rel, | |
334 | RelocationRef &Res) const = 0; | |
335 | virtual error_code getRelocationAddress(DataRefImpl Rel, | |
336 | uint64_t &Res) const =0; | |
337 | virtual error_code getRelocationOffset(DataRefImpl Rel, | |
338 | uint64_t &Res) const =0; | |
339 | virtual error_code getRelocationSymbol(DataRefImpl Rel, | |
340 | SymbolRef &Res) const = 0; | |
341 | virtual error_code getRelocationType(DataRefImpl Rel, | |
342 | uint64_t &Res) const = 0; | |
343 | virtual error_code getRelocationTypeName(DataRefImpl Rel, | |
344 | SmallVectorImpl<char> &Result) const = 0; | |
345 | virtual error_code getRelocationAdditionalInfo(DataRefImpl Rel, | |
346 | int64_t &Res) const = 0; | |
347 | virtual error_code getRelocationValueString(DataRefImpl Rel, | |
348 | SmallVectorImpl<char> &Result) const = 0; | |
349 | virtual error_code getRelocationHidden(DataRefImpl Rel, bool &Result) const { | |
350 | Result = false; | |
351 | return object_error::success; | |
352 | } | |
353 | ||
354 | // Same for LibraryRef | |
355 | friend class LibraryRef; | |
356 | virtual error_code getLibraryNext(DataRefImpl Lib, LibraryRef &Res) const = 0; | |
357 | virtual error_code getLibraryPath(DataRefImpl Lib, StringRef &Res) const = 0; | |
358 | ||
359 | public: | |
360 | ||
361 | virtual symbol_iterator begin_symbols() const = 0; | |
362 | virtual symbol_iterator end_symbols() const = 0; | |
363 | ||
364 | virtual symbol_iterator begin_dynamic_symbols() const = 0; | |
365 | virtual symbol_iterator end_dynamic_symbols() const = 0; | |
366 | ||
367 | virtual section_iterator begin_sections() const = 0; | |
368 | virtual section_iterator end_sections() const = 0; | |
369 | ||
370 | virtual library_iterator begin_libraries_needed() const = 0; | |
371 | virtual library_iterator end_libraries_needed() const = 0; | |
372 | ||
373 | /// @brief The number of bytes used to represent an address in this object | |
374 | /// file format. | |
375 | virtual uint8_t getBytesInAddress() const = 0; | |
376 | ||
377 | virtual StringRef getFileFormatName() const = 0; | |
378 | virtual /* Triple::ArchType */ unsigned getArch() const = 0; | |
379 | ||
380 | /// For shared objects, returns the name which this object should be | |
381 | /// loaded from at runtime. This corresponds to DT_SONAME on ELF and | |
382 | /// LC_ID_DYLIB (install name) on MachO. | |
383 | virtual StringRef getLoadName() const = 0; | |
384 | ||
385 | /// @returns Pointer to ObjectFile subclass to handle this type of object. | |
386 | /// @param ObjectPath The path to the object file. ObjectPath.isObject must | |
387 | /// return true. | |
388 | /// @brief Create ObjectFile from path. | |
389 | static ObjectFile *createObjectFile(StringRef ObjectPath); | |
390 | static ObjectFile *createObjectFile(MemoryBuffer *Object); | |
391 | ||
392 | static inline bool classof(const Binary *v) { | |
393 | return v->isObject(); | |
394 | } | |
223e47cc LB |
395 | |
396 | public: | |
397 | static ObjectFile *createCOFFObjectFile(MemoryBuffer *Object); | |
398 | static ObjectFile *createELFObjectFile(MemoryBuffer *Object); | |
399 | static ObjectFile *createMachOObjectFile(MemoryBuffer *Object); | |
400 | }; | |
401 | ||
402 | // Inline function definitions. | |
403 | inline SymbolRef::SymbolRef(DataRefImpl SymbolP, const ObjectFile *Owner) | |
404 | : SymbolPimpl(SymbolP) | |
405 | , OwningObject(Owner) {} | |
406 | ||
407 | inline bool SymbolRef::operator==(const SymbolRef &Other) const { | |
408 | return SymbolPimpl == Other.SymbolPimpl; | |
409 | } | |
410 | ||
970d7e83 | 411 | inline bool SymbolRef::operator<(const SymbolRef &Other) const { |
223e47cc LB |
412 | return SymbolPimpl < Other.SymbolPimpl; |
413 | } | |
414 | ||
415 | inline error_code SymbolRef::getNext(SymbolRef &Result) const { | |
416 | return OwningObject->getSymbolNext(SymbolPimpl, Result); | |
417 | } | |
418 | ||
419 | inline error_code SymbolRef::getName(StringRef &Result) const { | |
420 | return OwningObject->getSymbolName(SymbolPimpl, Result); | |
421 | } | |
422 | ||
423 | inline error_code SymbolRef::getAddress(uint64_t &Result) const { | |
424 | return OwningObject->getSymbolAddress(SymbolPimpl, Result); | |
425 | } | |
426 | ||
427 | inline error_code SymbolRef::getFileOffset(uint64_t &Result) const { | |
428 | return OwningObject->getSymbolFileOffset(SymbolPimpl, Result); | |
429 | } | |
430 | ||
431 | inline error_code SymbolRef::getSize(uint64_t &Result) const { | |
432 | return OwningObject->getSymbolSize(SymbolPimpl, Result); | |
433 | } | |
434 | ||
435 | inline error_code SymbolRef::getNMTypeChar(char &Result) const { | |
436 | return OwningObject->getSymbolNMTypeChar(SymbolPimpl, Result); | |
437 | } | |
438 | ||
439 | inline error_code SymbolRef::getFlags(uint32_t &Result) const { | |
440 | return OwningObject->getSymbolFlags(SymbolPimpl, Result); | |
441 | } | |
442 | ||
443 | inline error_code SymbolRef::getSection(section_iterator &Result) const { | |
444 | return OwningObject->getSymbolSection(SymbolPimpl, Result); | |
445 | } | |
446 | ||
447 | inline error_code SymbolRef::getType(SymbolRef::Type &Result) const { | |
448 | return OwningObject->getSymbolType(SymbolPimpl, Result); | |
449 | } | |
450 | ||
970d7e83 LB |
451 | inline error_code SymbolRef::getValue(uint64_t &Val) const { |
452 | return OwningObject->getSymbolValue(SymbolPimpl, Val); | |
453 | } | |
454 | ||
223e47cc LB |
455 | inline DataRefImpl SymbolRef::getRawDataRefImpl() const { |
456 | return SymbolPimpl; | |
457 | } | |
458 | ||
459 | ||
460 | /// SectionRef | |
461 | inline SectionRef::SectionRef(DataRefImpl SectionP, | |
462 | const ObjectFile *Owner) | |
463 | : SectionPimpl(SectionP) | |
464 | , OwningObject(Owner) {} | |
465 | ||
466 | inline bool SectionRef::operator==(const SectionRef &Other) const { | |
467 | return SectionPimpl == Other.SectionPimpl; | |
468 | } | |
469 | ||
970d7e83 | 470 | inline bool SectionRef::operator<(const SectionRef &Other) const { |
223e47cc LB |
471 | return SectionPimpl < Other.SectionPimpl; |
472 | } | |
473 | ||
474 | inline error_code SectionRef::getNext(SectionRef &Result) const { | |
475 | return OwningObject->getSectionNext(SectionPimpl, Result); | |
476 | } | |
477 | ||
478 | inline error_code SectionRef::getName(StringRef &Result) const { | |
479 | return OwningObject->getSectionName(SectionPimpl, Result); | |
480 | } | |
481 | ||
482 | inline error_code SectionRef::getAddress(uint64_t &Result) const { | |
483 | return OwningObject->getSectionAddress(SectionPimpl, Result); | |
484 | } | |
485 | ||
486 | inline error_code SectionRef::getSize(uint64_t &Result) const { | |
487 | return OwningObject->getSectionSize(SectionPimpl, Result); | |
488 | } | |
489 | ||
490 | inline error_code SectionRef::getContents(StringRef &Result) const { | |
491 | return OwningObject->getSectionContents(SectionPimpl, Result); | |
492 | } | |
493 | ||
494 | inline error_code SectionRef::getAlignment(uint64_t &Result) const { | |
495 | return OwningObject->getSectionAlignment(SectionPimpl, Result); | |
496 | } | |
497 | ||
498 | inline error_code SectionRef::isText(bool &Result) const { | |
499 | return OwningObject->isSectionText(SectionPimpl, Result); | |
500 | } | |
501 | ||
502 | inline error_code SectionRef::isData(bool &Result) const { | |
503 | return OwningObject->isSectionData(SectionPimpl, Result); | |
504 | } | |
505 | ||
506 | inline error_code SectionRef::isBSS(bool &Result) const { | |
507 | return OwningObject->isSectionBSS(SectionPimpl, Result); | |
508 | } | |
509 | ||
510 | inline error_code SectionRef::isRequiredForExecution(bool &Result) const { | |
511 | return OwningObject->isSectionRequiredForExecution(SectionPimpl, Result); | |
512 | } | |
513 | ||
514 | inline error_code SectionRef::isVirtual(bool &Result) const { | |
515 | return OwningObject->isSectionVirtual(SectionPimpl, Result); | |
516 | } | |
517 | ||
518 | inline error_code SectionRef::isZeroInit(bool &Result) const { | |
519 | return OwningObject->isSectionZeroInit(SectionPimpl, Result); | |
520 | } | |
521 | ||
970d7e83 LB |
522 | inline error_code SectionRef::isReadOnlyData(bool &Result) const { |
523 | return OwningObject->isSectionReadOnlyData(SectionPimpl, Result); | |
524 | } | |
525 | ||
223e47cc LB |
526 | inline error_code SectionRef::containsSymbol(SymbolRef S, bool &Result) const { |
527 | return OwningObject->sectionContainsSymbol(SectionPimpl, S.SymbolPimpl, | |
528 | Result); | |
529 | } | |
530 | ||
531 | inline relocation_iterator SectionRef::begin_relocations() const { | |
532 | return OwningObject->getSectionRelBegin(SectionPimpl); | |
533 | } | |
534 | ||
535 | inline relocation_iterator SectionRef::end_relocations() const { | |
536 | return OwningObject->getSectionRelEnd(SectionPimpl); | |
537 | } | |
538 | ||
539 | inline DataRefImpl SectionRef::getRawDataRefImpl() const { | |
540 | return SectionPimpl; | |
541 | } | |
542 | ||
543 | /// RelocationRef | |
544 | inline RelocationRef::RelocationRef(DataRefImpl RelocationP, | |
545 | const ObjectFile *Owner) | |
546 | : RelocationPimpl(RelocationP) | |
547 | , OwningObject(Owner) {} | |
548 | ||
549 | inline bool RelocationRef::operator==(const RelocationRef &Other) const { | |
550 | return RelocationPimpl == Other.RelocationPimpl; | |
551 | } | |
552 | ||
553 | inline error_code RelocationRef::getNext(RelocationRef &Result) const { | |
554 | return OwningObject->getRelocationNext(RelocationPimpl, Result); | |
555 | } | |
556 | ||
557 | inline error_code RelocationRef::getAddress(uint64_t &Result) const { | |
558 | return OwningObject->getRelocationAddress(RelocationPimpl, Result); | |
559 | } | |
560 | ||
561 | inline error_code RelocationRef::getOffset(uint64_t &Result) const { | |
562 | return OwningObject->getRelocationOffset(RelocationPimpl, Result); | |
563 | } | |
564 | ||
565 | inline error_code RelocationRef::getSymbol(SymbolRef &Result) const { | |
566 | return OwningObject->getRelocationSymbol(RelocationPimpl, Result); | |
567 | } | |
568 | ||
569 | inline error_code RelocationRef::getType(uint64_t &Result) const { | |
570 | return OwningObject->getRelocationType(RelocationPimpl, Result); | |
571 | } | |
572 | ||
573 | inline error_code RelocationRef::getTypeName(SmallVectorImpl<char> &Result) | |
574 | const { | |
575 | return OwningObject->getRelocationTypeName(RelocationPimpl, Result); | |
576 | } | |
577 | ||
578 | inline error_code RelocationRef::getAdditionalInfo(int64_t &Result) const { | |
579 | return OwningObject->getRelocationAdditionalInfo(RelocationPimpl, Result); | |
580 | } | |
581 | ||
582 | inline error_code RelocationRef::getValueString(SmallVectorImpl<char> &Result) | |
583 | const { | |
584 | return OwningObject->getRelocationValueString(RelocationPimpl, Result); | |
585 | } | |
586 | ||
587 | inline error_code RelocationRef::getHidden(bool &Result) const { | |
588 | return OwningObject->getRelocationHidden(RelocationPimpl, Result); | |
589 | } | |
590 | ||
591 | inline DataRefImpl RelocationRef::getRawDataRefImpl() const { | |
592 | return RelocationPimpl; | |
593 | } | |
594 | ||
595 | // Inline function definitions. | |
596 | inline LibraryRef::LibraryRef(DataRefImpl LibraryP, const ObjectFile *Owner) | |
597 | : LibraryPimpl(LibraryP) | |
598 | , OwningObject(Owner) {} | |
599 | ||
600 | inline bool LibraryRef::operator==(const LibraryRef &Other) const { | |
601 | return LibraryPimpl == Other.LibraryPimpl; | |
602 | } | |
603 | ||
970d7e83 | 604 | inline bool LibraryRef::operator<(const LibraryRef &Other) const { |
223e47cc LB |
605 | return LibraryPimpl < Other.LibraryPimpl; |
606 | } | |
607 | ||
608 | inline error_code LibraryRef::getNext(LibraryRef &Result) const { | |
609 | return OwningObject->getLibraryNext(LibraryPimpl, Result); | |
610 | } | |
611 | ||
612 | inline error_code LibraryRef::getPath(StringRef &Result) const { | |
613 | return OwningObject->getLibraryPath(LibraryPimpl, Result); | |
614 | } | |
615 | ||
616 | } // end namespace object | |
617 | } // end namespace llvm | |
618 | ||
619 | #endif |