/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

* 

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <fcntl.h>

#include <string.h>

#include <iostream>

#include <sstream>

#include <iomanip>

using namespace std;

#include "elfromerror.h"

#include "elfrom.h"

#include "inputfile.h"

#define NO_GAPS

void ElfRom::SetupE32RomData() {

	SetupRomElf32_EHdr();

	SetupRomImage();

}

// TODO: don't use primary file - fill header in by hand.

void ElfRom::SetupRomElf32_EHdr() {

	//create ELF header

	unsigned char c[EI_NIDENT] = {ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, ELFCLASS32, ELFDATA2LSB, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0}; 

	Elf32_Ehdr elf32_ehdr;

	for (int i=0; i <EI_NIDENT;i++)

		elf32_ehdr.e_ident[i] = c[i];

	elf32_ehdr.e_type		= ET_EXEC;

	elf32_ehdr.e_machine	= EM_ARM;

	elf32_ehdr.e_version	= EV_CURRENT;

	elf32_ehdr.e_entry		= iRomDetails->iRomPhysAddr;

	elf32_ehdr.e_shoff		= sizeof(Elf32_Ehdr);

// ARM specific flags 

// e_entry contains a program-loader entry point

#define EF_ARM_HASENTRY 0x02

// Each subsection of the symbol table is sorted by symbol value

#define EF_ARM_SYMSARESORTED 0x04

// Symbols in dynamic symbol tables that are defined in sections

// included in program segment n have st_shndx = n+ 1. 

#define EF_ARM_DYNSYMSUSESEGIDX 0x8

// Mapping symbols precede other local symbols in the symbol table

#define EF_ARM_MAPSYMSFIRST 0x10

// This masks an 8-bit version number, the version of the ARM EABI to

// which this ELF file conforms. This EABI is version 2. A value of 0

// denotes unknown conformance. (current version is 0x02000000)

#define EF_ARM_EABIMASK 0xFF000000

#define EF_ARM_EABI_VERSION 0x02000000

#define EF_ARM_BPABI_VERSION 0x04000000

	elf32_ehdr.e_flags		= EF_ARM_BPABI_VERSION | EF_ARM_HASENTRY;

	elf32_ehdr.e_ehsize		= sizeof(Elf32_Ehdr);

	elf32_ehdr.e_phentsize 	= sizeof(Elf32_Phdr);

	elf32_ehdr.e_shentsize 	= sizeof(Elf32_Shdr);

	elf32_ehdr.e_shnum		= 0;

	elf32_ehdr.e_shstrndx	= 0;

	elf32_ehdr.e_phnum		= 02;

	new (&iElf32Header) Elf32Header(elf32_ehdr);

#if 0

	iElf32Header.SetEntryPoint(iRomDetails->iRomPhysAddr);

	elf_end(e);

	close(fd);

#endif

	iElf32Header.SetEntryPoint(iRomDetails->iRomPhysAddr);

	iElf32Header.AddData(iOutputFile);

	assert(iElf32Header.GetOffset() == 0);

	if (iRomDetails->iTrace){

		cout << "\nElf header added.\n";

	}

}

void ElfRom::SetupRomImage(){

	// ensure image size is known and we know how to get hold of it

	iE32RomImage.SetupRomData();

	iE32RomImage.AddData(iOutputFile);

	assert(iE32RomImage.GetOffset() == iElf32Header.Size());

	if (iRomDetails->iTrace){

		size_t offset = iE32RomImage.GetOffset();

		size_t size = iE32RomImage.Size();

		cout << "\nAdded ROM image " << iRomDetails->iRomFile << "\n";

		cout.fill('0');

		cout << hex << "      offset 0x" << setw(8)

			<< offset << " size = 0x" << setw(8) << size << "\n" ;

	}

}

