[mirror_edk2.git] / BaseTools / Source / C / GenFw / Elf64Convert.c

/** @file\r
Elf64 convert solution\r
\r
Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>\r
Portions copyright (c) 2013-2014, ARM Ltd. All rights reserved.<BR>\r
\r
This program and the accompanying materials are licensed and made available\r
under the terms and conditions of the BSD License which accompanies this\r
distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "WinNtInclude.h"\r
\r
#ifndef __GNUC__\r
#include <windows.h>\r
#include <io.h>\r
#endif\r
#include <assert.h>\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <time.h>\r
#include <ctype.h>\r
\r
#include <Common/UefiBaseTypes.h>\r
#include <IndustryStandard/PeImage.h>\r
\r
#include "PeCoffLib.h"\r
#include "EfiUtilityMsgs.h"\r
\r
#include "GenFw.h"\r
#include "ElfConvert.h"\r
#include "Elf64Convert.h"\r
\r
STATIC\r
VOID\r
ScanSections64 (\r
  VOID\r
  );\r
\r
STATIC\r
BOOLEAN\r
WriteSections64 (\r
  SECTION_FILTER_TYPES  FilterType\r
  );\r
\r
STATIC\r
VOID\r
WriteRelocations64 (\r
  VOID\r
  );\r
\r
STATIC\r
VOID\r
WriteDebug64 (\r
  VOID\r
  );\r
\r
STATIC\r
VOID\r
SetImageSize64 (\r
  VOID\r
  );\r
\r
STATIC\r
VOID\r
CleanUp64 (\r
  VOID\r
  );\r
\r
//\r
// Rename ELF32 strucutres to common names to help when porting to ELF64.\r
//\r
typedef Elf64_Shdr Elf_Shdr;\r
typedef Elf64_Ehdr Elf_Ehdr;\r
typedef Elf64_Rel Elf_Rel;\r
typedef Elf64_Rela Elf_Rela;\r
typedef Elf64_Sym Elf_Sym;\r
typedef Elf64_Phdr Elf_Phdr;\r
typedef Elf64_Dyn Elf_Dyn;\r
#define ELFCLASS ELFCLASS64\r
#define ELF_R_TYPE(r) ELF64_R_TYPE(r)\r
#define ELF_R_SYM(r) ELF64_R_SYM(r)\r
\r
//\r
// Well known ELF structures.\r
//\r
STATIC Elf_Ehdr *mEhdr;\r
STATIC Elf_Shdr *mShdrBase;\r
STATIC Elf_Phdr *mPhdrBase;\r
\r
//\r
// Coff information\r
//\r
STATIC UINT32 mCoffAlignment = 0x20;\r
\r
//\r
// PE section alignment.\r
//\r
STATIC const UINT16 mCoffNbrSections = 4;\r
\r
//\r
// ELF sections to offset in Coff file.\r
//\r
STATIC UINT32 *mCoffSectionsOffset = NULL;\r
\r
//\r
// Offsets in COFF file\r
//\r
STATIC UINT32 mNtHdrOffset;\r
STATIC UINT32 mTextOffset;\r
STATIC UINT32 mDataOffset;\r
STATIC UINT32 mHiiRsrcOffset;\r
STATIC UINT32 mRelocOffset;\r
STATIC UINT32 mDebugOffset;\r
\r
//\r
// Initialization Function\r
//\r
BOOLEAN\r
InitializeElf64 (\r
  UINT8               *FileBuffer,\r
  ELF_FUNCTION_TABLE  *ElfFunctions\r
  )\r
{\r
  //\r
  // Initialize data pointer and structures.\r
  //\r
  VerboseMsg ("Set EHDR");\r
  mEhdr = (Elf_Ehdr*) FileBuffer;\r
\r
  //\r
  // Check the ELF64 specific header information.\r
  //\r
  VerboseMsg ("Check ELF64 Header Information");\r
  if (mEhdr->e_ident[EI_CLASS] != ELFCLASS64) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFCLASS64");\r
    return FALSE;\r
  }\r
  if (mEhdr->e_ident[EI_DATA] != ELFDATA2LSB) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");\r
    return FALSE;\r
  }\r
  if ((mEhdr->e_type != ET_EXEC) && (mEhdr->e_type != ET_DYN)) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");\r
    return FALSE;\r
  }\r
  if (!((mEhdr->e_machine == EM_X86_64) || (mEhdr->e_machine == EM_AARCH64))) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_X86_64 or EM_AARCH64");\r
    return FALSE;\r
  }\r
  if (mEhdr->e_version != EV_CURRENT) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) mEhdr->e_version, EV_CURRENT);\r
    return FALSE;\r
  }\r
\r
  //\r
  // Update section header pointers\r
  //\r
  VerboseMsg ("Update Header Pointers");\r
  mShdrBase  = (Elf_Shdr *)((UINT8 *)mEhdr + mEhdr->e_shoff);\r
  mPhdrBase = (Elf_Phdr *)((UINT8 *)mEhdr + mEhdr->e_phoff);\r
\r
  //\r
  // Create COFF Section offset buffer and zero.\r
  //\r
  VerboseMsg ("Create COFF Section Offset Buffer");\r
  mCoffSectionsOffset = (UINT32 *)malloc(mEhdr->e_shnum * sizeof (UINT32));\r
  memset(mCoffSectionsOffset, 0, mEhdr->e_shnum * sizeof(UINT32));\r
\r
  //\r
  // Fill in function pointers.\r
  //\r
  VerboseMsg ("Fill in Function Pointers");\r
  ElfFunctions->ScanSections = ScanSections64;\r
  ElfFunctions->WriteSections = WriteSections64;\r
  ElfFunctions->WriteRelocations = WriteRelocations64;\r
  ElfFunctions->WriteDebug = WriteDebug64;\r
  ElfFunctions->SetImageSize = SetImageSize64;\r
  ElfFunctions->CleanUp = CleanUp64;\r
\r
  return TRUE;\r
}\r
\r
\r
//\r
// Header by Index functions\r
//\r
STATIC\r
Elf_Shdr*\r
GetShdrByIndex (\r
  UINT32 Num\r
  )\r
{\r
  if (Num >= mEhdr->e_shnum)\r
    return NULL;\r
  return (Elf_Shdr*)((UINT8*)mShdrBase + Num * mEhdr->e_shentsize);\r
}\r
\r
STATIC\r
UINT32\r
CoffAlign (\r
  UINT32 Offset\r
  )\r
{\r
  return (Offset + mCoffAlignment - 1) & ~(mCoffAlignment - 1);\r
}\r
\r
//\r
// filter functions\r
//\r
STATIC\r
BOOLEAN\r
IsTextShdr (\r
  Elf_Shdr *Shdr\r
  )\r
{\r
  return (BOOLEAN) ((Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC);\r
}\r
\r
STATIC\r
BOOLEAN\r
IsHiiRsrcShdr (\r
  Elf_Shdr *Shdr\r
  )\r
{\r
  Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx);\r
\r
  return (BOOLEAN) (strcmp((CHAR8*)mEhdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0);\r
}\r
\r
STATIC\r
BOOLEAN\r
IsDataShdr (\r
  Elf_Shdr *Shdr\r
  )\r
{\r
  if (IsHiiRsrcShdr(Shdr)) {\r
    return FALSE;\r
  }\r
  return (BOOLEAN) (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);\r
}\r
\r
//\r
// Elf functions interface implementation\r
//\r
\r
STATIC\r
VOID\r
ScanSections64 (\r
  VOID\r
  )\r
{\r
  UINT32                          i;\r
  EFI_IMAGE_DOS_HEADER            *DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;\r
  UINT32                          CoffEntry;\r
  UINT32                          SectionCount;\r
  BOOLEAN                         FoundSection;\r
\r
  CoffEntry = 0;\r
  mCoffOffset = 0;\r
\r
  //\r
  // Coff file start with a DOS header.\r
  //\r
  mCoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;\r
  mNtHdrOffset = mCoffOffset;\r
  switch (mEhdr->e_machine) {\r
  case EM_X86_64:\r
  case EM_IA_64:\r
  case EM_AARCH64:\r
    mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);\r
  break;\r
  default:\r
    VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);\r
    mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);\r
  break;\r
  }\r
\r
  mTableOffset = mCoffOffset;\r
  mCoffOffset += mCoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);\r
\r
  //\r
  // Set mCoffAlignment to the maximum alignment of the input sections\r
  // we care about\r
  //\r
  for (i = 0; i < mEhdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (shdr->sh_addralign <= mCoffAlignment) {\r
      continue;\r
    }\r
    if (IsTextShdr(shdr) || IsDataShdr(shdr) || IsHiiRsrcShdr(shdr)) {\r
      mCoffAlignment = (UINT32)shdr->sh_addralign;\r
    }\r
  }\r
\r
  //\r
  // First text sections.\r
  //\r
  mCoffOffset = CoffAlign(mCoffOffset);\r
  mTextOffset = mCoffOffset;\r
  FoundSection = FALSE;\r
  SectionCount = 0;\r
  for (i = 0; i < mEhdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (IsTextShdr(shdr)) {\r
      if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {\r
        // the alignment field is valid\r
        if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {\r
          // if the section address is aligned we must align PE/COFF\r
          mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));\r
        } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {\r
          // ARM RVCT tools have behavior outside of the ELF specification to try\r
          // and make images smaller.  If sh_addr is not aligned to sh_addralign\r
          // then the section needs to preserve sh_addr MOD sh_addralign.\r
          // Normally doing nothing here works great.\r
          Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");\r
        }\r
      }\r
\r
      /* Relocate entry.  */\r
      if ((mEhdr->e_entry >= shdr->sh_addr) &&\r
          (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {\r
        CoffEntry = (UINT32) (mCoffOffset + mEhdr->e_entry - shdr->sh_addr);\r
      }\r
\r
      //\r
      // Set mTextOffset with the offset of the first '.text' section\r
      //\r
      if (!FoundSection) {\r
        mTextOffset = mCoffOffset;\r
        FoundSection = TRUE;\r
      }\r
\r
      mCoffSectionsOffset[i] = mCoffOffset;\r
      mCoffOffset += (UINT32) shdr->sh_size;\r
      SectionCount ++;\r
    }\r
  }\r
