projects / oota-llvm.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Move getELFDynamicSymbolIterators to a public header.
[oota-llvm.git] / include / llvm / Object / ELFObjectFile.h
diff --git a/include/llvm/Object/ELFObjectFile.h b/include/llvm/Object/ELFObjectFile.h
index 45bcde6155b191646e22bfdaeaab83ee0602cfaa..917786fd22738b987f29f9835c166fe46fea27f5 100644 (file)
--- a/include/llvm/Object/ELFObjectFile.h
+++ b/include/llvm/Object/ELFObjectFile.h
@@ -65,7 +65,7 @@ protected:
   error_code getSymbolAlignment(DataRefImpl Symb, uint32_t &Res) const
       LLVM_OVERRIDE;
   error_code getSymbolSize(DataRefImpl Symb, uint64_t &Res) const LLVM_OVERRIDE;
-  error_code getSymbolFlags(DataRefImpl Symb, uint32_t &Res) const;
+  uint32_t getSymbolFlags(DataRefImpl Symb) const LLVM_OVERRIDE;
   error_code getSymbolType(DataRefImpl Symb, SymbolRef::Type &Res) const
       LLVM_OVERRIDE;
   error_code getSymbolSection(DataRefImpl Symb, section_iterator &Res) const
@@ -180,17 +180,17 @@ public:
 
   const Elf_Sym *getSymbol(DataRefImpl Symb) const;
 
-  symbol_iterator begin_symbols() const LLVM_OVERRIDE;
-  symbol_iterator end_symbols() const LLVM_OVERRIDE;
+  basic_symbol_iterator symbol_begin_impl() const LLVM_OVERRIDE;
+  basic_symbol_iterator symbol_end_impl() const LLVM_OVERRIDE;
 
-  symbol_iterator begin_dynamic_symbols() const LLVM_OVERRIDE;
-  symbol_iterator end_dynamic_symbols() const LLVM_OVERRIDE;
+  symbol_iterator dynamic_symbol_begin() const;
+  symbol_iterator dynamic_symbol_end() const;
 
-  section_iterator begin_sections() const LLVM_OVERRIDE;
-  section_iterator end_sections() const LLVM_OVERRIDE;
+  section_iterator section_begin() const LLVM_OVERRIDE;
+  section_iterator section_end() const LLVM_OVERRIDE;
 
-  library_iterator begin_libraries_needed() const LLVM_OVERRIDE;
-  library_iterator end_libraries_needed() const LLVM_OVERRIDE;
+  library_iterator needed_library_begin() const LLVM_OVERRIDE;
+  library_iterator needed_library_end() const LLVM_OVERRIDE;
 
   error_code getRelocationAddend(DataRefImpl Rel, int64_t &Res) const;
   error_code getSymbolVersion(SymbolRef Symb, StringRef &Version,
@@ -378,11 +378,11 @@ error_code ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb,
 }
 
 template <class ELFT>
-error_code ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Symb,
-                                               uint32_t &Result) const {
-  const Elf_Sym *ESym = getSymbol(Symb);
+uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Symb) const {
+  Elf_Sym_Iter EIter = toELFSymIter(Symb);
+  const Elf_Sym *ESym = &*EIter;
 
-  Result = SymbolRef::SF_None;
+  uint32_t Result = SymbolRef::SF_None;
 
   if (ESym->getBinding() != ELF::STB_LOCAL)
     Result |= SymbolRef::SF_Global;
@@ -394,7 +394,7 @@ error_code ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Symb,
     Result |= SymbolRef::SF_Absolute;
 
   if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION ||
-      ESym == &*EF.begin_symbols())
+      EIter == EF.begin_symbols() || EIter == EF.begin_dynamic_symbols())
     Result |= SymbolRef::SF_FormatSpecific;
 
   if (EF.getSymbolTableIndex(ESym) == ELF::SHN_UNDEF)
@@ -404,10 +404,7 @@ error_code ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Symb,
       EF.getSymbolTableIndex(ESym) == ELF::SHN_COMMON)
     Result |= SymbolRef::SF_Common;
 
-  if (ESym->getType() == ELF::STT_TLS)
-    Result |= SymbolRef::SF_ThreadLocal;
-
-  return object_error::success;
+  return Result;
 }
 
 template <class ELFT>
@@ -416,7 +413,7 @@ error_code ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb,
   const Elf_Sym *ESym = getSymbol(Symb);
   const Elf_Shdr *ESec = EF.getSection(ESym);
   if (!ESec)
-    Res = end_sections();
+    Res = section_end();
   else {
     DataRefImpl Sec;
     Sec.p = reinterpret_cast<intptr_t>(ESec);
@@ -574,12 +571,12 @@ template <class ELFT>
 section_iterator
 ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
   if (EF.getHeader()->e_type != ELF::ET_REL)
-    return end_sections();
+    return section_end();
 
   Elf_Shdr_Iter EShdr = toELFShdrIter(Sec);
   uintX_t Type = EShdr->sh_type;
   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
-    return end_sections();
+    return section_end();
 
   const Elf_Shdr *R = EF.getSection(EShdr->sh_info);
   return section_iterator(SectionRef(toDRI(R), this));
@@ -609,7 +606,7 @@ ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
   }
   }
   if (!symbolIdx)