void ElfRom::SetupProgramHeaderTable(){

	size_t offsetx = AddBootStrapProgramHeader();

	RomDetails::XIPFileList::iterator aXIPFile = iRomDetails->iXIPFiles.begin();

	RomDetails::XIPFileList::iterator end = iRomDetails->iXIPFiles.end();

	unsigned int p = iRomDetails->iRomPhysAddr;

	unsigned int v = iRomDetails->iRomBaseLinearAddr;

	int addend = v > p ? -(v - p) : p - v;

	if (iRomDetails->iTrace){

		cout << "\nAdding program headers for e32images\n";

	}

	while (aXIPFile != end) {

		offsetx = SetupProgramHeaders(*aXIPFile, offsetx, addend);

		aXIPFile++;

	}

	AddFinalHeader(offsetx);

#ifdef NO_GAPS

	// check there are no gaps or overlaps in the phdrs

	Elf32_Word bsz = iBootStrapPHdr.GetPhdrFilesz();

	Elf32_Word coffset = iBootStrapPHdr.GetPhdrOffset() + bsz;

	Elf32_Addr phys_addr = iBootStrapPHdr.GetPhdrPaddr() + bsz;

	ElfPHdrList::iterator aCheckHdr = iElfPHdrList.begin();

	ElfPHdrList::iterator endCheckHdr = iElfPHdrList.end();

	while(aCheckHdr != endCheckHdr) {

		Elf32_Word o = aCheckHdr->GetPhdrOffset();

		if (coffset != o){

			cerr << "Error: Phdr table broken - offsets incorrect\n";

			assert(coffset == o);

		}

		Elf32_Addr addr = aCheckHdr->GetPhdrPaddr();

		if (phys_addr > addr){

			cerr << "Error: Phdr table broken - physical addresses incorrect\n";

			assert(phys_addr <= addr);

		}

		size_t sz = aCheckHdr->GetPhdrFilesz();

		coffset = o + sz;

		phys_addr = addr + sz;

		aCheckHdr++;

	}

#endif

	ElfPHdrList::iterator aHdr = iElfPHdrList.begin();

	ElfPHdrList::iterator endHdr = iElfPHdrList.end();

	while (aHdr != endHdr) {

		aHdr->AddData(iOutputFile);

		aHdr++;

	}

}

size_t ElfRom::AddBootStrapProgramHeader(){

	iBootStrapPHdr.SetPhdrType(PT_LOAD);

	iBootStrapPHdr.SetPhdrOffset(iE32RomImage.GetOffset());

	iBootStrapPHdr.SetPhdrVaddr(iRomDetails->iRomPhysAddr);

	iBootStrapPHdr.SetPhdrPaddr(iRomDetails->iRomPhysAddr);

	iBootStrapPHdr.SetPhdrAlign(4);

	iBootStrapPHdr.SetPhdrFlags(PF_X + PF_R);

	size_t bootstrapsize = iRomDetails->iXIPFiles[0].iLoadAddr - iRomDetails->iRomBaseLinearAddr;

	iBootStrapPHdr.SetPhdrFilesz(bootstrapsize);

	iBootStrapPHdr.SetPhdrMemsz(bootstrapsize);

	iBootStrapPHdr.AddData(iOutputFile);

	assert((iElf32Header.Size() + iE32RomImage.Size()) == iBootStrapPHdr.GetOffset());

	iElf32Header.AddProgramHdr();

	iElf32Header.SetProgramHdrOffset(iBootStrapPHdr.GetOffset());

	if (iRomDetails->iTrace){

		size_t offset = iBootStrapPHdr.GetOffset();

		cout << "\nAdded PHdr for bootstrap\n";

		cout.fill('0');

		cout << hex << "      offset 0x" << setw(8) << offset 

			 << " size = 0x" << setw(8) << bootstrapsize << "\n";

	}

	return iE32RomImage.GetOffset() + bootstrapsize;

}

static inline size_t InitE32HdrPHdr(ElfPHdr & hdr, size_t offset, Elf32_Word vaddr, Elf32_Word paddr, Elf32_Word size){

	hdr.SetPhdrType(PT_LOAD);

	hdr.SetPhdrOffset(offset);

	hdr.SetPhdrVaddr(vaddr);

	hdr.SetPhdrPaddr(paddr);

	hdr.SetPhdrAlign(0);

	hdr.SetPhdrFlags(PF_R);

	hdr.SetPhdrFilesz(size);

	hdr.SetPhdrMemsz(size);

	return offset + size;	

}