\r
  if (!FoundSection) {\r
    Error (NULL, 0, 3000, "Invalid", "Did not find any '.text' section.");\r
    assert (FALSE);\r
  }\r
\r
  mDebugOffset = mCoffOffset;\r
\r
  if (mEhdr->e_machine != EM_ARM) {\r
    mCoffOffset = CoffAlign(mCoffOffset);\r
  }\r
\r
  if (SectionCount > 1 && mOutImageType == FW_EFI_IMAGE) {\r
    Warning (NULL, 0, 0, NULL, "Mulitple sections in %s are merged into 1 text section. Source level debug might not work correctly.", mInImageName);\r
  }\r
\r
  //\r
  //  Then data sections.\r
  //\r
  mDataOffset = mCoffOffset;\r
  FoundSection = FALSE;\r
  SectionCount = 0;\r
  for (i = 0; i < mEhdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (IsDataShdr(shdr)) {\r
      if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {\r
        // the alignment field is valid\r
        if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {\r
          // if the section address is aligned we must align PE/COFF\r
          mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));\r
        } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {\r
          // ARM RVCT tools have behavior outside of the ELF specification to try\r
          // and make images smaller.  If sh_addr is not aligned to sh_addralign\r
          // then the section needs to preserve sh_addr MOD sh_addralign.\r
          // Normally doing nothing here works great.\r
          Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");\r
        }\r
      }\r
