tools/llvm-objdump/ELFDump.cpp - llvm - Git at Google

 //===-- ELFDump.cpp - ELF-specific dumper -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the ELF-specific dumper for llvm-objdump.
 ///
 //===----------------------------------------------------------------------===//

 #include "llvm-objdump.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"

 using namespace llvm;
 using namespace llvm::object;

 template <class ELFT>
 Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
   typedef ELFFile<ELFT> ELFO;

   auto DynamicEntriesOrError = Elf->dynamicEntries();
   if (!DynamicEntriesOrError)
     return DynamicEntriesOrError.takeError();

   for (const typename ELFO::Elf_Dyn &Dyn : *DynamicEntriesOrError) {
     if (Dyn.d_tag == ELF::DT_STRTAB) {
       auto MappedAddrOrError = Elf->toMappedAddr(Dyn.getPtr());
       if (!MappedAddrOrError)
         consumeError(MappedAddrOrError.takeError());
       return StringRef(reinterpret_cast<const char *>(*MappedAddrOrError));
     }
   }

   // If the dynamic segment is not present, we fall back on the sections.
   auto SectionsOrError = Elf->sections();
   if (!SectionsOrError)
     return SectionsOrError.takeError();

   for (const typename ELFO::Elf_Shdr &Sec : *SectionsOrError) {
     if (Sec.sh_type == ELF::SHT_DYNSYM)
       return Elf->getStringTableForSymtab(Sec);
   }

   return createError("dynamic string table not found");
 }

 template <class ELFT>
 static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
                                                 const RelocationRef &RelRef,
                                                 SmallVectorImpl<char> &Result) {
   typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela;

   const ELFFile<ELFT> &EF = *Obj->getELFFile();
   DataRefImpl Rel = RelRef.getRawDataRefImpl();
   auto SecOrErr = EF.getSection(Rel.d.a);
   if (!SecOrErr)
     return errorToErrorCode(SecOrErr.takeError());

   int64_t Addend = 0;
   // If there is no Symbol associated with the relocation, we set the undef
   // boolean value to 'true'. This will prevent us from calling functions that
   // requires the relocation to be associated with a symbol.
   //
   // In SHT_REL case we would need to read the addend from section data.
   // GNU objdump does not do that and we just follow for simplicity atm.
   bool Undef = false;
   if ((*SecOrErr)->sh_type == ELF::SHT_RELA) {
     const Elf_Rela *ERela = Obj->getRela(Rel);
     Addend = ERela->r_addend;
     Undef = ERela->getSymbol(false) == 0;
   } else if ((*SecOrErr)->sh_type != ELF::SHT_REL) {
     return object_error::parse_failed;
   }

   // Default scheme is to print Target, as well as "+ <addend>" for nonzero
   // addend. Should be acceptable for all normal purposes.
   std::string FmtBuf;
   raw_string_ostream Fmt(FmtBuf);

   if (!Undef) {
     symbol_iterator SI = RelRef.getSymbol();
     const Elf_Sym *Sym = Obj->getSymbol(SI->getRawDataRefImpl());
     if (Sym->getType() == ELF::STT_SECTION) {
       Expected<section_iterator> SymSI = SI->getSection();
       if (!SymSI)
         return errorToErrorCode(SymSI.takeError());
       const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
       auto SecName = EF.getSectionName(SymSec);
       if (!SecName)
         return errorToErrorCode(SecName.takeError());
       Fmt << *SecName;
     } else {
       Expected<StringRef> SymName = SI->getName();
       if (!SymName)
         return errorToErrorCode(SymName.takeError());
       if (Demangle)
         Fmt << demangle(*SymName);
       else
         Fmt << *SymName;
     }
   } else {
     Fmt << "*ABS*";
   }

   if (Addend != 0)
     Fmt << (Addend < 0 ? "" : "+") << Addend;
   Fmt.flush();
   Result.append(FmtBuf.begin(), FmtBuf.end());
   return std::error_code();
 }

 std::error_code
 llvm::getELFRelocationValueString(const ELFObjectFileBase *Obj,
                                   const RelocationRef &Rel,
                                   SmallVectorImpl<char> &Result) {
   if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
     return getRelocationValueString(ELF32LE, Rel, Result);
   if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
     return getRelocationValueString(ELF64LE, Rel, Result);
   if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
     return getRelocationValueString(ELF32BE, Rel, Result);
   auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
   return getRelocationValueString(ELF64BE, Rel, Result);
 }

 template <class ELFT>
 static uint64_t getSectionLMA(const ELFFile<ELFT> *Obj,
                               const object::ELFSectionRef &Sec) {
   auto PhdrRangeOrErr = Obj->program_headers();
   if (!PhdrRangeOrErr)
     report_fatal_error(errorToErrorCode(PhdrRangeOrErr.takeError()).message());

   // Search for a PT_LOAD segment containing the requested section. Use this
   // segment's p_addr to calculate the section's LMA.
   for (const typename ELFFile<ELFT>::Elf_Phdr &Phdr : *PhdrRangeOrErr)
     if ((Phdr.p_type == ELF::PT_LOAD) && (Phdr.p_vaddr <= Sec.getAddress()) &&
         (Phdr.p_vaddr + Phdr.p_memsz > Sec.getAddress()))
       return Sec.getAddress() - Phdr.p_vaddr + Phdr.p_paddr;

   // Return section's VMA if it isn't in a PT_LOAD segment.
   return Sec.getAddress();
 }

 uint64_t llvm::getELFSectionLMA(const object::ELFSectionRef &Sec) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Sec.getObject()))
     return getSectionLMA(ELFObj->getELFFile(), Sec);
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Sec.getObject()))
     return getSectionLMA(ELFObj->getELFFile(), Sec);
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
     return getSectionLMA(ELFObj->getELFFile(), Sec);
   const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
   return getSectionLMA(ELFObj->getELFFile(), Sec);
 }

 template <class ELFT>
 void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
   auto ProgramHeaderOrError = Elf->program_headers();
   if (!ProgramHeaderOrError)
     report_error(Filename, ProgramHeaderOrError.takeError());

   auto DynamicEntriesOrError = Elf->dynamicEntries();
   if (!DynamicEntriesOrError)
     report_error(Filename, DynamicEntriesOrError.takeError());

   outs() << "Dynamic Section:\n";
   for (const auto &Dyn : *DynamicEntriesOrError) {
     if (Dyn.d_tag == ELF::DT_NULL)
       continue;

     StringRef Str = StringRef(Elf->getDynamicTagAsString(Dyn.d_tag));

     if (Str.empty()) {
       std::string HexStr = utohexstr(static_cast<uint64_t>(Dyn.d_tag), true);
       outs() << format("  0x%-19s", HexStr.c_str());
     } else {
       // We use "-21" in order to match GNU objdump's output.
       outs() << format("  %-21s", Str.data());
     }

     const char *Fmt =
         ELFT::Is64Bits ? "0x%016" PRIx64 "\n" : "0x%08" PRIx64 "\n";
     if (Dyn.d_tag == ELF::DT_NEEDED) {
       Expected<StringRef> StrTabOrErr = getDynamicStrTab(Elf);
       if (StrTabOrErr) {
         const char *Data = StrTabOrErr.get().data();
         outs() << (Data + Dyn.d_un.d_val) << "\n";
         continue;
       }
       warn(errorToErrorCode(StrTabOrErr.takeError()).message());
       consumeError(StrTabOrErr.takeError());
     }
     outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
   }
 }

 template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
   typedef ELFFile<ELFT> ELFO;
   outs() << "Program Header:\n";
   auto ProgramHeaderOrError = o->program_headers();
   if (!ProgramHeaderOrError)
     report_fatal_error(
         errorToErrorCode(ProgramHeaderOrError.takeError()).message());
   for (const typename ELFO::Elf_Phdr &Phdr : *ProgramHeaderOrError) {
     switch (Phdr.p_type) {
     case ELF::PT_DYNAMIC:
       outs() << " DYNAMIC ";
       break;
     case ELF::PT_GNU_EH_FRAME:
       outs() << "EH_FRAME ";
       break;
     case ELF::PT_GNU_RELRO:
       outs() << "   RELRO ";
       break;
     case ELF::PT_GNU_STACK:
       outs() << "   STACK ";
       break;
     case ELF::PT_INTERP:
       outs() << "  INTERP ";
       break;
     case ELF::PT_LOAD:
       outs() << "    LOAD ";
       break;
     case ELF::PT_NOTE:
       outs() << "    NOTE ";
       break;
     case ELF::PT_OPENBSD_BOOTDATA:
       outs() << "    OPENBSD_BOOTDATA ";
       break;
     case ELF::PT_OPENBSD_RANDOMIZE:
       outs() << "    OPENBSD_RANDOMIZE ";
       break;
     case ELF::PT_OPENBSD_WXNEEDED:
       outs() << "    OPENBSD_WXNEEDED ";
       break;
     case ELF::PT_PHDR:
       outs() << "    PHDR ";
       break;
     case ELF::PT_TLS:
       outs() << "    TLS ";
       break;
     default:
       outs() << " UNKNOWN ";
     }

     const char *Fmt = ELFT::Is64Bits ? "0x%016" PRIx64 " " : "0x%08" PRIx64 " ";

     outs() << "off    " << format(Fmt, (uint64_t)Phdr.p_offset) << "vaddr "
            << format(Fmt, (uint64_t)Phdr.p_vaddr) << "paddr "
            << format(Fmt, (uint64_t)Phdr.p_paddr)
            << format("align 2**%u\n",
                      countTrailingZeros<uint64_t>(Phdr.p_align))
            << "         filesz " << format(Fmt, (uint64_t)Phdr.p_filesz)
            << "memsz " << format(Fmt, (uint64_t)Phdr.p_memsz) << "flags "
            << ((Phdr.p_flags & ELF::PF_R) ? "r" : "-")
            << ((Phdr.p_flags & ELF::PF_W) ? "w" : "-")
            << ((Phdr.p_flags & ELF::PF_X) ? "x" : "-") << "\n";
   }
   outs() << "\n";
 }

 void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
   else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
     printProgramHeaders(ELFObj->getELFFile());
 }

 void llvm::printELFDynamicSection(const object::ObjectFile *Obj) {
   if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
   else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
     printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
 }
	//===-- ELFDump.cpp - ELF-specific dumper ------------------------ C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file
	/// This file implements the ELF-specific dumper for llvm-objdump.
	///
	//===----------------------------------------------------------------------===//

	#include "llvm-objdump.h"
	#include "llvm/Demangle/Demangle.h"
	#include "llvm/Object/ELFObjectFile.h"
	#include "llvm/Support/Format.h"
	#include "llvm/Support/MathExtras.h"
	#include "llvm/Support/raw_ostream.h"

	using namespace llvm;
	using namespace llvm::object;

	template <class ELFT>
	Expected<StringRef> getDynamicStrTab(const ELFFile<ELFT> *Elf) {
	typedef ELFFile<ELFT> ELFO;

	auto DynamicEntriesOrError = Elf->dynamicEntries();
	if (!DynamicEntriesOrError)
	return DynamicEntriesOrError.takeError();

	for (const typename ELFO::Elf_Dyn &Dyn : *DynamicEntriesOrError) {
	if (Dyn.d_tag == ELF::DT_STRTAB) {
	auto MappedAddrOrError = Elf->toMappedAddr(Dyn.getPtr());
	if (!MappedAddrOrError)
	consumeError(MappedAddrOrError.takeError());
	return StringRef(reinterpret_cast<const char >(MappedAddrOrError));
	}
	}

	// If the dynamic segment is not present, we fall back on the sections.
	auto SectionsOrError = Elf->sections();
	if (!SectionsOrError)
	return SectionsOrError.takeError();

	for (const typename ELFO::Elf_Shdr &Sec : *SectionsOrError) {
	if (Sec.sh_type == ELF::SHT_DYNSYM)
	return Elf->getStringTableForSymtab(Sec);
	}

	return createError("dynamic string table not found");
	}

	template <class ELFT>
	static std::error_code getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
	const RelocationRef &RelRef,
	SmallVectorImpl<char> &Result) {
	typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
	typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;
	typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela;

	const ELFFile<ELFT> &EF = *Obj->getELFFile();
	DataRefImpl Rel = RelRef.getRawDataRefImpl();
	auto SecOrErr = EF.getSection(Rel.d.a);
	if (!SecOrErr)
	return errorToErrorCode(SecOrErr.takeError());

	int64_t Addend = 0;
	// If there is no Symbol associated with the relocation, we set the undef
	// boolean value to 'true'. This will prevent us from calling functions that
	// requires the relocation to be associated with a symbol.
	//
	// In SHT_REL case we would need to read the addend from section data.
	// GNU objdump does not do that and we just follow for simplicity atm.
	bool Undef = false;
	if ((*SecOrErr)->sh_type == ELF::SHT_RELA) {
	const Elf_Rela *ERela = Obj->getRela(Rel);
	Addend = ERela->r_addend;
	Undef = ERela->getSymbol(false) == 0;
	} else if ((*SecOrErr)->sh_type != ELF::SHT_REL) {
	return object_error::parse_failed;
	}

	// Default scheme is to print Target, as well as "+ <addend>" for nonzero
	// addend. Should be acceptable for all normal purposes.
	std::string FmtBuf;
	raw_string_ostream Fmt(FmtBuf);

	if (!Undef) {
	symbol_iterator SI = RelRef.getSymbol();
	const Elf_Sym *Sym = Obj->getSymbol(SI->getRawDataRefImpl());
	if (Sym->getType() == ELF::STT_SECTION) {
	Expected<section_iterator> SymSI = SI->getSection();
	if (!SymSI)
	return errorToErrorCode(SymSI.takeError());
	const Elf_Shdr SymSec = Obj->getSection((SymSI)->getRawDataRefImpl());
	auto SecName = EF.getSectionName(SymSec);
	if (!SecName)
	return errorToErrorCode(SecName.takeError());
	Fmt << *SecName;
	} else {
	Expected<StringRef> SymName = SI->getName();
	if (!SymName)
	return errorToErrorCode(SymName.takeError());
	if (Demangle)
	Fmt << demangle(*SymName);
	else
	Fmt << *SymName;
	}
	} else {
	Fmt << "ABS";
	}

	if (Addend != 0)
	Fmt << (Addend < 0 ? "" : "+") << Addend;
	Fmt.flush();
	Result.append(FmtBuf.begin(), FmtBuf.end());
	return std::error_code();
	}

	std::error_code
	llvm::getELFRelocationValueString(const ELFObjectFileBase *Obj,
	const RelocationRef &Rel,
	SmallVectorImpl<char> &Result) {
	if (auto *ELF32LE = dyn_cast<ELF32LEObjectFile>(Obj))
	return getRelocationValueString(ELF32LE, Rel, Result);
	if (auto *ELF64LE = dyn_cast<ELF64LEObjectFile>(Obj))
	return getRelocationValueString(ELF64LE, Rel, Result);
	if (auto *ELF32BE = dyn_cast<ELF32BEObjectFile>(Obj))
	return getRelocationValueString(ELF32BE, Rel, Result);
	auto *ELF64BE = cast<ELF64BEObjectFile>(Obj);
	return getRelocationValueString(ELF64BE, Rel, Result);
	}

	template <class ELFT>
	static uint64_t getSectionLMA(const ELFFile<ELFT> *Obj,
	const object::ELFSectionRef &Sec) {
	auto PhdrRangeOrErr = Obj->program_headers();
	if (!PhdrRangeOrErr)
	report_fatal_error(errorToErrorCode(PhdrRangeOrErr.takeError()).message());

	// Search for a PT_LOAD segment containing the requested section. Use this
	// segment's p_addr to calculate the section's LMA.
	for (const typename ELFFile<ELFT>::Elf_Phdr &Phdr : *PhdrRangeOrErr)
	if ((Phdr.p_type == ELF::PT_LOAD) && (Phdr.p_vaddr <= Sec.getAddress()) &&
	(Phdr.p_vaddr + Phdr.p_memsz > Sec.getAddress()))
	return Sec.getAddress() - Phdr.p_vaddr + Phdr.p_paddr;

	// Return section's VMA if it isn't in a PT_LOAD segment.
	return Sec.getAddress();
	}

	uint64_t llvm::getELFSectionLMA(const object::ELFSectionRef &Sec) {
	if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Sec.getObject()))
	return getSectionLMA(ELFObj->getELFFile(), Sec);
	else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Sec.getObject()))
	return getSectionLMA(ELFObj->getELFFile(), Sec);
	else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Sec.getObject()))
	return getSectionLMA(ELFObj->getELFFile(), Sec);
	const auto *ELFObj = cast<ELF64BEObjectFile>(Sec.getObject());
	return getSectionLMA(ELFObj->getELFFile(), Sec);
	}

	template <class ELFT>
	void printDynamicSection(const ELFFile<ELFT> *Elf, StringRef Filename) {
	auto ProgramHeaderOrError = Elf->program_headers();
	if (!ProgramHeaderOrError)
	report_error(Filename, ProgramHeaderOrError.takeError());

	auto DynamicEntriesOrError = Elf->dynamicEntries();
	if (!DynamicEntriesOrError)
	report_error(Filename, DynamicEntriesOrError.takeError());

	outs() << "Dynamic Section:\n";
	for (const auto &Dyn : *DynamicEntriesOrError) {
	if (Dyn.d_tag == ELF::DT_NULL)
	continue;

	StringRef Str = StringRef(Elf->getDynamicTagAsString(Dyn.d_tag));

	if (Str.empty()) {
	std::string HexStr = utohexstr(static_cast<uint64_t>(Dyn.d_tag), true);
	outs() << format(" 0x%-19s", HexStr.c_str());
	} else {
	// We use "-21" in order to match GNU objdump's output.
	outs() << format(" %-21s", Str.data());
	}

	const char *Fmt =
	ELFT::Is64Bits ? "0x%016" PRIx64 "\n" : "0x%08" PRIx64 "\n";
	if (Dyn.d_tag == ELF::DT_NEEDED) {
	Expected<StringRef> StrTabOrErr = getDynamicStrTab(Elf);
	if (StrTabOrErr) {
	const char *Data = StrTabOrErr.get().data();
	outs() << (Data + Dyn.d_un.d_val) << "\n";
	continue;
	}
	warn(errorToErrorCode(StrTabOrErr.takeError()).message());
	consumeError(StrTabOrErr.takeError());
	}
	outs() << format(Fmt, (uint64_t)Dyn.d_un.d_val);
	}
	}

	template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
	typedef ELFFile<ELFT> ELFO;
	outs() << "Program Header:\n";
	auto ProgramHeaderOrError = o->program_headers();
	if (!ProgramHeaderOrError)
	report_fatal_error(
	errorToErrorCode(ProgramHeaderOrError.takeError()).message());
	for (const typename ELFO::Elf_Phdr &Phdr : *ProgramHeaderOrError) {
	switch (Phdr.p_type) {
	case ELF::PT_DYNAMIC:
	outs() << " DYNAMIC ";
	break;
	case ELF::PT_GNU_EH_FRAME:
	outs() << "EH_FRAME ";
	break;
	case ELF::PT_GNU_RELRO:
	outs() << " RELRO ";
	break;
	case ELF::PT_GNU_STACK:
	outs() << " STACK ";
	break;
	case ELF::PT_INTERP:
	outs() << " INTERP ";
	break;
	case ELF::PT_LOAD:
	outs() << " LOAD ";
	break;
	case ELF::PT_NOTE:
	outs() << " NOTE ";
	break;
	case ELF::PT_OPENBSD_BOOTDATA:
	outs() << " OPENBSD_BOOTDATA ";
	break;
	case ELF::PT_OPENBSD_RANDOMIZE:
	outs() << " OPENBSD_RANDOMIZE ";
	break;
	case ELF::PT_OPENBSD_WXNEEDED:
	outs() << " OPENBSD_WXNEEDED ";
	break;
	case ELF::PT_PHDR:
	outs() << " PHDR ";
	break;
	case ELF::PT_TLS:
	outs() << " TLS ";
	break;
	default:
	outs() << " UNKNOWN ";
	}

	const char *Fmt = ELFT::Is64Bits ? "0x%016" PRIx64 " " : "0x%08" PRIx64 " ";

	outs() << "off " << format(Fmt, (uint64_t)Phdr.p_offset) << "vaddr "
	<< format(Fmt, (uint64_t)Phdr.p_vaddr) << "paddr "
	<< format(Fmt, (uint64_t)Phdr.p_paddr)
	<< format("align 2**%u\n",
	countTrailingZeros<uint64_t>(Phdr.p_align))
	<< " filesz " << format(Fmt, (uint64_t)Phdr.p_filesz)
	<< "memsz " << format(Fmt, (uint64_t)Phdr.p_memsz) << "flags "
	<< ((Phdr.p_flags & ELF::PF_R) ? "r" : "-")
	<< ((Phdr.p_flags & ELF::PF_W) ? "w" : "-")
	<< ((Phdr.p_flags & ELF::PF_X) ? "x" : "-") << "\n";
	}
	outs() << "\n";
	}

	void llvm::printELFFileHeader(const object::ObjectFile *Obj) {
	if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
	printProgramHeaders(ELFObj->getELFFile());
	else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
	printProgramHeaders(ELFObj->getELFFile());
	else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
	printProgramHeaders(ELFObj->getELFFile());
	else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
	printProgramHeaders(ELFObj->getELFFile());
	}

	void llvm::printELFDynamicSection(const object::ObjectFile *Obj) {
	if (const auto *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
	printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
	else if (const auto *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
	printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
	else if (const auto *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
	printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
	else if (const auto *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
	printDynamicSection(ELFObj->getELFFile(), Obj->getFileName());
	}