static inline size_t InitROPHdr(ElfPHdr & hdr, size_t offset, Elf32_Word vaddr, Elf32_Word paddr, Elf32_Word size){

	hdr.SetPhdrType(PT_LOAD);

	hdr.SetPhdrOffset(offset);

	hdr.SetPhdrVaddr(vaddr);

	hdr.SetPhdrPaddr(paddr);

	hdr.SetPhdrAlign(4);

	hdr.SetPhdrFlags(PF_X + PF_R);

	hdr.SetPhdrFilesz(size);

	hdr.SetPhdrMemsz(size);

	return offset + size;	

}

static inline size_t InitRWPHdr(ElfPHdr & hdr, size_t offset, Elf32_Word vaddr, Elf32_Word paddr, Elf32_Word fsize, Elf32_Word msize){

	hdr.SetPhdrType(PT_LOAD);

	hdr.SetPhdrOffset(offset);

	hdr.SetPhdrVaddr(vaddr);

	hdr.SetPhdrPaddr(paddr);

	hdr.SetPhdrAlign(4);

	hdr.SetPhdrFlags(PF_X + PF_R);

	hdr.SetPhdrFilesz(fsize);

	hdr.SetPhdrMemsz(msize);

	return offset + fsize;	

}

size_t ElfRom::SetupProgramHeaders(XIPFileDetails & aXIPFileDetails, size_t offset, int addend){

	ElfPHdr e32hdr;

	Elf32_Word e32hdrVaddr = aXIPFileDetails.iLoadAddr;

	Elf32_Word e32hdrPaddr = aXIPFileDetails.iLoadAddr + addend;

	Elf32_Word e32hdrSize = aXIPFileDetails.iROAddr - aXIPFileDetails.iLoadAddr ;

	size_t e32hdrOffsetInRom = aXIPFileDetails.iLoadAddr - iRomDetails->iRomBaseLinearAddr;

	size_t e32hdrOffsetInElf = iE32RomImage.GetOffset() + e32hdrOffsetInRom;

#ifdef NO_GAPS

	// But actually the offset we'll use is the one we were given as an argument.

	// This means we need to adjust the size, vaddr and paddr by the difference

	size_t diff = e32hdrOffsetInElf - offset;

	e32hdrSize += diff;

	e32hdrVaddr -= diff;

	e32hdrPaddr -= diff;

	offset = InitE32HdrPHdr(e32hdr, offset, e32hdrVaddr, e32hdrPaddr, e32hdrSize);

#else

	offset = InitE32HdrPHdr(e32hdr, e32hdrOffsetInElf, e32hdrVaddr, e32hdrPaddr, e32hdrSize);

#endif

	iElf32Header.AddProgramHdr();

	iElfPHdrList.push_back(e32hdr);

	ElfPHdr thdr;

	Elf32_Word textVaddr = aXIPFileDetails.iROAddr;

	Elf32_Word textPaddr = aXIPFileDetails.iROAddr + addend;

	Elf32_Word textSize = aXIPFileDetails.iROSize;

	size_t textOffsetInRom = aXIPFileDetails.iROAddr - iRomDetails->iRomBaseLinearAddr;

	size_t textOffsetInElf = iE32RomImage.GetOffset() + textOffsetInRom;

	offset = InitROPHdr(thdr, textOffsetInElf, textVaddr, textPaddr, textSize);

	iElf32Header.AddProgramHdr();

	iElfPHdrList.push_back(thdr);

	if (iRomDetails->iTrace){

		cout << "  " << aXIPFileDetails.iE32File << "\n";

		cout.fill(' ');

		cout << left << "    .text\n";

		cout.fill('0');

		cout << "      paddr = 0x" << right << setw(8) << textPaddr << " vaddr = 0x" << right << setw(8)<< textVaddr

		     << " offset = 0x" << right << setw(8) << textOffsetInElf 

			 << " size = 0x" << setw(8) << textSize << "\n" << flush;

	}

	if (aXIPFileDetails.iRWSize > 0){

		ElfPHdr dhdr;

		Elf32_Word dataVaddr = aXIPFileDetails.iRWAddr;

		Elf32_Word dataPaddr = aXIPFileDetails.iROMDataAddr + addend;

		Elf32_Word fsize = aXIPFileDetails.iRWSize;

		Elf32_Word msize = aXIPFileDetails.iBSSDataSize;

		size_t dataOffsetInRom = aXIPFileDetails.iROMDataAddr - iRomDetails->iRomBaseLinearAddr;

		size_t dataOffsetInElf = iE32RomImage.GetOffset() + dataOffsetInRom;

		offset = InitRWPHdr(dhdr, dataOffsetInElf, dataVaddr, dataPaddr, fsize, msize);

		iElf32Header.AddProgramHdr();

		iElfPHdrList.push_back(dhdr);

		if (iRomDetails->iTrace){

			cout.fill(' ');

			cout << left << "    .data\n";

			cout.fill('0');

			cout << "      paddr = 0x" << right << setw(8) << dataPaddr << " vaddr = 0x" << right << setw(8)<< dataVaddr  

				 << " offset = 0x" << right << setw(8)<< dataOffsetInElf

				 << " size = 0x" << right << setw(8) << fsize << "\n" << flush;

		}

	}

	return offset;

}

