Menu
▾
▴
SF.net SVN: edk2-buildtools:[1957] trunk/BaseTools/Source/C/GenFw
|
From: <gee...@us...> - 2010-04-28 21:40:09
|
Revision: 1957
http://edk2-buildtools.svn.sourceforge.net/edk2-buildtools/?rev=1957&view=rev
Author: geekboy15a
Date: 2010-04-28 21:40:01 +0000 (Wed, 28 Apr 2010)
Log Message:
-----------
Moved ELF conversion code out of GenFw into seperate files. Also added support for conversion of ELF64 file format to PE/COFF.
Modified Paths:
--------------
trunk/BaseTools/Source/C/GenFw/GNUmakefile
trunk/BaseTools/Source/C/GenFw/GenFw.c
trunk/BaseTools/Source/C/GenFw/Makefile
Added Paths:
-----------
trunk/BaseTools/Source/C/GenFw/Elf32Convert.c
trunk/BaseTools/Source/C/GenFw/Elf32Convert.h
trunk/BaseTools/Source/C/GenFw/Elf64Convert.c
trunk/BaseTools/Source/C/GenFw/Elf64Convert.h
trunk/BaseTools/Source/C/GenFw/ElfConvert.c
trunk/BaseTools/Source/C/GenFw/ElfConvert.h
trunk/BaseTools/Source/C/GenFw/GenFw.h
Added: trunk/BaseTools/Source/C/GenFw/Elf32Convert.c
===================================================================
--- trunk/BaseTools/Source/C/GenFw/Elf32Convert.c (rev 0)
+++ trunk/BaseTools/Source/C/GenFw/Elf32Convert.c 2010-04-28 21:40:01 UTC (rev 1957)
@@ -0,0 +1,964 @@
+/** @file
+
+Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
+
+This program and the accompanying materials are licensed and made available
+under the terms and conditions of the BSD License which accompanies this
+distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "WinNtInclude.h"
+
+#ifndef __GNUC__
+#include <windows.h>
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include <Common/UefiBaseTypes.h>
+#include <IndustryStandard/PeImage.h>
+
+#include "PeCoffLib.h"
+#include "EfiUtilityMsgs.h"
+
+#include "GenFw.h"
+#include "ElfConvert.h"
+#include "Elf32Convert.h"
+
+STATIC
+VOID
+ScanSections32 (
+ VOID
+ );
+
+STATIC
+BOOLEAN
+WriteSections32 (
+ SECTION_FILTER_TYPES FilterType
+ );
+
+STATIC
+VOID
+WriteRelocations32 (
+ VOID
+ );
+
+STATIC
+VOID
+WriteDebug32 (
+ VOID
+ );
+
+STATIC
+VOID
+SetImageSize32 (
+ VOID
+ );
+
+STATIC
+VOID
+CleanUp32 (
+ VOID
+ );
+
+//
+// Rename ELF32 strucutres to common names to help when porting to ELF64.
+//
+typedef Elf32_Shdr Elf_Shdr;
+typedef Elf32_Ehdr Elf_Ehdr;
+typedef Elf32_Rel Elf_Rel;
+typedef Elf32_Sym Elf_Sym;
+typedef Elf32_Phdr Elf_Phdr;
+typedef Elf32_Dyn Elf_Dyn;
+#define ELFCLASS ELFCLASS32
+#define ELF_R_TYPE(r) ELF32_R_TYPE(r)
+#define ELF_R_SYM(r) ELF32_R_SYM(r)
+
+//
+// Well known ELF structures.
+//
+STATIC Elf_Ehdr *mEhdr;
+STATIC Elf_Shdr *mShdrBase;
+STATIC Elf_Phdr *mPhdrBase;
+
+//
+// Coff information
+//
+STATIC const UINT32 mCoffAlignment = 0x20;
+
+//
+// PE section alignment.
+//
+STATIC const UINT16 mCoffNbrSections = 5;
+
+//
+// ELF sections to offset in Coff file.
+//
+STATIC UINT32 *mCoffSectionsOffset = NULL;
+
+//
+// Offsets in COFF file
+//
+STATIC UINT32 mNtHdrOffset;
+STATIC UINT32 mTextOffset;
+STATIC UINT32 mDataOffset;
+STATIC UINT32 mHiiRsrcOffset;
+STATIC UINT32 mRelocOffset;
+
+//
+// Initialization Function
+//
+BOOLEAN
+InitializeElf32 (
+ UINT8 *FileBuffer,
+ ELF_FUNCTION_TABLE *ElfFunctions
+ )
+{
+ //
+ // Initialize data pointer and structures.
+ //
+ mEhdr = (Elf_Ehdr*) FileBuffer;
+
+ //
+ // Check the ELF32 specific header information.
+ //
+ if (mEhdr->e_ident[EI_CLASS] != ELFCLASS32) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFCLASS32");
+ return FALSE;
+ }
+ if (mEhdr->e_ident[EI_DATA] != ELFDATA2LSB) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");
+ return FALSE;
+ }
+ if ((mEhdr->e_type != ET_EXEC) && (mEhdr->e_type != ET_DYN)) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");
+ return FALSE;
+ }
+ if (!((mEhdr->e_machine == EM_386) || (mEhdr->e_machine == EM_ARM))) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_386 or EM_ARM");
+ return FALSE;
+ }
+ if (mEhdr->e_version != EV_CURRENT) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) mEhdr->e_version, EV_CURRENT);
+ return FALSE;
+ }
+
+ //
+ // Update section header pointers
+ //
+ mShdrBase = (Elf_Shdr *)((UINT8 *)mEhdr + mEhdr->e_shoff);
+ mPhdrBase = (Elf_Phdr *)((UINT8 *)mEhdr + mEhdr->e_phoff);
+
+ //
+ // Create COFF Section offset buffer and zero.
+ //
+ mCoffSectionsOffset = (UINT32 *)malloc(mEhdr->e_shnum * sizeof (UINT32));
+ memset(mCoffSectionsOffset, 0, mEhdr->e_shnum * sizeof(UINT32));
+
+ //
+ // Fill in function pointers.
+ //
+ ElfFunctions->ScanSections = ScanSections32;
+ ElfFunctions->WriteSections = WriteSections32;
+ ElfFunctions->WriteRelocations = WriteRelocations32;
+ ElfFunctions->WriteDebug = WriteDebug32;
+ ElfFunctions->SetImageSize = SetImageSize32;
+ ElfFunctions->CleanUp = CleanUp32;
+
+ return TRUE;
+}
+
+
+//
+// Header by Index functions
+//
+STATIC
+Elf_Shdr*
+GetShdrByIndex (
+ UINT32 Num
+ )
+{
+ if (Num >= mEhdr->e_shnum)
+ return NULL;
+ return (Elf_Shdr*)((UINT8*)mShdrBase + Num * mEhdr->e_shentsize);
+}
+
+STATIC
+Elf_Phdr*
+GetPhdrByIndex (
+ UINT32 num
+ )
+{
+ if (num >= mEhdr->e_phnum) {
+ return NULL;
+ }
+
+ return (Elf_Phdr *)((UINT8*)mPhdrBase + num * mEhdr->e_phentsize);
+}
+
+STATIC
+UINT32
+CoffAlign (
+ UINT32 Offset
+ )
+{
+ return (Offset + mCoffAlignment - 1) & ~(mCoffAlignment - 1);
+}
+
+//
+// filter functions
+//
+STATIC
+BOOLEAN
+IsTextShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC;
+}
+
+STATIC
+BOOLEAN
+IsHiiRsrcShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx);
+
+ return (strcmp((CHAR8*)mEhdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0);
+}
+
+STATIC
+BOOLEAN
+IsDataShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ if (IsHiiRsrcShdr(Shdr)) {
+ return FALSE;
+ }
+ return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);
+}
+
+//
+// Elf functions interface implementation
+//
+
+STATIC
+VOID
+ScanSections32 (
+ VOID
+ )
+{
+ UINT32 i;
+ EFI_IMAGE_DOS_HEADER *DosHdr;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ UINT32 CoffEntry;
+
+ CoffEntry = 0;
+ mCoffOffset = 0;
+
+ //
+ // Coff file start with a DOS header.
+ //
+ mCoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;
+ mNtHdrOffset = mCoffOffset;
+ switch (mEhdr->e_machine) {
+ case EM_386:
+ case EM_ARM:
+ mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);
+ break;
+ default:
+ VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)mEhdr->e_machine);
+ mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);
+ break;
+ }
+
+ mTableOffset = mCoffOffset;
+ mCoffOffset += mCoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);
+
+ //
+ // First text sections.
+ //
+ mCoffOffset = CoffAlign(mCoffOffset);
+ mTextOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsTextShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+
+ /* Relocate entry. */
+ if ((mEhdr->e_entry >= shdr->sh_addr) &&
+ (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
+ CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
+ }
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ }
+ }
+
+ if (mEhdr->e_machine != EM_ARM) {
+ mCoffOffset = CoffAlign(mCoffOffset);
+ }
+
+ //
+ // Then data sections.
+ //
+ mDataOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsDataShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ }
+ }
+ mCoffOffset = CoffAlign(mCoffOffset);
+
+ //
+ // The HII resource sections.
+ //
+ mHiiRsrcOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsHiiRsrcShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+ if (shdr->sh_size != 0) {
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ mCoffOffset = CoffAlign(mCoffOffset);
+ SetHiiResourceHeader ((UINT8*) mEhdr + shdr->sh_offset, mHiiRsrcOffset);
+ }
+ break;
+ }
+ }
+
+ mRelocOffset = mCoffOffset;
+
+ //
+ // Allocate base Coff file. Will be expanded later for relocations.
+ //
+ mCoffFile = (UINT8 *)malloc(mCoffOffset);
+ memset(mCoffFile, 0, mCoffOffset);
+
+ //
+ // Fill headers.
+ //
+ DosHdr = (EFI_IMAGE_DOS_HEADER *)mCoffFile;
+ DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;
+ DosHdr->e_lfanew = mNtHdrOffset;
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(mCoffFile + mNtHdrOffset);
+
+ NtHdr->Pe32.Signature = EFI_IMAGE_NT_SIGNATURE;
+
+ switch (mEhdr->e_machine) {
+ case EM_386:
+ NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;
+ NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
+ break;
+ case EM_ARM:
+ NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_ARMT;
+ NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
+ break;
+ default:
+ VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)mEhdr->e_machine);
+ NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;
+ NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
+ }
+
+ NtHdr->Pe32.FileHeader.NumberOfSections = mCoffNbrSections;
+ NtHdr->Pe32.FileHeader.TimeDateStamp = (UINT32) time(NULL);
+ mImageTimeStamp = NtHdr->Pe32.FileHeader.TimeDateStamp;
+ NtHdr->Pe32.FileHeader.PointerToSymbolTable = 0;
+ NtHdr->Pe32.FileHeader.NumberOfSymbols = 0;
+ NtHdr->Pe32.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32.OptionalHeader);
+ NtHdr->Pe32.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE
+ | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED
+ | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED
+ | EFI_IMAGE_FILE_32BIT_MACHINE;
+
+ NtHdr->Pe32.OptionalHeader.SizeOfCode = mDataOffset - mTextOffset;
+ NtHdr->Pe32.OptionalHeader.SizeOfInitializedData = mRelocOffset - mDataOffset;
+ NtHdr->Pe32.OptionalHeader.SizeOfUninitializedData = 0;
+ NtHdr->Pe32.OptionalHeader.AddressOfEntryPoint = CoffEntry;
+
+ NtHdr->Pe32.OptionalHeader.BaseOfCode = mTextOffset;
+
+ NtHdr->Pe32.OptionalHeader.BaseOfData = mDataOffset;
+ NtHdr->Pe32.OptionalHeader.ImageBase = 0;
+ NtHdr->Pe32.OptionalHeader.SectionAlignment = mCoffAlignment;
+ NtHdr->Pe32.OptionalHeader.FileAlignment = mCoffAlignment;
+ NtHdr->Pe32.OptionalHeader.SizeOfImage = 0;
+
+ NtHdr->Pe32.OptionalHeader.SizeOfHeaders = mTextOffset;
+ NtHdr->Pe32.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
+
+ //
+ // Section headers.
+ //
+ if ((mDataOffset - mTextOffset) > 0) {
+ CreateSectionHeader (".text", mTextOffset, mDataOffset - mTextOffset,
+ EFI_IMAGE_SCN_CNT_CODE
+ | EFI_IMAGE_SCN_MEM_EXECUTE
+ | EFI_IMAGE_SCN_MEM_READ);
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32.FileHeader.NumberOfSections--;
+ }
+
+ if ((mHiiRsrcOffset - mDataOffset) > 0) {
+ CreateSectionHeader (".data", mDataOffset, mHiiRsrcOffset - mDataOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_WRITE
+ | EFI_IMAGE_SCN_MEM_READ);
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32.FileHeader.NumberOfSections--;
+ }
+
+ if ((mRelocOffset - mHiiRsrcOffset) > 0) {
+ CreateSectionHeader (".rsrc", mHiiRsrcOffset, mRelocOffset - mHiiRsrcOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_READ);
+
+ NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = mRelocOffset - mHiiRsrcOffset;
+ NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = mHiiRsrcOffset;
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32.FileHeader.NumberOfSections--;
+ }
+
+}
+
+STATIC
+BOOLEAN
+WriteSections32 (
+ SECTION_FILTER_TYPES FilterType
+ )
+{
+ UINT32 Idx;
+ Elf_Shdr *SecShdr;
+ UINT32 SecOffset;
+ BOOLEAN (*Filter)(Elf_Shdr *);
+
+ //
+ // Initialize filter pointer
+ //
+ switch (FilterType) {
+ case SECTION_TEXT:
+ Filter = IsTextShdr;
+ break;
+ case SECTION_HII:
+ Filter = IsHiiRsrcShdr;
+ break;
+ case SECTION_DATA:
+ Filter = IsDataShdr;
+ break;
+ default:
+ return FALSE;
+ }
+
+ //
+ // First: copy sections.
+ //
+ for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
+ Elf_Shdr *Shdr = GetShdrByIndex(Idx);
+ if ((*Filter)(Shdr)) {
+ switch (Shdr->sh_type) {
+ case SHT_PROGBITS:
+ /* Copy. */
+ memcpy(mCoffFile + mCoffSectionsOffset[Idx],
+ (UINT8*)mEhdr + Shdr->sh_offset,
+ Shdr->sh_size);
+ break;
+
+ case SHT_NOBITS:
+ memset(mCoffFile + mCoffSectionsOffset[Idx], 0, Shdr->sh_size);
+ break;
+
+ default:
+ //
+ // Ignore for unkown section type.
+ //
+ VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);
+ break;
+ }
+ }
+ }
+
+ //
+ // Second: apply relocations.
+ //
+ for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
+ //
+ // Determine if this is a relocation section.
+ //
+ Elf_Shdr *RelShdr = GetShdrByIndex(Idx);
+ if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {
+ continue;
+ }
+
+ //
+ // Relocation section found. Now extract section information that the relocations
+ // apply to in the ELF data and the new COFF data.
+ //
+ SecShdr = GetShdrByIndex(RelShdr->sh_info);
+ SecOffset = mCoffSectionsOffset[RelShdr->sh_info];
+
+ //
+ // Only process relocations for the current filter type.
+ //
+ if (RelShdr->sh_type == SHT_REL && (*Filter)(SecShdr)) {
+ UINT32 RelOffset;
+
+ //
+ // Determine the symbol table referenced by the relocation data.
+ //
+ Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);
+ UINT8 *Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
+
+ //
+ // Process all relocation entries for this section.
+ //
+ for (RelOffset = 0; RelOffset < RelShdr->sh_size; RelOffset += RelShdr->sh_entsize) {
+ //
+ // Set pointer to relocation entry
+ //
+ Elf_Rel *Rel = (Elf_Rel *)((UINT8*)mEhdr + RelShdr->sh_offset + RelOffset);
+
+ //
+ // Set pointer to symbol table entry associated with the relocation entry.
+ //
+ Elf_Sym *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
+
+ Elf_Shdr *SymShdr;
+ UINT8 *Targ;
+ UINT16 Address;
+
+ //
+ // Check section header index found in symbol table and get the section
+ // header location.
+ //
+ if (Sym->st_shndx == SHN_UNDEF
+ || Sym->st_shndx == SHN_ABS
+ || Sym->st_shndx > mEhdr->e_shnum) {
+ Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);
+ }
+ SymShdr = GetShdrByIndex(Sym->st_shndx);
+
+ //
+ // Convert the relocation data to a pointer into the coff file.
+ //
+ // Note:
+ // r_offset is the virtual address of the storage unit to be relocated.
+ // sh_addr is the virtual address for the base of the section.
+ //
+ Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);
+
+ //
+ // Determine how to handle each relocation type based on the machine type.
+ //
+ if (mEhdr->e_machine == EM_386) {
+ switch (ELF_R_TYPE(Rel->r_info)) {
+ case R_386_NONE:
+ break;
+ case R_386_32:
+ //
+ // Absolute relocation.
+ // Converts Targ from a absolute virtual address to the absolute
+ // COFF address.
+ //
+ *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr
+ + mCoffSectionsOffset[Sym->st_shndx];
+ break;
+ case R_386_PC32:
+ //
+ // Relative relocation: Symbol - Ip + Addend
+ //
+ *(UINT32 *)Targ = *(UINT32 *)Targ
+ + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)
+ - (SecOffset - SecShdr->sh_addr);
+ break;
+ default:
+ Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_386 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
+ }
+ } else if (mEhdr->e_machine == EM_ARM) {
+ switch (ELF32_R_TYPE(Rel->r_info)) {
+ case R_ARM_RBASE:
+ // No relocation - no action required
+
+ case R_ARM_PC24:
+ case R_ARM_XPC25:
+ case R_ARM_THM_PC22:
+ case R_ARM_THM_JUMP19:
+ case R_ARM_CALL:
+ case R_ARM_JMP24:
+ // Thease are all PC-relative relocations and don't require modification
+ // GCC does not seem to have the concept of a application that just needs to get relocated.
+ break;
+
+ case R_ARM_THM_MOVW_ABS_NC:
+ // MOVW is only lower 16-bits of the addres
+ Address = (UINT16)(Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
+ ThumbMovtImmediatePatch ((UINT16 *)Targ, Address);
+ break;
+
+ case R_ARM_THM_MOVT_ABS:
+ // MOVT is only upper 16-bits of the addres
+ Address = (UINT16)((Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]) >> 16);
+ ThumbMovtImmediatePatch ((UINT16 *)Targ, Address);
+ break;
+
+ case R_ARM_ABS32:
+ case R_ARM_RABS32:
+ //
+ // Absolute relocation.
+ //
+ *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];
+ break;
+
+ default:
+ Error (NULL, 0, 3000, "Invalid", "WriteSections (): %s unsupported ELF EM_ARM relocation 0x%x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));
+ }
+ }
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+STATIC
+VOID
+WriteRelocations32 (
+ VOID
+ )
+{
+ UINT32 Index;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ EFI_IMAGE_DATA_DIRECTORY *Dir;
+ BOOLEAN FoundRelocations;
+ Elf_Dyn *Dyn;
+ Elf_Rel *Rel;
+ UINTN RelElementSize;
+ UINTN RelSize;
+ UINTN RelOffset;
+ UINTN K;
+ UINT8 *Targ;
+ Elf32_Phdr *DynamicSegment;
+ Elf32_Phdr *TargetSegment;
+ Elf_Sym *Sym;
+ Elf_Shdr *SymtabShdr;
+ UINT8 *Symtab;
+
+
+ for (Index = 0, FoundRelocations = FALSE; Index < mEhdr->e_shnum; Index++) {
+ Elf_Shdr *RelShdr = GetShdrByIndex(Index);
+ if ((RelShdr->sh_type == SHT_REL) || (RelShdr->sh_type == SHT_RELA)) {
+ Elf_Shdr *SecShdr = GetShdrByIndex (RelShdr->sh_info);
+ if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {
+ UINT32 RelIdx;
+
+ SymtabShdr = GetShdrByIndex (RelShdr->sh_link);
+ Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
+ FoundRelocations = TRUE;
+ for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {
+ Elf_Rel *Rel = (Elf_Rel *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
+ Elf_Shdr *SymShdr;
+
+ Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
+ SymShdr = GetShdrByIndex (Sym->st_shndx);
+
+ if (mEhdr->e_machine == EM_386) {
+ switch (ELF_R_TYPE(Rel->r_info)) {
+ case R_386_NONE:
+ case R_386_PC32:
+ //
+ // No fixup entry required.
+ //
+ break;
+ case R_386_32:
+ //
+ // Creates a relative relocation entry from the absolute entry.
+ //
+ CoffAddFixup(mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_HIGHLOW);
+ break;
+ default:
+ Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_386 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
+ }
+ } else if (mEhdr->e_machine == EM_ARM) {
+ switch (ELF32_R_TYPE(Rel->r_info)) {
+ case R_ARM_RBASE:
+ // No relocation - no action required
+ case R_ARM_PC24:
+ case R_ARM_XPC25:
+ case R_ARM_THM_PC22:
+ case R_ARM_THM_JUMP19:
+ case R_ARM_CALL:
+ case R_ARM_JMP24:
+ // Thease are all PC-relative relocations and don't require modification
+ break;
+
+ case R_ARM_THM_MOVW_ABS_NC:
+ CoffAddFixup (
+ mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_ARM_THUMB_MOVW
+ );
+ break;
+
+ case R_ARM_THM_MOVT_ABS:
+ CoffAddFixup (
+ mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_ARM_THUMB_MOVT
+ );
+
+ // The relocation entry needs to contain the lower 16-bits so we can do math
+ CoffAddFixupEntry ((UINT16)(Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]));
+ break;
+
+ case R_ARM_ABS32:
+ case R_ARM_RABS32:
+ CoffAddFixup (
+ mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_HIGHLOW
+ );
+ break;
+
+ default:
+ Error (NULL, 0, 3000, "Invalid", "WriteRelocations(): %s unsupported ELF EM_ARM relocation 0x%x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));
+ }
+ } else {
+ Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) mEhdr->e_machine);
+ }
+ }
+ }
+ }
+ }
+
+ if (!FoundRelocations && (mEhdr->e_machine == EM_ARM)) {
+ /* Try again, but look for PT_DYNAMIC instead of SHT_REL */
+
+ for (Index = 0; Index < mEhdr->e_phnum; Index++) {
+ RelElementSize = 0;
+ RelSize = 0;
+ RelOffset = 0;
+
+ DynamicSegment = GetPhdrByIndex (Index);
+
+ if (DynamicSegment->p_type == PT_DYNAMIC) {
+ Dyn = (Elf32_Dyn *) ((UINT8 *)mEhdr + DynamicSegment->p_offset);
+
+ while (Dyn->d_tag != DT_NULL) {
+ switch (Dyn->d_tag) {
+ case DT_REL:
+ RelOffset = Dyn->d_un.d_val;
+ break;
+
+ case DT_RELSZ:
+ RelSize = Dyn->d_un.d_val;
+ break;
+
+ case DT_RELENT:
+ RelElementSize = Dyn->d_un.d_val;
+ break;
+
+ default:
+ break;
+ }
+ Dyn++;
+ }
+ if (( RelOffset == 0 ) || ( RelSize == 0 ) || ( RelElementSize == 0 )) {
+ Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations.", mInImageName);
+ }
+
+ for (K = 0; K < RelSize; K += RelElementSize) {
+
+ if (DynamicSegment->p_paddr == 0) {
+ // Older versions of the ARM ELF (SWS ESPC 0003 B-02) specification define DT_REL
+ // as an offset in the dynamic segment. p_paddr is defined to be zero for ARM tools
+ Rel = (Elf32_Rel *) ((UINT8 *) mEhdr + DynamicSegment->p_offset + RelOffset + K);
+ } else {
+ // This is how it reads in the generic ELF specification
+ Rel = (Elf32_Rel *) ((UINT8 *) mEhdr + RelOffset + K);
+ }
+
+ switch (ELF32_R_TYPE (Rel->r_info)) {
+ case R_ARM_RBASE:
+ break;
+
+ case R_ARM_RABS32:
+ TargetSegment = GetPhdrByIndex (ELF32_R_SYM (Rel->r_info) - 1);
+
+ // Note: r_offset in a memory address. Convert it to a pointer in the coff file.
+ Targ = mCoffFile + mCoffSectionsOffset[ ELF32_R_SYM( Rel->r_info ) ] + Rel->r_offset - TargetSegment->p_vaddr;
+
+ *(UINT32 *)Targ = *(UINT32 *)Targ + mCoffSectionsOffset [ELF32_R_SYM( Rel->r_info )];
+
+ CoffAddFixup (mCoffSectionsOffset[ELF32_R_SYM (Rel->r_info)] + (Rel->r_offset - TargetSegment->p_vaddr), EFI_IMAGE_REL_BASED_HIGHLOW);
+ break;
+
+ default:
+ Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations, unkown type %d.", mInImageName, ELF32_R_TYPE (Rel->r_info));
+ break;
+ }
+ }
+ break;
+ }
+ }
+ }
+
+ //
+ // Pad by adding empty entries.
+ //
+ while (mCoffOffset & (mCoffAlignment - 1)) {
+ CoffAddFixupEntry(0);
+ }
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ Dir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+ Dir->Size = mCoffOffset - mRelocOffset;
+ if (Dir->Size == 0) {
+ // If no relocations, null out the directory entry and don't add the .reloc section
+ Dir->VirtualAddress = 0;
+ NtHdr->Pe32.FileHeader.NumberOfSections--;
+ } else {
+ Dir->VirtualAddress = mRelocOffset;
+ CreateSectionHeader (".reloc", mRelocOffset, mCoffOffset - mRelocOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_DISCARDABLE
+ | EFI_IMAGE_SCN_MEM_READ);
+ }
+
+}
+
+STATIC
+VOID
+WriteDebug32 (
+ VOID
+ )
+{
+ UINT32 Len;
+ UINT32 DebugOffset;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ EFI_IMAGE_DATA_DIRECTORY *DataDir;
+ EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *Dir;
+ EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;
+
+ Len = strlen(mInImageName) + 1;
+ DebugOffset = mCoffOffset;
+
+ mCoffOffset += sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)
+ + sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)
+ + Len;
+ mCoffOffset = CoffAlign(mCoffOffset);
+
+ mCoffFile = realloc(mCoffFile, mCoffOffset);
+ memset(mCoffFile + DebugOffset, 0, mCoffOffset - DebugOffset);
+
+ Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(mCoffFile + DebugOffset);
+ Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
+ Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;
+ Dir->RVA = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+ Dir->FileOffset = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+
+ Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);
+ Nb10->Signature = CODEVIEW_SIGNATURE_NB10;
+ strcpy ((char *)(Nb10 + 1), mInImageName);
+
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ DataDir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];
+ DataDir->VirtualAddress = DebugOffset;
+ DataDir->Size = mCoffOffset - DebugOffset;
+ if (DataDir->Size == 0) {
+ // If no debug, null out the directory entry and don't add the .debug section
+ DataDir->VirtualAddress = 0;
+ NtHdr->Pe32.FileHeader.NumberOfSections--;
+ } else {
+ DataDir->VirtualAddress = DebugOffset;
+ CreateSectionHeader (".debug", DebugOffset, mCoffOffset - DebugOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_DISCARDABLE
+ | EFI_IMAGE_SCN_MEM_READ);
+
+ }
+}
+
+STATIC
+VOID
+SetImageSize32 (
+ VOID
+ )
+{
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+
+ //
+ // Set image size
+ //
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ NtHdr->Pe32.OptionalHeader.SizeOfImage = mCoffOffset;
+}
+
+STATIC
+VOID
+CleanUp32 (
+ VOID
+ )
+{
+ if (mCoffSectionsOffset != NULL) {
+ free (mCoffSectionsOffset);
+ }
+}
+
+
Added: trunk/BaseTools/Source/C/GenFw/Elf32Convert.h
===================================================================
--- trunk/BaseTools/Source/C/GenFw/Elf32Convert.h (rev 0)
+++ trunk/BaseTools/Source/C/GenFw/Elf32Convert.h 2010-04-28 21:40:01 UTC (rev 1957)
@@ -0,0 +1,24 @@
+/** @file
+
+Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
+
+This program and the accompanying materials are licensed and made available
+under the terms and conditions of the BSD License which accompanies this
+distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _ELF_32_CONVERT_
+#define _ELF_32_CONVERT_
+
+BOOLEAN
+InitializeElf32 (
+ UINT8 *FileBuffer,
+ ELF_FUNCTION_TABLE *ElfFunctions
+ );
+
+#endif
Added: trunk/BaseTools/Source/C/GenFw/Elf64Convert.c
===================================================================
--- trunk/BaseTools/Source/C/GenFw/Elf64Convert.c (rev 0)
+++ trunk/BaseTools/Source/C/GenFw/Elf64Convert.c 2010-04-28 21:40:01 UTC (rev 1957)
@@ -0,0 +1,783 @@
+/** @file
+
+Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
+
+This program and the accompanying materials are licensed and made available
+under the terms and conditions of the BSD License which accompanies this
+distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "WinNtInclude.h"
+
+#ifndef __GNUC__
+#include <windows.h>
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include <Common/UefiBaseTypes.h>
+#include <IndustryStandard/PeImage.h>
+
+#include "PeCoffLib.h"
+#include "EfiUtilityMsgs.h"
+
+#include "GenFw.h"
+#include "ElfConvert.h"
+#include "Elf64Convert.h"
+
+STATIC
+VOID
+ScanSections64 (
+ VOID
+ );
+
+STATIC
+BOOLEAN
+WriteSections64 (
+ SECTION_FILTER_TYPES FilterType
+ );
+
+STATIC
+VOID
+WriteRelocations64 (
+ VOID
+ );
+
+STATIC
+VOID
+WriteDebug64 (
+ VOID
+ );
+
+STATIC
+VOID
+SetImageSize64 (
+ VOID
+ );
+
+STATIC
+VOID
+CleanUp64 (
+ VOID
+ );
+
+//
+// Rename ELF32 strucutres to common names to help when porting to ELF64.
+//
+typedef Elf64_Shdr Elf_Shdr;
+typedef Elf64_Ehdr Elf_Ehdr;
+typedef Elf64_Rel Elf_Rel;
+typedef Elf64_Rela Elf_Rela;
+typedef Elf64_Sym Elf_Sym;
+typedef Elf64_Phdr Elf_Phdr;
+typedef Elf64_Dyn Elf_Dyn;
+#define ELFCLASS ELFCLASS64
+#define ELF_R_TYPE(r) ELF64_R_TYPE(r)
+#define ELF_R_SYM(r) ELF64_R_SYM(r)
+
+//
+// Well known ELF structures.
+//
+STATIC Elf_Ehdr *mEhdr;
+STATIC Elf_Shdr *mShdrBase;
+STATIC Elf_Phdr *mPhdrBase;
+
+//
+// Coff information
+//
+STATIC const UINT32 mCoffAlignment = 0x20;
+
+//
+// PE section alignment.
+//
+STATIC const UINT16 mCoffNbrSections = 5;
+
+//
+// ELF sections to offset in Coff file.
+//
+STATIC UINT32 *mCoffSectionsOffset = NULL;
+
+//
+// Offsets in COFF file
+//
+STATIC UINT32 mNtHdrOffset;
+STATIC UINT32 mTextOffset;
+STATIC UINT32 mDataOffset;
+STATIC UINT32 mHiiRsrcOffset;
+STATIC UINT32 mRelocOffset;
+
+//
+// Initialization Function
+//
+BOOLEAN
+InitializeElf64 (
+ UINT8 *FileBuffer,
+ ELF_FUNCTION_TABLE *ElfFunctions
+ )
+{
+ //
+ // Initialize data pointer and structures.
+ //
+ VerboseMsg ("Set EHDR");
+ mEhdr = (Elf_Ehdr*) FileBuffer;
+
+ //
+ // Check the ELF64 specific header information.
+ //
+ VerboseMsg ("Check ELF64 Header Information");
+ if (mEhdr->e_ident[EI_CLASS] != ELFCLASS64) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFCLASS64");
+ return FALSE;
+ }
+ if (mEhdr->e_ident[EI_DATA] != ELFDATA2LSB) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");
+ return FALSE;
+ }
+ if ((mEhdr->e_type != ET_EXEC) && (mEhdr->e_type != ET_DYN)) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");
+ return FALSE;
+ }
+ if (!((mEhdr->e_machine == EM_X86_64))) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_X86_64");
+ return FALSE;
+ }
+ if (mEhdr->e_version != EV_CURRENT) {
+ Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) mEhdr->e_version, EV_CURRENT);
+ return FALSE;
+ }
+
+ //
+ // Update section header pointers
+ //
+ VerboseMsg ("Update Header Pointers");
+ mShdrBase = (Elf_Shdr *)((UINT8 *)mEhdr + mEhdr->e_shoff);
+ mPhdrBase = (Elf_Phdr *)((UINT8 *)mEhdr + mEhdr->e_phoff);
+
+ //
+ // Create COFF Section offset buffer and zero.
+ //
+ VerboseMsg ("Create COFF Section Offset Buffer");
+ mCoffSectionsOffset = (UINT32 *)malloc(mEhdr->e_shnum * sizeof (UINT32));
+ memset(mCoffSectionsOffset, 0, mEhdr->e_shnum * sizeof(UINT32));
+
+ //
+ // Fill in function pointers.
+ //
+ VerboseMsg ("Fill in Function Pointers");
+ ElfFunctions->ScanSections = ScanSections64;
+ ElfFunctions->WriteSections = WriteSections64;
+ ElfFunctions->WriteRelocations = WriteRelocations64;
+ ElfFunctions->WriteDebug = WriteDebug64;
+ ElfFunctions->SetImageSize = SetImageSize64;
+ ElfFunctions->CleanUp = CleanUp64;
+
+ return TRUE;
+}
+
+
+//
+// Header by Index functions
+//
+STATIC
+Elf_Shdr*
+GetShdrByIndex (
+ UINT32 Num
+ )
+{
+ if (Num >= mEhdr->e_shnum)
+ return NULL;
+ return (Elf_Shdr*)((UINT8*)mShdrBase + Num * mEhdr->e_shentsize);
+}
+
+STATIC
+UINT32
+CoffAlign (
+ UINT32 Offset
+ )
+{
+ return (Offset + mCoffAlignment - 1) & ~(mCoffAlignment - 1);
+}
+
+//
+// filter functions
+//
+STATIC
+BOOLEAN
+IsTextShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC;
+}
+
+STATIC
+BOOLEAN
+IsHiiRsrcShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx);
+
+ return (strcmp((CHAR8*)mEhdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0);
+}
+
+STATIC
+BOOLEAN
+IsDataShdr (
+ Elf_Shdr *Shdr
+ )
+{
+ if (IsHiiRsrcShdr(Shdr)) {
+ return FALSE;
+ }
+ return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);
+}
+
+//
+// Elf functions interface implementation
+//
+
+STATIC
+VOID
+ScanSections64 (
+ VOID
+ )
+{
+ UINT32 i;
+ EFI_IMAGE_DOS_HEADER *DosHdr;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ UINT32 CoffEntry;
+
+ CoffEntry = 0;
+ mCoffOffset = 0;
+
+ //
+ // Coff file start with a DOS header.
+ //
+ mCoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;
+ mNtHdrOffset = mCoffOffset;
+ switch (mEhdr->e_machine) {
+ case EM_X86_64:
+ case EM_IA_64:
+ mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);
+ break;
+ default:
+ VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);
+ mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);
+ break;
+ }
+
+ mTableOffset = mCoffOffset;
+ mCoffOffset += mCoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);
+
+ //
+ // First text sections.
+ //
+ mCoffOffset = CoffAlign(mCoffOffset);
+ mTextOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsTextShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+
+ /* Relocate entry. */
+ if ((mEhdr->e_entry >= shdr->sh_addr) &&
+ (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
+ CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
+ }
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ }
+ }
+
+ if (mEhdr->e_machine != EM_ARM) {
+ mCoffOffset = CoffAlign(mCoffOffset);
+ }
+
+ //
+ // Then data sections.
+ //
+ mDataOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsDataShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ }
+ }
+ mCoffOffset = CoffAlign(mCoffOffset);
+
+ //
+ // The HII resource sections.
+ //
+ mHiiRsrcOffset = mCoffOffset;
+ for (i = 0; i < mEhdr->e_shnum; i++) {
+ Elf_Shdr *shdr = GetShdrByIndex(i);
+ if (IsHiiRsrcShdr(shdr)) {
+ if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
+ // the alignment field is valid
+ if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
+ // if the section address is aligned we must align PE/COFF
+ mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
+ } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
+ // ARM RVCT tools have behavior outside of the ELF specification to try
+ // and make images smaller. If sh_addr is not aligned to sh_addralign
+ // then the section needs to preserve sh_addr MOD sh_addralign.
+ // Normally doing nothing here works great.
+ Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
+ }
+ }
+ if (shdr->sh_size != 0) {
+ mCoffSectionsOffset[i] = mCoffOffset;
+ mCoffOffset += shdr->sh_size;
+ mCoffOffset = CoffAlign(mCoffOffset);
+ SetHiiResourceHeader ((UINT8*) mEhdr + shdr->sh_offset, mHiiRsrcOffset);
+ }
+ break;
+ }
+ }
+
+ mRelocOffset = mCoffOffset;
+
+ //
+ // Allocate base Coff file. Will be expanded later for relocations.
+ //
+ mCoffFile = (UINT8 *)malloc(mCoffOffset);
+ memset(mCoffFile, 0, mCoffOffset);
+
+ //
+ // Fill headers.
+ //
+ DosHdr = (EFI_IMAGE_DOS_HEADER *)mCoffFile;
+ DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;
+ DosHdr->e_lfanew = mNtHdrOffset;
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(mCoffFile + mNtHdrOffset);
+
+ NtHdr->Pe32Plus.Signature = EFI_IMAGE_NT_SIGNATURE;
+
+ switch (mEhdr->e_machine) {
+ case EM_X86_64:
+ NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;
+ NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+ break;
+ case EM_IA_64:
+ NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_IPF;
+ NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+ break;
+ default:
+ VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);
+ NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;
+ NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
+ }
+
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections = mCoffNbrSections;
+ NtHdr->Pe32Plus.FileHeader.TimeDateStamp = (UINT32) time(NULL);
+ mImageTimeStamp = NtHdr->Pe32Plus.FileHeader.TimeDateStamp;
+ NtHdr->Pe32Plus.FileHeader.PointerToSymbolTable = 0;
+ NtHdr->Pe32Plus.FileHeader.NumberOfSymbols = 0;
+ NtHdr->Pe32Plus.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32Plus.OptionalHeader);
+ NtHdr->Pe32Plus.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE
+ | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED
+ | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED
+ | EFI_IMAGE_FILE_LARGE_ADDRESS_AWARE;
+
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfCode = mDataOffset - mTextOffset;
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfInitializedData = mRelocOffset - mDataOffset;
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfUninitializedData = 0;
+ NtHdr->Pe32Plus.OptionalHeader.AddressOfEntryPoint = CoffEntry;
+
+ NtHdr->Pe32Plus.OptionalHeader.BaseOfCode = mTextOffset;
+
+ NtHdr->Pe32Plus.OptionalHeader.ImageBase = 0;
+ NtHdr->Pe32Plus.OptionalHeader.SectionAlignment = mCoffAlignment;
+ NtHdr->Pe32Plus.OptionalHeader.FileAlignment = mCoffAlignment;
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = 0;
+
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfHeaders = mTextOffset;
+ NtHdr->Pe32Plus.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
+
+ //
+ // Section headers.
+ //
+ if ((mDataOffset - mTextOffset) > 0) {
+ CreateSectionHeader (".text", mTextOffset, mDataOffset - mTextOffset,
+ EFI_IMAGE_SCN_CNT_CODE
+ | EFI_IMAGE_SCN_MEM_EXECUTE
+ | EFI_IMAGE_SCN_MEM_READ);
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
+ }
+
+ if ((mHiiRsrcOffset - mDataOffset) > 0) {
+ CreateSectionHeader (".data", mDataOffset, mHiiRsrcOffset - mDataOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_WRITE
+ | EFI_IMAGE_SCN_MEM_READ);
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
+ }
+
+ if ((mRelocOffset - mHiiRsrcOffset) > 0) {
+ CreateSectionHeader (".rsrc", mHiiRsrcOffset, mRelocOffset - mHiiRsrcOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_READ);
+
+ NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = mRelocOffset - mHiiRsrcOffset;
+ NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = mHiiRsrcOffset;
+ } else {
+ // Don't make a section of size 0.
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
+ }
+
+}
+
+STATIC
+BOOLEAN
+WriteSections64 (
+ SECTION_FILTER_TYPES FilterType
+ )
+{
+ UINT32 Idx;
+ Elf_Shdr *SecShdr;
+ UINT32 SecOffset;
+ BOOLEAN (*Filter)(Elf_Shdr *);
+
+ //
+ // Initialize filter pointer
+ //
+ switch (FilterType) {
+ case SECTION_TEXT:
+ Filter = IsTextShdr;
+ break;
+ case SECTION_HII:
+ Filter = IsHiiRsrcShdr;
+ break;
+ case SECTION_DATA:
+ Filter = IsDataShdr;
+ break;
+ default:
+ return FALSE;
+ }
+
+ //
+ // First: copy sections.
+ //
+ for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
+ Elf_Shdr *Shdr = GetShdrByIndex(Idx);
+ if ((*Filter)(Shdr)) {
+ switch (Shdr->sh_type) {
+ case SHT_PROGBITS:
+ /* Copy. */
+ memcpy(mCoffFile + mCoffSectionsOffset[Idx],
+ (UINT8*)mEhdr + Shdr->sh_offset,
+ Shdr->sh_size);
+ break;
+
+ case SHT_NOBITS:
+ memset(mCoffFile + mCoffSectionsOffset[Idx], 0, Shdr->sh_size);
+ break;
+
+ default:
+ //
+ // Ignore for unkown section type.
+ //
+ VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);
+ break;
+ }
+ }
+ }
+
+ //
+ // Second: apply relocations.
+ //
+ VerboseMsg ("Applying Relocations...");
+ for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
+ Elf_Shdr *RelShdr = GetShdrByIndex(Idx);
+ if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {
+ continue;
+ }
+ SecShdr = GetShdrByIndex(RelShdr->sh_info);
+ SecOffset = mCoffSectionsOffset[RelShdr->sh_info];
+ if (RelShdr->sh_type == SHT_RELA && (*Filter)(SecShdr)) {
+ UINT32 RelIdx;
+ Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);
+ UINT8 *Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
+ for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {
+ Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
+ Elf_Sym *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
+ Elf_Shdr *SymShdr;
+ UINT8 *Targ;
+
+ if (Sym->st_shndx == SHN_UNDEF
+ || Sym->st_shndx == SHN_ABS
+ || Sym->st_shndx > mEhdr->e_shnum) {
+ Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);
+ }
+ SymShdr = GetShdrByIndex(Sym->st_shndx);
+
+ //
+ // Note: r_offset in a memory address.
+ // Convert it to a pointer in the coff file.
+ //
+ Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);
+
+ if (mEhdr->e_machine == EM_X86_64) {
+ switch (ELF_R_TYPE(Rel->r_info)) {
+ case R_X86_64_NONE:
+ break;
+ case R_X86_64_64:
+ //
+ // Absolute relocation.
+ //
+ VerboseMsg ("R_X86_64_64");
+ VerboseMsg ("Offset: 0x%08X, Addend: 0x%016LX",
+ (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
+ *(UINT64 *)Targ);
+ *(UINT64 *)Targ = *(UINT64 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];
+ VerboseMsg ("Relocation: 0x%016LX", *(UINT64*)Targ);
+ break;
+ case R_X86_64_32:
+ VerboseMsg ("R_X86_64_32");
+ VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
+ (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
+ *(UINT32 *)Targ);
+ *(UINT32 *)Targ = (UINT32)((UINT64)(*(UINT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
+ VerboseMsg ("Relocation: 0x%08X", *(UINT32*)Targ);
+ break;
+ case R_X86_64_32S:
+ VerboseMsg ("R_X86_64_32S");
+ VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
+ (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
+ *(UINT32 *)Targ);
+ *(INT32 *)Targ = (INT32)((INT64)(*(INT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
+ VerboseMsg ("Relocation: 0x%08X", *(UINT32*)Targ);
+ break;
+ case R_X86_64_PC32:
+ //
+ // Relative relocation: Symbol - Ip + Addend
+ //
+ VerboseMsg ("R_X86_64_PC32");
+ VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
+ (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
+ *(UINT32 *)Targ);
+ *(UINT32 *)Targ = *(UINT32 *)Targ
+ + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)
+ - (SecOffset - SecShdr->sh_addr);
+ VerboseMsg ("Relocation: 0x%08X", *(UINT32 *)Targ);
+ break;
+ default:
+ Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
+ }
+ } else {
+ Error (NULL, 0, 3000, "Invalid", "Not EM_X86_X64");
+ }
+ }
+ }
+ }
+
+ return TRUE;
+}
+
+STATIC
+VOID
+WriteRelocations64 (
+ VOID
+ )
+{
+ UINT32 Index;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ EFI_IMAGE_DATA_DIRECTORY *Dir;
+ BOOLEAN FoundRelocations;
+ Elf_Sym *Sym;
+ Elf_Shdr *SymtabShdr;
+ UINT8 *Symtab;
+
+
+ for (Index = 0, FoundRelocations = FALSE; Index < mEhdr->e_shnum; Index++) {
+ Elf_Shdr *RelShdr = GetShdrByIndex(Index);
+ if ((RelShdr->sh_type == SHT_REL) || (RelShdr->sh_type == SHT_RELA)) {
+ Elf_Shdr *SecShdr = GetShdrByIndex (RelShdr->sh_info);
+ if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {
+ UINT32 RelIdx;
+
+ SymtabShdr = GetShdrByIndex (RelShdr->sh_link);
+ Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
+ FoundRelocations = TRUE;
+ for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {
+ Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
+ Elf_Shdr *SymShdr;
+
+ Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
+ SymShdr = GetShdrByIndex (Sym->st_shndx);
+
+ if (mEhdr->e_machine == EM_X86_64) {
+ switch (ELF_R_TYPE(Rel->r_info)) {
+ case R_X86_64_NONE:
+ case R_X86_64_PC32:
+ break;
+ case R_X86_64_64:
+ VerboseMsg ("EFI_IMAGE_REL_BASED_DIR64 Offset: 0x%08X",
+ mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));
+ CoffAddFixup(mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_DIR64);
+ break;
+ case R_X86_64_32S:
+ case R_X86_64_32:
+ VerboseMsg ("EFI_IMAGE_REL_BASED_HIGHLOW Offset: 0x%08X",
+ mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));
+ CoffAddFixup(mCoffSectionsOffset[RelShdr->sh_info]
+ + (Rel->r_offset - SecShdr->sh_addr),
+ EFI_IMAGE_REL_BASED_HIGHLOW);
+ break;
+ default:
+ Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
+ }
+ } else {
+ Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) mEhdr->e_machine);
+ }
+ }
+ }
+ }
+ }
+
+ //
+ // Pad by adding empty entries.
+ //
+ while (mCoffOffset & (mCoffAlignment - 1)) {
+ CoffAddFixupEntry(0);
+ }
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ Dir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
+ Dir->Size = mCoffOffset - mRelocOffset;
+ if (Dir->Size == 0) {
+ // If no relocations, null out the directory entry and don't add the .reloc section
+ Dir->VirtualAddress = 0;
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
+ } else {
+ Dir->VirtualAddress = mRelocOffset;
+ CreateSectionHeader (".reloc", mRelocOffset, mCoffOffset - mRelocOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_DISCARDABLE
+ | EFI_IMAGE_SCN_MEM_READ);
+ }
+}
+
+STATIC
+VOID
+WriteDebug64 (
+ VOID
+ )
+{
+ UINT32 Len;
+ UINT32 DebugOffset;
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+ EFI_IMAGE_DATA_DIRECTORY *DataDir;
+ EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *Dir;
+ EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;
+
+ Len = strlen(mInImageName) + 1;
+ DebugOffset = mCoffOffset;
+
+ mCoffOffset += sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)
+ + sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)
+ + Len;
+ mCoffOffset = CoffAlign(mCoffOffset);
+
+ mCoffFile = realloc(mCoffFile, mCoffOffset);
+ memset(mCoffFile + DebugOffset, 0, mCoffOffset - DebugOffset);
+
+ Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(mCoffFile + DebugOffset);
+ Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
+ Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;
+ Dir->RVA = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+ Dir->FileOffset = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
+
+ Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);
+ Nb10->Signature = CODEVIEW_SIGNATURE_NB10;
+ strcpy ((char *)(Nb10 + 1), mInImageName);
+
+
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ DataDir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];
+ DataDir->VirtualAddress = DebugOffset;
+ DataDir->Size = mCoffOffset - DebugOffset;
+ if (DataDir->Size == 0) {
+ // If no debug, null out the directory entry and don't add the .debug section
+ DataDir->VirtualAddress = 0;
+ NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
+ } else {
+ DataDir->VirtualAddress = DebugOffset;
+ CreateSectionHeader (".debug", DebugOffset, mCoffOffset - DebugOffset,
+ EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
+ | EFI_IMAGE_SCN_MEM_DISCARDABLE
+ | EFI_IMAGE_SCN_MEM_READ);
+
+ }
+}
+
+STATIC
+VOID
+SetImageSize64 (
+ VOID
+ )
+{
+ EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
+
+ //
+ // Set image size
+ //
+ NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
+ NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = mCoffOffset;
+}
+
+STATIC
+VOID
+CleanUp64 (
+ VOID
+ )
+{
+ if (mCoffSectionsOffset != NULL) {
+ free (mCoffSectionsOffset);
+ }
+}
+
+
Added: trunk/BaseTools/Source/C/GenFw/Elf64Convert.h
===================================================================
--- trunk/BaseTools/Source/C/GenFw/Elf64Convert.h (rev 0)
+++ trunk/BaseTools/Source/C/GenFw/Elf64Convert.h 2010-04-28 21:40:01 UTC (rev 1957)
@@ -0,0 +1,24 @@
+/** @file
+
+Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
+
+This program and the accompanying materials are licensed and made available
+under the terms and conditions of the BSD License which accompanies this
+distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#ifndef _ELF_64_CONVERT_
+#define _ELF_64_CONVERT_
+
+BOOLEAN
+InitializeElf64 (
+ UINT8 *FileBuffer,
+ ELF_FUNCTION_TABLE *ElfFunctions
+ );
+
+#endif
Added: trunk/BaseTools/Source/C/GenFw/ElfConvert.c
===================================================================
--- trunk/BaseTools/Source/C/GenFw/ElfConvert.c (rev 0)
+++ trunk/BaseTools/Source/C/GenFw/ElfConvert.c 2010-04-28 21:40:01 UTC (rev 1957)
@@ -0,0 +1,233 @@
+/** @file
+
+Copyright (c) 2010, Intel Corporation. All rights reserved. <BR>
+
+This program and the accompanying materials are licensed and made available
+under the terms and conditions of the BSD License which accompanies this
+distribution. The full text of the license may be found at
+http://opensource.org/licenses/bsd-license.php
+
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+
+#include "WinNtInclude.h"
+
+#ifndef __GNUC__
+#include <windows.h>
+#include <io.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include <Common/UefiBaseTypes.h>
+#include <IndustryStandard/PeImage.h>
+
+#include "EfiUtilityMsgs.h"
+
+#include "GenFw.h"
+#include "ElfConvert.h"
+#include "Elf32Convert.h"
+#include "Elf64Convert.h"
+
+//
+// Result Coff file in memory.
+//
+UINT8 *mCoffFile = NULL;
+
+//
+// COFF relocation data
+//
+EFI_IMAGE_BASE_RELOCATION *mCoffBaseRel;
+UINT16 *mCoffEntryRel;
+
+//
+// Current offset in coff file.
+//
+UINT32 mCoffOffset;
+
+//
+// Offset in Coff file of headers and sections.
+//
+UINT32 mTableOffset;
+
+//
+//*****************************************************************************
+// Common ELF Functions
+//*****************************************************************************
+//
+
+VOID
+CoffAddFixupEntry(
+ UINT16 Val
+ )
+{
+ *mCoffEntryRel = Val;
+ mCoffEntryRel++;
+ mCoffBaseRel->SizeOfBlock += 2;
+ mCoffOffset += 2;
+}
+
+VOID
+CoffAddFixup(
+ UINT32 Offset,
+ UINT8 Type
+ )
+{
+ if (mCoffBaseRel == NULL
+ || mCoffBaseRel->VirtualAddress != (Offset & ~0xfff)) {
+ if (mCoffBaseRel != NULL) {
+ //
+ // Add a null entry (is it required ?)
+ //
+ CoffAddFixupEntry (0);
+
+ //
+ // Pad for alignment.
+ //
+ if (mCoffOffset % 4 != 0)
+ CoffAddFixupEntry (0);
+ }
+
+ mCoffFile = realloc (
+ mCoffFile,
+ mCoffOffset + sizeof(EFI_IMAGE_BASE_RELOCATION) + 2*0x1000
+ );
+ memset (
+ mCoffFile + mCoffOffset, 0,
+ sizeof(EFI_IMAGE_BASE_RELOCATION) + 2*0x1000
+ );
+
+ mCoffBaseRel = (EFI_IMAGE_BASE_RELOCATION*)(mCoffFile + mCoffOffset);
+ mCoffBaseRel->VirtualAddress = Offset & ~0xfff;
+ mCoffBa...
[truncated message content] |