\r
      //\r
      // Set mDataOffset with the offset of the first '.data' section\r
      //\r
      if (!FoundSection) {\r
        mDataOffset = mCoffOffset;\r
        FoundSection = TRUE;\r
      }\r
      mCoffSectionsOffset[i] = mCoffOffset;\r
      mCoffOffset += (UINT32) shdr->sh_size;\r
      SectionCount ++;\r
    }\r
  }\r
\r
  //\r
  // Make room for .debug data in .data (or .text if .data is empty) instead of\r
  // putting it in a section of its own. This is explicitly allowed by the\r
  // PE/COFF spec, and prevents bloat in the binary when using large values for\r
  // section alignment.\r
  //\r
  if (SectionCount > 0) {\r
    mDebugOffset = mCoffOffset;\r
  }\r
  mCoffOffset = mDebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY) +\r
                sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) +\r
                strlen(mInImageName) + 1;\r
\r
  mCoffOffset = CoffAlign(mCoffOffset);\r
  if (SectionCount == 0) {\r
    mDataOffset = mCoffOffset;\r
  }\r
\r
  if (SectionCount > 1 && mOutImageType == FW_EFI_IMAGE) {\r
    Warning (NULL, 0, 0, NULL, "Mulitple sections in %s are merged into 1 data section. Source level debug might not work correctly.", mInImageName);\r
  }\r