// This adds a header for the remainder of the ROM image after the last XIP file

size_t ElfRom::AddFinalHeader(size_t offset){

	ElfPHdr & lastHdr = iElfPHdrList.back();

	Elf32_Word startAddr = lastHdr.GetPhdrPaddr() + lastHdr.GetPhdrFilesz();

	ElfPHdr e32hdr;

	Elf32_Word e32hdrVaddr = startAddr;

	Elf32_Word e32hdrPaddr = startAddr;

	Elf32_Word e32hdrSize = iE32RomImage.Size() - offset + iE32RomImage.GetOffset();

	offset = InitE32HdrPHdr(e32hdr, offset, e32hdrVaddr, e32hdrPaddr, e32hdrSize);

	iElf32Header.AddProgramHdr();

	iElfPHdrList.push_back(e32hdr);	

	if (iRomDetails->iTrace){

		cout << "\nAdded final PHdr\n" << "      offset 0x" << hex << right << setw(8) << offset 

			<< " size = 0x" << setw(8) << e32hdrSize << "\n";

	}

	return offset;

}

void ElfRom::SetupAuxilarySections(){

	SetupLogFile();

}

void ElfRom::SetupLogFile(){

	if (!iRomDetails->iLogFile.size()) return;

	InputFile * aLogFile = new InputFile(iRomDetails->iLogFile);

	ElfSectionFileData * aLogFileData = new ElfSectionFileData(aLogFile);

	Elf32_Shdr shdr;

	shdr.sh_name = 0; // for now.

	shdr.sh_offset = 0; // for now

	shdr.sh_info = 0;

	shdr.sh_link = SHN_UNDEF;

	shdr.sh_addr = 0;

	shdr.sh_addralign = 0;

	shdr.sh_type = SHT_PROGBITS;

	shdr.sh_size = 0; // for now.

	shdr.sh_flags = 0;

	shdr.sh_entsize = 0;

	ElfSection aLogFileSection(aLogFileData, "ROMLogFile", shdr);

	iElfSectionManager.AddSection(aLogFileSection);

}

void ElfRom::SetupELFRomData() {

	SetupProgramHeaderTable();

	SetupAuxilarySections();

	if (!iRomDetails->iStrip){

		SetupSectionHeaderTable();

		SetupSymbolTable();

		if (!iRomDetails->iNoDwarf){

			SetupDwarfSections();

		}

	}

}

void ElfRom::SetupSectionHeaderTable(){

	RomDetails::XIPFileList::iterator aXIPFile = iRomDetails->iXIPFiles.begin();

	RomDetails::XIPFileList::iterator end = iRomDetails->iXIPFiles.end();

	if (iRomDetails->iTrace && aXIPFile != end){

		cout << "\nAdding Section headers from associated ELF files\n";

	}

	while (aXIPFile != end) {

		SetupSectionHeaders(*aXIPFile);

		aXIPFile++;

	}

}

