summaryrefslogtreecommitdiff
path: root/Source/cmELF.cxx
diff options
context:
space:
mode:
authorAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
committerAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
commit035c7fabc3b82cbc9a346c11abe2e9462b4c0379 (patch)
tree7e40f5a790eae329a8c5d3e59f046451767956ff /Source/cmELF.cxx
downloadcmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.zip
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.gz
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.bz2
Imported Upstream version 2.8.9upstream/2.8.9
Diffstat (limited to 'Source/cmELF.cxx')
-rw-r--r--Source/cmELF.cxx920
1 files changed, 920 insertions, 0 deletions
diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx
new file mode 100644
index 0000000..1158fc0
--- /dev/null
+++ b/Source/cmELF.cxx
@@ -0,0 +1,920 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+#include "cmStandardIncludes.h" // to get CMAKE_USE_ELF_PARSER first
+#include "cmELF.h"
+
+#include <cmsys/auto_ptr.hxx>
+
+// Need the native byte order of the running CPU.
+#define cmsys_CPU_UNKNOWN_OKAY // We can decide at runtime if not known.
+#include <cmsys/CPU.h>
+
+// Include the ELF format information system header.
+#include <elf.h>
+#if defined(__sun)
+# include <sys/link.h> // For dynamic section information
+#endif
+
+//----------------------------------------------------------------------------
+// Low-level byte swapping implementation.
+template <size_t s> struct cmELFByteSwapSize {};
+void cmELFByteSwap(char*, cmELFByteSwapSize<1> const&)
+{
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<2> const&)
+{
+ char one_byte;
+ one_byte = data[0]; data[0] = data[1]; data[1] = one_byte;
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<4> const&)
+{
+ char one_byte;
+ one_byte = data[0]; data[0] = data[3]; data[3] = one_byte;
+ one_byte = data[1]; data[1] = data[2]; data[2] = one_byte;
+}
+void cmELFByteSwap(char* data, cmELFByteSwapSize<8> const&)
+{
+ char one_byte;
+ one_byte = data[0]; data[0] = data[7]; data[7] = one_byte;
+ one_byte = data[1]; data[1] = data[6]; data[6] = one_byte;
+ one_byte = data[2]; data[2] = data[5]; data[5] = one_byte;
+ one_byte = data[3]; data[3] = data[4]; data[4] = one_byte;
+}
+
+// Low-level byte swapping interface.
+template <typename T>
+void cmELFByteSwap(T& x)
+{
+ cmELFByteSwap(reinterpret_cast<char*>(&x), cmELFByteSwapSize<sizeof(T)>());
+}
+
+//----------------------------------------------------------------------------
+class cmELFInternal
+{
+public:
+ typedef cmELF::StringEntry StringEntry;
+ enum ByteOrderType { ByteOrderMSB, ByteOrderLSB };
+
+ // Construct and take ownership of the file stream object.
+ cmELFInternal(cmELF* external,
+ cmsys::auto_ptr<std::ifstream>& fin,
+ ByteOrderType order):
+ External(external),
+ Stream(*fin.release()),
+ ByteOrder(order),
+ ELFType(cmELF::FileTypeInvalid)
+ {
+ // In most cases the processor-specific byte order will match that
+ // of the target execution environment. If we choose wrong here
+ // it is fixed when the header is read.
+#if cmsys_CPU_ENDIAN_ID == cmsys_CPU_ENDIAN_ID_LITTLE
+ this->NeedSwap = (this->ByteOrder == ByteOrderMSB);
+#elif cmsys_CPU_ENDIAN_ID == cmsys_CPU_ENDIAN_ID_BIG
+ this->NeedSwap = (this->ByteOrder == ByteOrderLSB);
+#else
+ this->NeedSwap = false; // Final decision is at runtime anyway.
+#endif
+
+ // We have not yet loaded the section info.
+ this->DynamicSectionIndex = -1;
+ }
+
+ // Destruct and delete the file stream object.
+ virtual ~cmELFInternal()
+ {
+ delete &this->Stream;
+ }
+
+ // Forward to the per-class implementation.
+ virtual unsigned int GetNumberOfSections() const = 0;
+ virtual unsigned int GetDynamicEntryCount() = 0;
+ virtual unsigned long GetDynamicEntryPosition(int j) = 0;
+ virtual StringEntry const* GetDynamicSectionString(int tag) = 0;
+ virtual void PrintInfo(std::ostream& os) const = 0;
+
+ bool ReadBytes(unsigned long pos, unsigned long size, char* buf)
+ {
+ this->Stream.seekg(pos);
+ this->Stream.read(buf, size);
+ return this->Stream?true:false;
+ }
+
+ // Lookup the SONAME in the DYNAMIC section.
+ StringEntry const* GetSOName()
+ {
+ return this->GetDynamicSectionString(DT_SONAME);
+ }
+
+ // Lookup the RPATH in the DYNAMIC section.
+ StringEntry const* GetRPath()
+ {
+ return this->GetDynamicSectionString(DT_RPATH);
+ }
+
+ // Lookup the RUNPATH in the DYNAMIC section.
+ StringEntry const* GetRunPath()
+ {
+#if defined(DT_RUNPATH)
+ return this->GetDynamicSectionString(DT_RUNPATH);
+#else
+ return 0;
+#endif
+ }
+
+ // Return the recorded ELF type.
+ cmELF::FileType GetFileType() const { return this->ELFType; }
+protected:
+ // Data common to all ELF class implementations.
+
+ // The external cmELF object.
+ cmELF* External;
+
+ // The stream from which to read.
+ std::istream& Stream;
+
+ // The byte order of the ELF file.
+ ByteOrderType ByteOrder;
+
+ // The ELF file type.
+ cmELF::FileType ELFType;
+
+ // Whether we need to byte-swap structures read from the stream.
+ bool NeedSwap;
+
+ // The section header index of the DYNAMIC section (-1 if none).
+ int DynamicSectionIndex;
+
+ // Helper methods for subclasses.
+ void SetErrorMessage(const char* msg)
+ {
+ this->External->ErrorMessage = msg;
+ this->ELFType = cmELF::FileTypeInvalid;
+ }
+
+ // Store string table entry states.
+ std::map<int, StringEntry> DynamicSectionStrings;
+};
+
+//----------------------------------------------------------------------------
+// Configure the implementation template for 32-bit ELF files.
+struct cmELFTypes32
+{
+ typedef Elf32_Ehdr ELF_Ehdr;
+ typedef Elf32_Shdr ELF_Shdr;
+ typedef Elf32_Dyn ELF_Dyn;
+ typedef Elf32_Half ELF_Half;
+ static const char* GetName() { return "32-bit"; }
+};
+
+// Configure the implementation template for 32-bit ELF files.
+struct cmELFTypes64
+{
+ typedef Elf64_Ehdr ELF_Ehdr;
+ typedef Elf64_Shdr ELF_Shdr;
+ typedef Elf64_Dyn ELF_Dyn;
+ typedef Elf64_Half ELF_Half;
+ static const char* GetName() { return "64-bit"; }
+};
+
+//----------------------------------------------------------------------------
+// Parser implementation template.
+template <class Types>
+class cmELFInternalImpl: public cmELFInternal
+{
+public:
+ // Copy the ELF file format types from our configuration parameter.
+ typedef typename Types::ELF_Ehdr ELF_Ehdr;
+ typedef typename Types::ELF_Shdr ELF_Shdr;
+ typedef typename Types::ELF_Dyn ELF_Dyn;
+ typedef typename Types::ELF_Half ELF_Half;
+
+ // Construct with a stream and byte swap indicator.
+ cmELFInternalImpl(cmELF* external,
+ cmsys::auto_ptr<std::ifstream>& fin,
+ ByteOrderType order);
+
+ // Return the number of sections as specified by the ELF header.
+ virtual unsigned int GetNumberOfSections() const
+ {
+ return static_cast<unsigned int>(this->ELFHeader.e_shnum);
+ }
+
+ // Get the file position and size of a dynamic section entry.
+ virtual unsigned int GetDynamicEntryCount();
+ virtual unsigned long GetDynamicEntryPosition(int j);
+
+ // Lookup a string from the dynamic section with the given tag.
+ virtual StringEntry const* GetDynamicSectionString(int tag);
+
+ // Print information about the ELF file.
+ virtual void PrintInfo(std::ostream& os) const
+ {
+ os << "ELF " << Types::GetName();
+ if(this->ByteOrder == ByteOrderMSB)
+ {
+ os << " MSB";
+ }
+ else if(this->ByteOrder == ByteOrderLSB)
+ {
+ os << " LSB";
+ }
+ switch(this->ELFType)
+ {
+ case cmELF::FileTypeInvalid:
+ os << " invalid file";
+ break;
+ case cmELF::FileTypeRelocatableObject:
+ os << " relocatable object";
+ break;
+ case cmELF::FileTypeExecutable:
+ os << " executable";
+ break;
+ case cmELF::FileTypeSharedLibrary:
+ os << " shared library";
+ break;
+ case cmELF::FileTypeCore:
+ os << " core file";
+ break;
+ case cmELF::FileTypeSpecificOS:
+ os << " os-specific type";
+ break;
+ case cmELF::FileTypeSpecificProc:
+ os << " processor-specific type";
+ break;
+ }
+ os << "\n";
+ }
+
+private:
+ void ByteSwap(ELF_Ehdr& elf_header)
+ {
+ cmELFByteSwap(elf_header.e_type);
+ cmELFByteSwap(elf_header.e_machine);
+ cmELFByteSwap(elf_header.e_version);
+ cmELFByteSwap(elf_header.e_entry);
+ cmELFByteSwap(elf_header.e_phoff);
+ cmELFByteSwap(elf_header.e_shoff);
+ cmELFByteSwap(elf_header.e_flags);
+ cmELFByteSwap(elf_header.e_ehsize);
+ cmELFByteSwap(elf_header.e_phentsize);
+ cmELFByteSwap(elf_header.e_phnum);
+ cmELFByteSwap(elf_header.e_shentsize);
+ cmELFByteSwap(elf_header.e_shnum);
+ cmELFByteSwap(elf_header.e_shstrndx);
+ }
+
+ void ByteSwap(ELF_Shdr& sec_header)
+ {
+ cmELFByteSwap(sec_header.sh_name);
+ cmELFByteSwap(sec_header.sh_type);
+ cmELFByteSwap(sec_header.sh_flags);
+ cmELFByteSwap(sec_header.sh_addr);
+ cmELFByteSwap(sec_header.sh_offset);
+ cmELFByteSwap(sec_header.sh_size);
+ cmELFByteSwap(sec_header.sh_link);
+ cmELFByteSwap(sec_header.sh_info);
+ cmELFByteSwap(sec_header.sh_addralign);
+ cmELFByteSwap(sec_header.sh_entsize);
+ }
+
+ void ByteSwap(ELF_Dyn& dyn)
+ {
+ cmELFByteSwap(dyn.d_tag);
+ switch (dyn.d_tag)
+ {
+ case DT_NULL: /* dyn.d_un ignored */ break;
+ case DT_NEEDED: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_PLTRELSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_PLTGOT: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_HASH: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_STRTAB: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_SYMTAB: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_RELA: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_RELASZ: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_RELAENT: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_STRSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_SYMENT: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_INIT: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_FINI: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_SONAME: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_RPATH: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_SYMBOLIC: /* dyn.d_un ignored */ break;
+ case DT_REL: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_RELSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_RELENT: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_PLTREL: cmELFByteSwap(dyn.d_un.d_val); break;
+ case DT_DEBUG: cmELFByteSwap(dyn.d_un.d_ptr); break;
+ case DT_TEXTREL: /* dyn.d_un ignored */ break;
+ case DT_JMPREL: cmELFByteSwap(dyn.d_un.d_ptr); break;
+#ifdef T_BIND_NOW
+ case T_BIND_NOW: /* dyn.d_un ignored */ break;
+#endif
+#ifdef DT_INIT_ARRAY
+ case DT_INIT_ARRAY: cmELFByteSwap(dyn.d_un.d_ptr); break;
+#endif
+#ifdef DT_FINI_ARRAY
+ case DT_FINI_ARRAY: cmELFByteSwap(dyn.d_un.d_ptr); break;
+#endif
+#ifdef DT_INIT_ARRAYSZ
+ case DT_INIT_ARRAYSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+#endif
+#ifdef DT_FINI_ARRAYSZ
+ case DT_FINI_ARRAYSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+#endif
+#ifdef DT_RUNPATH
+ case DT_RUNPATH: cmELFByteSwap(dyn.d_un.d_val); break;
+#endif
+#ifdef DT_FLAGS
+ case DT_FLAGS: cmELFByteSwap(dyn.d_un.d_val); break;
+#endif
+#ifdef DT_PREINIT_ARRAY
+ case DT_PREINIT_ARRAY: cmELFByteSwap(dyn.d_un.d_ptr); break;
+#endif
+#ifdef DT_PREINIT_ARRAYSZ
+ case DT_PREINIT_ARRAYSZ: cmELFByteSwap(dyn.d_un.d_val); break;
+#endif
+ }
+ }
+
+ bool FileTypeValid(ELF_Half et)
+ {
+ unsigned int eti = static_cast<unsigned int>(et);
+ if(eti == ET_NONE || eti == ET_REL || eti == ET_EXEC ||
+ eti == ET_DYN || eti == ET_CORE)
+ {
+ return true;
+ }
+#if defined(ET_LOOS) && defined(ET_HIOS)
+ if(eti >= ET_LOOS && eti <= ET_HIOS)
+ {
+ return true;
+ }
+#endif
+#if defined(ET_LOPROC) && defined(ET_HIPROC)
+ if(eti >= ET_LOPROC && eti <= ET_HIPROC)
+ {
+ return true;
+ }
+#endif
+ return false;
+ }
+
+ bool Read(ELF_Ehdr& x)
+ {
+ // Read the header from the file.
+ if(!this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)))
+ {
+ return false;
+ }
+
+ // The byte order of ELF header fields may not match that of the
+ // processor-specific data. The header fields are ordered to
+ // match the target execution environment, so we may need to
+ // memorize the order of all platforms based on the e_machine
+ // value. As a heuristic, if the type is invalid but its
+ // swapped value is okay then flip our swap mode.
+ ELF_Half et = x.e_type;
+ if(this->NeedSwap)
+ {
+ cmELFByteSwap(et);
+ }
+ if(!this->FileTypeValid(et))
+ {
+ cmELFByteSwap(et);
+ if(this->FileTypeValid(et))
+ {
+ // The previous byte order guess was wrong. Flip it.
+ this->NeedSwap = !this->NeedSwap;
+ }
+ }
+
+ // Fix the byte order of the header.
+ if(this->NeedSwap)
+ {
+ ByteSwap(x);
+ }
+ return true;
+ }
+ bool Read(ELF_Shdr& x)
+ {
+ if(this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+ this->NeedSwap)
+ {
+ ByteSwap(x);
+ }
+ return this->Stream? true:false;
+ }
+ bool Read(ELF_Dyn& x)
+ {
+ if(this->Stream.read(reinterpret_cast<char*>(&x), sizeof(x)) &&
+ this->NeedSwap)
+ {
+ ByteSwap(x);
+ }
+ return this->Stream? true:false;
+ }
+
+ bool LoadSectionHeader(ELF_Half i)
+ {
+ // Read the section header from the file.
+ this->Stream.seekg(this->ELFHeader.e_shoff +
+ this->ELFHeader.e_shentsize * i);
+ if(!this->Read(this->SectionHeaders[i]))
+ {
+ return false;
+ }
+
+ // Identify some important sections.
+ if(this->SectionHeaders[i].sh_type == SHT_DYNAMIC)
+ {
+ this->DynamicSectionIndex = i;
+ }
+ return true;
+ }
+
+ bool LoadDynamicSection();
+
+ // Store the main ELF header.
+ ELF_Ehdr ELFHeader;
+
+ // Store all the section headers.
+ std::vector<ELF_Shdr> SectionHeaders;
+
+ // Store all entries of the DYNAMIC section.
+ std::vector<ELF_Dyn> DynamicSectionEntries;
+};
+
+//----------------------------------------------------------------------------
+template <class Types>
+cmELFInternalImpl<Types>
+::cmELFInternalImpl(cmELF* external,
+ cmsys::auto_ptr<std::ifstream>& fin,
+ ByteOrderType order):
+ cmELFInternal(external, fin, order)
+{
+ // Read the main header.
+ if(!this->Read(this->ELFHeader))
+ {
+ this->SetErrorMessage("Failed to read main ELF header.");
+ return;
+ }
+
+ // Determine the ELF file type.
+ switch(this->ELFHeader.e_type)
+ {
+ case ET_NONE:
+ this->SetErrorMessage("ELF file type is NONE.");
+ return;
+ case ET_REL:
+ this->ELFType = cmELF::FileTypeRelocatableObject;
+ break;
+ case ET_EXEC:
+ this->ELFType = cmELF::FileTypeExecutable;
+ break;
+ case ET_DYN:
+ this->ELFType = cmELF::FileTypeSharedLibrary;
+ break;
+ case ET_CORE:
+ this->ELFType = cmELF::FileTypeCore;
+ break;
+ default:
+ {
+ unsigned int eti = static_cast<unsigned int>(this->ELFHeader.e_type);
+#if defined(ET_LOOS) && defined(ET_HIOS)
+ if(eti >= ET_LOOS && eti <= ET_HIOS)
+ {
+ this->ELFType = cmELF::FileTypeSpecificOS;
+ break;
+ }
+#endif
+#if defined(ET_LOPROC) && defined(ET_HIPROC)
+ if(eti >= ET_LOPROC && eti <= ET_HIPROC)
+ {
+ this->ELFType = cmELF::FileTypeSpecificProc;
+ break;
+ }
+#endif
+ cmOStringStream e;
+ e << "Unknown ELF file type " << eti;
+ this->SetErrorMessage(e.str().c_str());
+ return;
+ }
+ }
+
+ // Load the section headers.
+ this->SectionHeaders.resize(this->ELFHeader.e_shnum);
+ for(ELF_Half i=0; i < this->ELFHeader.e_shnum; ++i)
+ {
+ if(!this->LoadSectionHeader(i))
+ {
+ this->SetErrorMessage("Failed to load section headers.");
+ return;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+template <class Types>
+bool cmELFInternalImpl<Types>::LoadDynamicSection()
+{
+ // If there is no dynamic section we are done.
+ if(this->DynamicSectionIndex < 0)
+ {
+ return false;
+ }
+
+ // If the section was already loaded we are done.
+ if(!this->DynamicSectionEntries.empty())
+ {
+ return true;
+ }
+
+ // Allocate the dynamic section entries.
+ ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+ int n = static_cast<int>(sec.sh_size / sec.sh_entsize);
+ this->DynamicSectionEntries.resize(n);
+
+ // Read each entry.
+ for(int j=0; j < n; ++j)
+ {
+ // Seek to the beginning of the section entry.
+ this->Stream.seekg(sec.sh_offset + sec.sh_entsize*j);
+ ELF_Dyn& dyn = this->DynamicSectionEntries[j];
+
+ // Try reading the entry.
+ if(!this->Read(dyn))
+ {
+ this->SetErrorMessage("Error reading entry from DYNAMIC section.");
+ this->DynamicSectionIndex = -1;
+ return false;
+ }
+ }
+ return true;
+}
+
+//----------------------------------------------------------------------------
+template <class Types>
+unsigned int cmELFInternalImpl<Types>::GetDynamicEntryCount()
+{
+ if(!this->LoadDynamicSection())
+ {
+ return 0;
+ }
+ for(unsigned int i = 0; i < this->DynamicSectionEntries.size(); ++i)
+ {
+ if(this->DynamicSectionEntries[i].d_tag == DT_NULL)
+ {
+ return i;
+ }
+ }
+ return static_cast<unsigned int>(this->DynamicSectionEntries.size());
+}
+
+//----------------------------------------------------------------------------
+template <class Types>
+unsigned long cmELFInternalImpl<Types>::GetDynamicEntryPosition(int j)
+{
+ if(!this->LoadDynamicSection())
+ {
+ return 0;
+ }
+ if(j < 0 || j >= static_cast<int>(this->DynamicSectionEntries.size()))
+ {
+ return 0;
+ }
+ ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+ return static_cast<unsigned long>(sec.sh_offset + sec.sh_entsize*j);
+}
+
+//----------------------------------------------------------------------------
+template <class Types>
+cmELF::StringEntry const*
+cmELFInternalImpl<Types>::GetDynamicSectionString(int tag)
+{
+ // Short-circuit if already checked.
+ std::map<int, StringEntry>::iterator dssi =
+ this->DynamicSectionStrings.find(tag);
+ if(dssi != this->DynamicSectionStrings.end())
+ {
+ if(dssi->second.Position > 0)
+ {
+ return &dssi->second;
+ }
+ return 0;
+ }
+
+ // Create an entry for this tag. Assume it is missing until found.
+ StringEntry& se = this->DynamicSectionStrings[tag];
+ se.Position = 0;
+ se.Size = 0;
+ se.IndexInSection = -1;
+
+ // Try reading the dynamic section.
+ if(!this->LoadDynamicSection())
+ {
+ return 0;
+ }
+
+ // Get the string table referenced by the DYNAMIC section.
+ ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex];
+ if(sec.sh_link >= this->SectionHeaders.size())
+ {
+ this->SetErrorMessage("Section DYNAMIC has invalid string table index.");
+ return 0;
+ }
+ ELF_Shdr const& strtab = this->SectionHeaders[sec.sh_link];
+
+ // Look for the requested entry.
+ for(typename std::vector<ELF_Dyn>::iterator
+ di = this->DynamicSectionEntries.begin();
+ di != this->DynamicSectionEntries.end(); ++di)
+ {
+ ELF_Dyn& dyn = *di;
+ if(dyn.d_tag == tag)
+ {
+ // We found the tag requested.
+ // Make sure the position given is within the string section.
+ if(dyn.d_un.d_val >= strtab.sh_size)
+ {
+ this->SetErrorMessage("Section DYNAMIC references string beyond "
+ "the end of its string section.");
+ return 0;
+ }
+
+ // Seek to the position reported by the entry.
+ unsigned long first = static_cast<unsigned long>(dyn.d_un.d_val);
+ unsigned long last = first;
+ unsigned long end = static_cast<unsigned long>(strtab.sh_size);
+ this->Stream.seekg(strtab.sh_offset + first);
+
+ // Read the string. It may be followed by more than one NULL
+ // terminator. Count the total size of the region allocated to
+ // the string. This assumes that the next string in the table
+ // is non-empty, but the "chrpath" tool makes the same
+ // assumption.
+ bool terminated = false;
+ char c;
+ while(last != end && this->Stream.get(c) && !(terminated && c))
+ {
+ ++last;
+ if(c)
+ {
+ se.Value += c;
+ }
+ else
+ {
+ terminated = true;
+ }
+ }
+
+ // Make sure the whole value was read.
+ if(!this->Stream)
+ {
+ this->SetErrorMessage("Dynamic section specifies unreadable RPATH.");
+ se.Value = "";
+ return 0;
+ }
+
+ // The value has been read successfully. Report it.
+ se.Position = static_cast<unsigned long>(strtab.sh_offset + first);
+ se.Size = last - first;
+ se.IndexInSection =
+ static_cast<int>(di - this->DynamicSectionEntries.begin());
+ return &se;
+ }
+ }
+ return 0;
+}
+
+//============================================================================
+// External class implementation.
+
+//----------------------------------------------------------------------------
+cmELF::cmELF(const char* fname): Internal(0)
+{
+ // Try to open the file.
+ cmsys::auto_ptr<std::ifstream> fin(new std::ifstream(fname));
+
+ // Quit now if the file could not be opened.
+ if(!fin.get() || !*fin)
+ {
+ this->ErrorMessage = "Error opening input file.";
+ return;
+ }
+
+ // Read the ELF identification block.
+ char ident[EI_NIDENT];
+ if(!fin->read(ident, EI_NIDENT))
+ {
+ this->ErrorMessage = "Error reading ELF identification.";
+ return;
+ }
+ if(!fin->seekg(0))
+ {
+ this->ErrorMessage = "Error seeking to beginning of file.";
+ return;
+ }
+
+ // Verify the ELF identification.
+ if(!(ident[EI_MAG0] == ELFMAG0 &&
+ ident[EI_MAG1] == ELFMAG1 &&
+ ident[EI_MAG2] == ELFMAG2 &&
+ ident[EI_MAG3] == ELFMAG3))
+ {
+ this->ErrorMessage = "File does not have a valid ELF identification.";
+ return;
+ }
+
+ // Check the byte order in which the rest of the file is encoded.
+ cmELFInternal::ByteOrderType order;
+ if(ident[EI_DATA] == ELFDATA2LSB)
+ {
+ // File is LSB.
+ order = cmELFInternal::ByteOrderLSB;
+ }
+ else if(ident[EI_DATA] == ELFDATA2MSB)
+ {
+ // File is MSB.
+ order = cmELFInternal::ByteOrderMSB;
+ }
+ else
+ {
+ this->ErrorMessage = "ELF file is not LSB or MSB encoded.";
+ return;
+ }
+
+ // Check the class of the file and construct the corresponding
+ // parser implementation.
+ if(ident[EI_CLASS] == ELFCLASS32)
+ {
+ // 32-bit ELF
+ this->Internal = new cmELFInternalImpl<cmELFTypes32>(this, fin, order);
+ }
+ else if(ident[EI_CLASS] == ELFCLASS64)
+ {
+ // 64-bit ELF
+ this->Internal = new cmELFInternalImpl<cmELFTypes64>(this, fin, order);
+ }
+ else
+ {
+ this->ErrorMessage = "ELF file class is not 32-bit or 64-bit.";
+ return;
+ }
+}
+
+//----------------------------------------------------------------------------
+cmELF::~cmELF()
+{
+ delete this->Internal;
+}
+
+//----------------------------------------------------------------------------
+bool cmELF::Valid() const
+{
+ return this->Internal && this->Internal->GetFileType() != FileTypeInvalid;
+}
+
+//----------------------------------------------------------------------------
+cmELF::FileType cmELF::GetFileType() const
+{
+ if(this->Valid())
+ {
+ return this->Internal->GetFileType();
+ }
+ else
+ {
+ return FileTypeInvalid;
+ }
+}
+
+//----------------------------------------------------------------------------
+unsigned int cmELF::GetNumberOfSections() const
+{
+ if(this->Valid())
+ {
+ return this->Internal->GetNumberOfSections();
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+unsigned int cmELF::GetDynamicEntryCount() const
+{
+ if(this->Valid())
+ {
+ return this->Internal->GetDynamicEntryCount();
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+unsigned long cmELF::GetDynamicEntryPosition(int index) const
+{
+ if(this->Valid())
+ {
+ return this->Internal->GetDynamicEntryPosition(index);
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+bool cmELF::ReadBytes(unsigned long pos, unsigned long size, char* buf) const
+{
+ if(this->Valid())
+ {
+ return this->Internal->ReadBytes(pos, size, buf);
+ }
+ else
+ {
+ return false;
+ }
+}
+
+//----------------------------------------------------------------------------
+bool cmELF::GetSOName(std::string& soname)
+{
+ if(StringEntry const* se = this->GetSOName())
+ {
+ soname = se->Value;
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+//----------------------------------------------------------------------------
+cmELF::StringEntry const* cmELF::GetSOName()
+{
+ if(this->Valid() &&
+ this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)
+ {
+ return this->Internal->GetSOName();
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+cmELF::StringEntry const* cmELF::GetRPath()
+{
+ if(this->Valid() &&
+ (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+ this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary))
+ {
+ return this->Internal->GetRPath();
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+cmELF::StringEntry const* cmELF::GetRunPath()
+{
+ if(this->Valid() &&
+ (this->Internal->GetFileType() == cmELF::FileTypeExecutable ||
+ this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary))
+ {
+ return this->Internal->GetRunPath();
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmELF::PrintInfo(std::ostream& os) const
+{
+ if(this->Valid())
+ {
+ this->Internal->PrintInfo(os);
+ }
+ else
+ {
+ os << "Not a valid ELF file.\n";
+ }
+}