\r
  //\r
  //  The HII resource sections.\r
  //\r
  mHiiRsrcOffset = mCoffOffset;\r
  for (i = 0; i < mEhdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (IsHiiRsrcShdr(shdr)) {\r
      if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {\r
        // the alignment field is valid\r
        if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {\r
          // if the section address is aligned we must align PE/COFF\r
          mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));\r
        } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {\r
          // ARM RVCT tools have behavior outside of the ELF specification to try\r
          // and make images smaller.  If sh_addr is not aligned to sh_addralign\r
          // then the section needs to preserve sh_addr MOD sh_addralign.\r
          // Normally doing nothing here works great.\r
          Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");\r
        }\r
      }\r
      if (shdr->sh_size != 0) {\r
        mHiiRsrcOffset = mCoffOffset;\r
        mCoffSectionsOffset[i] = mCoffOffset;\r
        mCoffOffset += (UINT32) shdr->sh_size;\r
        mCoffOffset = CoffAlign(mCoffOffset);\r
        SetHiiResourceHeader ((UINT8*) mEhdr + shdr->sh_offset, mHiiRsrcOffset);\r
      }\r
      break;\r
    }\r
  }\r
\r
  mRelocOffset = mCoffOffset;\r
\r
  //\r
  // Allocate base Coff file.  Will be expanded later for relocations.\r
  //\r
  mCoffFile = (UINT8 *)malloc(mCoffOffset);\r
  memset(mCoffFile, 0, mCoffOffset);\r
\r
  //\r
  // Fill headers.\r
  //\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)mCoffFile;\r
  DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;\r
  DosHdr->e_lfanew = mNtHdrOffset;\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(mCoffFile + mNtHdrOffset);\r
\r
  NtHdr->Pe32Plus.Signature = EFI_IMAGE_NT_SIGNATURE;\r
\r
  switch (mEhdr->e_machine) {\r
  case EM_X86_64:\r
    NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;\r
    NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
    break;\r
  case EM_IA_64:\r
    NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_IPF;\r
    NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
    break;\r
  case EM_AARCH64:\r
    NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_AARCH64;\r
    NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
    break;\r
  default:\r
    VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);\r
    NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;\r
    NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
  }\r
\r
  NtHdr->Pe32Plus.FileHeader.NumberOfSections = mCoffNbrSections;\r
  NtHdr->Pe32Plus.FileHeader.TimeDateStamp = (UINT32) time(NULL);\r
  mImageTimeStamp = NtHdr->Pe32Plus.FileHeader.TimeDateStamp;\r
  NtHdr->Pe32Plus.FileHeader.PointerToSymbolTable = 0;\r
  NtHdr->Pe32Plus.FileHeader.NumberOfSymbols = 0;\r
  NtHdr->Pe32Plus.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32Plus.OptionalHeader);\r
  NtHdr->Pe32Plus.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE\r
    | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED\r
    | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED\r
    | EFI_IMAGE_FILE_LARGE_ADDRESS_AWARE;\r
\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfCode = mDataOffset - mTextOffset;\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfInitializedData = mRelocOffset - mDataOffset;\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfUninitializedData = 0;\r
  NtHdr->Pe32Plus.OptionalHeader.AddressOfEntryPoint = CoffEntry;\r
\r
  NtHdr->Pe32Plus.OptionalHeader.BaseOfCode = mTextOffset;\r
\r
  NtHdr->Pe32Plus.OptionalHeader.ImageBase = 0;\r
  NtHdr->Pe32Plus.OptionalHeader.SectionAlignment = mCoffAlignment;\r
  NtHdr->Pe32Plus.OptionalHeader.FileAlignment = mCoffAlignment;\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = 0;\r
