Context Navigation

source: bootcd/isolinux/syslinux-6.03/gpxe/src/util/elf2efi.c

Last change on this file was e16e8f2, checked in by Edwin Eefting <edwin@datux.nl>, 3 years ago
bootstuff
Property mode set to `100644`
File size: 21.7 KB

Rev	Line
[e16e8f2]	1	/*
	2	* Copyright (C) 2009 Michael Brown <mbrown@fensystems.co.uk>.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License as
	6	* published by the Free Software Foundation; either version 2 of the
	7	* License, or any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful, but
	10	* WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	17	*/
	18
	19	#define _GNU_SOURCE
	20	#include <stdint.h>
	21	#include <stddef.h>
	22	#include <stdlib.h>
	23	#include <stdio.h>
	24	#include <string.h>
	25	#include <unistd.h>
	26	#include <errno.h>
	27	#include <assert.h>
	28	#include <getopt.h>
	29	#include <bfd.h>
	30	#include <gpxe/efi/efi.h>
	31	#include <gpxe/efi/IndustryStandard/PeImage.h>
	32	#include <libgen.h>
	33
	34	#define eprintf(...) fprintf ( stderr, __VA_ARGS__ )
	35
	36	#define EFI_FILE_ALIGN 0x20
	37
	38	struct pe_section {
	39	struct pe_section *next;
	40	EFI_IMAGE_SECTION_HEADER hdr;
	41	uint8_t contents[0];
	42	};
	43
	44	struct pe_relocs {
	45	struct pe_relocs *next;
	46	unsigned long start_rva;
	47	unsigned int used_relocs;
	48	unsigned int total_relocs;
	49	uint16_t *relocs;
	50	};
	51
	52	struct pe_header {
	53	EFI_IMAGE_DOS_HEADER dos;
	54	uint8_t padding[128];
	55	#if defined(MDE_CPU_IA32)
	56	EFI_IMAGE_NT_HEADERS32 nt;
	57	#elif defined(MDE_CPU_X64)
	58	EFI_IMAGE_NT_HEADERS64 nt;
	59	#endif
	60	};
	61
	62	static struct pe_header efi_pe_header = {
	63	.dos = {
	64	.e_magic = EFI_IMAGE_DOS_SIGNATURE,
	65	.e_lfanew = offsetof ( typeof ( efi_pe_header ), nt ),
	66	},
	67	.nt = {
	68	.Signature = EFI_IMAGE_NT_SIGNATURE,
	69	.FileHeader = {
	70	#if defined(MDE_CPU_IA32)
	71	.Machine = EFI_IMAGE_MACHINE_IA32,
	72	#elif defined(MDE_CPU_X64)
	73	.Machine = EFI_IMAGE_MACHINE_X64,
	74	#endif
	75	.TimeDateStamp = 0x10d1a884,
	76	.SizeOfOptionalHeader =
	77	sizeof ( efi_pe_header.nt.OptionalHeader ),
	78	.Characteristics = ( EFI_IMAGE_FILE_DLL \|
	79	#if defined(MDE_CPU_IA32)
	80	EFI_IMAGE_FILE_32BIT_MACHINE \|
	81	#endif
	82	EFI_IMAGE_FILE_EXECUTABLE_IMAGE ),
	83	},
	84	.OptionalHeader = {
	85	#if defined(MDE_CPU_IA32)
	86	.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC,
	87	#elif defined(MDE_CPU_X64)
	88	.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC,
	89	#endif
	90	.SectionAlignment = EFI_FILE_ALIGN,
	91	.FileAlignment = EFI_FILE_ALIGN,
	92	.SizeOfImage = sizeof ( efi_pe_header ),
	93	.SizeOfHeaders = sizeof ( efi_pe_header ),
	94	.NumberOfRvaAndSizes =
	95	EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES,
	96	},
	97	},
	98	};
	99
	100	/** Command-line options */
	101	struct options {
	102	unsigned int subsystem;
	103	};
	104
	105	/**
	106	* Allocate memory
	107	*
	108	* @v len Length of memory to allocate
	109	* @ret ptr Pointer to allocated memory
	110	*/
	111	static void * xmalloc ( size_t len ) {
	112	void *ptr;
	113
	114	ptr = malloc ( len );
	115	if ( ! ptr ) {
	116	eprintf ( "Could not allocate %zd bytes\n", len );
	117	exit ( 1 );
	118	}
	119
	120	return ptr;
	121	}
	122
	123	/**
	124	* Align section within PE file
	125	*
	126	* @v offset Unaligned offset
	127	* @ret aligned_offset Aligned offset
	128	*/
	129	static unsigned long efi_file_align ( unsigned long offset ) {
	130	return ( ( offset + EFI_FILE_ALIGN - 1 ) & ~( EFI_FILE_ALIGN - 1 ) );
	131	}
	132
	133	/**
	134	* Generate entry in PE relocation table
	135	*
	136	* @v pe_reltab PE relocation table
	137	* @v rva RVA
	138	* @v size Size of relocation entry
	139	*/
	140	static void generate_pe_reloc ( struct pe_relocs **pe_reltab,
	141	unsigned long rva, size_t size ) {
	142	unsigned long start_rva;
	143	uint16_t reloc;
	144	struct pe_relocs *pe_rel;
	145	uint16_t *relocs;
	146
	147	/* Construct */
	148	start_rva = ( rva & ~0xfff );
	149	reloc = ( rva & 0xfff );
	150	switch ( size ) {
	151	case 8:
	152	reloc \|= 0xa000;
	153	break;
	154	case 4:
	155	reloc \|= 0x3000;
	156	break;
	157	case 2:
	158	reloc \|= 0x2000;
	159	break;
	160	default:
	161	eprintf ( "Unsupported relocation size %zd\n", size );
	162	exit ( 1 );
	163	}
	164
	165	/* Locate or create PE relocation table */
	166	for ( pe_rel = *pe_reltab ; pe_rel ; pe_rel = pe_rel->next ) {
	167	if ( pe_rel->start_rva == start_rva )
	168	break;
	169	}
	170	if ( ! pe_rel ) {
	171	pe_rel = xmalloc ( sizeof ( *pe_rel ) );
	172	memset ( pe_rel, 0, sizeof ( *pe_rel ) );
	173	pe_rel->next = *pe_reltab;
	174	*pe_reltab = pe_rel;
	175	pe_rel->start_rva = start_rva;
	176	}
	177
	178	/* Expand relocation list if necessary */
	179	if ( pe_rel->used_relocs < pe_rel->total_relocs ) {
	180	relocs = pe_rel->relocs;
	181	} else {
	182	pe_rel->total_relocs = ( pe_rel->total_relocs ?
	183	( pe_rel->total_relocs * 2 ) : 256 );
	184	relocs = xmalloc ( pe_rel->total_relocs *
	185	sizeof ( pe_rel->relocs[0] ) );
	186	memset ( relocs, 0,
	187	pe_rel->total_relocs * sizeof ( pe_rel->relocs[0] ) );
	188	memcpy ( relocs, pe_rel->relocs,
	189	pe_rel->used_relocs * sizeof ( pe_rel->relocs[0] ) );
	190	free ( pe_rel->relocs );
	191	pe_rel->relocs = relocs;
	192	}
	193
	194	/* Store relocation */
	195	pe_rel->relocs[ pe_rel->used_relocs++ ] = reloc;
	196	}
	197
	198	/**
	199	* Calculate size of binary PE relocation table
	200	*
	201	* @v pe_reltab PE relocation table
	202	* @v buffer Buffer to contain binary table, or NULL
	203	* @ret size Size of binary table
	204	*/
	205	static size_t output_pe_reltab ( struct pe_relocs *pe_reltab,
	206	void *buffer ) {
	207	struct pe_relocs *pe_rel;
	208	unsigned int num_relocs;
	209	size_t size;
	210	size_t total_size = 0;
	211
	212	for ( pe_rel = pe_reltab ; pe_rel ; pe_rel = pe_rel->next ) {
	213	num_relocs = ( ( pe_rel->used_relocs + 1 ) & ~1 );
	214	size = ( sizeof ( uint32_t ) /* VirtualAddress */ +
	215	sizeof ( uint32_t ) /* SizeOfBlock */ +
	216	( num_relocs * sizeof ( uint16_t ) ) );
	217	if ( buffer ) {
	218	( (uint32_t ) ( buffer + total_size + 0 ) )
	219	= pe_rel->start_rva;
	220	( (uint32_t ) ( buffer + total_size + 4 ) ) = size;
	221	memcpy ( ( buffer + total_size + 8 ), pe_rel->relocs,
	222	( num_relocs * sizeof ( uint16_t ) ) );
	223	}
	224	total_size += size;
	225	}
	226
	227	return total_size;
	228	}
	229
	230	/**
	231	* Open input BFD file
	232	*
	233	* @v filename File name
	234	* @ret ibfd BFD file
	235	*/
	236	static bfd * open_input_bfd ( const char *filename ) {
	237	bfd *bfd;
	238
	239	/* Open the file */
	240	bfd = bfd_openr ( filename, NULL );
	241	if ( ! bfd ) {
	242	eprintf ( "Cannot open %s: ", filename );
	243	bfd_perror ( NULL );
	244	exit ( 1 );
	245	}
	246
	247	/* The call to bfd_check_format() must be present, otherwise
	248	* we get a segfault from later BFD calls.
	249	*/
	250	if ( bfd_check_format ( bfd, bfd_object ) < 0 ) {
	251	eprintf ( "%s is not an object file\n", filename );
	252	exit ( 1 );
	253	}
	254
	255	return bfd;
	256	}
	257
	258	/**
	259	* Read symbol table
	260	*
	261	* @v bfd BFD file
	262	*/
	263	static asymbol ** read_symtab ( bfd *bfd ) {
	264	long symtab_size;
	265	asymbol **symtab;
	266	long symcount;
	267
	268	/* Get symbol table size */
	269	symtab_size = bfd_get_symtab_upper_bound ( bfd );
	270	if ( symtab_size < 0 ) {
	271	bfd_perror ( "Could not get symbol table upper bound" );
	272	exit ( 1 );
	273	}
	274
	275	/* Allocate and read symbol table */
	276	symtab = xmalloc ( symtab_size );
	277	symcount = bfd_canonicalize_symtab ( bfd, symtab );
	278	if ( symcount < 0 ) {
	279	bfd_perror ( "Cannot read symbol table" );
	280	exit ( 1 );
	281	}
	282
	283	return symtab;
	284	}
	285
	286	/**
	287	* Read relocation table
	288	*
	289	* @v bfd BFD file
	290	* @v symtab Symbol table
	291	* @v section Section
	292	* @v symtab Symbol table
	293	* @ret reltab Relocation table
	294	*/
	295	static arelent ** read_reltab ( bfd bfd, asymbol *symtab,
	296	asection *section ) {
	297	long reltab_size;
	298	arelent **reltab;
	299	long numrels;
	300
	301	/* Get relocation table size */
	302	reltab_size = bfd_get_reloc_upper_bound ( bfd, section );
	303	if ( reltab_size < 0 ) {
	304	bfd_perror ( "Could not get relocation table upper bound" );
	305	exit ( 1 );
	306	}
	307
	308	/* Allocate and read relocation table */
	309	reltab = xmalloc ( reltab_size );
	310	numrels = bfd_canonicalize_reloc ( bfd, section, reltab, symtab );
	311	if ( numrels < 0 ) {
	312	bfd_perror ( "Cannot read relocation table" );
	313	exit ( 1 );
	314	}
	315
	316	return reltab;
	317	}
	318
	319	/**
	320	* Process section
	321	*
	322	* @v bfd BFD file
	323	* @v pe_header PE file header
	324	* @v section Section
	325	* @ret new New PE section
	326	*/
	327	static struct pe_section * process_section ( bfd *bfd,
	328	struct pe_header *pe_header,
	329	asection *section ) {
	330	struct pe_section *new;
	331	size_t section_memsz;
	332	size_t section_filesz;
	333	unsigned long flags = bfd_get_section_flags ( bfd, section );
	334	unsigned long code_start;
	335	unsigned long code_end;
	336	unsigned long data_start;
	337	unsigned long data_mid;
	338	unsigned long data_end;
	339	unsigned long start;
	340	unsigned long end;
	341	unsigned long *applicable_start;
	342	unsigned long *applicable_end;
	343
	344	/* Extract current RVA limits from file header */
	345	code_start = pe_header->nt.OptionalHeader.BaseOfCode;
	346	code_end = ( code_start + pe_header->nt.OptionalHeader.SizeOfCode );
	347	#if defined(MDE_CPU_IA32)
	348	data_start = pe_header->nt.OptionalHeader.BaseOfData;
	349	#elif defined(MDE_CPU_X64)
	350	data_start = code_end;
	351	#endif
	352	data_mid = ( data_start +
	353	pe_header->nt.OptionalHeader.SizeOfInitializedData );
	354	data_end = ( data_mid +
	355	pe_header->nt.OptionalHeader.SizeOfUninitializedData );
	356
	357	/* Allocate PE section */
	358	section_memsz = bfd_section_size ( bfd, section );
	359	section_filesz = ( ( flags & SEC_LOAD ) ?
	360	efi_file_align ( section_memsz ) : 0 );
	361	new = xmalloc ( sizeof ( *new ) + section_filesz );
	362	memset ( new, 0, sizeof ( *new ) + section_filesz );
	363
	364	/* Fill in section header details */
	365	strncpy ( ( char * ) new->hdr.Name, section->name,
	366	sizeof ( new->hdr.Name ) );
	367	new->hdr.Misc.VirtualSize = section_memsz;
	368	new->hdr.VirtualAddress = bfd_get_section_vma ( bfd, section );
	369	new->hdr.SizeOfRawData = section_filesz;
	370
	371	/* Fill in section characteristics and update RVA limits */
	372	if ( flags & SEC_CODE ) {
	373	/* .text-type section */
	374	new->hdr.Characteristics =
	375	( EFI_IMAGE_SCN_CNT_CODE \|
	376	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	377	EFI_IMAGE_SCN_MEM_EXECUTE \|
	378	EFI_IMAGE_SCN_MEM_READ );
	379	applicable_start = &code_start;
	380	applicable_end = &code_end;
	381	} else if ( flags & SEC_DATA ) {
	382	/* .data-type section */
	383	new->hdr.Characteristics =
	384	( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA \|
	385	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	386	EFI_IMAGE_SCN_MEM_READ \|
	387	EFI_IMAGE_SCN_MEM_WRITE );
	388	applicable_start = &data_start;
	389	applicable_end = &data_mid;
	390	} else if ( flags & SEC_READONLY ) {
	391	/* .rodata-type section */
	392	new->hdr.Characteristics =
	393	( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA \|
	394	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	395	EFI_IMAGE_SCN_MEM_READ );
	396	applicable_start = &data_start;
	397	applicable_end = &data_mid;
	398	} else if ( ! ( flags & SEC_LOAD ) ) {
	399	/* .bss-type section */
	400	new->hdr.Characteristics =
	401	( EFI_IMAGE_SCN_CNT_UNINITIALIZED_DATA \|
	402	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	403	EFI_IMAGE_SCN_MEM_READ \|
	404	EFI_IMAGE_SCN_MEM_WRITE );
	405	applicable_start = &data_mid;
	406	applicable_end = &data_end;
	407	}
	408
	409	/* Copy in section contents */
	410	if ( flags & SEC_LOAD ) {
	411	if ( ! bfd_get_section_contents ( bfd, section, new->contents,
	412	0, section_memsz ) ) {
	413	eprintf ( "Cannot read section %s: ", section->name );
	414	bfd_perror ( NULL );
	415	exit ( 1 );
	416	}
	417	}
	418
	419	/* Update RVA limits */
	420	start = new->hdr.VirtualAddress;
	421	end = ( start + new->hdr.Misc.VirtualSize );
	422	if ( ( ! applicable_start ) \|\| ( applicable_start >= start ) )
	423	*applicable_start = start;
	424	if ( *applicable_end < end )
	425	*applicable_end = end;
	426	if ( data_start < code_end )
	427	data_start = code_end;
	428	if ( data_mid < data_start )
	429	data_mid = data_start;
	430	if ( data_end < data_mid )
	431	data_end = data_mid;
	432
	433	/* Write RVA limits back to file header */
	434	pe_header->nt.OptionalHeader.BaseOfCode = code_start;
	435	pe_header->nt.OptionalHeader.SizeOfCode = ( code_end - code_start );
	436	#if defined(MDE_CPU_IA32)
	437	pe_header->nt.OptionalHeader.BaseOfData = data_start;
	438	#endif
	439	pe_header->nt.OptionalHeader.SizeOfInitializedData =
	440	( data_mid - data_start );
	441	pe_header->nt.OptionalHeader.SizeOfUninitializedData =
	442	( data_end - data_mid );
	443
	444	/* Update remaining file header fields */
	445	pe_header->nt.FileHeader.NumberOfSections++;
	446	pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( new->hdr );
	447	pe_header->nt.OptionalHeader.SizeOfImage =
	448	efi_file_align ( data_end );
	449
	450	return new;
	451	}
	452
	453	/**
	454	* Process relocation record
	455	*
	456	* @v bfd BFD file
	457	* @v section Section
	458	* @v rel Relocation entry
	459	* @v pe_reltab PE relocation table to fill in
	460	*/
	461	static void process_reloc ( bfd bfd, asection section, arelent *rel,
	462	struct pe_relocs **pe_reltab ) {
	463	reloc_howto_type *howto = rel->howto;
	464	asymbol sym = (rel->sym_ptr_ptr);
	465	unsigned long offset = ( bfd_get_section_vma ( bfd, section ) +
	466	rel->address );
	467
	468	if ( bfd_is_abs_section ( sym->section ) ) {
	469	/* Skip absolute symbols; the symbol value won't
	470	* change when the object is loaded.
	471	*/
	472	} else if ( strcmp ( howto->name, "R_X86_64_64" ) == 0 ) {
	473	/* Generate an 8-byte PE relocation */
	474	generate_pe_reloc ( pe_reltab, offset, 8 );
	475	} else if ( ( strcmp ( howto->name, "R_386_32" ) == 0 ) \|\|
	476	( strcmp ( howto->name, "R_X86_64_32" ) == 0 ) ) {
	477	/* Generate a 4-byte PE relocation */
	478	generate_pe_reloc ( pe_reltab, offset, 4 );
	479	} else if ( strcmp ( howto->name, "R_386_16" ) == 0 ) {
	480	/* Generate a 2-byte PE relocation */
	481	generate_pe_reloc ( pe_reltab, offset, 2 );
	482	} else if ( ( strcmp ( howto->name, "R_386_PC32" ) == 0 ) \|\|
	483	( strcmp ( howto->name, "R_X86_64_PC32" ) == 0 ) ) {
	484	/* Skip PC-relative relocations; all relative offsets
	485	* remain unaltered when the object is loaded.
	486	*/
	487	} else {
	488	eprintf ( "Unrecognised relocation type %s\n", howto->name );
	489	exit ( 1 );
	490	}
	491	}
	492
	493	/**
	494	* Create relocations section
	495	*
	496	* @v pe_header PE file header
	497	* @v pe_reltab PE relocation table
	498	* @ret section Relocation section
	499	*/
	500	static struct pe_section *
	501	create_reloc_section ( struct pe_header *pe_header,
	502	struct pe_relocs *pe_reltab ) {
	503	struct pe_section *reloc;
	504	size_t section_memsz;
	505	size_t section_filesz;
	506	EFI_IMAGE_DATA_DIRECTORY *relocdir;
	507
	508	/* Allocate PE section */
	509	section_memsz = output_pe_reltab ( pe_reltab, NULL );
	510	section_filesz = efi_file_align ( section_memsz );
	511	reloc = xmalloc ( sizeof ( *reloc ) + section_filesz );
	512	memset ( reloc, 0, sizeof ( *reloc ) + section_filesz );
	513
	514	/* Fill in section header details */
	515	strncpy ( ( char * ) reloc->hdr.Name, ".reloc",
	516	sizeof ( reloc->hdr.Name ) );
	517	reloc->hdr.Misc.VirtualSize = section_memsz;
	518	reloc->hdr.VirtualAddress = pe_header->nt.OptionalHeader.SizeOfImage;
	519	reloc->hdr.SizeOfRawData = section_filesz;
	520	reloc->hdr.Characteristics = ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA \|
	521	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	522	EFI_IMAGE_SCN_MEM_READ );
	523
	524	/* Copy in section contents */
	525	output_pe_reltab ( pe_reltab, reloc->contents );
	526
	527	/* Update file header details */
	528	pe_header->nt.FileHeader.NumberOfSections++;
	529	pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( reloc->hdr );
	530	pe_header->nt.OptionalHeader.SizeOfImage += section_filesz;
	531	relocdir = &(pe_header->nt.OptionalHeader.DataDirectory
	532	[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]);
	533	relocdir->VirtualAddress = reloc->hdr.VirtualAddress;
	534	relocdir->Size = reloc->hdr.Misc.VirtualSize;
	535
	536	return reloc;
	537	}
	538
	539	/**
	540	* Create debug section
	541	*
	542	* @v pe_header PE file header
	543	* @ret section Debug section
	544	*/
	545	static struct pe_section *
	546	create_debug_section ( struct pe_header pe_header, const char filename ) {
	547	struct pe_section *debug;
	548	size_t section_memsz;
	549	size_t section_filesz;
	550	EFI_IMAGE_DATA_DIRECTORY *debugdir;
	551	struct {
	552	EFI_IMAGE_DEBUG_DIRECTORY_ENTRY debug;
	553	EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY rsds;
	554	char name[ strlen ( filename ) + 1 ];
	555	} *contents;
	556
	557	/* Allocate PE section */
	558	section_memsz = sizeof ( *contents );
	559	section_filesz = efi_file_align ( section_memsz );
	560	debug = xmalloc ( sizeof ( *debug ) + section_filesz );
	561	memset ( debug, 0, sizeof ( *debug ) + section_filesz );
	562	contents = ( void * ) debug->contents;
	563
	564	/* Fill in section header details */
	565	strncpy ( ( char * ) debug->hdr.Name, ".debug",
	566	sizeof ( debug->hdr.Name ) );
	567	debug->hdr.Misc.VirtualSize = section_memsz;
	568	debug->hdr.VirtualAddress = pe_header->nt.OptionalHeader.SizeOfImage;
	569	debug->hdr.SizeOfRawData = section_filesz;
	570	debug->hdr.Characteristics = ( EFI_IMAGE_SCN_CNT_INITIALIZED_DATA \|
	571	EFI_IMAGE_SCN_MEM_NOT_PAGED \|
	572	EFI_IMAGE_SCN_MEM_READ );
	573
	574	/* Create section contents */
	575	contents->debug.TimeDateStamp = 0x10d1a884;
	576	contents->debug.Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
	577	contents->debug.SizeOfData =
	578	( sizeof ( *contents ) - sizeof ( contents->debug ) );
	579	contents->debug.RVA = ( debug->hdr.VirtualAddress +
	580	offsetof ( typeof ( *contents ), rsds ) );
	581	contents->rsds.Signature = CODEVIEW_SIGNATURE_RSDS;
	582	snprintf ( contents->name, sizeof ( contents->name ), "%s",
	583	filename );
	584
	585	/* Update file header details */
	586	pe_header->nt.FileHeader.NumberOfSections++;
	587	pe_header->nt.OptionalHeader.SizeOfHeaders += sizeof ( debug->hdr );
	588	pe_header->nt.OptionalHeader.SizeOfImage += section_filesz;
	589	debugdir = &(pe_header->nt.OptionalHeader.DataDirectory
	590	[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
	591	debugdir->VirtualAddress = debug->hdr.VirtualAddress;
	592	debugdir->Size = debug->hdr.Misc.VirtualSize;
	593
	594	return debug;
	595	}
	596
	597	/**
	598	* Write out PE file
	599	*
	600	* @v pe_header PE file header
	601	* @v pe_sections List of PE sections
	602	* @v pe Output file
	603	*/
	604	static void write_pe_file ( struct pe_header *pe_header,
	605	struct pe_section *pe_sections,
	606	FILE *pe ) {
	607	struct pe_section *section;
	608	unsigned long fpos = 0;
	609
	610	/* Assign raw data pointers */
	611	fpos = efi_file_align ( pe_header->nt.OptionalHeader.SizeOfHeaders );
	612	for ( section = pe_sections ; section ; section = section->next ) {
	613	if ( section->hdr.SizeOfRawData ) {
	614	section->hdr.PointerToRawData = fpos;
	615	fpos += section->hdr.SizeOfRawData;
	616	fpos = efi_file_align ( fpos );
	617	}
	618	}
	619
	620	/* Write file header */
	621	if ( fwrite ( pe_header, sizeof ( *pe_header ), 1, pe ) != 1 ) {
	622	perror ( "Could not write PE header" );
	623	exit ( 1 );
	624	}
	625
	626	/* Write section headers */
	627	for ( section = pe_sections ; section ; section = section->next ) {
	628	if ( fwrite ( &section->hdr, sizeof ( section->hdr ),
	629	1, pe ) != 1 ) {
	630	perror ( "Could not write section header" );
	631	exit ( 1 );
	632	}
	633	}
	634
	635	/* Write sections */
	636	for ( section = pe_sections ; section ; section = section->next ) {
	637	if ( fseek ( pe, section->hdr.PointerToRawData,
	638	SEEK_SET ) != 0 ) {
	639	eprintf ( "Could not seek to %lx: %s\n",
	640	section->hdr.PointerToRawData,
	641	strerror ( errno ) );
	642	exit ( 1 );
	643	}
	644	if ( section->hdr.SizeOfRawData &&
	645	( fwrite ( section->contents, section->hdr.SizeOfRawData,
	646	1, pe ) != 1 ) ) {
	647	eprintf ( "Could not write section %.8s: %s\n",
	648	section->hdr.Name, strerror ( errno ) );
	649	exit ( 1 );
	650	}
	651	}
	652	}
	653
	654	/**
	655	* Convert ELF to PE
	656	*
	657	* @v elf_name ELF file name
	658	* @v pe_name PE file name
	659	*/
	660	static void elf2pe ( const char elf_name, const char pe_name,
	661	struct options *opts ) {
	662	char pe_name_tmp[ strlen ( pe_name ) + 1 ];
	663	bfd *bfd;
	664	asymbol **symtab;
	665	asection *section;
	666	arelent **reltab;
	667	arelent **rel;
	668	struct pe_relocs *pe_reltab = NULL;
	669	struct pe_section *pe_sections = NULL;
	670	struct pe_section **next_pe_section = &pe_sections;
	671	struct pe_header pe_header;
	672	FILE *pe;
	673
	674	/* Create a modifiable copy of the PE name */
	675	memcpy ( pe_name_tmp, pe_name, sizeof ( pe_name_tmp ) );
	676
	677	/* Open the file */
	678	bfd = open_input_bfd ( elf_name );
	679	symtab = read_symtab ( bfd );
	680
	681	/* Initialise the PE header */
	682	memcpy ( &pe_header, &efi_pe_header, sizeof ( pe_header ) );
	683	pe_header.nt.OptionalHeader.AddressOfEntryPoint =
	684	bfd_get_start_address ( bfd );
	685	pe_header.nt.OptionalHeader.Subsystem = opts->subsystem;
	686
	687	/* For each input section, build an output section and create
	688	* the appropriate relocation records
	689	*/
	690	for ( section = bfd->sections ; section ; section = section->next ) {
	691	/* Discard non-allocatable sections */
	692	if ( ! ( bfd_get_section_flags ( bfd, section ) & SEC_ALLOC ) )
	693	continue;
	694	/* Create output section */
	695	*(next_pe_section) = process_section ( bfd, &pe_header,
	696	section );
	697	next_pe_section = &(*next_pe_section)->next;
	698	/* Add relocations from this section */
	699	reltab = read_reltab ( bfd, symtab, section );
	700	for ( rel = reltab ; *rel ; rel++ )
	701	process_reloc ( bfd, section, *rel, &pe_reltab );
	702	free ( reltab );
	703	}
	704
	705	/* Create the .reloc section */
	706	*(next_pe_section) = create_reloc_section ( &pe_header, pe_reltab );
	707	next_pe_section = &(*next_pe_section)->next;
	708
	709	/* Create the .reloc section */
	710	*(next_pe_section) = create_debug_section ( &pe_header,
	711	basename ( pe_name_tmp ) );
	712	next_pe_section = &(*next_pe_section)->next;
	713
	714	/* Write out PE file */
	715	pe = fopen ( pe_name, "w" );
	716	if ( ! pe ) {
	717	eprintf ( "Could not open %s for writing: %s\n",
	718	pe_name, strerror ( errno ) );
	719	exit ( 1 );
	720	}
	721	write_pe_file ( &pe_header, pe_sections, pe );
	722	fclose ( pe );
	723
	724	/* Close BFD file */
	725	bfd_close ( bfd );
	726	}
	727
	728	/**
	729	* Print help
	730	*
	731	* @v program_name Program name
	732	*/
	733	static void print_help ( const char *program_name ) {
	734	eprintf ( "Syntax: %s [--subsystem=<number>] infile outfile\n",
	735	program_name );
	736	}
	737
	738	/**
	739	* Parse command-line options
	740	*
	741	* @v argc Argument count
	742	* @v argv Argument list
	743	* @v opts Options structure to populate
	744	*/
	745	static int parse_options ( const int argc, char **argv,
	746	struct options *opts ) {
	747	char *end;
	748	int c;
	749
	750	while (1) {
	751	int option_index = 0;
	752	static struct option long_options[] = {
	753	{ "subsystem", required_argument, NULL, 's' },
	754	{ "help", 0, NULL, 'h' },
	755	{ 0, 0, 0, 0 }
	756	};
	757
	758	if ( ( c = getopt_long ( argc, argv, "s:h",
	759	long_options,
	760	&option_index ) ) == -1 ) {
	761	break;
	762	}
	763
	764	switch ( c ) {
	765	case 's':
	766	opts->subsystem = strtoul ( optarg, &end, 0 );
	767	if ( *end ) {
	768	eprintf ( "Invalid subsytem \"%s\"\n",
	769	optarg );
	770	exit ( 2 );
	771	}
	772	break;
	773	case 'h':
	774	print_help ( argv[0] );
	775	exit ( 0 );
	776	case '?':
	777	default:
	778	exit ( 2 );
	779	}
	780	}
	781	return optind;
	782	}
	783
	784	int main ( int argc, char **argv ) {
	785	struct options opts = {
	786	.subsystem = EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION,
	787	};
	788	unsigned int infile_index;
	789	const char *infile;
	790	const char *outfile;
	791
	792	/* Initialise libbfd */
	793	bfd_init();
	794
	795	/* Parse command-line arguments */
	796	infile_index = parse_options ( argc, argv, &opts );
	797	if ( argc != ( infile_index + 2 ) ) {
	798	print_help ( argv[0] );
	799	exit ( 2 );
	800	}
	801	infile = argv[infile_index];
	802	outfile = argv[infile_index + 1];
	803
	804	/* Convert file */
	805	elf2pe ( infile, outfile, &opts );
	806
	807	return 0;
	808	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: