/*============================================================================ 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"; } }