\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfHeaders = mTextOffset;\r
  NtHdr->Pe32Plus.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;\r
\r
  //\r
  // Section headers.\r
  //\r
  if ((mDataOffset - mTextOffset) > 0) {\r
    CreateSectionHeader (".text", mTextOffset, mDataOffset - mTextOffset,\r
            EFI_IMAGE_SCN_CNT_CODE\r
            | EFI_IMAGE_SCN_MEM_EXECUTE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  } else {\r
    // Don't make a section of size 0.\r
    NtHdr->Pe32Plus.FileHeader.NumberOfSections--;\r
  }\r
\r
  if ((mHiiRsrcOffset - mDataOffset) > 0) {\r
    CreateSectionHeader (".data", mDataOffset, mHiiRsrcOffset - mDataOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_WRITE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  } else {\r
    // Don't make a section of size 0.\r
    NtHdr->Pe32Plus.FileHeader.NumberOfSections--;\r
  }\r
\r
  if ((mRelocOffset - mHiiRsrcOffset) > 0) {\r
    CreateSectionHeader (".rsrc", mHiiRsrcOffset, mRelocOffset - mHiiRsrcOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_READ);\r
\r
    NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = mRelocOffset - mHiiRsrcOffset;\r
    NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = mHiiRsrcOffset;\r
  } else {\r
    // Don't make a section of size 0.\r
    NtHdr->Pe32Plus.FileHeader.NumberOfSections--;\r
  }\r
\r
}\r
\r
STATIC\r
BOOLEAN\r
WriteSections64 (\r
  SECTION_FILTER_TYPES  FilterType\r
  )\r
{\r
  UINT32      Idx;\r
  Elf_Shdr    *SecShdr;\r
  UINT32      SecOffset;\r
  BOOLEAN     (*Filter)(Elf_Shdr *);\r
\r
  //\r
  // Initialize filter pointer\r
  //\r
  switch (FilterType) {\r
    case SECTION_TEXT:\r
      Filter = IsTextShdr;\r
      break;\r
    case SECTION_HII:\r
      Filter = IsHiiRsrcShdr;\r
      break;\r
    case SECTION_DATA:\r
      Filter = IsDataShdr;\r
      break;\r
    default:\r
      return FALSE;\r
  }\r
\r
  //\r
  // First: copy sections.\r
  //\r
  for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {\r
    Elf_Shdr *Shdr = GetShdrByIndex(Idx);\r
    if ((*Filter)(Shdr)) {\r
      switch (Shdr->sh_type) {\r
      case SHT_PROGBITS:\r
        /* Copy.  */\r
        memcpy(mCoffFile + mCoffSectionsOffset[Idx],\r
              (UINT8*)mEhdr + Shdr->sh_offset,\r
              (size_t) Shdr->sh_size);\r
        break;\r
\r
      case SHT_NOBITS:\r
        memset(mCoffFile + mCoffSectionsOffset[Idx], 0, (size_t) Shdr->sh_size);\r
        break;\r
\r
      default:\r
        //\r
        //  Ignore for unkown section type.\r
        //\r
        VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);\r
        break;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Second: apply relocations.\r
  //\r
  VerboseMsg ("Applying Relocations...");\r
  for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {\r
    //\r
    // Determine if this is a relocation section.\r
    //\r
    Elf_Shdr *RelShdr = GetShdrByIndex(Idx);\r
    if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {\r
      continue;\r
    }\r
\r
    //\r
    // Relocation section found.  Now extract section information that the relocations\r
    // apply to in the ELF data and the new COFF data.\r
    //\r
    SecShdr = GetShdrByIndex(RelShdr->sh_info);\r
    SecOffset = mCoffSectionsOffset[RelShdr->sh_info];\r
\r
    //\r
    // Only process relocations for the current filter type.\r
    //\r
    if (RelShdr->sh_type == SHT_RELA && (*Filter)(SecShdr)) {\r
      UINT64 RelIdx;\r
\r
      //\r
      // Determine the symbol table referenced by the relocation data.\r
      //\r
      Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);\r
      UINT8 *Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;\r
\r
      //\r
      // Process all relocation entries for this section.\r
      //\r
      for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += (UINT32) RelShdr->sh_entsize) {\r
\r
        //\r
        // Set pointer to relocation entry\r
        //\r
        Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);\r
\r
        //\r
        // Set pointer to symbol table entry associated with the relocation entry.\r
        //\r
        Elf_Sym  *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);\r
\r
        Elf_Shdr *SymShdr;\r
        UINT8    *Targ;\r
\r
        //\r
        // Check section header index found in symbol table and get the section\r
        // header location.\r
        //\r
        if (Sym->st_shndx == SHN_UNDEF\r
            || Sym->st_shndx == SHN_ABS\r
            || Sym->st_shndx > mEhdr->e_shnum) {\r
          Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);\r
        }\r
        SymShdr = GetShdrByIndex(Sym->st_shndx);\r
\r
        //\r
        // Convert the relocation data to a pointer into the coff file.\r
        //\r
        // Note:\r
        //   r_offset is the virtual address of the storage unit to be relocated.\r
        //   sh_addr is the virtual address for the base of the section.\r
        //\r
        //   r_offset in a memory address.\r
        //   Convert it to a pointer in the coff file.\r
        //\r
        Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);\r
\r
        //\r
        // Determine how to handle each relocation type based on the machine type.\r
        //\r
        if (mEhdr->e_machine == EM_X86_64) {\r
          switch (ELF_R_TYPE(Rel->r_info)) {\r
          case R_X86_64_NONE:\r
            break;\r
          case R_X86_64_64:\r
            //\r
            // Absolute relocation.\r
            //\r
            VerboseMsg ("R_X86_64_64");\r
            VerboseMsg ("Offset: 0x%08X, Addend: 0x%016LX", \r
              (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)), \r
              *(UINT64 *)Targ);\r
            *(UINT64 *)Targ = *(UINT64 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];\r
            VerboseMsg ("Relocation:  0x%016LX", *(UINT64*)Targ);\r
            break;\r
          case R_X86_64_32:\r
            VerboseMsg ("R_X86_64_32");\r
            VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X", \r
              (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)), \r
              *(UINT32 *)Targ);\r
            *(UINT32 *)Targ = (UINT32)((UINT64)(*(UINT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);\r
            VerboseMsg ("Relocation:  0x%08X", *(UINT32*)Targ);\r
            break;\r
          case R_X86_64_32S:\r
            VerboseMsg ("R_X86_64_32S");\r
            VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X", \r
              (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)), \r
              *(UINT32 *)Targ);\r
            *(INT32 *)Targ = (INT32)((INT64)(*(INT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);\r
            VerboseMsg ("Relocation:  0x%08X", *(UINT32*)Targ);\r
            break;\r
          case R_X86_64_PC32:\r
            //\r
            // Relative relocation: Symbol - Ip + Addend\r
            //\r
            VerboseMsg ("R_X86_64_PC32");\r
            VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X", \r
              (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)), \r
              *(UINT32 *)Targ);\r
            *(UINT32 *)Targ = (UINT32) (*(UINT32 *)Targ\r
              + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)\r
              - (SecOffset - SecShdr->sh_addr));\r
            VerboseMsg ("Relocation:  0x%08X", *(UINT32 *)Targ);\r
            break;\r
          default:\r
            Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
          }\r
        } else if (mEhdr->e_machine == EM_AARCH64) {\r
\r
          // AARCH64 GCC uses RELA relocation, so all relocations have to be fixed up.\r
          // As opposed to ARM32 using REL.\r
\r
          switch (ELF_R_TYPE(Rel->r_info)) {\r
\r
          case R_AARCH64_ADR_PREL_LO21:\r
            if  (Rel->r_addend != 0 ) { /* TODO */\r
              Error (NULL, 0, 3000, "Invalid", "AArch64: R_AARCH64_ADR_PREL_LO21 Need to fixup with addend!.");\r
            }\r
            break;\r
\r
          case R_AARCH64_CONDBR19:\r
            if  (Rel->r_addend != 0 ) { /* TODO */\r
              Error (NULL, 0, 3000, "Invalid", "AArch64: R_AARCH64_CONDBR19 Need to fixup with addend!.");\r
            }\r
            break;\r
\r
          case R_AARCH64_LD_PREL_LO19:\r
            if  (Rel->r_addend != 0 ) { /* TODO */\r
              Error (NULL, 0, 3000, "Invalid", "AArch64: R_AARCH64_LD_PREL_LO19 Need to fixup with addend!.");\r
            }\r
            break;\r
\r
          case R_AARCH64_CALL26:\r
          case R_AARCH64_JUMP26:\r
            if  (Rel->r_addend != 0 ) {\r
              // Some references to static functions sometime start at the base of .text + addend.\r
              // It is safe to ignore these relocations because they patch a `BL` instructions that\r
              // contains an offset from the instruction itself and there is only a single .text section.\r
              // So we check if the symbol is a "section symbol"\r
              if (ELF64_ST_TYPE (Sym->st_info) == STT_SECTION) {\r
                break;\r
              }\r
              Error (NULL, 0, 3000, "Invalid", "AArch64: R_AARCH64_JUMP26 Need to fixup with addend!.");\r
            }\r
            break;\r
\r
          case R_AARCH64_ADR_PREL_PG_HI21:\r
            // TODO : AArch64 'small' memory model.\r
            Error (NULL, 0, 3000, "Invalid", "WriteSections64(): %s unsupported ELF EM_AARCH64 relocation R_AARCH64_ADR_PREL_PG_HI21.", mInImageName);\r
            break;\r
\r
          case R_AARCH64_ADD_ABS_LO12_NC:\r
            // TODO : AArch64 'small' memory model.\r
            Error (NULL, 0, 3000, "Invalid", "WriteSections64(): %s unsupported ELF EM_AARCH64 relocation R_AARCH64_ADD_ABS_LO12_NC.", mInImageName);\r
            break;\r
\r
          // Absolute relocations.\r
          case R_AARCH64_ABS64:\r
            *(UINT64 *)Targ = *(UINT64 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];\r
            break;\r
\r
          default:\r
            Error (NULL, 0, 3000, "Invalid", "WriteSections64(): %s unsupported ELF EM_AARCH64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
          }\r
        } else {\r
          Error (NULL, 0, 3000, "Invalid", "Not a supported machine type");\r
        }\r
      }\r
    }\r
  }\r
