| /** @file |
| |
| Copyright (c) 2010 - 2011, 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 (BOOLEAN) ((Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC); |
| } |
| |
| STATIC |
| BOOLEAN |
| IsHiiRsrcShdr ( |
| Elf_Shdr *Shdr |
| ) |
| { |
| Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx); |
| |
| return (BOOLEAN) (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 (BOOLEAN) (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; |
| UINT32 SectionCount; |
| |
| 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; |
| SectionCount = 0; |
| 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; |
| SectionCount ++; |
| } |
| } |
| |
| if (mEhdr->e_machine != EM_ARM) { |
| mCoffOffset = CoffAlign(mCoffOffset); |
| } |
| |
| if (SectionCount > 1 && mOutImageType == FW_EFI_IMAGE) { |
| Warning (NULL, 0, 0, NULL, "Mulitple sections in %s are merged into 1 text section. Source level debug might not work correctly.", mInImageName); |
| } |
| |
| // |
| // Then data sections. |
| // |
| mDataOffset = mCoffOffset; |
| SectionCount = 0; |
| 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; |
| SectionCount ++; |
| } |
| } |
| mCoffOffset = CoffAlign(mCoffOffset); |
| |
| if (SectionCount > 1 && mOutImageType == FW_EFI_IMAGE) { |
| Warning (NULL, 0, 0, NULL, "Mulitple sections in %s are merged into 1 data section. Source level debug might not work correctly.", mInImageName); |
| } |
| |
| // |
| // 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 |
| // break skipped |
| |
| 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: |
| case R_ARM_THM_JUMP24: |
| case R_ARM_PREL31: |
| case R_ARM_MOVW_PREL_NC: |
| case R_ARM_MOVT_PREL: |
| case R_ARM_THM_MOVW_PREL_NC: |
| case R_ARM_THM_MOVT_PREL: |
| case R_ARM_THM_JMP6: |
| case R_ARM_THM_ALU_PREL_11_0: |
| case R_ARM_THM_PC12: |
| case R_ARM_REL32_NOI: |
| case R_ARM_ALU_PC_G0_NC: |
| case R_ARM_ALU_PC_G0: |
| case R_ARM_ALU_PC_G1_NC: |
| case R_ARM_ALU_PC_G1: |
| case R_ARM_ALU_PC_G2: |
| case R_ARM_LDR_PC_G1: |
| case R_ARM_LDR_PC_G2: |
| case R_ARM_LDRS_PC_G0: |
| case R_ARM_LDRS_PC_G1: |
| case R_ARM_LDRS_PC_G2: |
| case R_ARM_LDC_PC_G0: |
| case R_ARM_LDC_PC_G1: |
| case R_ARM_LDC_PC_G2: |
| case R_ARM_GOT_PREL: |
| case R_ARM_THM_JUMP11: |
| case R_ARM_THM_JUMP8: |
| case R_ARM_TLS_GD32: |
| case R_ARM_TLS_LDM32: |
| case R_ARM_TLS_IE32: |
| // 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; |
| } |
| |
| UINTN gMovwOffset = 0; |
| |
| 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; |
| |
| 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; |
| |
| FoundRelocations = TRUE; |
| for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) { |
| Elf_Rel *Rel = (Elf_Rel *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx); |
| |
| 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 |
| // break skipped |
| |
| 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: |
| case R_ARM_THM_JUMP24: |
| case R_ARM_PREL31: |
| case R_ARM_MOVW_PREL_NC: |
| case R_ARM_MOVT_PREL: |
| case R_ARM_THM_MOVW_PREL_NC: |
| case R_ARM_THM_MOVT_PREL: |
| case R_ARM_THM_JMP6: |
| case R_ARM_THM_ALU_PREL_11_0: |
| case R_ARM_THM_PC12: |
| case R_ARM_REL32_NOI: |
| case R_ARM_ALU_PC_G0_NC: |
| case R_ARM_ALU_PC_G0: |
| case R_ARM_ALU_PC_G1_NC: |
| case R_ARM_ALU_PC_G1: |
| case R_ARM_ALU_PC_G2: |
| case R_ARM_LDR_PC_G1: |
| case R_ARM_LDR_PC_G2: |
| case R_ARM_LDRS_PC_G0: |
| case R_ARM_LDRS_PC_G1: |
| case R_ARM_LDRS_PC_G2: |
| case R_ARM_LDC_PC_G0: |
| case R_ARM_LDC_PC_G1: |
| case R_ARM_LDC_PC_G2: |
| case R_ARM_GOT_PREL: |
| case R_ARM_THM_JUMP11: |
| case R_ARM_THM_JUMP8: |
| case R_ARM_TLS_GD32: |
| case R_ARM_TLS_LDM32: |
| case R_ARM_TLS_IE32: |
| // 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_MOV32T |
| ); |
| |
| // PE/COFF treats MOVW/MOVT relocation as single 64-bit instruction |
| // Track this address so we can log an error for unsupported sequence of MOVW/MOVT |
| gMovwOffset = mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr); |
| break; |
| |
| case R_ARM_THM_MOVT_ABS: |
| if ((gMovwOffset + 4) != (mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr))) { |
| Error (NULL, 0, 3000, "Not Supported", "PE/COFF requires MOVW+MOVT instruction sequence %x +4 != %x.", gMovwOffset, mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr)); |
| } |
| 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); |
| } |
| } |
| |
| |