-    return end_symbols();
+    return symbol_end();
 
   const Elf_Shdr *SymSec = EF.getSection(sec->sh_link);
 
@@ -827,32 +824,32 @@ ELFObjectFile<ELFT>::ELFObjectFile(MemoryBuffer *Object, error_code &ec,
       EF(Object, ec) {}
 
 template <class ELFT>
-symbol_iterator ELFObjectFile<ELFT>::begin_symbols() const {
-  return symbol_iterator(SymbolRef(toDRI(EF.begin_symbols()), this));
+basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin_impl() const {
+  return basic_symbol_iterator(SymbolRef(toDRI(EF.begin_symbols()), this));
 }
 
 template <class ELFT>
-symbol_iterator ELFObjectFile<ELFT>::end_symbols() const {
-  return symbol_iterator(SymbolRef(toDRI(EF.end_symbols()), this));
+basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end_impl() const {
+  return basic_symbol_iterator(SymbolRef(toDRI(EF.end_symbols()), this));
 }
 
 template <class ELFT>
-symbol_iterator ELFObjectFile<ELFT>::begin_dynamic_symbols() const {
+symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
   return symbol_iterator(SymbolRef(toDRI(EF.begin_dynamic_symbols()), this));
 }
 
 template <class ELFT>
-symbol_iterator ELFObjectFile<ELFT>::end_dynamic_symbols() const {
+symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
   return symbol_iterator(SymbolRef(toDRI(EF.end_dynamic_symbols()), this));
 }
 
 template <class ELFT>
-section_iterator ELFObjectFile<ELFT>::begin_sections() const {
+section_iterator ELFObjectFile<ELFT>::section_begin() const {
   return section_iterator(SectionRef(toDRI(EF.begin_sections()), this));
 }
 
 template <class ELFT>
-section_iterator ELFObjectFile<ELFT>::end_sections() const {
+section_iterator ELFObjectFile<ELFT>::section_end() const {
   return section_iterator(SectionRef(toDRI(EF.end_sections()), this));
 }
 
@@ -870,7 +867,7 @@ StringRef ELFObjectFile<ELFT>::getLoadName() const {
 }
 
 template <class ELFT>
-library_iterator ELFObjectFile<ELFT>::begin_libraries_needed() const {
+library_iterator ELFObjectFile<ELFT>::needed_library_begin() const {
   Elf_Dyn_Iter DI = EF.begin_dynamic_table();
   Elf_Dyn_Iter DE = EF.end_dynamic_table();
 
@@ -903,7 +900,7 @@ error_code ELFObjectFile<ELFT>::getLibraryPath(DataRefImpl Data,
 }
 
 template <class ELFT>
-library_iterator ELFObjectFile<ELFT>::end_libraries_needed() const {
+library_iterator ELFObjectFile<ELFT>::needed_library_end() const {
   return library_iterator(LibraryRef(toDRI(EF.end_dynamic_table()), this));
 }
 
@@ -949,6 +946,8 @@ StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
       return "ELF64-s390";
     case ELF::EM_SPARCV9:
       return "ELF64-sparc";
+    case ELF::EM_MIPS:
+      return "ELF64-mips";
     default:
       return "ELF64-unknown";
     }
@@ -1016,6 +1015,25 @@ static inline error_code getELFRelocationAddend(const RelocationRef R,
   llvm_unreachable("Object passed to getELFRelocationAddend() is not ELF");
 }
 
+static inline std::pair<symbol_iterator, symbol_iterator>
+getELFDynamicSymbolIterators(SymbolicFile *Obj) {
+  if (const ELF32LEObjectFile *ELF = dyn_cast<ELF32LEObjectFile>(Obj))
+    return std::make_pair(ELF->dynamic_symbol_begin(),
+                          ELF->dynamic_symbol_end());
+  if (const ELF64LEObjectFile *ELF = dyn_cast<ELF64LEObjectFile>(Obj))
+    return std::make_pair(ELF->dynamic_symbol_begin(),
+                          ELF->dynamic_symbol_end());
+  if (const ELF32BEObjectFile *ELF = dyn_cast<ELF32BEObjectFile>(Obj))
+    return std::make_pair(ELF->dynamic_symbol_begin(),
+                          ELF->dynamic_symbol_end());
+  if (const ELF64BEObjectFile *ELF = cast<ELF64BEObjectFile>(Obj))
+    return std::make_pair(ELF->dynamic_symbol_begin(),
+                          ELF->dynamic_symbol_end());
+
+  llvm_unreachable(
+      "Object passed to getELFDynamicSymbolIterators() is not ELF");
+}
+
 /// This is a generic interface for retrieving GNU symbol version
 /// information from an ELFObjectFile.
 static inline error_code GetELFSymbolVersion(const ObjectFile *Obj,
C/C++ LLVM-based compilers that forbids OOTA behaviors