\r
  return TRUE;\r
}\r
\r
STATIC\r
VOID\r
WriteRelocations64 (\r
  VOID\r
  )\r
{\r
  UINT32                           Index;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION  *NtHdr;\r
  EFI_IMAGE_DATA_DIRECTORY         *Dir;\r
\r
  for (Index = 0; Index < mEhdr->e_shnum; Index++) {\r
    Elf_Shdr *RelShdr = GetShdrByIndex(Index);\r
    if ((RelShdr->sh_type == SHT_REL) || (RelShdr->sh_type == SHT_RELA)) {\r
      Elf_Shdr *SecShdr = GetShdrByIndex (RelShdr->sh_info);\r
      if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {\r
        UINT64 RelIdx;\r
\r
        for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {\r
          Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);\r
\r
          if (mEhdr->e_machine == EM_X86_64) {\r
            switch (ELF_R_TYPE(Rel->r_info)) {\r
            case R_X86_64_NONE:\r
            case R_X86_64_PC32:\r
              break;\r
            case R_X86_64_64:\r
              VerboseMsg ("EFI_IMAGE_REL_BASED_DIR64 Offset: 0x%08X", \r
                mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));\r
              CoffAddFixup(\r
                (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]\r
                + (Rel->r_offset - SecShdr->sh_addr)),\r
                EFI_IMAGE_REL_BASED_DIR64);\r
              break;\r
            case R_X86_64_32S:\r
            case R_X86_64_32:\r
              VerboseMsg ("EFI_IMAGE_REL_BASED_HIGHLOW Offset: 0x%08X", \r
                mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));\r
              CoffAddFixup(\r
                (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]\r
                + (Rel->r_offset - SecShdr->sh_addr)),\r
                EFI_IMAGE_REL_BASED_HIGHLOW);\r
              break;\r
            default:\r
              Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
            }\r
          } else if (mEhdr->e_machine == EM_AARCH64) {\r
            // AArch64 GCC uses RELA relocation, so all relocations has to be fixed up. ARM32 uses REL.\r
            switch (ELF_R_TYPE(Rel->r_info)) {\r
            case R_AARCH64_ADR_PREL_LO21:\r
              break;\r
\r
            case R_AARCH64_CONDBR19:\r
              break;\r
\r
            case R_AARCH64_LD_PREL_LO19:\r
              break;\r
\r
            case R_AARCH64_CALL26:\r
              break;\r
\r
            case R_AARCH64_JUMP26:\r
              break;\r
\r
            case R_AARCH64_ADR_PREL_PG_HI21:\r
              // TODO : AArch64 'small' memory model.\r
              Error (NULL, 0, 3000, "Invalid", "WriteRelocations64(): %s unsupported ELF EM_AARCH64 relocation R_AARCH64_ADR_PREL_PG_HI21.", mInImageName);\r
              break;\r
\r
            case R_AARCH64_ADD_ABS_LO12_NC:\r
              // TODO : AArch64 'small' memory model.\r
              Error (NULL, 0, 3000, "Invalid", "WriteRelocations64(): %s unsupported ELF EM_AARCH64 relocation R_AARCH64_ADD_ABS_LO12_NC.", mInImageName);\r
              break;\r
\r
            case R_AARCH64_ABS64:\r
              CoffAddFixup(\r
                (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]\r
                + (Rel->r_offset - SecShdr->sh_addr)),\r
                EFI_IMAGE_REL_BASED_DIR64);\r
              break;\r
\r
            case R_AARCH64_ABS32:\r
              CoffAddFixup(\r
                (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]\r
                + (Rel->r_offset - SecShdr->sh_addr)),\r
                EFI_IMAGE_REL_BASED_HIGHLOW);\r
             break;\r
