reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-12-12 22:05:57 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
5444bd6ca3
CMake/Source/cmELF.cxx
Bill Hoffman f2d18d6e99 Try to remove some warnings.
2010-05-12 10:41:06 -04:00

920 lines
25 KiB
C++
Raw Blame History

/*============================================================================
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 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";
}
}
Reference in New Issue View Git Blame Copy Permalink