void ElfRom::SetupSectionHeaders(XIPFileDetails & aXIPFileDetails) {

	// Open ELF file

	PathName aPath = aXIPFileDetails.iElfFile;

	if (aPath.size() == 0) return;

	int fd;

	Elf * e;

	size_t shstrndx;

	bool hasSectionStringTable = true;

	if ((fd = open(aPath.c_str(), O_RDONLY|O_BINARY, 0)) < 0){

		warnx(EX_NOINPUT, "open \"%s\" failed\n", aPath.c_str());

		goto finish;

	}

	if ((e = elf_begin(fd, ELF_C_READ , NULL)) == NULL)

		errx(EX_SOFTWARE, "elf_begin() failed: %s.\n", elf_errmsg(-1));

	if (elf_kind(e) != ELF_K_ELF)

		errx(EX_SOFTWARE, "file not of kind ELF_K_ELF: %s.\n", aPath.c_str());

	if (elf_getshstrndx(e, &shstrndx) == 0) {

		hasSectionStringTable = false;

		warnx(EX_SOFTWARE, "getshstrndx() failed for \"%s\"\n", aPath.c_str());

	}

	if (hasSectionStringTable){

		SetUpSegmentInfo(aXIPFileDetails, e);

		SetupSectionHeaders(aXIPFileDetails, e, shstrndx);

	}

	elf_end(e);

	close(fd);	

finish:

	return;

}

void ElfRom::SetupSectionHeaders(XIPFileDetails & aXIPFileDetails, Elf * e, size_t shstrndx){

	// Iterate through sections looking for the ones we're after. Namely:

	// text, data, bss/zi, symtab, strtable,  and .debug*

	Elf_Scn * scn = NULL; 

	Elf32_Shdr * shdr;

	SectionNumberMap aSectionNumberMap;

	SectionVaddrAddendMap aSectionVaddrAddendMap;

	String aPath(aXIPFileDetails.iElfFile);

	const char * debugName = ".debug";

	const size_t debugNameLength = strlen(debugName);

	const char * staticStrTab = ".strtab";

	if (iRomDetails->iTrace){

		cout << "  " << aXIPFileDetails.iElfFile << "\n";

	}

	while ((scn = elf_nextscn(e, scn)) != NULL) {

    	if ((shdr = elf32_getshdr(scn)) == NULL)

    		errx(EX_SOFTWARE, "getshdr() failed: %s.\n", elf_errmsg(-1));

		size_t aOldNdx = elf_ndxscn(scn);

    	char * name = elf_strptr(e, shstrndx, shdr->sh_name);

    	VirtualAddr sectionAddr = shdr->sh_addr;

    	switch (shdr->sh_type) {

    	case SHT_NOBITS:

    		// Check for BSS or ZI

    		if ((shdr->sh_flags & SHF_WRITE) && (shdr->sh_flags & SHF_ALLOC)) {

    			// set up section number mapping

    			size_t aNew = AddBssSectionHeader(aXIPFileDetails, shdr, name);

    			aSectionNumberMap.push_back(SectionNumberMapping(aOldNdx, aNew));

    			// set up address adjustment for relocation of e.g. symbols

    			int addend = aXIPFileDetails.iBSSAddr - sectionAddr;

    			aSectionVaddrAddendMap.push_back(SectionVaddrAddendMapping(aOldNdx, addend));

    		}

    		break;

#define ARM_EXIDX	(SHT_LOPROC + 1)

    	case ARM_EXIDX:    		

    	case SHT_PROGBITS:

    		// text/ro or data/rw will have SHF_ALLOC set

    		if (shdr->sh_flags & SHF_ALLOC) {

    			size_t aNew = 0;

    		    int addend = 0;

    		    if (shdr->sh_flags & SHF_WRITE) {

    				aNew = AddRwSectionHeader(aXIPFileDetails, shdr, name);

    				addend = aXIPFileDetails.iRWAddr - sectionAddr;

    		    } else {

    				aNew = AddRoSectionHeader(aXIPFileDetails, shdr, name);

    				addend = aXIPFileDetails.iROAddr - sectionAddr;

    		    }

    			// set up section number mapping

    		    aSectionNumberMap.push_back(SectionNumberMapping(aOldNdx, aNew)); 

    			// set up address adjustment for relocation of e.g. symbols

    		    aSectionVaddrAddendMap.push_back(SectionVaddrAddendMapping(aOldNdx, addend));     	

    		} else if (!iRomDetails->iNoDwarf && !strncmp(debugName, name, debugNameLength)) {

    			iDwarfFound = true;

    			iDwarfManager.AddSection(aXIPFileDetails, name, shdr);

    		}

    		break;

    	case SHT_SYMTAB:

    		iElfSymbolTableManager.AddSymbolTable(aPath, shdr->sh_offset, shdr->sh_size, shdr->sh_info);

    		break;

    	case SHT_STRTAB:

    		if (!strcmp(staticStrTab, name))

    			iElfSymbolTableManager.AddStringTable(aPath, shdr->sh_offset, shdr->sh_size);

    		break;

    	}

    }

	iElfSymbolTableManager.Finalize(aSectionNumberMap, aSectionVaddrAddendMap);

}