\r
            default:\r
                Error (NULL, 0, 3000, "Invalid", "WriteRelocations64(): %s unsupported ELF EM_AARCH64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
            }\r
          } else {\r
            Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) mEhdr->e_machine);\r
          }\r
        }\r
      }\r
    }\r
  }\r
\r
  //\r
  // Pad by adding empty entries.\r
  //\r
  while (mCoffOffset & (mCoffAlignment - 1)) {\r
    CoffAddFixupEntry(0);\r
  }\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);\r
  Dir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
  Dir->Size = mCoffOffset - mRelocOffset;\r
  if (Dir->Size == 0) {\r
    // If no relocations, null out the directory entry and don't add the .reloc section\r
    Dir->VirtualAddress = 0;\r
    NtHdr->Pe32Plus.FileHeader.NumberOfSections--;\r
  } else {\r
    Dir->VirtualAddress = mRelocOffset;\r
    CreateSectionHeader (".reloc", mRelocOffset, mCoffOffset - mRelocOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_DISCARDABLE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  }\r
}\r
\r
STATIC\r
VOID\r
WriteDebug64 (\r
  VOID\r
  )\r
{\r
  UINT32                              Len;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION     *NtHdr;\r
  EFI_IMAGE_DATA_DIRECTORY            *DataDir;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY     *Dir;\r
  EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;\r
\r
  Len = strlen(mInImageName) + 1;\r
\r
  Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(mCoffFile + mDebugOffset);\r
  Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;\r
  Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;\r
  Dir->RVA = mDebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
  Dir->FileOffset = mDebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
\r
  Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);\r
  Nb10->Signature = CODEVIEW_SIGNATURE_NB10;\r
  strcpy ((char *)(Nb10 + 1), mInImageName);\r
\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);\r
  DataDir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];\r
  DataDir->VirtualAddress = mDebugOffset;\r
  DataDir->Size = Dir->SizeOfData + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
}\r
\r
STATIC\r
VOID\r
SetImageSize64 (\r
  VOID\r
  )\r
{\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;\r
\r
  //\r
  // Set image size\r
  //\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);\r
  NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = mCoffOffset;\r
}\r
\r
STATIC\r
VOID\r
CleanUp64 (\r
  VOID\r
  )\r
{\r
  if (mCoffSectionsOffset != NULL) {\r
    free (mCoffSectionsOffset);\r
  }\r
}\r
\r
\r