1.7.5.1Copyright © 2003-2013 University of Illinois at Urbana-Champaign. All Rights Reserved.
LLVM API Documentation
00001 //===- ELF.h - ELF object file implementation -------------------*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file declares the ELFObjectFile template class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #ifndef LLVM_OBJECT_ELF_H 00015 #define LLVM_OBJECT_ELF_H 00016 00017 #include "llvm/ADT/DenseMap.h" 00018 #include "llvm/ADT/PointerIntPair.h" 00019 #include "llvm/ADT/SmallVector.h" 00020 #include "llvm/ADT/StringSwitch.h" 00021 #include "llvm/ADT/Triple.h" 00022 #include "llvm/Object/ObjectFile.h" 00023 #include "llvm/Support/Casting.h" 00024 #include "llvm/Support/ELF.h" 00025 #include "llvm/Support/Endian.h" 00026 #include "llvm/Support/ErrorHandling.h" 00027 #include "llvm/Support/MemoryBuffer.h" 00028 #include "llvm/Support/raw_ostream.h" 00029 #include <algorithm> 00030 #include <limits> 00031 #include <utility> 00032 00033 namespace llvm { 00034 namespace object { 00035 00036 using support::endianness; 00037 00038 template<endianness target_endianness, std::size_t max_alignment, bool is64Bits> 00039 struct ELFType { 00040 static const endianness TargetEndianness = target_endianness; 00041 static const std::size_t MaxAlignment = max_alignment; 00042 static const bool Is64Bits = is64Bits; 00043 }; 00044 00045 template<typename T, int max_align> 00046 struct MaximumAlignment { 00047 enum {value = AlignOf<T>::Alignment > max_align ? max_align 00048 : AlignOf<T>::Alignment}; 00049 }; 00050 00051 // Subclasses of ELFObjectFile may need this for template instantiation 00052 inline std::pair<unsigned char, unsigned char> 00053 getElfArchType(MemoryBuffer *Object) { 00054 if (Object->getBufferSize() < ELF::EI_NIDENT) 00055 return std::make_pair((uint8_t)ELF::ELFCLASSNONE,(uint8_t)ELF::ELFDATANONE); 00056 return std::make_pair((uint8_t) Object->getBufferStart()[ELF::EI_CLASS], 00057 (uint8_t) Object->getBufferStart()[ELF::EI_DATA]); 00058 } 00059 00060 // Templates to choose Elf_Addr and Elf_Off depending on is64Bits. 00061 template<endianness target_endianness, std::size_t max_alignment> 00062 struct ELFDataTypeTypedefHelperCommon { 00063 typedef support::detail::packed_endian_specific_integral 00064 <uint16_t, target_endianness, 00065 MaximumAlignment<uint16_t, max_alignment>::value> Elf_Half; 00066 typedef support::detail::packed_endian_specific_integral 00067 <uint32_t, target_endianness, 00068 MaximumAlignment<uint32_t, max_alignment>::value> Elf_Word; 00069 typedef support::detail::packed_endian_specific_integral 00070 <int32_t, target_endianness, 00071 MaximumAlignment<int32_t, max_alignment>::value> Elf_Sword; 00072 typedef support::detail::packed_endian_specific_integral 00073 <uint64_t, target_endianness, 00074 MaximumAlignment<uint64_t, max_alignment>::value> Elf_Xword; 00075 typedef support::detail::packed_endian_specific_integral 00076 <int64_t, target_endianness, 00077 MaximumAlignment<int64_t, max_alignment>::value> Elf_Sxword; 00078 }; 00079 00080 template<class ELFT> 00081 struct ELFDataTypeTypedefHelper; 00082 00083 /// ELF 32bit types. 00084 template<endianness TargetEndianness, std::size_t MaxAlign> 00085 struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, MaxAlign, false> > 00086 : ELFDataTypeTypedefHelperCommon<TargetEndianness, MaxAlign> { 00087 typedef uint32_t value_type; 00088 typedef support::detail::packed_endian_specific_integral 00089 <value_type, TargetEndianness, 00090 MaximumAlignment<value_type, MaxAlign>::value> Elf_Addr; 00091 typedef support::detail::packed_endian_specific_integral 00092 <value_type, TargetEndianness, 00093 MaximumAlignment<value_type, MaxAlign>::value> Elf_Off; 00094 }; 00095 00096 /// ELF 64bit types. 00097 template<endianness TargetEndianness, std::size_t MaxAlign> 00098 struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, MaxAlign, true> > 00099 : ELFDataTypeTypedefHelperCommon<TargetEndianness, MaxAlign> { 00100 typedef uint64_t value_type; 00101 typedef support::detail::packed_endian_specific_integral 00102 <value_type, TargetEndianness, 00103 MaximumAlignment<value_type, MaxAlign>::value> Elf_Addr; 00104 typedef support::detail::packed_endian_specific_integral 00105 <value_type, TargetEndianness, 00106 MaximumAlignment<value_type, MaxAlign>::value> Elf_Off; 00107 }; 00108 00109 // I really don't like doing this, but the alternative is copypasta. 00110 #define LLVM_ELF_IMPORT_TYPES(E, M, W) \ 00111 typedef typename ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Addr Elf_Addr; \ 00112 typedef typename ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Off Elf_Off; \ 00113 typedef typename ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Half Elf_Half; \ 00114 typedef typename ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Word Elf_Word; \ 00115 typedef typename \ 00116 ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Sword Elf_Sword; \ 00117 typedef typename \ 00118 ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Xword Elf_Xword; \ 00119 typedef typename \ 00120 ELFDataTypeTypedefHelper<ELFType<E,M,W> >::Elf_Sxword Elf_Sxword; 00121 00122 #define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \ 00123 LLVM_ELF_IMPORT_TYPES(ELFT::TargetEndianness, ELFT::MaxAlignment, \ 00124 ELFT::Is64Bits) 00125 00126 // Section header. 00127 template<class ELFT> 00128 struct Elf_Shdr_Base; 00129 00130 template<endianness TargetEndianness, std::size_t MaxAlign> 00131 struct Elf_Shdr_Base<ELFType<TargetEndianness, MaxAlign, false> > { 00132 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00133 Elf_Word sh_name; // Section name (index into string table) 00134 Elf_Word sh_type; // Section type (SHT_*) 00135 Elf_Word sh_flags; // Section flags (SHF_*) 00136 Elf_Addr sh_addr; // Address where section is to be loaded 00137 Elf_Off sh_offset; // File offset of section data, in bytes 00138 Elf_Word sh_size; // Size of section, in bytes 00139 Elf_Word sh_link; // Section type-specific header table index link 00140 Elf_Word sh_info; // Section type-specific extra information 00141 Elf_Word sh_addralign;// Section address alignment 00142 Elf_Word sh_entsize; // Size of records contained within the section 00143 }; 00144 00145 template<endianness TargetEndianness, std::size_t MaxAlign> 00146 struct Elf_Shdr_Base<ELFType<TargetEndianness, MaxAlign, true> > { 00147 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00148 Elf_Word sh_name; // Section name (index into string table) 00149 Elf_Word sh_type; // Section type (SHT_*) 00150 Elf_Xword sh_flags; // Section flags (SHF_*) 00151 Elf_Addr sh_addr; // Address where section is to be loaded 00152 Elf_Off sh_offset; // File offset of section data, in bytes 00153 Elf_Xword sh_size; // Size of section, in bytes 00154 Elf_Word sh_link; // Section type-specific header table index link 00155 Elf_Word sh_info; // Section type-specific extra information 00156 Elf_Xword sh_addralign;// Section address alignment 00157 Elf_Xword sh_entsize; // Size of records contained within the section 00158 }; 00159 00160 template<class ELFT> 00161 struct Elf_Shdr_Impl : Elf_Shdr_Base<ELFT> { 00162 using Elf_Shdr_Base<ELFT>::sh_entsize; 00163 using Elf_Shdr_Base<ELFT>::sh_size; 00164 00165 /// @brief Get the number of entities this section contains if it has any. 00166 unsigned getEntityCount() const { 00167 if (sh_entsize == 0) 00168 return 0; 00169 return sh_size / sh_entsize; 00170 } 00171 }; 00172 00173 template<class ELFT> 00174 struct Elf_Sym_Base; 00175 00176 template<endianness TargetEndianness, std::size_t MaxAlign> 00177 struct Elf_Sym_Base<ELFType<TargetEndianness, MaxAlign, false> > { 00178 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00179 Elf_Word st_name; // Symbol name (index into string table) 00180 Elf_Addr st_value; // Value or address associated with the symbol 00181 Elf_Word st_size; // Size of the symbol 00182 unsigned char st_info; // Symbol's type and binding attributes 00183 unsigned char st_other; // Must be zero; reserved 00184 Elf_Half st_shndx; // Which section (header table index) it's defined in 00185 }; 00186 00187 template<endianness TargetEndianness, std::size_t MaxAlign> 00188 struct Elf_Sym_Base<ELFType<TargetEndianness, MaxAlign, true> > { 00189 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00190 Elf_Word st_name; // Symbol name (index into string table) 00191 unsigned char st_info; // Symbol's type and binding attributes 00192 unsigned char st_other; // Must be zero; reserved 00193 Elf_Half st_shndx; // Which section (header table index) it's defined in 00194 Elf_Addr st_value; // Value or address associated with the symbol 00195 Elf_Xword st_size; // Size of the symbol 00196 }; 00197 00198 template<class ELFT> 00199 struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> { 00200 using Elf_Sym_Base<ELFT>::st_info; 00201 00202 // These accessors and mutators correspond to the ELF32_ST_BIND, 00203 // ELF32_ST_TYPE, and ELF32_ST_INFO macros defined in the ELF specification: 00204 unsigned char getBinding() const { return st_info >> 4; } 00205 unsigned char getType() const { return st_info & 0x0f; } 00206 void setBinding(unsigned char b) { setBindingAndType(b, getType()); } 00207 void setType(unsigned char t) { setBindingAndType(getBinding(), t); } 00208 void setBindingAndType(unsigned char b, unsigned char t) { 00209 st_info = (b << 4) + (t & 0x0f); 00210 } 00211 }; 00212 00213 /// Elf_Versym: This is the structure of entries in the SHT_GNU_versym section 00214 /// (.gnu.version). This structure is identical for ELF32 and ELF64. 00215 template<class ELFT> 00216 struct Elf_Versym_Impl { 00217 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00218 Elf_Half vs_index; // Version index with flags (e.g. VERSYM_HIDDEN) 00219 }; 00220 00221 template<class ELFT> 00222 struct Elf_Verdaux_Impl; 00223 00224 /// Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section 00225 /// (.gnu.version_d). This structure is identical for ELF32 and ELF64. 00226 template<class ELFT> 00227 struct Elf_Verdef_Impl { 00228 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00229 typedef Elf_Verdaux_Impl<ELFT> Elf_Verdaux; 00230 Elf_Half vd_version; // Version of this structure (e.g. VER_DEF_CURRENT) 00231 Elf_Half vd_flags; // Bitwise flags (VER_DEF_*) 00232 Elf_Half vd_ndx; // Version index, used in .gnu.version entries 00233 Elf_Half vd_cnt; // Number of Verdaux entries 00234 Elf_Word vd_hash; // Hash of name 00235 Elf_Word vd_aux; // Offset to the first Verdaux entry (in bytes) 00236 Elf_Word vd_next; // Offset to the next Verdef entry (in bytes) 00237 00238 /// Get the first Verdaux entry for this Verdef. 00239 const Elf_Verdaux *getAux() const { 00240 return reinterpret_cast<const Elf_Verdaux*>((const char*)this + vd_aux); 00241 } 00242 }; 00243 00244 /// Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef 00245 /// section (.gnu.version_d). This structure is identical for ELF32 and ELF64. 00246 template<class ELFT> 00247 struct Elf_Verdaux_Impl { 00248 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00249 Elf_Word vda_name; // Version name (offset in string table) 00250 Elf_Word vda_next; // Offset to next Verdaux entry (in bytes) 00251 }; 00252 00253 /// Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed 00254 /// section (.gnu.version_r). This structure is identical for ELF32 and ELF64. 00255 template<class ELFT> 00256 struct Elf_Verneed_Impl { 00257 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00258 Elf_Half vn_version; // Version of this structure (e.g. VER_NEED_CURRENT) 00259 Elf_Half vn_cnt; // Number of associated Vernaux entries 00260 Elf_Word vn_file; // Library name (string table offset) 00261 Elf_Word vn_aux; // Offset to first Vernaux entry (in bytes) 00262 Elf_Word vn_next; // Offset to next Verneed entry (in bytes) 00263 }; 00264 00265 /// Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed 00266 /// section (.gnu.version_r). This structure is identical for ELF32 and ELF64. 00267 template<class ELFT> 00268 struct Elf_Vernaux_Impl { 00269 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00270 Elf_Word vna_hash; // Hash of dependency name 00271 Elf_Half vna_flags; // Bitwise Flags (VER_FLAG_*) 00272 Elf_Half vna_other; // Version index, used in .gnu.version entries 00273 Elf_Word vna_name; // Dependency name 00274 Elf_Word vna_next; // Offset to next Vernaux entry (in bytes) 00275 }; 00276 00277 /// Elf_Dyn_Base: This structure matches the form of entries in the dynamic 00278 /// table section (.dynamic) look like. 00279 template<class ELFT> 00280 struct Elf_Dyn_Base; 00281 00282 template<endianness TargetEndianness, std::size_t MaxAlign> 00283 struct Elf_Dyn_Base<ELFType<TargetEndianness, MaxAlign, false> > { 00284 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00285 Elf_Sword d_tag; 00286 union { 00287 Elf_Word d_val; 00288 Elf_Addr d_ptr; 00289 } d_un; 00290 }; 00291 00292 template<endianness TargetEndianness, std::size_t MaxAlign> 00293 struct Elf_Dyn_Base<ELFType<TargetEndianness, MaxAlign, true> > { 00294 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00295 Elf_Sxword d_tag; 00296 union { 00297 Elf_Xword d_val; 00298 Elf_Addr d_ptr; 00299 } d_un; 00300 }; 00301 00302 /// Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters and setters. 00303 template<class ELFT> 00304 struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> { 00305 using Elf_Dyn_Base<ELFT>::d_tag; 00306 using Elf_Dyn_Base<ELFT>::d_un; 00307 int64_t getTag() const { return d_tag; } 00308 uint64_t getVal() const { return d_un.d_val; } 00309 uint64_t getPtr() const { return d_un.ptr; } 00310 }; 00311 00312 // Elf_Rel: Elf Relocation 00313 template<class ELFT, bool isRela> 00314 struct Elf_Rel_Base; 00315 00316 template<endianness TargetEndianness, std::size_t MaxAlign> 00317 struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, false> { 00318 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00319 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 00320 Elf_Word r_info; // Symbol table index and type of relocation to apply 00321 00322 uint32_t getRInfo(bool isMips64EL) const { 00323 assert(!isMips64EL); 00324 return r_info; 00325 } 00326 void setRInfo(uint32_t R) { 00327 r_info = R; 00328 } 00329 }; 00330 00331 template<endianness TargetEndianness, std::size_t MaxAlign> 00332 struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, false> { 00333 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00334 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 00335 Elf_Xword r_info; // Symbol table index and type of relocation to apply 00336 00337 uint64_t getRInfo(bool isMips64EL) const { 00338 uint64_t t = r_info; 00339 if (!isMips64EL) 00340 return t; 00341 // Mips64 little endian has a "special" encoding of r_info. Instead of one 00342 // 64 bit little endian number, it is a little endian 32 bit number followed 00343 // by a 32 bit big endian number. 00344 return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) | 00345 ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff); 00346 } 00347 void setRInfo(uint64_t R) { 00348 // FIXME: Add mips64el support. 00349 r_info = R; 00350 } 00351 }; 00352 00353 template<endianness TargetEndianness, std::size_t MaxAlign> 00354 struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, true> { 00355 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00356 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 00357 Elf_Word r_info; // Symbol table index and type of relocation to apply 00358 Elf_Sword r_addend; // Compute value for relocatable field by adding this 00359 00360 uint32_t getRInfo(bool isMips64EL) const { 00361 assert(!isMips64EL); 00362 return r_info; 00363 } 00364 void setRInfo(uint32_t R) { 00365 r_info = R; 00366 } 00367 }; 00368 00369 template<endianness TargetEndianness, std::size_t MaxAlign> 00370 struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, true> { 00371 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00372 Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) 00373 Elf_Xword r_info; // Symbol table index and type of relocation to apply 00374 Elf_Sxword r_addend; // Compute value for relocatable field by adding this. 00375 00376 uint64_t getRInfo(bool isMips64EL) const { 00377 // Mips64 little endian has a "special" encoding of r_info. Instead of one 00378 // 64 bit little endian number, it is a little endian 32 bit number followed 00379 // by a 32 bit big endian number. 00380 uint64_t t = r_info; 00381 if (!isMips64EL) 00382 return t; 00383 return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) | 00384 ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff); 00385 } 00386 void setRInfo(uint64_t R) { 00387 // FIXME: Add mips64el support. 00388 r_info = R; 00389 } 00390 }; 00391 00392 template<class ELFT, bool isRela> 00393 struct Elf_Rel_Impl; 00394 00395 template<endianness TargetEndianness, std::size_t MaxAlign, bool isRela> 00396 struct Elf_Rel_Impl<ELFType<TargetEndianness, MaxAlign, true>, isRela> 00397 : Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, isRela> { 00398 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00399 00400 // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE, 00401 // and ELF64_R_INFO macros defined in the ELF specification: 00402 uint32_t getSymbol(bool isMips64EL) const { 00403 return (uint32_t) (this->getRInfo(isMips64EL) >> 32); 00404 } 00405 uint32_t getType(bool isMips64EL) const { 00406 return (uint32_t) (this->getRInfo(isMips64EL) & 0xffffffffL); 00407 } 00408 void setSymbol(uint32_t s) { setSymbolAndType(s, getType()); } 00409 void setType(uint32_t t) { setSymbolAndType(getSymbol(), t); } 00410 void setSymbolAndType(uint32_t s, uint32_t t) { 00411 this->setRInfo(((uint64_t)s << 32) + (t&0xffffffffL)); 00412 } 00413 }; 00414 00415 template<endianness TargetEndianness, std::size_t MaxAlign, bool isRela> 00416 struct Elf_Rel_Impl<ELFType<TargetEndianness, MaxAlign, false>, isRela> 00417 : Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, isRela> { 00418 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00419 00420 // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE, 00421 // and ELF32_R_INFO macros defined in the ELF specification: 00422 uint32_t getSymbol(bool isMips64EL) const { 00423 return this->getRInfo(isMips64EL) >> 8; 00424 } 00425 unsigned char getType(bool isMips64EL) const { 00426 return (unsigned char) (this->getRInfo(isMips64EL) & 0x0ff); 00427 } 00428 void setSymbol(uint32_t s) { setSymbolAndType(s, getType()); } 00429 void setType(unsigned char t) { setSymbolAndType(getSymbol(), t); } 00430 void setSymbolAndType(uint32_t s, unsigned char t) { 00431 this->setRInfo((s << 8) + t); 00432 } 00433 }; 00434 00435 template<class ELFT> 00436 struct Elf_Ehdr_Impl { 00437 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00438 unsigned char e_ident[ELF::EI_NIDENT]; // ELF Identification bytes 00439 Elf_Half e_type; // Type of file (see ET_*) 00440 Elf_Half e_machine; // Required architecture for this file (see EM_*) 00441 Elf_Word e_version; // Must be equal to 1 00442 Elf_Addr e_entry; // Address to jump to in order to start program 00443 Elf_Off e_phoff; // Program header table's file offset, in bytes 00444 Elf_Off e_shoff; // Section header table's file offset, in bytes 00445 Elf_Word e_flags; // Processor-specific flags 00446 Elf_Half e_ehsize; // Size of ELF header, in bytes 00447 Elf_Half e_phentsize;// Size of an entry in the program header table 00448 Elf_Half e_phnum; // Number of entries in the program header table 00449 Elf_Half e_shentsize;// Size of an entry in the section header table 00450 Elf_Half e_shnum; // Number of entries in the section header table 00451 Elf_Half e_shstrndx; // Section header table index of section name 00452 // string table 00453 bool checkMagic() const { 00454 return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0; 00455 } 00456 unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; } 00457 unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; } 00458 }; 00459 00460 template<class ELFT> 00461 struct Elf_Phdr_Impl; 00462 00463 template<endianness TargetEndianness, std::size_t MaxAlign> 00464 struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, false> > { 00465 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) 00466 Elf_Word p_type; // Type of segment 00467 Elf_Off p_offset; // FileOffset where segment is located, in bytes 00468 Elf_Addr p_vaddr; // Virtual Address of beginning of segment 00469 Elf_Addr p_paddr; // Physical address of beginning of segment (OS-specific) 00470 Elf_Word p_filesz; // Num. of bytes in file image of segment (may be zero) 00471 Elf_Word p_memsz; // Num. of bytes in mem image of segment (may be zero) 00472 Elf_Word p_flags; // Segment flags 00473 Elf_Word p_align; // Segment alignment constraint 00474 }; 00475 00476 template<endianness TargetEndianness, std::size_t MaxAlign> 00477 struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, true> > { 00478 LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) 00479 Elf_Word p_type; // Type of segment 00480 Elf_Word p_flags; // Segment flags 00481 Elf_Off p_offset; // FileOffset where segment is located, in bytes 00482 Elf_Addr p_vaddr; // Virtual Address of beginning of segment 00483 Elf_Addr p_paddr; // Physical address of beginning of segment (OS-specific) 00484 Elf_Xword p_filesz; // Num. of bytes in file image of segment (may be zero) 00485 Elf_Xword p_memsz; // Num. of bytes in mem image of segment (may be zero) 00486 Elf_Xword p_align; // Segment alignment constraint 00487 }; 00488 00489 template<class ELFT> 00490 class ELFObjectFile : public ObjectFile { 00491 LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) 00492 00493 public: 00494 /// \brief Iterate over constant sized entities. 00495 template<class EntT> 00496 class ELFEntityIterator { 00497 public: 00498 typedef ptrdiff_t difference_type; 00499 typedef EntT value_type; 00500 typedef std::random_access_iterator_tag iterator_category; 00501 typedef value_type &reference; 00502 typedef value_type *pointer; 00503 00504 /// \brief Default construct iterator. 00505 ELFEntityIterator() : EntitySize(0), Current(0) {} 00506 ELFEntityIterator(uint64_t EntSize, const char *Start) 00507 : EntitySize(EntSize) 00508 , Current(Start) {} 00509 00510 reference operator *() { 00511 assert(Current && "Attempted to dereference an invalid iterator!"); 00512 return *reinterpret_cast<pointer>(Current); 00513 } 00514 00515 pointer operator ->() { 00516 assert(Current && "Attempted to dereference an invalid iterator!"); 00517 return reinterpret_cast<pointer>(Current); 00518 } 00519 00520 bool operator ==(const ELFEntityIterator &Other) { 00521 return Current == Other.Current; 00522 } 00523 00524 bool operator !=(const ELFEntityIterator &Other) { 00525 return !(*this == Other); 00526 } 00527 00528 ELFEntityIterator &operator ++() { 00529 assert(Current && "Attempted to increment an invalid iterator!"); 00530 Current += EntitySize; 00531 return *this; 00532 } 00533 00534 ELFEntityIterator operator ++(int) { 00535 ELFEntityIterator Tmp = *this; 00536 ++*this; 00537 return Tmp; 00538 } 00539 00540 ELFEntityIterator &operator =(const ELFEntityIterator &Other) { 00541 EntitySize = Other.EntitySize; 00542 Current = Other.Current; 00543 return *this; 00544 } 00545 00546 difference_type operator -(const ELFEntityIterator &Other) const { 00547 assert(EntitySize == Other.EntitySize && 00548 "Subtracting iterators of different EntitiySize!"); 00549 return (Current - Other.Current) / EntitySize; 00550 } 00551 00552 const char *get() const { return Current; } 00553 00554 private: 00555 uint64_t EntitySize; 00556 const char *Current; 00557 }; 00558 00559 typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr; 00560 typedef Elf_Shdr_Impl<ELFT> Elf_Shdr; 00561 typedef Elf_Sym_Impl<ELFT> Elf_Sym; 00562 typedef Elf_Dyn_Impl<ELFT> Elf_Dyn; 00563 typedef Elf_Phdr_Impl<ELFT> Elf_Phdr; 00564 typedef Elf_Rel_Impl<ELFT, false> Elf_Rel; 00565 typedef Elf_Rel_Impl<ELFT, true> Elf_Rela; 00566 typedef Elf_Verdef_Impl<ELFT> Elf_Verdef; 00567 typedef Elf_Verdaux_Impl<ELFT> Elf_Verdaux; 00568 typedef Elf_Verneed_Impl<ELFT> Elf_Verneed; 00569 typedef Elf_Vernaux_Impl<ELFT> Elf_Vernaux; 00570 typedef Elf_Versym_Impl<ELFT> Elf_Versym; 00571 typedef ELFEntityIterator<const Elf_Dyn> Elf_Dyn_iterator; 00572 typedef ELFEntityIterator<const Elf_Sym> Elf_Sym_iterator; 00573 typedef ELFEntityIterator<const Elf_Rela> Elf_Rela_Iter; 00574 typedef ELFEntityIterator<const Elf_Rel> Elf_Rel_Iter; 00575 00576 protected: 00577 // This flag is used for classof, to distinguish ELFObjectFile from 00578 // its subclass. If more subclasses will be created, this flag will 00579 // have to become an enum. 00580 bool isDyldELFObject; 00581 00582 private: 00583 const Elf_Ehdr *Header; 00584 const Elf_Shdr *SectionHeaderTable; 00585 const Elf_Shdr *dot_shstrtab_sec; // Section header string table. 00586 const Elf_Shdr *dot_strtab_sec; // Symbol header string table. 00587 const Elf_Shdr *dot_dynstr_sec; // Dynamic symbol string table. 00588 00589 int SymbolTableIndex; 00590 int DynamicSymbolTableIndex; 00591 DenseMap<const Elf_Sym*, ELF::Elf64_Word> ExtendedSymbolTable; 00592 00593 const Elf_Shdr *dot_dynamic_sec; // .dynamic 00594 const Elf_Shdr *dot_gnu_version_sec; // .gnu.version 00595 const Elf_Shdr *dot_gnu_version_r_sec; // .gnu.version_r 00596 const Elf_Shdr *dot_gnu_version_d_sec; // .gnu.version_d 00597 00598 // Pointer to SONAME entry in dynamic string table 00599 // This is set the first time getLoadName is called. 00600 mutable const char *dt_soname; 00601 00602 private: 00603 uint64_t getROffset(DataRefImpl Rel) const; 00604 00605 // Records for each version index the corresponding Verdef or Vernaux entry. 00606 // This is filled the first time LoadVersionMap() is called. 00607 class VersionMapEntry : public PointerIntPair<const void*, 1> { 00608 public: 00609 // If the integer is 0, this is an Elf_Verdef*. 00610 // If the integer is 1, this is an Elf_Vernaux*. 00611 VersionMapEntry() : PointerIntPair<const void*, 1>(NULL, 0) { } 00612 VersionMapEntry(const Elf_Verdef *verdef) 00613 : PointerIntPair<const void*, 1>(verdef, 0) { } 00614 VersionMapEntry(const Elf_Vernaux *vernaux) 00615 : PointerIntPair<const void*, 1>(vernaux, 1) { } 00616 bool isNull() const { return getPointer() == NULL; } 00617 bool isVerdef() const { return !isNull() && getInt() == 0; } 00618 bool isVernaux() const { return !isNull() && getInt() == 1; } 00619 const Elf_Verdef *getVerdef() const { 00620 return isVerdef() ? (const Elf_Verdef*)getPointer() : NULL; 00621 } 00622 const Elf_Vernaux *getVernaux() const { 00623 return isVernaux() ? (const Elf_Vernaux*)getPointer() : NULL; 00624 } 00625 }; 00626 mutable SmallVector<VersionMapEntry, 16> VersionMap; 00627 void LoadVersionDefs(const Elf_Shdr *sec) const; 00628 void LoadVersionNeeds(const Elf_Shdr *ec) const; 00629 void LoadVersionMap() const; 00630 00631 /// @brief Get the relocation section that contains \a Rel. 00632 const Elf_Shdr *getRelSection(DataRefImpl Rel) const { 00633 return getSection(Rel.d.a); 00634 } 00635 00636 public: 00637 bool isRelocationHasAddend(DataRefImpl Rel) const; 00638 template<typename T> 00639 const T *getEntry(uint32_t Section, uint32_t Entry) const; 00640 template<typename T> 00641 const T *getEntry(const Elf_Shdr *Section, uint32_t Entry) const; 00642 const Elf_Shdr *getSection(DataRefImpl index) const; 00643 const Elf_Shdr *getSection(uint32_t index) const; 00644 const Elf_Rel *getRel(DataRefImpl Rel) const; 00645 const Elf_Rela *getRela(DataRefImpl Rela) const; 00646 const char *getString(uint32_t section, uint32_t offset) const; 00647 const char *getString(const Elf_Shdr *section, uint32_t offset) const; 00648 error_code getSymbolVersion(const Elf_Shdr *section, 00649 const Elf_Sym *Symb, 00650 StringRef &Version, 00651 bool &IsDefault) const; 00652 void VerifyStrTab(const Elf_Shdr *sh) const; 00653 00654 protected: 00655 const Elf_Sym *getSymbol(DataRefImpl Symb) const; // FIXME: Should be private? 00656 void validateSymbol(DataRefImpl Symb) const; 00657 StringRef getRelocationTypeName(uint32_t Type) const; 00658 00659 public: 00660 error_code getSymbolName(const Elf_Shdr *section, 00661 const Elf_Sym *Symb, 00662 StringRef &Res) const; 00663 error_code getSectionName(const Elf_Shdr *section, 00664 StringRef &Res) const; 00665 const Elf_Dyn *getDyn(DataRefImpl DynData) const; 00666 error_code getSymbolVersion(SymbolRef Symb, StringRef &Version, 00667 bool &IsDefault) const; 00668 uint64_t getSymbolIndex(const Elf_Sym *sym) const; 00669 error_code getRelocationAddend(DataRefImpl Rel, int64_t &Res) const; 00670 protected: 00671 virtual error_code getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const; 00672 virtual error_code getSymbolName(DataRefImpl Symb, StringRef &Res) const; 00673 virtual error_code getSymbolFileOffset(DataRefImpl Symb, uint64_t &Res) const; 00674 virtual error_code getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const; 00675 virtual error_code getSymbolAlignment(DataRefImpl Symb, uint32_t &Res) const; 00676 virtual error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const; 00677 virtual error_code getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const; 00678 virtual error_code getSymbolFlags(DataRefImpl Symb, uint32_t &Res) const; 00679 virtual error_code getSymbolType(DataRefImpl Symb, 00680 SymbolRef::Type &Res) const; 00681 virtual error_code getSymbolSection(DataRefImpl Symb, 00682 section_iterator &Res) const; 00683 virtual error_code getSymbolValue(DataRefImpl Symb, uint64_t &Val) const; 00684 00685 virtual error_code getLibraryNext(DataRefImpl Data, LibraryRef &Result) const; 00686 virtual error_code getLibraryPath(DataRefImpl Data, StringRef &Res) const; 00687 00688 virtual error_code getSectionNext(DataRefImpl Sec, SectionRef &Res) const; 00689 virtual error_code getSectionName(DataRefImpl Sec, StringRef &Res) const; 00690 virtual error_code getSectionAddress(DataRefImpl Sec, uint64_t &Res) const; 00691 virtual error_code getSectionSize(DataRefImpl Sec, uint64_t &Res) const; 00692 virtual error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const; 00693 virtual error_code getSectionAlignment(DataRefImpl Sec, uint64_t &Res) const; 00694 virtual error_code isSectionText(DataRefImpl Sec, bool &Res) const; 00695 virtual error_code isSectionData(DataRefImpl Sec, bool &Res) const; 00696 virtual error_code isSectionBSS(DataRefImpl Sec, bool &Res) const; 00697 virtual error_code isSectionRequiredForExecution(DataRefImpl Sec, 00698 bool &Res) const; 00699 virtual error_code isSectionVirtual(DataRefImpl Sec, bool &Res) const; 00700 virtual error_code isSectionZeroInit(DataRefImpl Sec, bool &Res) const; 00701 virtual error_code isSectionReadOnlyData(DataRefImpl Sec, bool &Res) const; 00702 virtual error_code sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb, 00703 bool &Result) const; 00704 virtual relocation_iterator getSectionRelBegin(DataRefImpl Sec) const; 00705 virtual relocation_iterator getSectionRelEnd(DataRefImpl Sec) const; 00706 virtual section_iterator getRelocatedSection(DataRefImpl Sec) const; 00707 00708 virtual error_code getRelocationNext(DataRefImpl Rel, 00709 RelocationRef &Res) const; 00710 virtual error_code getRelocationAddress(DataRefImpl Rel, 00711 uint64_t &Res) const; 00712 virtual error_code getRelocationOffset(DataRefImpl Rel, 00713 uint64_t &Res) const; 00714 virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const; 00715 virtual error_code getRelocationType(DataRefImpl Rel, 00716 uint64_t &Res) const; 00717 virtual error_code getRelocationTypeName(DataRefImpl Rel, 00718 SmallVectorImpl<char> &Result) const; 00719 virtual error_code getRelocationValueString(DataRefImpl Rel, 00720 SmallVectorImpl<char> &Result) const; 00721 00722 public: 00723 ELFObjectFile(MemoryBuffer *Object, error_code &ec); 00724 00725 bool isMips64EL() const { 00726 return Header->e_machine == ELF::EM_MIPS && 00727 Header->getFileClass() == ELF::ELFCLASS64 && 00728 Header->getDataEncoding() == ELF::ELFDATA2LSB; 00729 } 00730 00731 virtual symbol_iterator begin_symbols() const; 00732 virtual symbol_iterator end_symbols() const; 00733 00734 virtual symbol_iterator begin_dynamic_symbols() const; 00735 virtual symbol_iterator end_dynamic_symbols() const; 00736 00737 virtual section_iterator begin_sections() const; 00738 virtual section_iterator end_sections() const; 00739 00740 virtual library_iterator begin_libraries_needed() const; 00741 virtual library_iterator end_libraries_needed() const; 00742 00743 const Elf_Shdr *getDynamicSymbolTableSectionHeader() const { 00744 return getSection(DynamicSymbolTableIndex); 00745 } 00746 00747 const Elf_Shdr *getDynamicStringTableSectionHeader() const { 00748 return dot_dynstr_sec; 00749 } 00750 00751 Elf_Dyn_iterator begin_dynamic_table() const; 00752 /// \param NULLEnd use one past the first DT_NULL entry as the end instead of 00753 /// the section size. 00754 Elf_Dyn_iterator end_dynamic_table(bool NULLEnd = false) const; 00755 00756 Elf_Sym_iterator begin_elf_dynamic_symbols() const { 00757 const Elf_Shdr *DynSymtab = getDynamicSymbolTableSectionHeader(); 00758 if (DynSymtab) 00759 return Elf_Sym_iterator(DynSymtab->sh_entsize, 00760 (const char *)base() + DynSymtab->sh_offset); 00761 return Elf_Sym_iterator(0, 0); 00762 } 00763 00764 Elf_Sym_iterator end_elf_dynamic_symbols() const { 00765 const Elf_Shdr *DynSymtab = getDynamicSymbolTableSectionHeader(); 00766 if (DynSymtab) 00767 return Elf_Sym_iterator(DynSymtab->sh_entsize, (const char *)base() + 00768 DynSymtab->sh_offset + DynSymtab->sh_size); 00769 return Elf_Sym_iterator(0, 0); 00770 } 00771 00772 Elf_Rela_Iter beginELFRela(const Elf_Shdr *sec) const { 00773 return Elf_Rela_Iter(sec->sh_entsize, 00774 (const char *)(base() + sec->sh_offset)); 00775 } 00776 00777 Elf_Rela_Iter endELFRela(const Elf_Shdr *sec) const { 00778 return Elf_Rela_Iter(sec->sh_entsize, (const char *) 00779 (base() + sec->sh_offset + sec->sh_size)); 00780 } 00781 00782 Elf_Rel_Iter beginELFRel(const Elf_Shdr *sec) const { 00783 return Elf_Rel_Iter(sec->sh_entsize, 00784 (const char *)(base() + sec->sh_offset)); 00785 } 00786 00787 Elf_Rel_Iter endELFRel(const Elf_Shdr *sec) const { 00788 return Elf_Rel_Iter(sec->sh_entsize, (const char *) 00789 (base() + sec->sh_offset + sec->sh_size)); 00790 } 00791 00792 /// \brief Iterate over program header table. 00793 typedef ELFEntityIterator<const Elf_Phdr> Elf_Phdr_Iter; 00794 00795 Elf_Phdr_Iter begin_program_headers() const { 00796 return Elf_Phdr_Iter(Header->e_phentsize, 00797 (const char*)base() + Header->e_phoff); 00798 } 00799 00800 Elf_Phdr_Iter end_program_headers() const { 00801 return Elf_Phdr_Iter(Header->e_phentsize, 00802 (const char*)base() + 00803 Header->e_phoff + 00804 (Header->e_phnum * Header->e_phentsize)); 00805 } 00806 00807 virtual uint8_t getBytesInAddress() const; 00808 virtual StringRef getFileFormatName() const; 00809 virtual StringRef getObjectType() const { return "ELF"; } 00810 virtual unsigned getArch() const; 00811 virtual StringRef getLoadName() const; 00812 virtual error_code getSectionContents(const Elf_Shdr *sec, 00813 StringRef &Res) const; 00814 00815 uint64_t getNumSections() const; 00816 uint64_t getStringTableIndex() const; 00817 ELF::Elf64_Word getSymbolTableIndex(const Elf_Sym *symb) const; 00818 const Elf_Ehdr *getElfHeader() const; 00819 const Elf_Shdr *getSection(const Elf_Sym *symb) const; 00820 const Elf_Shdr *getElfSection(section_iterator &It) const; 00821 const Elf_Sym *getElfSymbol(symbol_iterator &It) const; 00822 const Elf_Sym *getElfSymbol(uint32_t index) const; 00823 00824 // Methods for type inquiry through isa, cast, and dyn_cast 00825 bool isDyldType() const { return isDyldELFObject; } 00826 static inline bool classof(const Binary *v) { 00827 return v->getType() == getELFType(ELFT::TargetEndianness == support::little, 00828 ELFT::Is64Bits); 00829 } 00830 }; 00831 00832 // Use an alignment of 2 for the typedefs since that is the worst case for 00833 // ELF files in archives. 00834 typedef ELFObjectFile<ELFType<support::little, 2, false> > ELF32LEObjectFile; 00835 typedef ELFObjectFile<ELFType<support::little, 2, true> > ELF64LEObjectFile; 00836 typedef ELFObjectFile<ELFType<support::big, 2, false> > ELF32BEObjectFile; 00837 typedef ELFObjectFile<ELFType<support::big, 2, true> > ELF64BEObjectFile; 00838 00839 // Iterate through the version definitions, and place each Elf_Verdef 00840 // in the VersionMap according to its index. 00841 template<class ELFT> 00842 void ELFObjectFile<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const { 00843 unsigned vd_size = sec->sh_size; // Size of section in bytes 00844 unsigned vd_count = sec->sh_info; // Number of Verdef entries 00845 const char *sec_start = (const char*)base() + sec->sh_offset; 00846 const char *sec_end = sec_start + vd_size; 00847 // The first Verdef entry is at the start of the section. 00848 const char *p = sec_start; 00849 for (unsigned i = 0; i < vd_count; i++) { 00850 if (p + sizeof(Elf_Verdef) > sec_end) 00851 report_fatal_error("Section ended unexpectedly while scanning " 00852 "version definitions."); 00853 const Elf_Verdef *vd = reinterpret_cast<const Elf_Verdef *>(p); 00854 if (vd->vd_version != ELF::VER_DEF_CURRENT) 00855 report_fatal_error("Unexpected verdef version"); 00856 size_t index = vd->vd_ndx & ELF::VERSYM_VERSION; 00857 if (index >= VersionMap.size()) 00858 VersionMap.resize(index+1); 00859 VersionMap[index] = VersionMapEntry(vd); 00860 p += vd->vd_next; 00861 } 00862 } 00863 00864 // Iterate through the versions needed section, and place each Elf_Vernaux 00865 // in the VersionMap according to its index. 00866 template<class ELFT> 00867 void ELFObjectFile<ELFT>::LoadVersionNeeds(const Elf_Shdr *sec) const { 00868 unsigned vn_size = sec->sh_size; // Size of section in bytes 00869 unsigned vn_count = sec->sh_info; // Number of Verneed entries 00870 const char *sec_start = (const char*)base() + sec->sh_offset; 00871 const char *sec_end = sec_start + vn_size; 00872 // The first Verneed entry is at the start of the section. 00873 const char *p = sec_start; 00874 for (unsigned i = 0; i < vn_count; i++) { 00875 if (p + sizeof(Elf_Verneed) > sec_end) 00876 report_fatal_error("Section ended unexpectedly while scanning " 00877 "version needed records."); 00878 const Elf_Verneed *vn = reinterpret_cast<const Elf_Verneed *>(p); 00879 if (vn->vn_version != ELF::VER_NEED_CURRENT) 00880 report_fatal_error("Unexpected verneed version"); 00881 // Iterate through the Vernaux entries 00882 const char *paux = p + vn->vn_aux; 00883 for (unsigned j = 0; j < vn->vn_cnt; j++) { 00884 if (paux + sizeof(Elf_Vernaux) > sec_end) 00885 report_fatal_error("Section ended unexpected while scanning auxiliary " 00886 "version needed records."); 00887 const Elf_Vernaux *vna = reinterpret_cast<const Elf_Vernaux *>(paux); 00888 size_t index = vna->vna_other & ELF::VERSYM_VERSION; 00889 if (index >= VersionMap.size()) 00890 VersionMap.resize(index+1); 00891 VersionMap[index] = VersionMapEntry(vna); 00892 paux += vna->vna_next; 00893 } 00894 p += vn->vn_next; 00895 } 00896 } 00897 00898 template<class ELFT> 00899 void ELFObjectFile<ELFT>::LoadVersionMap() const { 00900 // If there is no dynamic symtab or version table, there is nothing to do. 00901 if (getDynamicStringTableSectionHeader() == NULL || 00902 dot_gnu_version_sec == NULL) 00903 return; 00904 00905 // Has the VersionMap already been loaded? 00906 if (VersionMap.size() > 0) 00907 return; 00908 00909 // The first two version indexes are reserved. 00910 // Index 0 is LOCAL, index 1 is GLOBAL. 00911 VersionMap.push_back(VersionMapEntry()); 00912 VersionMap.push_back(VersionMapEntry()); 00913 00914 if (dot_gnu_version_d_sec) 00915 LoadVersionDefs(dot_gnu_version_d_sec); 00916 00917 if (dot_gnu_version_r_sec) 00918 LoadVersionNeeds(dot_gnu_version_r_sec); 00919 } 00920 00921 template<class ELFT> 00922 void ELFObjectFile<ELFT>::validateSymbol(DataRefImpl Symb) const { 00923 #ifndef NDEBUG 00924 const Elf_Sym *symb = getSymbol(Symb); 00925 const Elf_Shdr *SymbolTableSection = getSection(Symb.d.b); 00926 // FIXME: We really need to do proper error handling in the case of an invalid 00927 // input file. Because we don't use exceptions, I think we'll just pass 00928 // an error object around. 00929 if (!( symb 00930 && SymbolTableSection 00931 && symb >= (const Elf_Sym*)(base() 00932 + SymbolTableSection->sh_offset) 00933 && symb < (const Elf_Sym*)(base() 00934 + SymbolTableSection->sh_offset 00935 + SymbolTableSection->sh_size))) 00936 // FIXME: Proper error handling. 00937 report_fatal_error("Symb must point to a valid symbol!"); 00938 #endif 00939 } 00940 00941 template<class ELFT> 00942 error_code ELFObjectFile<ELFT>::getSymbolNext(DataRefImpl Symb, 00943 SymbolRef &Result) const { 00944 validateSymbol(Symb); 00945 ++Symb.d.a; 00946 Result = SymbolRef(Symb, this); 00947 return object_error::success; 00948 } 00949 00950 template<class ELFT> 00951 error_code ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Symb, 00952 StringRef &Result) const { 00953 validateSymbol(Symb); 00954 const Elf_Sym *symb = getSymbol(Symb); 00955 return getSymbolName(getSection(Symb.d.b), symb, Result); 00956 } 00957 00958 template<class ELFT> 00959 error_code ELFObjectFile<ELFT>::getSymbolVersion(SymbolRef SymRef, 00960 StringRef &Version, 00961 bool &IsDefault) const { 00962 DataRefImpl Symb = SymRef.getRawDataRefImpl(); 00963 validateSymbol(Symb); 00964 const Elf_Sym *symb = getSymbol(Symb); 00965 return getSymbolVersion(getSection(Symb.d.b), symb, Version, IsDefault); 00966 } 00967 00968 template<class ELFT> 00969 ELF::Elf64_Word ELFObjectFile<ELFT> 00970 ::getSymbolTableIndex(const Elf_Sym *symb) const { 00971 if (symb->st_shndx == ELF::SHN_XINDEX) 00972 return ExtendedSymbolTable.lookup(symb); 00973 return symb->st_shndx; 00974 } 00975 00976 template<class ELFT> 00977 const typename ELFObjectFile<ELFT>::Elf_Shdr * 00978 ELFObjectFile<ELFT>::getSection(const Elf_Sym *symb) const { 00979 if (symb->st_shndx == ELF::SHN_XINDEX) 00980 return getSection(ExtendedSymbolTable.lookup(symb)); 00981 if (symb->st_shndx >= ELF::SHN_LORESERVE) 00982 return 0; 00983 return getSection(symb->st_shndx); 00984 } 00985 00986 template<class ELFT> 00987 const typename ELFObjectFile<ELFT>::Elf_Ehdr * 00988 ELFObjectFile<ELFT>::getElfHeader() const { 00989 return Header; 00990 } 00991 00992 template<class ELFT> 00993 const typename ELFObjectFile<ELFT>::Elf_Shdr * 00994 ELFObjectFile<ELFT>::getElfSection(section_iterator &It) const { 00995 llvm::object::DataRefImpl ShdrRef = It->getRawDataRefImpl(); 00996 return reinterpret_cast<const Elf_Shdr *>(ShdrRef.p); 00997 } 00998 00999 template<class ELFT> 01000 const typename ELFObjectFile<ELFT>::Elf_Sym * 01001 ELFObjectFile<ELFT>::getElfSymbol(symbol_iterator &It) const { 01002 return getSymbol(It->getRawDataRefImpl()); 01003 } 01004 01005 template<class ELFT> 01006 const typename ELFObjectFile<ELFT>::Elf_Sym * 01007 ELFObjectFile<ELFT>::getElfSymbol(uint32_t index) const { 01008 DataRefImpl SymbolData; 01009 SymbolData.d.a = index; 01010 SymbolData.d.b = SymbolTableIndex; 01011 return getSymbol(SymbolData); 01012 } 01013 01014 template<class ELFT> 01015 error_code ELFObjectFile<ELFT>::getSymbolFileOffset(DataRefImpl Symb, 01016 uint64_t &Result) const { 01017 validateSymbol(Symb); 01018 const Elf_Sym *symb = getSymbol(Symb); 01019 const Elf_Shdr *Section; 01020 switch (getSymbolTableIndex(symb)) { 01021 case ELF::SHN_COMMON: 01022 // Unintialized symbols have no offset in the object file 01023 case ELF::SHN_UNDEF: 01024 Result = UnknownAddressOrSize; 01025 return object_error::success; 01026 case ELF::SHN_ABS: 01027 Result = symb->st_value; 01028 return object_error::success; 01029 default: Section = getSection(symb); 01030 } 01031 01032 switch (symb->getType()) { 01033 case ELF::STT_SECTION: 01034 Result = Section ? Section->sh_offset : UnknownAddressOrSize; 01035 return object_error::success; 01036 case ELF::STT_FUNC: 01037 case ELF::STT_OBJECT: 01038 case ELF::STT_NOTYPE: 01039 Result = symb->st_value + 01040 (Section ? Section->sh_offset : 0); 01041 return object_error::success; 01042 default: 01043 Result = UnknownAddressOrSize; 01044 return object_error::success; 01045 } 01046 } 01047 01048 template<class ELFT> 01049 error_code ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb, 01050 uint64_t &Result) const { 01051 validateSymbol(Symb); 01052 const Elf_Sym *symb = getSymbol(Symb); 01053 const Elf_Shdr *Section; 01054 switch (getSymbolTableIndex(symb)) { 01055 case ELF::SHN_COMMON: 01056 case ELF::SHN_UNDEF: 01057 Result = UnknownAddressOrSize; 01058 return object_error::success; 01059 case ELF::SHN_ABS: 01060 Result = symb->st_value; 01061 return object_error::success; 01062 default: Section = getSection(symb); 01063 } 01064 01065 switch (symb->getType()) { 01066 case ELF::STT_SECTION: 01067 Result = Section ? Section->sh_addr : UnknownAddressOrSize; 01068 return object_error::success; 01069 case ELF::STT_FUNC: 01070 case ELF::STT_OBJECT: 01071 case ELF::STT_NOTYPE: 01072 bool IsRelocatable; 01073 switch(Header->e_type) { 01074 case ELF::ET_EXEC: 01075 case ELF::ET_DYN: 01076 IsRelocatable = false; 01077 break; 01078 default: 01079 IsRelocatable = true; 01080 } 01081 Result = symb->st_value; 01082 01083 // Clear the ARM/Thumb indicator flag. 01084 if (Header->e_machine == ELF::EM_ARM) 01085 Result &= ~1; 01086 01087 if (IsRelocatable && Section != 0) 01088 Result += Section->sh_addr; 01089 return object_error::success; 01090 default: 01091 Result = UnknownAddressOrSize; 01092 return object_error::success; 01093 } 01094 } 01095 01096 template<class ELFT> 01097 error_code ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb, 01098 uint32_t &Res) const { 01099 uint32_t flags; 01100 getSymbolFlags(Symb, flags); 01101 if (flags & SymbolRef::SF_Common) { 01102 uint64_t Value; 01103 getSymbolValue(Symb, Value); 01104 Res = Value; 01105 } else { 01106 Res = 0; 01107 } 01108 return object_error::success; 01109 } 01110 01111 template<class ELFT> 01112 error_code ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Symb, 01113 uint64_t &Result) const { 01114 validateSymbol(Symb); 01115 const Elf_Sym *symb = getSymbol(Symb); 01116 if (symb->st_size == 0) 01117 Result = UnknownAddressOrSize; 01118 Result = symb->st_size; 01119 return object_error::success; 01120 } 01121 01122 template<class ELFT> 01123 error_code ELFObjectFile<ELFT>::getSymbolNMTypeChar(DataRefImpl Symb, 01124 char &Result) const { 01125 validateSymbol(Symb); 01126 const Elf_Sym *symb = getSymbol(Symb); 01127 const Elf_Shdr *Section = getSection(symb); 01128 01129 char ret = '?'; 01130 01131 if (Section) { 01132 switch (Section->sh_type) { 01133 case ELF::SHT_PROGBITS: 01134 case ELF::SHT_DYNAMIC: 01135 switch (Section->sh_flags) { 01136 case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR): 01137 ret = 't'; break; 01138 case (ELF::SHF_ALLOC | ELF::SHF_WRITE): 01139 ret = 'd'; break; 01140 case ELF::SHF_ALLOC: 01141 case (ELF::SHF_ALLOC | ELF::SHF_MERGE): 01142 case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS): 01143 ret = 'r'; break; 01144 } 01145 break; 01146 case ELF::SHT_NOBITS: ret = 'b'; 01147 } 01148 } 01149 01150 switch (getSymbolTableIndex(symb)) { 01151 case ELF::SHN_UNDEF: 01152 if (ret == '?') 01153 ret = 'U'; 01154 break; 01155 case ELF::SHN_ABS: ret = 'a'; break; 01156 case ELF::SHN_COMMON: ret = 'c'; break; 01157 } 01158 01159 switch (symb->getBinding()) { 01160 case ELF::STB_GLOBAL: ret = ::toupper(ret); break; 01161 case ELF::STB_WEAK: 01162 if (getSymbolTableIndex(symb) == ELF::SHN_UNDEF) 01163 ret = 'w'; 01164 else 01165 if (symb->getType() == ELF::STT_OBJECT) 01166 ret = 'V'; 01167 else 01168 ret = 'W'; 01169 } 01170 01171 if (ret == '?' && symb->getType() == ELF::STT_SECTION) { 01172 StringRef name; 01173 if (error_code ec = getSymbolName(Symb, name)) 01174 return ec; 01175 Result = StringSwitch<char>(name) 01176 .StartsWith(".debug", 'N') 01177 .StartsWith(".note", 'n') 01178 .Default('?'); 01179 return object_error::success; 01180 } 01181 01182 Result = ret; 01183 return object_error::success; 01184 } 01185 01186 template<class ELFT> 01187 error_code ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb, 01188 SymbolRef::Type &Result) const { 01189 validateSymbol(Symb); 01190 const Elf_Sym *symb = getSymbol(Symb); 01191 01192 switch (symb->getType()) { 01193 case ELF::STT_NOTYPE: 01194 Result = SymbolRef::ST_Unknown; 01195 break; 01196 case ELF::STT_SECTION: 01197 Result = SymbolRef::ST_Debug; 01198 break; 01199 case ELF::STT_FILE: 01200 Result = SymbolRef::ST_File; 01201 break; 01202 case ELF::STT_FUNC: 01203 Result = SymbolRef::ST_Function; 01204 break; 01205 case ELF::STT_OBJECT: 01206 case ELF::STT_COMMON: 01207 case ELF::STT_TLS: 01208 Result = SymbolRef::ST_Data; 01209 break; 01210 default: 01211 Result = SymbolRef::ST_Other; 01212 break; 01213 } 01214 return object_error::success; 01215 } 01216 01217 template<class ELFT> 01218 error_code ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Symb, 01219 uint32_t &Result) const { 01220 validateSymbol(Symb); 01221 const Elf_Sym *symb = getSymbol(Symb); 01222 01223 Result = SymbolRef::SF_None; 01224 01225 if (symb->getBinding() != ELF::STB_LOCAL) 01226 Result |= SymbolRef::SF_Global; 01227 01228 if (symb->getBinding() == ELF::STB_WEAK) 01229 Result |= SymbolRef::SF_Weak; 01230 01231 if (symb->st_shndx == ELF::SHN_ABS) 01232 Result |= SymbolRef::SF_Absolute; 01233 01234 if (symb->getType() == ELF::STT_FILE || 01235 symb->getType() == ELF::STT_SECTION) 01236 Result |= SymbolRef::SF_FormatSpecific; 01237 01238 if (getSymbolTableIndex(symb) == ELF::SHN_UNDEF) 01239 Result |= SymbolRef::SF_Undefined; 01240 01241 if (symb->getType() == ELF::STT_COMMON || 01242 getSymbolTableIndex(symb) == ELF::SHN_COMMON) 01243 Result |= SymbolRef::SF_Common; 01244 01245 if (symb->getType() == ELF::STT_TLS) 01246 Result |= SymbolRef::SF_ThreadLocal; 01247 01248 return object_error::success; 01249 } 01250 01251 template<class ELFT> 01252 error_code ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb, 01253 section_iterator &Res) const { 01254 validateSymbol(Symb); 01255 const Elf_Sym *symb = getSymbol(Symb); 01256 const Elf_Shdr *sec = getSection(symb); 01257 if (!sec) 01258 Res = end_sections(); 01259 else { 01260 DataRefImpl Sec; 01261 Sec.p = reinterpret_cast<intptr_t>(sec); 01262 Res = section_iterator(SectionRef(Sec, this)); 01263 } 01264 return object_error::success; 01265 } 01266 01267 template<class ELFT> 01268 error_code ELFObjectFile<ELFT>::getSymbolValue(DataRefImpl Symb, 01269 uint64_t &Val) const { 01270 validateSymbol(Symb); 01271 const Elf_Sym *symb = getSymbol(Symb); 01272 Val = symb->st_value; 01273 return object_error::success; 01274 } 01275 01276 template<class ELFT> 01277 error_code ELFObjectFile<ELFT>::getSectionNext(DataRefImpl Sec, 01278 SectionRef &Result) const { 01279 const uint8_t *sec = reinterpret_cast<const uint8_t *>(Sec.p); 01280 sec += Header->e_shentsize; 01281 Sec.p = reinterpret_cast<intptr_t>(sec); 01282 Result = SectionRef(Sec, this); 01283 return object_error::success; 01284 } 01285 01286 template<class ELFT> 01287 error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec, 01288 StringRef &Result) const { 01289 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01290 Result = StringRef(getString(dot_shstrtab_sec, sec->sh_name)); 01291 return object_error::success; 01292 } 01293 01294 template<class ELFT> 01295 error_code ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec, 01296 uint64_t &Result) const { 01297 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01298 Result = sec->sh_addr; 01299 return object_error::success; 01300 } 01301 01302 template<class ELFT> 01303 error_code ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec, 01304 uint64_t &Result) const { 01305 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01306 Result = sec->sh_size; 01307 return object_error::success; 01308 } 01309 01310 template<class ELFT> 01311 error_code ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec, 01312 StringRef &Result) const { 01313 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01314 const char *start = (const char*)base() + sec->sh_offset; 01315 Result = StringRef(start, sec->sh_size); 01316 return object_error::success; 01317 } 01318 01319 template<class ELFT> 01320 error_code ELFObjectFile<ELFT>::getSectionContents(const Elf_Shdr *Sec, 01321 StringRef &Result) const { 01322 const char *start = (const char*)base() + Sec->sh_offset; 01323 Result = StringRef(start, Sec->sh_size); 01324 return object_error::success; 01325 } 01326 01327 template<class ELFT> 01328 error_code ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec, 01329 uint64_t &Result) const { 01330 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01331 Result = sec->sh_addralign; 01332 return object_error::success; 01333 } 01334 01335 template<class ELFT> 01336 error_code ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec, 01337 bool &Result) const { 01338 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01339 if (sec->sh_flags & ELF::SHF_EXECINSTR) 01340 Result = true; 01341 else 01342 Result = false; 01343 return object_error::success; 01344 } 01345 01346 template<class ELFT> 01347 error_code ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec, 01348 bool &Result) const { 01349 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01350 if (sec->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) 01351 && sec->sh_type == ELF::SHT_PROGBITS) 01352 Result = true; 01353 else 01354 Result = false; 01355 return object_error::success; 01356 } 01357 01358 template<class ELFT> 01359 error_code ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec, 01360 bool &Result) const { 01361 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01362 if (sec->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) 01363 && sec->sh_type == ELF::SHT_NOBITS) 01364 Result = true; 01365 else 01366 Result = false; 01367 return object_error::success; 01368 } 01369 01370 template<class ELFT> 01371 error_code ELFObjectFile<ELFT>::isSectionRequiredForExecution( 01372 DataRefImpl Sec, bool &Result) const { 01373 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01374 if (sec->sh_flags & ELF::SHF_ALLOC) 01375 Result = true; 01376 else 01377 Result = false; 01378 return object_error::success; 01379 } 01380 01381 template<class ELFT> 01382 error_code ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec, 01383 bool &Result) const { 01384 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01385 if (sec->sh_type == ELF::SHT_NOBITS) 01386 Result = true; 01387 else 01388 Result = false; 01389 return object_error::success; 01390 } 01391 01392 template<class ELFT> 01393 error_code ELFObjectFile<ELFT>::isSectionZeroInit(DataRefImpl Sec, 01394 bool &Result) const { 01395 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01396 // For ELF, all zero-init sections are virtual (that is, they occupy no space 01397 // in the object image) and vice versa. 01398 Result = sec->sh_type == ELF::SHT_NOBITS; 01399 return object_error::success; 01400 } 01401 01402 template<class ELFT> 01403 error_code ELFObjectFile<ELFT>::isSectionReadOnlyData(DataRefImpl Sec, 01404 bool &Result) const { 01405 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01406 if (sec->sh_flags & ELF::SHF_WRITE || sec->sh_flags & ELF::SHF_EXECINSTR) 01407 Result = false; 01408 else 01409 Result = true; 01410 return object_error::success; 01411 } 01412 01413 template<class ELFT> 01414 error_code ELFObjectFile<ELFT>::sectionContainsSymbol(DataRefImpl Sec, 01415 DataRefImpl Symb, 01416 bool &Result) const { 01417 validateSymbol(Symb); 01418 01419 const Elf_Shdr *sec = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01420 const Elf_Sym *symb = getSymbol(Symb); 01421 01422 unsigned shndx = symb->st_shndx; 01423 bool Reserved = shndx >= ELF::SHN_LORESERVE 01424 && shndx <= ELF::SHN_HIRESERVE; 01425 01426 Result = !Reserved && (sec == getSection(symb->st_shndx)); 01427 return object_error::success; 01428 } 01429 01430 template<class ELFT> 01431 relocation_iterator 01432 ELFObjectFile<ELFT>::getSectionRelBegin(DataRefImpl Sec) const { 01433 DataRefImpl RelData; 01434 uintptr_t SHT = reinterpret_cast<uintptr_t>(SectionHeaderTable); 01435 RelData.d.a = (Sec.p - SHT) / Header->e_shentsize; 01436 RelData.d.b = 0; 01437 return relocation_iterator(RelocationRef(RelData, this)); 01438 } 01439 01440 template<class ELFT> 01441 relocation_iterator 01442 ELFObjectFile<ELFT>::getSectionRelEnd(DataRefImpl Sec) const { 01443 DataRefImpl RelData; 01444 uintptr_t SHT = reinterpret_cast<uintptr_t>(SectionHeaderTable); 01445 const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01446 RelData.d.a = (Sec.p - SHT) / Header->e_shentsize; 01447 if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL) 01448 RelData.d.b = 0; 01449 else 01450 RelData.d.b = S->sh_size / S->sh_entsize; 01451 01452 return relocation_iterator(RelocationRef(RelData, this)); 01453 } 01454 01455 template <class ELFT> 01456 section_iterator 01457 ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const { 01458 if (Header->e_type != ELF::ET_REL) 01459 return end_sections(); 01460 01461 const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p); 01462 unsigned sh_type = S->sh_type; 01463 if (sh_type != ELF::SHT_RELA && sh_type != ELF::SHT_REL) 01464 return end_sections(); 01465 01466 assert(S->sh_info != 0); 01467 const Elf_Shdr *R = getSection(S->sh_info); 01468 DataRefImpl D; 01469 D.p = reinterpret_cast<uintptr_t>(R); 01470 return section_iterator(SectionRef(D, this)); 01471 } 01472 01473 // Relocations 01474 template<class ELFT> 01475 error_code ELFObjectFile<ELFT>::getRelocationNext(DataRefImpl Rel, 01476 RelocationRef &Result) const { 01477 ++Rel.d.b; 01478 Result = RelocationRef(Rel, this); 01479 return object_error::success; 01480 } 01481 01482 template <class ELFT> 01483 symbol_iterator 01484 ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const { 01485 uint32_t symbolIdx; 01486 const Elf_Shdr *sec = getRelSection(Rel); 01487 switch (sec->sh_type) { 01488 default : 01489 report_fatal_error("Invalid section type in Rel!"); 01490 case ELF::SHT_REL : { 01491 symbolIdx = getRel(Rel)->getSymbol(isMips64EL()); 01492 break; 01493 } 01494 case ELF::SHT_RELA : { 01495 symbolIdx = getRela(Rel)->getSymbol(isMips64EL()); 01496 break; 01497 } 01498 } 01499 if (!symbolIdx) 01500 return end_symbols(); 01501 01502 DataRefImpl SymbolData; 01503 SymbolData.d.a = symbolIdx; 01504 SymbolData.d.b = sec->sh_link; 01505 return symbol_iterator(SymbolRef(SymbolData, this)); 01506 } 01507 01508 template<class ELFT> 01509 error_code ELFObjectFile<ELFT>::getRelocationAddress(DataRefImpl Rel, 01510 uint64_t &Result) const { 01511 assert((Header->e_type == ELF::ET_EXEC || Header->e_type == ELF::ET_DYN) && 01512 "Only executable and shared objects files have addresses"); 01513 Result = getROffset(Rel); 01514 return object_error::success; 01515 } 01516 01517 template<class ELFT> 01518 error_code ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel, 01519 uint64_t &Result) const { 01520 assert(Header->e_type == ELF::ET_REL && 01521 "Only relocatable object files have relocation offsets"); 01522 Result = getROffset(Rel); 01523 return object_error::success; 01524 } 01525 01526 template<class ELFT> 01527 uint64_t ELFObjectFile<ELFT>::getROffset(DataRefImpl Rel) const { 01528 const Elf_Shdr *sec = getRelSection(Rel); 01529 switch (sec->sh_type) { 01530 default: 01531 report_fatal_error("Invalid section type in Rel!"); 01532 case ELF::SHT_REL: 01533 return getRel(Rel)->r_offset; 01534 case ELF::SHT_RELA: 01535 return getRela(Rel)->r_offset; 01536 } 01537 } 01538 01539 template<class ELFT> 01540 error_code ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel, 01541 uint64_t &Result) const { 01542 const Elf_Shdr *sec = getRelSection(Rel); 01543 switch (sec->sh_type) { 01544 default : 01545 report_fatal_error("Invalid section type in Rel!"); 01546 case ELF::SHT_REL : { 01547 Result = getRel(Rel)->getType(isMips64EL()); 01548 break; 01549 } 01550 case ELF::SHT_RELA : { 01551 Result = getRela(Rel)->getType(isMips64EL()); 01552 break; 01553 } 01554 } 01555 return object_error::success; 01556 } 01557 01558 #define LLVM_ELF_SWITCH_RELOC_TYPE_NAME(enum) \ 01559 case ELF::enum: Res = #enum; break; 01560 01561 template<class ELFT> 01562 StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const { 01563 StringRef Res = "Unknown"; 01564 switch (Header->e_machine) { 01565 case ELF::EM_X86_64: 01566 switch (Type) { 01567 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_NONE); 01568 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_64); 01569 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC32); 01570 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOT32); 01571 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PLT32); 01572 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_COPY); 01573 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GLOB_DAT); 01574 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_JUMP_SLOT); 01575 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_RELATIVE); 01576 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPCREL); 01577 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_32); 01578 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_32S); 01579 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_16); 01580 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC16); 01581 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_8); 01582 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC8); 01583 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPMOD64); 01584 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPOFF64); 01585 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TPOFF64); 01586 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSGD); 01587 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSLD); 01588 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_DTPOFF32); 01589 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTTPOFF); 01590 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TPOFF32); 01591 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PC64); 01592 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTOFF64); 01593 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPC32); 01594 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOT64); 01595 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPCREL64); 01596 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPC64); 01597 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPLT64); 01598 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_PLTOFF64); 01599 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_SIZE32); 01600 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_SIZE64); 01601 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_GOTPC32_TLSDESC); 01602 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSDESC_CALL); 01603 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_TLSDESC); 01604 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_X86_64_IRELATIVE); 01605 default: break; 01606 } 01607 break; 01608 case ELF::EM_386: 01609 switch (Type) { 01610 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_NONE); 01611 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_32); 01612 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC32); 01613 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOT32); 01614 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PLT32); 01615 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_COPY); 01616 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GLOB_DAT); 01617 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_JUMP_SLOT); 01618 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_RELATIVE); 01619 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOTOFF); 01620 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_GOTPC); 01621 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_32PLT); 01622 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_TPOFF); 01623 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_IE); 01624 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GOTIE); 01625 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LE); 01626 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD); 01627 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM); 01628 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_16); 01629 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC16); 01630 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_8); 01631 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_PC8); 01632 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_32); 01633 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_PUSH); 01634 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_CALL); 01635 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GD_POP); 01636 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_32); 01637 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_PUSH); 01638 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_CALL); 01639 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDM_POP); 01640 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LDO_32); 01641 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_IE_32); 01642 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_LE_32); 01643 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DTPMOD32); 01644 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DTPOFF32); 01645 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_TPOFF32); 01646 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_GOTDESC); 01647 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DESC_CALL); 01648 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_TLS_DESC); 01649 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_386_IRELATIVE); 01650 default: break; 01651 } 01652 break; 01653 case ELF::EM_MIPS: 01654 switch (Type) { 01655 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_NONE); 01656 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_16); 01657 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_32); 01658 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_REL32); 01659 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_26); 01660 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_HI16); 01661 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_LO16); 01662 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GPREL16); 01663 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_LITERAL); 01664 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT16); 01665 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_PC16); 01666 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_CALL16); 01667 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GPREL32); 01668 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_SHIFT5); 01669 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_SHIFT6); 01670 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_64); 01671 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT_DISP); 01672 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT_PAGE); 01673 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT_OFST); 01674 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT_HI16); 01675 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GOT_LO16); 01676 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_SUB); 01677 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_INSERT_A); 01678 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_INSERT_B); 01679 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_DELETE); 01680 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_HIGHER); 01681 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_HIGHEST); 01682 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_CALL_HI16); 01683 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_CALL_LO16); 01684 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_SCN_DISP); 01685 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_REL16); 01686 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_ADD_IMMEDIATE); 01687 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_PJUMP); 01688 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_RELGOT); 01689 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_JALR); 01690 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPMOD32); 01691 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPREL32); 01692 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPMOD64); 01693 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPREL64); 01694 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_GD); 01695 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_LDM); 01696 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPREL_HI16); 01697 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_DTPREL_LO16); 01698 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_GOTTPREL); 01699 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_TPREL32); 01700 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_TPREL64); 01701 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_TPREL_HI16); 01702 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_TLS_TPREL_LO16); 01703 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_GLOB_DAT); 01704 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_COPY); 01705 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_JUMP_SLOT); 01706 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_MIPS_NUM); 01707 default: break; 01708 } 01709 break; 01710 case ELF::EM_AARCH64: 01711 switch (Type) { 01712 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_NONE); 01713 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ABS64); 01714 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ABS32); 01715 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ABS16); 01716 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_PREL64); 01717 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_PREL32); 01718 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_PREL16); 01719 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G0); 01720 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G0_NC); 01721 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G1); 01722 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G1_NC); 01723 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G2); 01724 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G2_NC); 01725 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_UABS_G3); 01726 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_SABS_G0); 01727 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_SABS_G1); 01728 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_MOVW_SABS_G2); 01729 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LD_PREL_LO19); 01730 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ADR_PREL_LO21); 01731 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ADR_PREL_PG_HI21); 01732 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ADD_ABS_LO12_NC); 01733 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LDST8_ABS_LO12_NC); 01734 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TSTBR14); 01735 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_CONDBR19); 01736 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_JUMP26); 01737 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_CALL26); 01738 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LDST16_ABS_LO12_NC); 01739 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LDST32_ABS_LO12_NC); 01740 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LDST64_ABS_LO12_NC); 01741 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LDST128_ABS_LO12_NC); 01742 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_ADR_GOT_PAGE); 01743 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_LD64_GOT_LO12_NC); 01744 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_MOVW_DTPREL_G2); 01745 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_MOVW_DTPREL_G1); 01746 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC); 01747 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_MOVW_DTPREL_G0); 01748 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC); 01749 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_ADD_DTPREL_HI12); 01750 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_ADD_DTPREL_LO12); 01751 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC); 01752 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST8_DTPREL_LO12); 01753 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC); 01754 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST16_DTPREL_LO12); 01755 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC); 01756 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST32_DTPREL_LO12); 01757 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC); 01758 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST64_DTPREL_LO12); 01759 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC); 01760 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSIE_MOVW_GOTTPREL_G1); 01761 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC); 01762 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21); 01763 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC); 01764 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSIE_LD_GOTTPREL_PREL19); 01765 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_MOVW_TPREL_G2); 01766 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_MOVW_TPREL_G1); 01767 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_MOVW_TPREL_G1_NC); 01768 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_MOVW_TPREL_G0); 01769 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_MOVW_TPREL_G0_NC); 01770 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_ADD_TPREL_HI12); 01771 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_ADD_TPREL_LO12); 01772 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_ADD_TPREL_LO12_NC); 01773 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST8_TPREL_LO12); 01774 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC); 01775 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST16_TPREL_LO12); 01776 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC); 01777 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST32_TPREL_LO12); 01778 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC); 01779 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST64_TPREL_LO12); 01780 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC); 01781 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSDESC_ADR_PAGE); 01782 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSDESC_LD64_LO12_NC); 01783 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSDESC_ADD_LO12_NC); 01784 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_AARCH64_TLSDESC_CALL); 01785 default: break; 01786 } 01787 break; 01788 case ELF::EM_ARM: 01789 switch (Type) { 01790 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_NONE); 01791 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PC24); 01792 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ABS32); 01793 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_REL32); 01794 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_PC_G0); 01795 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ABS16); 01796 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ABS12); 01797 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_ABS5); 01798 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ABS8); 01799 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_SBREL32); 01800 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_CALL); 01801 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_PC8); 01802 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_BREL_ADJ); 01803 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_DESC); 01804 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_SWI8); 01805 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_XPC25); 01806 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_XPC22); 01807 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_DTPMOD32); 01808 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_DTPOFF32); 01809 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_TPOFF32); 01810 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_COPY); 01811 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GLOB_DAT); 01812 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_JUMP_SLOT); 01813 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_RELATIVE); 01814 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOTOFF32); 01815 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_BASE_PREL); 01816 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOT_BREL); 01817 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PLT32); 01818 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_CALL); 01819 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_JUMP24); 01820 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_JUMP24); 01821 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_BASE_ABS); 01822 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PCREL_7_0); 01823 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PCREL_15_8); 01824 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PCREL_23_15); 01825 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_SBREL_11_0_NC); 01826 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SBREL_19_12_NC); 01827 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SBREL_27_20_CK); 01828 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TARGET1); 01829 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_SBREL31); 01830 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_V4BX); 01831 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TARGET2); 01832 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PREL31); 01833 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVW_ABS_NC); 01834 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVT_ABS); 01835 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVW_PREL_NC); 01836 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVT_PREL); 01837 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVW_ABS_NC); 01838 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVT_ABS); 01839 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVW_PREL_NC); 01840 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVT_PREL); 01841 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_JUMP19); 01842 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_JUMP6); 01843 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_ALU_PREL_11_0); 01844 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_PC12); 01845 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ABS32_NOI); 01846 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_REL32_NOI); 01847 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PC_G0_NC); 01848 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PC_G0); 01849 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PC_G1_NC); 01850 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PC_G1); 01851 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_PC_G2); 01852 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_PC_G1); 01853 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_PC_G2); 01854 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_PC_G0); 01855 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_PC_G1); 01856 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_PC_G2); 01857 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_PC_G0); 01858 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_PC_G1); 01859 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_PC_G2); 01860 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SB_G0_NC); 01861 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SB_G0); 01862 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SB_G1_NC); 01863 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SB_G1); 01864 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ALU_SB_G2); 01865 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_SB_G0); 01866 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_SB_G1); 01867 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDR_SB_G2); 01868 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_SB_G0); 01869 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_SB_G1); 01870 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDRS_SB_G2); 01871 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_SB_G0); 01872 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_SB_G1); 01873 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_LDC_SB_G2); 01874 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVW_BREL_NC); 01875 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVT_BREL); 01876 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_MOVW_BREL); 01877 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVW_BREL_NC); 01878 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVT_BREL); 01879 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_MOVW_BREL); 01880 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_GOTDESC); 01881 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_CALL); 01882 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_DESCSEQ); 01883 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_TLS_CALL); 01884 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PLT32_ABS); 01885 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOT_ABS); 01886 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOT_PREL); 01887 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOT_BREL12); 01888 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOTOFF12); 01889 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GOTRELAX); 01890 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GNU_VTENTRY); 01891 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_GNU_VTINHERIT); 01892 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_JUMP11); 01893 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_JUMP8); 01894 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_GD32); 01895 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_LDM32); 01896 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_LDO32); 01897 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_IE32); 01898 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_LE32); 01899 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_LDO12); 01900 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_LE12); 01901 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_TLS_IE12GP); 01902 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_0); 01903 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_1); 01904 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_2); 01905 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_3); 01906 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_4); 01907 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_5); 01908 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_6); 01909 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_7); 01910 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_8); 01911 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_9); 01912 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_10); 01913 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_11); 01914 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_12); 01915 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_13); 01916 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_14); 01917 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_PRIVATE_15); 01918 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_ME_TOO); 01919 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_TLS_DESCSEQ16); 01920 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_ARM_THM_TLS_DESCSEQ32); 01921 default: break; 01922 } 01923 break; 01924 case ELF::EM_HEXAGON: 01925 switch (Type) { 01926 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_NONE); 01927 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B22_PCREL); 01928 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B15_PCREL); 01929 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B7_PCREL); 01930 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_LO16); 01931 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_HI16); 01932 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_32); 01933 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_16); 01934 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_8); 01935 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GPREL16_0); 01936 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GPREL16_1); 01937 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GPREL16_2); 01938 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GPREL16_3); 01939 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_HL16); 01940 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B13_PCREL); 01941 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B9_PCREL); 01942 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B32_PCREL_X); 01943 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_32_6_X); 01944 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B22_PCREL_X); 01945 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B15_PCREL_X); 01946 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B13_PCREL_X); 01947 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B9_PCREL_X); 01948 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_B7_PCREL_X); 01949 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_16_X); 01950 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_12_X); 01951 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_11_X); 01952 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_10_X); 01953 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_9_X); 01954 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_8_X); 01955 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_7_X); 01956 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_6_X); 01957 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_32_PCREL); 01958 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_COPY); 01959 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GLOB_DAT); 01960 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_JMP_SLOT); 01961 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_RELATIVE); 01962 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_PLT_B22_PCREL); 01963 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_LO16); 01964 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_HI16); 01965 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_32); 01966 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_LO16); 01967 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_HI16); 01968 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_32); 01969 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_16); 01970 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPMOD_32); 01971 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_LO16); 01972 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_HI16); 01973 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_32); 01974 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_16); 01975 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_PLT_B22_PCREL); 01976 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_LO16); 01977 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_HI16); 01978 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_32); 01979 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_16); 01980 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_LO16); 01981 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_HI16); 01982 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_32); 01983 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_LO16); 01984 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_HI16); 01985 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_32); 01986 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_16); 01987 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_LO16); 01988 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_HI16); 01989 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_32); 01990 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_16); 01991 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_6_PCREL_X); 01992 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_32_6_X); 01993 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_16_X); 01994 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOTREL_11_X); 01995 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_32_6_X); 01996 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_16_X); 01997 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GOT_11_X); 01998 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_32_6_X); 01999 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_16_X); 02000 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_DTPREL_11_X); 02001 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_32_6_X); 02002 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_16_X); 02003 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_GD_GOT_11_X); 02004 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_32_6_X); 02005 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_16_X); 02006 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_32_6_X); 02007 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_16_X); 02008 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_IE_GOT_11_X); 02009 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_32_6_X); 02010 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_16_X); 02011 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_HEX_TPREL_11_X); 02012 default: break; 02013 } 02014 break; 02015 case ELF::EM_PPC: 02016 switch (Type) { 02017 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_NONE); 02018 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR32); 02019 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR24); 02020 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR16); 02021 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR16_LO); 02022 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR16_HI); 02023 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR16_HA); 02024 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR14); 02025 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR14_BRTAKEN); 02026 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_ADDR14_BRNTAKEN); 02027 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_REL24); 02028 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_REL14); 02029 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_REL14_BRTAKEN); 02030 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_REL14_BRNTAKEN); 02031 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_REL32); 02032 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_TPREL16_LO); 02033 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC_TPREL16_HA); 02034 default: break; 02035 } 02036 break; 02037 case ELF::EM_PPC64: 02038 switch (Type) { 02039 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_NONE); 02040 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR32); 02041 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR24); 02042 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16); 02043 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_LO); 02044 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_HI); 02045 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_HA); 02046 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR14); 02047 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR14_BRTAKEN); 02048 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR14_BRNTAKEN); 02049 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL24); 02050 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL14); 02051 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL14_BRTAKEN); 02052 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL14_BRNTAKEN); 02053 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL32); 02054 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR64); 02055 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_HIGHER); 02056 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_HIGHEST); 02057 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_REL64); 02058 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC16); 02059 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC16_LO); 02060 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC16_HA); 02061 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC); 02062 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_DS); 02063 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_ADDR16_LO_DS); 02064 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC16_DS); 02065 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TOC16_LO_DS); 02066 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TLS); 02067 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TPREL16_LO); 02068 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TPREL16_HA); 02069 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_DTPREL16_LO); 02070 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_DTPREL16_HA); 02071 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TLSGD16_LO); 02072 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TLSGD16_HA); 02073 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TLSLD16_LO); 02074 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TLSLD16_HA); 02075 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TPREL16_LO_DS); 02076 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_GOT_TPREL16_HA); 02077 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TLSGD); 02078 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_PPC64_TLSLD); 02079 default: break; 02080 } 02081 break; 02082 case ELF::EM_S390: 02083 switch (Type) { 02084 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_NONE); 02085 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_8); 02086 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_12); 02087 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_16); 02088 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_32); 02089 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PC32); 02090 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOT12); 02091 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOT32); 02092 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLT32); 02093 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_COPY); 02094 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GLOB_DAT); 02095 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_JMP_SLOT); 02096 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_RELATIVE); 02097 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTOFF); 02098 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPC); 02099 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOT16); 02100 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PC16); 02101 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PC16DBL); 02102 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLT16DBL); 02103 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PC32DBL); 02104 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLT32DBL); 02105 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPCDBL); 02106 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_64); 02107 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PC64); 02108 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOT64); 02109 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLT64); 02110 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTENT); 02111 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTOFF16); 02112 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTOFF64); 02113 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLT12); 02114 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLT16); 02115 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLT32); 02116 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLT64); 02117 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLTENT); 02118 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLTOFF16); 02119 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLTOFF32); 02120 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_PLTOFF64); 02121 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LOAD); 02122 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GDCALL); 02123 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LDCALL); 02124 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GD32); 02125 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GD64); 02126 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GOTIE12); 02127 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GOTIE32); 02128 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GOTIE64); 02129 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LDM32); 02130 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LDM64); 02131 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_IE32); 02132 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_IE64); 02133 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_IEENT); 02134 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LE32); 02135 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LE64); 02136 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LDO32); 02137 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_LDO64); 02138 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_DTPMOD); 02139 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_DTPOFF); 02140 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_TPOFF); 02141 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_20); 02142 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOT20); 02143 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_GOTPLT20); 02144 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_TLS_GOTIE20); 02145 LLVM_ELF_SWITCH_RELOC_TYPE_NAME(R_390_IRELATIVE); 02146 default: break; 02147 } 02148 break; 02149 default: break; 02150 } 02151 return Res; 02152 } 02153 02154 #undef LLVM_ELF_SWITCH_RELOC_TYPE_NAME 02155 02156 template<class ELFT> 02157 error_code ELFObjectFile<ELFT>::getRelocationTypeName( 02158 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 02159 const Elf_Shdr *sec = getRelSection(Rel); 02160 uint32_t type; 02161 switch (sec->sh_type) { 02162 default : 02163 return object_error::parse_failed; 02164 case ELF::SHT_REL : { 02165 type = getRel(Rel)->getType(isMips64EL()); 02166 break; 02167 } 02168 case ELF::SHT_RELA : { 02169 type = getRela(Rel)->getType(isMips64EL()); 02170 break; 02171 } 02172 } 02173 02174 if (!isMips64EL()) { 02175 StringRef Name = getRelocationTypeName(type); 02176 Result.append(Name.begin(), Name.end()); 02177 } else { 02178 uint8_t Type1 = (type >> 0) & 0xFF; 02179 uint8_t Type2 = (type >> 8) & 0xFF; 02180 uint8_t Type3 = (type >> 16) & 0xFF; 02181 02182 // Concat all three relocation type names. 02183 StringRef Name = getRelocationTypeName(Type1); 02184 Result.append(Name.begin(), Name.end()); 02185 02186 Name = getRelocationTypeName(Type2); 02187 Result.append(1, '/'); 02188 Result.append(Name.begin(), Name.end()); 02189 02190 Name = getRelocationTypeName(Type3); 02191 Result.append(1, '/'); 02192 Result.append(Name.begin(), Name.end()); 02193 } 02194 02195 return object_error::success; 02196 } 02197 02198 template<class ELFT> 02199 error_code ELFObjectFile<ELFT>::getRelocationAddend( 02200 DataRefImpl Rel, int64_t &Result) const { 02201 const Elf_Shdr *sec = getRelSection(Rel); 02202 switch (sec->sh_type) { 02203 default : 02204 report_fatal_error("Invalid section type in Rel!"); 02205 case ELF::SHT_REL : { 02206 Result = 0; 02207 return object_error::success; 02208 } 02209 case ELF::SHT_RELA : { 02210 Result = getRela(Rel)->r_addend; 02211 return object_error::success; 02212 } 02213 } 02214 } 02215 02216 template<class ELFT> 02217 error_code ELFObjectFile<ELFT>::getRelocationValueString( 02218 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 02219 const Elf_Shdr *sec = getRelSection(Rel); 02220 uint8_t type; 02221 StringRef res; 02222 int64_t addend = 0; 02223 uint16_t symbol_index = 0; 02224 switch (sec->sh_type) { 02225 default: 02226 return object_error::parse_failed; 02227 case ELF::SHT_REL: { 02228 type = getRel(Rel)->getType(isMips64EL()); 02229 symbol_index = getRel(Rel)->getSymbol(isMips64EL()); 02230 // TODO: Read implicit addend from section data. 02231 break; 02232 } 02233 case ELF::SHT_RELA: { 02234 type = getRela(Rel)->getType(isMips64EL()); 02235 symbol_index = getRela(Rel)->getSymbol(isMips64EL()); 02236 addend = getRela(Rel)->r_addend; 02237 break; 02238 } 02239 } 02240 const Elf_Sym *symb = getEntry<Elf_Sym>(sec->sh_link, symbol_index); 02241 StringRef symname; 02242 if (error_code ec = getSymbolName(getSection(sec->sh_link), symb, symname)) 02243 return ec; 02244 switch (Header->e_machine) { 02245 case ELF::EM_X86_64: 02246 switch (type) { 02247 case ELF::R_X86_64_PC8: 02248 case ELF::R_X86_64_PC16: 02249 case ELF::R_X86_64_PC32: { 02250 std::string fmtbuf; 02251 raw_string_ostream fmt(fmtbuf); 02252 fmt << symname << (addend < 0 ? "" : "+") << addend << "-P"; 02253 fmt.flush(); 02254 Result.append(fmtbuf.begin(), fmtbuf.end()); 02255 } 02256 break; 02257 case ELF::R_X86_64_8: 02258 case ELF::R_X86_64_16: 02259 case ELF::R_X86_64_32: 02260 case ELF::R_X86_64_32S: 02261 case ELF::R_X86_64_64: { 02262 std::string fmtbuf; 02263 raw_string_ostream fmt(fmtbuf); 02264 fmt << symname << (addend < 0 ? "" : "+") << addend; 02265 fmt.flush(); 02266 Result.append(fmtbuf.begin(), fmtbuf.end()); 02267 } 02268 break; 02269 default: 02270 res = "Unknown"; 02271 } 02272 break; 02273 case ELF::EM_AARCH64: { 02274 std::string fmtbuf; 02275 raw_string_ostream fmt(fmtbuf); 02276 fmt << symname; 02277 if (addend != 0) 02278 fmt << (addend < 0 ? "" : "+") << addend; 02279 fmt.flush(); 02280 Result.append(fmtbuf.begin(), fmtbuf.end()); 02281 break; 02282 } 02283 case ELF::EM_ARM: 02284 case ELF::EM_HEXAGON: 02285 res = symname; 02286 break; 02287 default: 02288 res = "Unknown"; 02289 } 02290 if (Result.empty()) 02291 Result.append(res.begin(), res.end()); 02292 return object_error::success; 02293 } 02294 02295 // Verify that the last byte in the string table in a null. 02296 template<class ELFT> 02297 void ELFObjectFile<ELFT>::VerifyStrTab(const Elf_Shdr *sh) const { 02298 const char *strtab = (const char*)base() + sh->sh_offset; 02299 if (strtab[sh->sh_size - 1] != 0) 02300 // FIXME: Proper error handling. 02301 report_fatal_error("String table must end with a null terminator!"); 02302 } 02303 02304 template<class ELFT> 02305 ELFObjectFile<ELFT>::ELFObjectFile(MemoryBuffer *Object, error_code &ec) 02306 : ObjectFile(getELFType( 02307 static_cast<endianness>(ELFT::TargetEndianness) == support::little, 02308 ELFT::Is64Bits), 02309 Object) 02310 , isDyldELFObject(false) 02311 , SectionHeaderTable(0) 02312 , dot_shstrtab_sec(0) 02313 , dot_strtab_sec(0) 02314 , dot_dynstr_sec(0) 02315 , dot_dynamic_sec(0) 02316 , dot_gnu_version_sec(0) 02317 , dot_gnu_version_r_sec(0) 02318 , dot_gnu_version_d_sec(0) 02319 , dt_soname(0) 02320 { 02321 02322 const uint64_t FileSize = Data->getBufferSize(); 02323 02324 if (sizeof(Elf_Ehdr) > FileSize) 02325 // FIXME: Proper error handling. 02326 report_fatal_error("File too short!"); 02327 02328 Header = reinterpret_cast<const Elf_Ehdr *>(base()); 02329 02330 if (Header->e_shoff == 0) 02331 return; 02332 02333 const uint64_t SectionTableOffset = Header->e_shoff; 02334 02335 if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize) 02336 // FIXME: Proper error handling. 02337 report_fatal_error("Section header table goes past end of file!"); 02338 02339 // The getNumSections() call below depends on SectionHeaderTable being set. 02340 SectionHeaderTable = 02341 reinterpret_cast<const Elf_Shdr *>(base() + SectionTableOffset); 02342 const uint64_t SectionTableSize = getNumSections() * Header->e_shentsize; 02343 02344 if (SectionTableOffset + SectionTableSize > FileSize) 02345 // FIXME: Proper error handling. 02346 report_fatal_error("Section table goes past end of file!"); 02347 02348 // To find the symbol tables we walk the section table to find SHT_SYMTAB. 02349 const Elf_Shdr* SymbolTableSectionHeaderIndex = 0; 02350 const Elf_Shdr* sh = SectionHeaderTable; 02351 02352 SymbolTableIndex = -1; 02353 DynamicSymbolTableIndex = -1; 02354 02355 for (uint64_t i = 0, e = getNumSections(); i != e; ++i) { 02356 switch (sh->sh_type) { 02357 case ELF::SHT_SYMTAB_SHNDX: { 02358 if (SymbolTableSectionHeaderIndex) 02359 // FIXME: Proper error handling. 02360 report_fatal_error("More than one .symtab_shndx!"); 02361 SymbolTableSectionHeaderIndex = sh; 02362 break; 02363 } 02364 case ELF::SHT_SYMTAB: { 02365 if (SymbolTableIndex != -1) 02366 report_fatal_error("More than one SHT_SYMTAB!"); 02367 SymbolTableIndex = i; 02368 break; 02369 } 02370 case ELF::SHT_DYNSYM: { 02371 if (DynamicSymbolTableIndex != -1) 02372 // FIXME: Proper error handling. 02373 report_fatal_error("More than one SHT_DYNSYM!"); 02374 DynamicSymbolTableIndex = i; 02375 break; 02376 } 02377 case ELF::SHT_REL: 02378 case ELF::SHT_RELA: 02379 break; 02380 case ELF::SHT_DYNAMIC: { 02381 if (dot_dynamic_sec != NULL) 02382 // FIXME: Proper error handling. 02383 report_fatal_error("More than one .dynamic!"); 02384 dot_dynamic_sec = sh; 02385 break; 02386 } 02387 case ELF::SHT_GNU_versym: { 02388 if (dot_gnu_version_sec != NULL) 02389 // FIXME: Proper error handling. 02390 report_fatal_error("More than one .gnu.version section!"); 02391 dot_gnu_version_sec = sh; 02392 break; 02393 } 02394 case ELF::SHT_GNU_verdef: { 02395 if (dot_gnu_version_d_sec != NULL) 02396 // FIXME: Proper error handling. 02397 report_fatal_error("More than one .gnu.version_d section!"); 02398 dot_gnu_version_d_sec = sh; 02399 break; 02400 } 02401 case ELF::SHT_GNU_verneed: { 02402 if (dot_gnu_version_r_sec != NULL) 02403 // FIXME: Proper error handling. 02404 report_fatal_error("More than one .gnu.version_r section!"); 02405 dot_gnu_version_r_sec = sh; 02406 break; 02407 } 02408 } 02409 ++sh; 02410 } 02411 02412 // Get string table sections. 02413 dot_shstrtab_sec = getSection(getStringTableIndex()); 02414 if (dot_shstrtab_sec) { 02415 // Verify that the last byte in the string table in a null. 02416 VerifyStrTab(dot_shstrtab_sec); 02417 } 02418 02419 // Merge this into the above loop. 02420 for (const char *i = reinterpret_cast<const char *>(SectionHeaderTable), 02421 *e = i + getNumSections() * Header->e_shentsize; 02422 i != e; i += Header->e_shentsize) { 02423 const Elf_Shdr *sh = reinterpret_cast<const Elf_Shdr*>(i); 02424 if (sh->sh_type == ELF::SHT_STRTAB) { 02425 StringRef SectionName(getString(dot_shstrtab_sec, sh->sh_name)); 02426 if (SectionName == ".strtab") { 02427 if (dot_strtab_sec != 0) 02428 // FIXME: Proper error handling. 02429 report_fatal_error("Already found section named .strtab!"); 02430 dot_strtab_sec = sh; 02431 VerifyStrTab(dot_strtab_sec); 02432 } else if (SectionName == ".dynstr") { 02433 if (dot_dynstr_sec != 0) 02434 // FIXME: Proper error handling. 02435 report_fatal_error("Already found section named .dynstr!"); 02436 dot_dynstr_sec = sh; 02437 VerifyStrTab(dot_dynstr_sec); 02438 } 02439 } 02440 } 02441 02442 // Build symbol name side-mapping if there is one. 02443 if (SymbolTableSectionHeaderIndex) { 02444 const Elf_Word *ShndxTable = reinterpret_cast<const Elf_Word*>(base() + 02445 SymbolTableSectionHeaderIndex->sh_offset); 02446 error_code ec; 02447 for (symbol_iterator si = begin_symbols(), 02448 se = end_symbols(); si != se; si.increment(ec)) { 02449 if (ec) 02450 report_fatal_error("Fewer extended symbol table entries than symbols!"); 02451 if (*ShndxTable != ELF::SHN_UNDEF) 02452 ExtendedSymbolTable[getSymbol(si->getRawDataRefImpl())] = *ShndxTable; 02453 ++ShndxTable; 02454 } 02455 } 02456 } 02457 02458 // Get the symbol table index in the symtab section given a symbol 02459 template<class ELFT> 02460 uint64_t ELFObjectFile<ELFT>::getSymbolIndex(const Elf_Sym *Sym) const { 02461 const Elf_Shdr *SymTab = getSection(SymbolTableIndex); 02462 uintptr_t SymLoc = uintptr_t(Sym); 02463 uintptr_t SymTabLoc = uintptr_t(base() + SymTab->sh_offset); 02464 assert(SymLoc > SymTabLoc && "Symbol not in symbol table!"); 02465 uint64_t SymOffset = SymLoc - SymTabLoc; 02466 assert(SymOffset % SymTab->sh_entsize == 0 && 02467 "Symbol not multiple of symbol size!"); 02468 return SymOffset / SymTab->sh_entsize; 02469 } 02470 02471 template<class ELFT> 02472 symbol_iterator ELFObjectFile<ELFT>::begin_symbols() const { 02473 DataRefImpl SymbolData; 02474 if (SymbolTableIndex == -1) { 02475 SymbolData.d.a = 0; 02476 SymbolData.d.b = 0; 02477 } else { 02478 SymbolData.d.a = 0; 02479 SymbolData.d.b = SymbolTableIndex; 02480 } 02481 return symbol_iterator(SymbolRef(SymbolData, this)); 02482 } 02483 02484 template<class ELFT> 02485 symbol_iterator ELFObjectFile<ELFT>::end_symbols() const { 02486 DataRefImpl SymbolData; 02487 if (SymbolTableIndex == -1) { 02488 SymbolData.d.a = 0; 02489 SymbolData.d.b = 0; 02490 } else { 02491 const Elf_Shdr *SymbolTableSection = getSection(SymbolTableIndex); 02492 SymbolData.d.a = SymbolTableSection->getEntityCount(); 02493 SymbolData.d.b = SymbolTableIndex; 02494 } 02495 return symbol_iterator(SymbolRef(SymbolData, this)); 02496 } 02497 02498 template<class ELFT> 02499 symbol_iterator ELFObjectFile<ELFT>::begin_dynamic_symbols() const { 02500 DataRefImpl SymbolData; 02501 if (DynamicSymbolTableIndex == -1) { 02502 SymbolData.d.a = 0; 02503 SymbolData.d.b = 0; 02504 } else { 02505 SymbolData.d.a = 0; 02506 SymbolData.d.b = DynamicSymbolTableIndex; 02507 } 02508 return symbol_iterator(SymbolRef(SymbolData, this)); 02509 } 02510 02511 template<class ELFT> 02512 symbol_iterator ELFObjectFile<ELFT>::end_dynamic_symbols() const { 02513 DataRefImpl SymbolData; 02514 if (DynamicSymbolTableIndex == -1) { 02515 SymbolData.d.a = 0; 02516 SymbolData.d.b = 0; 02517 } else { 02518 const Elf_Shdr *SymbolTableSection = getSection(DynamicSymbolTableIndex); 02519 SymbolData.d.a = SymbolTableSection->getEntityCount(); 02520 SymbolData.d.b = DynamicSymbolTableIndex; 02521 } 02522 return symbol_iterator(SymbolRef(SymbolData, this)); 02523 } 02524 02525 template<class ELFT> 02526 section_iterator ELFObjectFile<ELFT>::begin_sections() const { 02527 DataRefImpl ret; 02528 ret.p = reinterpret_cast<intptr_t>(base() + Header->e_shoff); 02529 return section_iterator(SectionRef(ret, this)); 02530 } 02531 02532 template<class ELFT> 02533 section_iterator ELFObjectFile<ELFT>::end_sections() const { 02534 DataRefImpl ret; 02535 ret.p = reinterpret_cast<intptr_t>(base() 02536 + Header->e_shoff 02537 + (Header->e_shentsize*getNumSections())); 02538 return section_iterator(SectionRef(ret, this)); 02539 } 02540 02541 template<class ELFT> 02542 typename ELFObjectFile<ELFT>::Elf_Dyn_iterator 02543 ELFObjectFile<ELFT>::begin_dynamic_table() const { 02544 if (dot_dynamic_sec) 02545 return Elf_Dyn_iterator(dot_dynamic_sec->sh_entsize, 02546 (const char *)base() + dot_dynamic_sec->sh_offset); 02547 return Elf_Dyn_iterator(0, 0); 02548 } 02549 02550 template<class ELFT> 02551 typename ELFObjectFile<ELFT>::Elf_Dyn_iterator 02552 ELFObjectFile<ELFT>::end_dynamic_table(bool NULLEnd) const { 02553 if (dot_dynamic_sec) { 02554 Elf_Dyn_iterator Ret(dot_dynamic_sec->sh_entsize, 02555 (const char *)base() + dot_dynamic_sec->sh_offset + 02556 dot_dynamic_sec->sh_size); 02557 02558 if (NULLEnd) { 02559 Elf_Dyn_iterator Start = begin_dynamic_table(); 02560 while (Start != Ret && Start->getTag() != ELF::DT_NULL) 02561 ++Start; 02562 02563 // Include the DT_NULL. 02564 if (Start != Ret) 02565 ++Start; 02566 Ret = Start; 02567 } 02568 return Ret; 02569 } 02570 return Elf_Dyn_iterator(0, 0); 02571 } 02572 02573 template<class ELFT> 02574 StringRef ELFObjectFile<ELFT>::getLoadName() const { 02575 if (!dt_soname) { 02576 // Find the DT_SONAME entry 02577 Elf_Dyn_iterator it = begin_dynamic_table(); 02578 Elf_Dyn_iterator ie = end_dynamic_table(); 02579 while (it != ie && it->getTag() != ELF::DT_SONAME) 02580 ++it; 02581 02582 if (it != ie) { 02583 if (dot_dynstr_sec == NULL) 02584 report_fatal_error("Dynamic string table is missing"); 02585 dt_soname = getString(dot_dynstr_sec, it->getVal()); 02586 } else { 02587 dt_soname = ""; 02588 } 02589 } 02590 return dt_soname; 02591 } 02592 02593 template<class ELFT> 02594 library_iterator ELFObjectFile<ELFT>::begin_libraries_needed() const { 02595 // Find the first DT_NEEDED entry 02596 Elf_Dyn_iterator i = begin_dynamic_table(); 02597 Elf_Dyn_iterator e = end_dynamic_table(); 02598 while (i != e && i->getTag() != ELF::DT_NEEDED) 02599 ++i; 02600 02601 DataRefImpl DRI; 02602 DRI.p = reinterpret_cast<uintptr_t>(i.get()); 02603 return library_iterator(LibraryRef(DRI, this)); 02604 } 02605 02606 template<class ELFT> 02607 error_code ELFObjectFile<ELFT>::getLibraryNext(DataRefImpl Data, 02608 LibraryRef &Result) const { 02609 // Use the same DataRefImpl format as DynRef. 02610 Elf_Dyn_iterator i = Elf_Dyn_iterator(dot_dynamic_sec->sh_entsize, 02611 reinterpret_cast<const char *>(Data.p)); 02612 Elf_Dyn_iterator e = end_dynamic_table(); 02613 02614 // Skip the current dynamic table entry and find the next DT_NEEDED entry. 02615 do 02616 ++i; 02617 while (i != e && i->getTag() != ELF::DT_NEEDED); 02618 02619 DataRefImpl DRI; 02620 DRI.p = reinterpret_cast<uintptr_t>(i.get()); 02621 Result = LibraryRef(DRI, this); 02622 return object_error::success; 02623 } 02624 02625 template<class ELFT> 02626 error_code ELFObjectFile<ELFT>::getLibraryPath(DataRefImpl Data, 02627 StringRef &Res) const { 02628 Elf_Dyn_iterator i = Elf_Dyn_iterator(dot_dynamic_sec->sh_entsize, 02629 reinterpret_cast<const char *>(Data.p)); 02630 if (i == end_dynamic_table()) 02631 report_fatal_error("getLibraryPath() called on iterator end"); 02632 02633 if (i->getTag() != ELF::DT_NEEDED) 02634 report_fatal_error("Invalid library_iterator"); 02635 02636 // This uses .dynstr to lookup the name of the DT_NEEDED entry. 02637 // THis works as long as DT_STRTAB == .dynstr. This is true most of 02638 // the time, but the specification allows exceptions. 02639 // TODO: This should really use DT_STRTAB instead. Doing this requires 02640 // reading the program headers. 02641 if (dot_dynstr_sec == NULL) 02642 report_fatal_error("Dynamic string table is missing"); 02643 Res = getString(dot_dynstr_sec, i->getVal()); 02644 return object_error::success; 02645 } 02646 02647 template<class ELFT> 02648 library_iterator ELFObjectFile<ELFT>::end_libraries_needed() const { 02649 Elf_Dyn_iterator e = end_dynamic_table(); 02650 DataRefImpl DRI; 02651 DRI.p = reinterpret_cast<uintptr_t>(e.get()); 02652 return library_iterator(LibraryRef(DRI, this)); 02653 } 02654 02655 template<class ELFT> 02656 uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const { 02657 return ELFT::Is64Bits ? 8 : 4; 02658 } 02659 02660 template<class ELFT> 02661 StringRef ELFObjectFile<ELFT>::getFileFormatName() const { 02662 switch(Header->e_ident[ELF::EI_CLASS]) { 02663 case ELF::ELFCLASS32: 02664 switch(Header->e_machine) { 02665 case ELF::EM_386: 02666 return "ELF32-i386"; 02667 case ELF::EM_X86_64: 02668 return "ELF32-x86-64"; 02669 case ELF::EM_ARM: 02670 return "ELF32-arm"; 02671 case ELF::EM_HEXAGON: 02672 return "ELF32-hexagon"; 02673 case ELF::EM_MIPS: 02674 return "ELF32-mips"; 02675 case ELF::EM_PPC: 02676 return "ELF32-ppc"; 02677 default: 02678 return "ELF32-unknown"; 02679 } 02680 case ELF::ELFCLASS64: 02681 switch(Header->e_machine) { 02682 case ELF::EM_386: 02683 return "ELF64-i386"; 02684 case ELF::EM_X86_64: 02685 return "ELF64-x86-64"; 02686 case ELF::EM_AARCH64: 02687 return "ELF64-aarch64"; 02688 case ELF::EM_PPC64: 02689 return "ELF64-ppc64"; 02690 case ELF::EM_S390: 02691 return "ELF64-s390"; 02692 default: 02693 return "ELF64-unknown"; 02694 } 02695 default: 02696 // FIXME: Proper error handling. 02697 report_fatal_error("Invalid ELFCLASS!"); 02698 } 02699 } 02700 02701 template<class ELFT> 02702 unsigned ELFObjectFile<ELFT>::getArch() const { 02703 switch(Header->e_machine) { 02704 case ELF::EM_386: 02705 return Triple::x86; 02706 case ELF::EM_X86_64: 02707 return Triple::x86_64; 02708 case ELF::EM_AARCH64: 02709 return Triple::aarch64; 02710 case ELF::EM_ARM: 02711 return Triple::arm; 02712 case ELF::EM_HEXAGON: 02713 return Triple::hexagon; 02714 case ELF::EM_MIPS: 02715 return (ELFT::TargetEndianness == support::little) ? 02716 Triple::mipsel : Triple::mips; 02717 case ELF::EM_PPC64: 02718 return Triple::ppc64; 02719 case ELF::EM_S390: 02720 return Triple::systemz; 02721 default: 02722 return Triple::UnknownArch; 02723 } 02724 } 02725 02726 template<class ELFT> 02727 uint64_t ELFObjectFile<ELFT>::getNumSections() const { 02728 assert(Header && "Header not initialized!"); 02729 if (Header->e_shnum == ELF::SHN_UNDEF) { 02730 assert(SectionHeaderTable && "SectionHeaderTable not initialized!"); 02731 return SectionHeaderTable->sh_size; 02732 } 02733 return Header->e_shnum; 02734 } 02735 02736 template<class ELFT> 02737 uint64_t 02738 ELFObjectFile<ELFT>::getStringTableIndex() const { 02739 if (Header->e_shnum == ELF::SHN_UNDEF) { 02740 if (Header->e_shstrndx == ELF::SHN_HIRESERVE) 02741 return SectionHeaderTable->sh_link; 02742 if (Header->e_shstrndx >= getNumSections()) 02743 return 0; 02744 } 02745 return Header->e_shstrndx; 02746 } 02747 02748 template<class ELFT> 02749 template<typename T> 02750 inline const T * 02751 ELFObjectFile<ELFT>::getEntry(uint32_t Section, uint32_t Entry) const { 02752 return getEntry<T>(getSection(Section), Entry); 02753 } 02754 02755 template<class ELFT> 02756 template<typename T> 02757 inline const T * 02758 ELFObjectFile<ELFT>::getEntry(const Elf_Shdr * Section, uint32_t Entry) const { 02759 return reinterpret_cast<const T *>( 02760 base() 02761 + Section->sh_offset 02762 + (Entry * Section->sh_entsize)); 02763 } 02764 02765 template<class ELFT> 02766 const typename ELFObjectFile<ELFT>::Elf_Sym * 02767 ELFObjectFile<ELFT>::getSymbol(DataRefImpl Symb) const { 02768 return getEntry<Elf_Sym>(Symb.d.b, Symb.d.a); 02769 } 02770 02771 template<class ELFT> 02772 const typename ELFObjectFile<ELFT>::Elf_Rel * 02773 ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const { 02774 return getEntry<Elf_Rel>(Rel.d.a, Rel.d.b); 02775 } 02776 02777 template<class ELFT> 02778 const typename ELFObjectFile<ELFT>::Elf_Rela * 02779 ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const { 02780 return getEntry<Elf_Rela>(Rela.d.a, Rela.d.b); 02781 } 02782 02783 template<class ELFT> 02784 const typename ELFObjectFile<ELFT>::Elf_Shdr * 02785 ELFObjectFile<ELFT>::getSection(DataRefImpl Symb) const { 02786 const Elf_Shdr *sec = getSection(Symb.d.b); 02787 if (sec->sh_type != ELF::SHT_SYMTAB || sec->sh_type != ELF::SHT_DYNSYM) 02788 // FIXME: Proper error handling. 02789 report_fatal_error("Invalid symbol table section!"); 02790 return sec; 02791 } 02792 02793 template<class ELFT> 02794 const typename ELFObjectFile<ELFT>::Elf_Shdr * 02795 ELFObjectFile<ELFT>::getSection(uint32_t index) const { 02796 if (index == 0) 02797 return 0; 02798 if (!SectionHeaderTable || index >= getNumSections()) 02799 // FIXME: Proper error handling. 02800 report_fatal_error("Invalid section index!"); 02801 02802 return reinterpret_cast<const Elf_Shdr *>( 02803 reinterpret_cast<const char *>(SectionHeaderTable) 02804 + (index * Header->e_shentsize)); 02805 } 02806 02807 template<class ELFT> 02808 const char *ELFObjectFile<ELFT>::getString(uint32_t section, 02809 ELF::Elf32_Word offset) const { 02810 return getString(getSection(section), offset); 02811 } 02812 02813 template<class ELFT> 02814 const char *ELFObjectFile<ELFT>::getString(const Elf_Shdr *section, 02815 ELF::Elf32_Word offset) const { 02816 assert(section && section->sh_type == ELF::SHT_STRTAB && "Invalid section!"); 02817 if (offset >= section->sh_size) 02818 // FIXME: Proper error handling. 02819 report_fatal_error("Symbol name offset outside of string table!"); 02820 return (const char *)base() + section->sh_offset + offset; 02821 } 02822 02823 template<class ELFT> 02824 error_code ELFObjectFile<ELFT>::getSymbolName(const Elf_Shdr *section, 02825 const Elf_Sym *symb, 02826 StringRef &Result) const { 02827 if (symb->st_name == 0) { 02828 const Elf_Shdr *section = getSection(symb); 02829 if (!section) 02830 Result = ""; 02831 else 02832 Result = getString(dot_shstrtab_sec, section->sh_name); 02833 return object_error::success; 02834 } 02835 02836 if (DynamicSymbolTableIndex != -1 && 02837 section == getSection(DynamicSymbolTableIndex)) { 02838 // Symbol is in .dynsym, use .dynstr string table 02839 Result = getString(dot_dynstr_sec, symb->st_name); 02840 } else { 02841 // Use the default symbol table name section. 02842 Result = getString(dot_strtab_sec, symb->st_name); 02843 } 02844 return object_error::success; 02845 } 02846 02847 template<class ELFT> 02848 error_code ELFObjectFile<ELFT>::getSectionName(const Elf_Shdr *section, 02849 StringRef &Result) const { 02850 Result = StringRef(getString(dot_shstrtab_sec, section->sh_name)); 02851 return object_error::success; 02852 } 02853 02854 template<class ELFT> 02855 error_code ELFObjectFile<ELFT>::getSymbolVersion(const Elf_Shdr *section, 02856 const Elf_Sym *symb, 02857 StringRef &Version, 02858 bool &IsDefault) const { 02859 // Handle non-dynamic symbols. 02860 if (section != getSection(DynamicSymbolTableIndex)) { 02861 // Non-dynamic symbols can have versions in their names 02862 // A name of the form 'foo@V1' indicates version 'V1', non-default. 02863 // A name of the form 'foo@@V2' indicates version 'V2', default version. 02864 StringRef Name; 02865 error_code ec = getSymbolName(section, symb, Name); 02866 if (ec != object_error::success) 02867 return ec; 02868 size_t atpos = Name.find('@'); 02869 if (atpos == StringRef::npos) { 02870 Version = ""; 02871 IsDefault = false; 02872 return object_error::success; 02873 } 02874 ++atpos; 02875 if (atpos < Name.size() && Name[atpos] == '@') { 02876 IsDefault = true; 02877 ++atpos; 02878 } else { 02879 IsDefault = false; 02880 } 02881 Version = Name.substr(atpos); 02882 return object_error::success; 02883 } 02884 02885 // This is a dynamic symbol. Look in the GNU symbol version table. 02886 if (dot_gnu_version_sec == NULL) { 02887 // No version table. 02888 Version = ""; 02889 IsDefault = false; 02890 return object_error::success; 02891 } 02892 02893 // Determine the position in the symbol table of this entry. 02894 const char *sec_start = (const char*)base() + section->sh_offset; 02895 size_t entry_index = ((const char*)symb - sec_start)/section->sh_entsize; 02896 02897 // Get the corresponding version index entry 02898 const Elf_Versym *vs = getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index); 02899 size_t version_index = vs->vs_index & ELF::VERSYM_VERSION; 02900 02901 // Special markers for unversioned symbols. 02902 if (version_index == ELF::VER_NDX_LOCAL || 02903 version_index == ELF::VER_NDX_GLOBAL) { 02904 Version = ""; 02905 IsDefault = false; 02906 return object_error::success; 02907 } 02908 02909 // Lookup this symbol in the version table 02910 LoadVersionMap(); 02911 if (version_index >= VersionMap.size() || VersionMap[version_index].isNull()) 02912 report_fatal_error("Symbol has version index without corresponding " 02913 "define or reference entry"); 02914 const VersionMapEntry &entry = VersionMap[version_index]; 02915 02916 // Get the version name string 02917 size_t name_offset; 02918 if (entry.isVerdef()) { 02919 // The first Verdaux entry holds the name. 02920 name_offset = entry.getVerdef()->getAux()->vda_name; 02921 } else { 02922 name_offset = entry.getVernaux()->vna_name; 02923 } 02924 Version = getString(dot_dynstr_sec, name_offset); 02925 02926 // Set IsDefault 02927 if (entry.isVerdef()) { 02928 IsDefault = !(vs->vs_index & ELF::VERSYM_HIDDEN); 02929 } else { 02930 IsDefault = false; 02931 } 02932 02933 return object_error::success; 02934 } 02935 02936 /// FIXME: Maybe we should have a base ElfObjectFile that is not a template 02937 /// and make these member functions? 02938 static inline error_code getELFRelocationAddend(const RelocationRef R, 02939 int64_t &Addend) { 02940 const ObjectFile *Obj = R.getObjectFile(); 02941 DataRefImpl DRI = R.getRawDataRefImpl(); 02942 // Little-endian 32-bit 02943 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) 02944 return ELFObj->getRelocationAddend(DRI, Addend); 02945 02946 // Big-endian 32-bit 02947 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj)) 02948 return ELFObj->getRelocationAddend(DRI, Addend); 02949 02950 // Little-endian 64-bit 02951 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj)) 02952 return ELFObj->getRelocationAddend(DRI, Addend); 02953 02954 // Big-endian 64-bit 02955 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj)) 02956 return ELFObj->getRelocationAddend(DRI, Addend); 02957 02958 llvm_unreachable("Object passed to getELFRelocationAddend() is not ELF"); 02959 } 02960 02961 /// This is a generic interface for retrieving GNU symbol version 02962 /// information from an ELFObjectFile. 02963 static inline error_code GetELFSymbolVersion(const ObjectFile *Obj, 02964 const SymbolRef &Sym, 02965 StringRef &Version, 02966 bool &IsDefault) { 02967 // Little-endian 32-bit 02968 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj)) 02969 return ELFObj->getSymbolVersion(Sym, Version, IsDefault); 02970 02971 // Big-endian 32-bit 02972 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj)) 02973 return ELFObj->getSymbolVersion(Sym, Version, IsDefault); 02974 02975 // Little-endian 64-bit 02976 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj)) 02977 return ELFObj->getSymbolVersion(Sym, Version, IsDefault); 02978 02979 // Big-endian 64-bit 02980 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj)) 02981 return ELFObj->getSymbolVersion(Sym, Version, IsDefault); 02982 02983 llvm_unreachable("Object passed to GetELFSymbolVersion() is not ELF"); 02984 } 02985 02986 /// This function returns the hash value for a symbol in the .dynsym section 02987 /// Name of the API remains consistent as specified in the libelf 02988 /// REF : http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash 02989 static inline unsigned elf_hash(StringRef &symbolName) { 02990 unsigned h = 0, g; 02991 for (unsigned i = 0, j = symbolName.size(); i < j; i++) { 02992 h = (h << 4) + symbolName[i]; 02993 g = h & 0xf0000000L; 02994 if (g != 0) 02995 h ^= g >> 24; 02996 h &= ~g; 02997 } 02998 return h; 02999 } 03000 03001 } 03002 } 03003 03004 #endif
Generated on Wed Jun 19 2013 02:37:53 for LLVM by
1.7.5.1
Copyright © 2003-2013 University of Illinois at Urbana-Champaign.
All Rights Reserved.