size_t ElfRom::AddRoSectionHeader(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr, char * aName){

	size_t delta = aShdr->sh_addr - aXIPFileDetails.iElfTextBase;

	VirtualAddr vaddr = aXIPFileDetails.iROAddr + delta;

	size_t offsetInRom = vaddr - iRomDetails->iRomBaseLinearAddr;

	size_t offsetInElf = iE32RomImage.GetOffset() + offsetInRom;

	aShdr->sh_addr = vaddr;

	return AddROMSectionHeader(aXIPFileDetails, aShdr, aName, offsetInElf );

}

size_t ElfRom::AddRwSectionHeader(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr, char * aName){		

	size_t delta = aShdr->sh_addr - aXIPFileDetails.iElfDataBase;

	VirtualAddr vaddr = aXIPFileDetails.iROMDataAddr + delta;

	size_t offsetInRom = vaddr - iRomDetails->iRomBaseLinearAddr;

	size_t offsetInElf = iE32RomImage.GetOffset() + offsetInRom;	

	aShdr->sh_addr = aXIPFileDetails.iRWAddr;

	return AddROMSectionHeader(aXIPFileDetails, aShdr, aName, offsetInElf);

}

size_t ElfRom::AddBssSectionHeader(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr, char * aName){	

	size_t delta = aShdr->sh_addr - aXIPFileDetails.iElfDataBase;

	VirtualAddr vaddr = aXIPFileDetails.iROMDataAddr + delta;

	size_t offsetInRom = vaddr - iRomDetails->iRomBaseLinearAddr;

	size_t offsetInElf = iE32RomImage.GetOffset() + offsetInRom;	

	aShdr->sh_addr = aXIPFileDetails.iBSSAddr;

	return AddROMSectionHeader(aXIPFileDetails, aShdr, aName, offsetInElf);

}

size_t ElfRom::AddROMSectionHeader(XIPFileDetails & aXIPFileDetails, Elf32_Shdr * aShdr, char * aName, size_t aOffset){	

	ElfSectionData * romData = aOffset ? 

								(ElfSectionData *)new ElfSectionRomData(aOffset, aShdr->sh_size) 

								: (ElfSectionData *)new ElfSectionNoData();

	ElfSection aSection(romData, aName, *aShdr);

	iElfSectionManager.AddSection(aSection);

	if (iRomDetails->iTrace){

		cout.fill(' ');

		cout << "    " << left << setw(22) << aName << "\n";

		cout.fill('0');

		cout << "      vaddr = 0x" << right << hex << setw(8) << aShdr->sh_addr << " offset = 0x" 

			 << right << hex << setw(8) << aOffset 

			 << " size = 0x" << right << hex << setw(8) << aShdr->sh_size << "\n";

	}

	return aSection.GetIndex();

}

void ElfRom::SetUpSegmentInfo(XIPFileDetails & aXIPFileDetails, Elf * e){

	Elf32_Ehdr * ehdr = elf32_getehdr(e);

	if (ehdr == NULL)

		errx(EX_SOFTWARE, "elf32_getehdr() failed: %s.", elf_errmsg(-1));

	size_t n = ehdr->e_phnum;

	Elf32_Phdr * phdr = elf32_getphdr(e);

	if (phdr == NULL)

		errx(EX_SOFTWARE, "elf32_getphdr() failed: %s.", elf_errmsg(-1));

	for (size_t i = 0; i < n; i++) {

		if (phdr[i].p_flags & PF_X){