BaseTools/Source/C/GenFw/Elf64Convert.c

   1 /** @file
   2
   3 Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
   4
   5 This program and the accompanying materials are licensed and made available
   6 under the terms and conditions of the BSD License which accompanies this
   7 distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "WinNtInclude.h"
  16
  17 #ifndef __GNUC__
  18 #include <windows.h>
  19 #include <io.h>
  20 #endif
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <ctype.h>
  26
  27 #include <Common/UefiBaseTypes.h>
  28 #include <IndustryStandard/PeImage.h>
  29
  30 #include "PeCoffLib.h"
  31 #include "EfiUtilityMsgs.h"
  32
  33 #include "GenFw.h"
  34 #include "ElfConvert.h"
  35 #include "Elf64Convert.h"
  36
  37 STATIC
  38 VOID
  39 ScanSections64 (
  40   VOID
  41   );
  42
  43 STATIC
  44 BOOLEAN
  45 WriteSections64 (
  46   SECTION_FILTER_TYPES  FilterType
  47   );
  48
  49 STATIC
  50 VOID
  51 WriteRelocations64 (
  52   VOID
  53   );
  54
  55 STATIC
  56 VOID
  57 WriteDebug64 (
  58   VOID
  59   );
  60
  61 STATIC
  62 VOID
  63 SetImageSize64 (
  64   VOID
  65   );
  66
  67 STATIC
  68 VOID
  69 CleanUp64 (
  70   VOID
  71   );
  72
  73 //
  74 // Rename ELF32 strucutres to common names to help when porting to ELF64.
  75 //
  76 typedef Elf64_Shdr Elf_Shdr;
  77 typedef Elf64_Ehdr Elf_Ehdr;
  78 typedef Elf64_Rel Elf_Rel;
  79 typedef Elf64_Rela Elf_Rela;
  80 typedef Elf64_Sym Elf_Sym;
  81 typedef Elf64_Phdr Elf_Phdr;
  82 typedef Elf64_Dyn Elf_Dyn;
  83 #define ELFCLASS ELFCLASS64
  84 #define ELF_R_TYPE(r) ELF64_R_TYPE(r)
  85 #define ELF_R_SYM(r) ELF64_R_SYM(r)
  86
  87 //
  88 // Well known ELF structures.
  89 //
  90 STATIC Elf_Ehdr *mEhdr;
  91 STATIC Elf_Shdr *mShdrBase;
  92 STATIC Elf_Phdr *mPhdrBase;
  93
  94 //
  95 // Coff information
  96 //
  97 STATIC const UINT32 mCoffAlignment = 0x20;
  98
  99 //
 100 // PE section alignment.
 101 //
 102 STATIC const UINT16 mCoffNbrSections = 5;
 103
 104 //
 105 // ELF sections to offset in Coff file.
 106 //
 107 STATIC UINT32 *mCoffSectionsOffset = NULL;
 108
 109 //
 110 // Offsets in COFF file
 111 //
 112 STATIC UINT32 mNtHdrOffset;
 113 STATIC UINT32 mTextOffset;
 114 STATIC UINT32 mDataOffset;
 115 STATIC UINT32 mHiiRsrcOffset;
 116 STATIC UINT32 mRelocOffset;
 117
 118 //
 119 // Initialization Function
 120 //
 121 BOOLEAN
 122 InitializeElf64 (
 123   UINT8               *FileBuffer,
 124   ELF_FUNCTION_TABLE  *ElfFunctions
 125   )
 126 {
 127   //
 128   // Initialize data pointer and structures.
 129   //
 130   VerboseMsg ("Set EHDR");
 131   mEhdr = (Elf_Ehdr*) FileBuffer;
 132
 133   //
 134   // Check the ELF64 specific header information.
 135   //
 136   VerboseMsg ("Check ELF64 Header Information");
 137   if (mEhdr->e_ident[EI_CLASS] != ELFCLASS64) {
 138     Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFCLASS64");
 139     return FALSE;
 140   }
 141   if (mEhdr->e_ident[EI_DATA] != ELFDATA2LSB) {
 142     Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");
 143     return FALSE;
 144   }
 145   if ((mEhdr->e_type != ET_EXEC) && (mEhdr->e_type != ET_DYN)) {
 146     Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");
 147     return FALSE;
 148   }
 149   if (!((mEhdr->e_machine == EM_X86_64))) {
 150     Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_X86_64");
 151     return FALSE;
 152   }
 153   if (mEhdr->e_version != EV_CURRENT) {
 154     Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) mEhdr->e_version, EV_CURRENT);
 155     return FALSE;
 156   }
 157
 158   //
 159   // Update section header pointers
 160   //
 161   VerboseMsg ("Update Header Pointers");
 162   mShdrBase  = (Elf_Shdr *)((UINT8 *)mEhdr + mEhdr->e_shoff);
 163   mPhdrBase = (Elf_Phdr *)((UINT8 *)mEhdr + mEhdr->e_phoff);
 164
 165   //
 166   // Create COFF Section offset buffer and zero.
 167   //
 168   VerboseMsg ("Create COFF Section Offset Buffer");
 169   mCoffSectionsOffset = (UINT32 *)malloc(mEhdr->e_shnum * sizeof (UINT32));
 170   memset(mCoffSectionsOffset, 0, mEhdr->e_shnum * sizeof(UINT32));
 171
 172   //
 173   // Fill in function pointers.
 174   //
 175   VerboseMsg ("Fill in Function Pointers");
 176   ElfFunctions->ScanSections = ScanSections64;
 177   ElfFunctions->WriteSections = WriteSections64;
 178   ElfFunctions->WriteRelocations = WriteRelocations64;
 179   ElfFunctions->WriteDebug = WriteDebug64;
 180   ElfFunctions->SetImageSize = SetImageSize64;
 181   ElfFunctions->CleanUp = CleanUp64;
 182
 183   return TRUE;
 184 }
 185
 186
 187 //
 188 // Header by Index functions
 189 //
 190 STATIC
 191 Elf_Shdr*
 192 GetShdrByIndex (
 193   UINT32 Num
 194   )
 195 {
 196   if (Num >= mEhdr->e_shnum)
 197     return NULL;
 198   return (Elf_Shdr*)((UINT8*)mShdrBase + Num * mEhdr->e_shentsize);
 199 }
 200
 201 STATIC
 202 UINT32
 203 CoffAlign (
 204   UINT32 Offset
 205   )
 206 {
 207   return (Offset + mCoffAlignment - 1) & ~(mCoffAlignment - 1);
 208 }
 209
 210 //
 211 // filter functions
 212 //
 213 STATIC
 214 BOOLEAN
 215 IsTextShdr (
 216   Elf_Shdr *Shdr
 217   )
 218 {
 219   return (BOOLEAN) ((Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC);
 220 }
 221
 222 STATIC
 223 BOOLEAN
 224 IsHiiRsrcShdr (
 225   Elf_Shdr *Shdr
 226   )
 227 {
 228   Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx);
 229
 230   return (BOOLEAN) (strcmp((CHAR8*)mEhdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0);
 231 }
 232
 233 STATIC
 234 BOOLEAN
 235 IsDataShdr (
 236   Elf_Shdr *Shdr
 237   )
 238 {
 239   if (IsHiiRsrcShdr(Shdr)) {
 240     return FALSE;
 241   }
 242   return (BOOLEAN) (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);
 243 }
 244
 245 //
 246 // Elf functions interface implementation
 247 //
 248
 249 STATIC
 250 VOID
 251 ScanSections64 (
 252   VOID
 253   )
 254 {
 255   UINT32                          i;
 256   EFI_IMAGE_DOS_HEADER            *DosHdr;
 257   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
 258   UINT32                          CoffEntry;
 259
 260   CoffEntry = 0;
 261   mCoffOffset = 0;
 262
 263   //
 264   // Coff file start with a DOS header.
 265   //
 266   mCoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;
 267   mNtHdrOffset = mCoffOffset;
 268   switch (mEhdr->e_machine) {
 269   case EM_X86_64:
 270   case EM_IA_64:
 271     mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);
 272   break;
 273   default:
 274     VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);
 275     mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);
 276   break;
 277   }
 278
 279   mTableOffset = mCoffOffset;
 280   mCoffOffset += mCoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);
 281
 282   //
 283   // First text sections.
 284   //
 285   mCoffOffset = CoffAlign(mCoffOffset);
 286   mTextOffset = mCoffOffset;
 287   for (i = 0; i < mEhdr->e_shnum; i++) {
 288     Elf_Shdr *shdr = GetShdrByIndex(i);
 289     if (IsTextShdr(shdr)) {
 290       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 291         // the alignment field is valid
 292         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 293           // if the section address is aligned we must align PE/COFF
 294           mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));
 295         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 296           // ARM RVCT tools have behavior outside of the ELF specification to try
 297           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 298           // then the section needs to preserve sh_addr MOD sh_addralign.
 299           // Normally doing nothing here works great.
 300           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 301         }
 302       }
 303
 304       /* Relocate entry.  */
 305       if ((mEhdr->e_entry >= shdr->sh_addr) &&
 306           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
 307         CoffEntry = (UINT32) (mCoffOffset + mEhdr->e_entry - shdr->sh_addr);
 308       }
 309       mCoffSectionsOffset[i] = mCoffOffset;
 310       mCoffOffset += (UINT32) shdr->sh_size;
 311     }
 312   }
 313
 314   if (mEhdr->e_machine != EM_ARM) {
 315     mCoffOffset = CoffAlign(mCoffOffset);
 316   }
 317
 318   //
 319   //  Then data sections.
 320   //
 321   mDataOffset = mCoffOffset;
 322   for (i = 0; i < mEhdr->e_shnum; i++) {
 323     Elf_Shdr *shdr = GetShdrByIndex(i);
 324     if (IsDataShdr(shdr)) {
 325       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 326         // the alignment field is valid
 327         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 328           // if the section address is aligned we must align PE/COFF
 329           mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));
 330         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 331           // ARM RVCT tools have behavior outside of the ELF specification to try
 332           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 333           // then the section needs to preserve sh_addr MOD sh_addralign.
 334           // Normally doing nothing here works great.
 335           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 336         }
 337       }
 338       mCoffSectionsOffset[i] = mCoffOffset;
 339       mCoffOffset += (UINT32) shdr->sh_size;
 340     }
 341   }
 342   mCoffOffset = CoffAlign(mCoffOffset);
 343
 344   //
 345   //  The HII resource sections.
 346   //
 347   mHiiRsrcOffset = mCoffOffset;
 348   for (i = 0; i < mEhdr->e_shnum; i++) {
 349     Elf_Shdr *shdr = GetShdrByIndex(i);
 350     if (IsHiiRsrcShdr(shdr)) {
 351       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 352         // the alignment field is valid
 353         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 354           // if the section address is aligned we must align PE/COFF
 355           mCoffOffset = (UINT32) ((mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1));
 356         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 357           // ARM RVCT tools have behavior outside of the ELF specification to try
 358           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 359           // then the section needs to preserve sh_addr MOD sh_addralign.
 360           // Normally doing nothing here works great.
 361           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 362         }
 363       }
 364       if (shdr->sh_size != 0) {
 365         mCoffSectionsOffset[i] = mCoffOffset;
 366         mCoffOffset += (UINT32) shdr->sh_size;
 367         mCoffOffset = CoffAlign(mCoffOffset);
 368         SetHiiResourceHeader ((UINT8*) mEhdr + shdr->sh_offset, mHiiRsrcOffset);
 369       }
 370       break;
 371     }
 372   }
 373
 374   mRelocOffset = mCoffOffset;
 375
 376   //
 377   // Allocate base Coff file.  Will be expanded later for relocations.
 378   //
 379   mCoffFile = (UINT8 *)malloc(mCoffOffset);
 380   memset(mCoffFile, 0, mCoffOffset);
 381
 382   //
 383   // Fill headers.
 384   //
 385   DosHdr = (EFI_IMAGE_DOS_HEADER *)mCoffFile;
 386   DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;
 387   DosHdr->e_lfanew = mNtHdrOffset;
 388
 389   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(mCoffFile + mNtHdrOffset);
 390
 391   NtHdr->Pe32Plus.Signature = EFI_IMAGE_NT_SIGNATURE;
 392
 393   switch (mEhdr->e_machine) {
 394   case EM_X86_64:
 395     NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;
 396     NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 397     break;
 398   case EM_IA_64:
 399     NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_IPF;
 400     NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 401     break;
 402   default:
 403     VerboseMsg ("%s unknown e_machine type. Assume X64", (UINTN)mEhdr->e_machine);
 404     NtHdr->Pe32Plus.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;
 405     NtHdr->Pe32Plus.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 406   }
 407
 408   NtHdr->Pe32Plus.FileHeader.NumberOfSections = mCoffNbrSections;
 409   NtHdr->Pe32Plus.FileHeader.TimeDateStamp = (UINT32) time(NULL);
 410   mImageTimeStamp = NtHdr->Pe32Plus.FileHeader.TimeDateStamp;
 411   NtHdr->Pe32Plus.FileHeader.PointerToSymbolTable = 0;
 412   NtHdr->Pe32Plus.FileHeader.NumberOfSymbols = 0;
 413   NtHdr->Pe32Plus.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32Plus.OptionalHeader);
 414   NtHdr->Pe32Plus.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE
 415     | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED
 416     | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED
 417     | EFI_IMAGE_FILE_LARGE_ADDRESS_AWARE;
 418
 419   NtHdr->Pe32Plus.OptionalHeader.SizeOfCode = mDataOffset - mTextOffset;
 420   NtHdr->Pe32Plus.OptionalHeader.SizeOfInitializedData = mRelocOffset - mDataOffset;
 421   NtHdr->Pe32Plus.OptionalHeader.SizeOfUninitializedData = 0;
 422   NtHdr->Pe32Plus.OptionalHeader.AddressOfEntryPoint = CoffEntry;
 423
 424   NtHdr->Pe32Plus.OptionalHeader.BaseOfCode = mTextOffset;
 425
 426   NtHdr->Pe32Plus.OptionalHeader.ImageBase = 0;
 427   NtHdr->Pe32Plus.OptionalHeader.SectionAlignment = mCoffAlignment;
 428   NtHdr->Pe32Plus.OptionalHeader.FileAlignment = mCoffAlignment;
 429   NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = 0;
 430
 431   NtHdr->Pe32Plus.OptionalHeader.SizeOfHeaders = mTextOffset;
 432   NtHdr->Pe32Plus.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
 433
 434   //
 435   // Section headers.
 436   //
 437   if ((mDataOffset - mTextOffset) > 0) {
 438     CreateSectionHeader (".text", mTextOffset, mDataOffset - mTextOffset,
 439             EFI_IMAGE_SCN_CNT_CODE
 440             | EFI_IMAGE_SCN_MEM_EXECUTE
 441             | EFI_IMAGE_SCN_MEM_READ);
 442   } else {
 443     // Don't make a section of size 0.
 444     NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
 445   }
 446
 447   if ((mHiiRsrcOffset - mDataOffset) > 0) {
 448     CreateSectionHeader (".data", mDataOffset, mHiiRsrcOffset - mDataOffset,
 449             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 450             | EFI_IMAGE_SCN_MEM_WRITE
 451             | EFI_IMAGE_SCN_MEM_READ);
 452   } else {
 453     // Don't make a section of size 0.
 454     NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
 455   }
 456
 457   if ((mRelocOffset - mHiiRsrcOffset) > 0) {
 458     CreateSectionHeader (".rsrc", mHiiRsrcOffset, mRelocOffset - mHiiRsrcOffset,
 459             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 460             | EFI_IMAGE_SCN_MEM_READ);
 461
 462     NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = mRelocOffset - mHiiRsrcOffset;
 463     NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = mHiiRsrcOffset;
 464   } else {
 465     // Don't make a section of size 0.
 466     NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
 467   }
 468
 469 }
 470
 471 STATIC
 472 BOOLEAN
 473 WriteSections64 (
 474   SECTION_FILTER_TYPES  FilterType
 475   )
 476 {
 477   UINT32      Idx;
 478   Elf_Shdr    *SecShdr;
 479   UINT32      SecOffset;
 480   BOOLEAN     (*Filter)(Elf_Shdr *);
 481
 482   //
 483   // Initialize filter pointer
 484   //
 485   switch (FilterType) {
 486     case SECTION_TEXT:
 487       Filter = IsTextShdr;
 488       break;
 489     case SECTION_HII:
 490       Filter = IsHiiRsrcShdr;
 491       break;
 492     case SECTION_DATA:
 493       Filter = IsDataShdr;
 494       break;
 495     default:
 496       return FALSE;
 497   }
 498
 499   //
 500   // First: copy sections.
 501   //
 502   for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
 503     Elf_Shdr *Shdr = GetShdrByIndex(Idx);
 504     if ((*Filter)(Shdr)) {
 505       switch (Shdr->sh_type) {
 506       case SHT_PROGBITS:
 507         /* Copy.  */
 508         memcpy(mCoffFile + mCoffSectionsOffset[Idx],
 509               (UINT8*)mEhdr + Shdr->sh_offset,
 510               (size_t) Shdr->sh_size);
 511         break;
 512
 513       case SHT_NOBITS:
 514         memset(mCoffFile + mCoffSectionsOffset[Idx], 0, (size_t) Shdr->sh_size);
 515         break;
 516
 517       default:
 518         //
 519         //  Ignore for unkown section type.
 520         //
 521         VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);
 522         break;
 523       }
 524     }
 525   }
 526
 527   //
 528   // Second: apply relocations.
 529   //
 530   VerboseMsg ("Applying Relocations...");
 531   for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
 532     Elf_Shdr *RelShdr = GetShdrByIndex(Idx);
 533     if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {
 534       continue;
 535     }
 536     SecShdr = GetShdrByIndex(RelShdr->sh_info);
 537     SecOffset = mCoffSectionsOffset[RelShdr->sh_info];
 538     if (RelShdr->sh_type == SHT_RELA && (*Filter)(SecShdr)) {
 539       UINT64 RelIdx;
 540       Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);
 541       UINT8 *Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
 542       for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += (UINT32) RelShdr->sh_entsize) {
 543         Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
 544         Elf_Sym  *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
 545         Elf_Shdr *SymShdr;
 546         UINT8    *Targ;
 547
 548         if (Sym->st_shndx == SHN_UNDEF
 549             || Sym->st_shndx == SHN_ABS
 550             || Sym->st_shndx > mEhdr->e_shnum) {
 551           Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);
 552         }
 553         SymShdr = GetShdrByIndex(Sym->st_shndx);
 554
 555         //
 556         // Note: r_offset in a memory address.
 557         //  Convert it to a pointer in the coff file.
 558         //
 559         Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);
 560
 561         if (mEhdr->e_machine == EM_X86_64) {
 562           switch (ELF_R_TYPE(Rel->r_info)) {
 563           case R_X86_64_NONE:
 564             break;
 565           case R_X86_64_64:
 566             //
 567             // Absolute relocation.
 568             //
 569             VerboseMsg ("R_X86_64_64");
 570             VerboseMsg ("Offset: 0x%08X, Addend: 0x%016LX",
 571               (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
 572               *(UINT64 *)Targ);
 573             *(UINT64 *)Targ = *(UINT64 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];
 574             VerboseMsg ("Relocation:  0x%016LX", *(UINT64*)Targ);
 575             break;
 576           case R_X86_64_32:
 577             VerboseMsg ("R_X86_64_32");
 578             VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
 579               (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
 580               *(UINT32 *)Targ);
 581             *(UINT32 *)Targ = (UINT32)((UINT64)(*(UINT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
 582             VerboseMsg ("Relocation:  0x%08X", *(UINT32*)Targ);
 583             break;
 584           case R_X86_64_32S:
 585             VerboseMsg ("R_X86_64_32S");
 586             VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
 587               (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
 588               *(UINT32 *)Targ);
 589             *(INT32 *)Targ = (INT32)((INT64)(*(INT32 *)Targ) - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
 590             VerboseMsg ("Relocation:  0x%08X", *(UINT32*)Targ);
 591             break;
 592           case R_X86_64_PC32:
 593             //
 594             // Relative relocation: Symbol - Ip + Addend
 595             //
 596             VerboseMsg ("R_X86_64_PC32");
 597             VerboseMsg ("Offset: 0x%08X, Addend: 0x%08X",
 598               (UINT32)(SecOffset + (Rel->r_offset - SecShdr->sh_addr)),
 599               *(UINT32 *)Targ);
 600             *(UINT32 *)Targ = (UINT32) (*(UINT32 *)Targ
 601               + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)
 602               - (SecOffset - SecShdr->sh_addr));
 603             VerboseMsg ("Relocation:  0x%08X", *(UINT32 *)Targ);
 604             break;
 605           default:
 606             Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
 607           }
 608         } else {
 609           Error (NULL, 0, 3000, "Invalid", "Not EM_X86_X64");
 610         }
 611       }
 612     }
 613   }
 614
 615   return TRUE;
 616 }
 617
 618 STATIC
 619 VOID
 620 WriteRelocations64 (
 621   VOID
 622   )
 623 {
 624   UINT32                           Index;
 625   EFI_IMAGE_OPTIONAL_HEADER_UNION  *NtHdr;
 626   EFI_IMAGE_DATA_DIRECTORY         *Dir;
 627   BOOLEAN                          FoundRelocations;
 628   Elf_Sym                          *Sym;
 629   Elf_Shdr                         *SymtabShdr;
 630   UINT8                            *Symtab;
 631
 632
 633   for (Index = 0, FoundRelocations = FALSE; Index < mEhdr->e_shnum; Index++) {
 634     Elf_Shdr *RelShdr = GetShdrByIndex(Index);
 635     if ((RelShdr->sh_type == SHT_REL) || (RelShdr->sh_type == SHT_RELA)) {
 636       Elf_Shdr *SecShdr = GetShdrByIndex (RelShdr->sh_info);
 637       if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {
 638         UINT64 RelIdx;
 639
 640         SymtabShdr = GetShdrByIndex (RelShdr->sh_link);
 641         Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
 642         FoundRelocations = TRUE;
 643         for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {
 644           Elf_Rela *Rel = (Elf_Rela *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
 645           Elf_Shdr *SymShdr;
 646
 647           Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
 648           SymShdr = GetShdrByIndex (Sym->st_shndx);
 649
 650           if (mEhdr->e_machine == EM_X86_64) {
 651             switch (ELF_R_TYPE(Rel->r_info)) {
 652             case R_X86_64_NONE:
 653             case R_X86_64_PC32:
 654               break;
 655             case R_X86_64_64:
 656               VerboseMsg ("EFI_IMAGE_REL_BASED_DIR64 Offset: 0x%08X",
 657                 mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));
 658               CoffAddFixup(
 659                 (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]
 660                 + (Rel->r_offset - SecShdr->sh_addr)),
 661                 EFI_IMAGE_REL_BASED_DIR64);
 662               break;
 663             case R_X86_64_32S:
 664             case R_X86_64_32:
 665               VerboseMsg ("EFI_IMAGE_REL_BASED_HIGHLOW Offset: 0x%08X",
 666                 mCoffSectionsOffset[RelShdr->sh_info] + (Rel->r_offset - SecShdr->sh_addr));
 667               CoffAddFixup(
 668                 (UINT32) ((UINT64) mCoffSectionsOffset[RelShdr->sh_info]
 669                 + (Rel->r_offset - SecShdr->sh_addr)),
 670                 EFI_IMAGE_REL_BASED_HIGHLOW);
 671               break;
 672             default:
 673               Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_X86_64 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
 674             }
 675           } else {
 676             Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) mEhdr->e_machine);
 677           }
 678         }
 679       }
 680     }
 681   }
 682
 683   //
 684   // Pad by adding empty entries.
 685   //
 686   while (mCoffOffset & (mCoffAlignment - 1)) {
 687     CoffAddFixupEntry(0);
 688   }
 689
 690   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 691   Dir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
 692   Dir->Size = mCoffOffset - mRelocOffset;
 693   if (Dir->Size == 0) {
 694     // If no relocations, null out the directory entry and don't add the .reloc section
 695     Dir->VirtualAddress = 0;
 696     NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
 697   } else {
 698     Dir->VirtualAddress = mRelocOffset;
 699     CreateSectionHeader (".reloc", mRelocOffset, mCoffOffset - mRelocOffset,
 700             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 701             | EFI_IMAGE_SCN_MEM_DISCARDABLE
 702             | EFI_IMAGE_SCN_MEM_READ);
 703   }
 704 }
 705
 706 STATIC
 707 VOID
 708 WriteDebug64 (
 709   VOID
 710   )
 711 {
 712   UINT32                              Len;
 713   UINT32                              DebugOffset;
 714   EFI_IMAGE_OPTIONAL_HEADER_UNION     *NtHdr;
 715   EFI_IMAGE_DATA_DIRECTORY            *DataDir;
 716   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY     *Dir;
 717   EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;
 718
 719   Len = strlen(mInImageName) + 1;
 720   DebugOffset = mCoffOffset;
 721
 722   mCoffOffset += sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)
 723     + sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)
 724     + Len;
 725   mCoffOffset = CoffAlign(mCoffOffset);
 726
 727   mCoffFile = realloc(mCoffFile, mCoffOffset);
 728   memset(mCoffFile + DebugOffset, 0, mCoffOffset - DebugOffset);
 729
 730   Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(mCoffFile + DebugOffset);
 731   Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
 732   Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;
 733   Dir->RVA = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
 734   Dir->FileOffset = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
 735
 736   Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);
 737   Nb10->Signature = CODEVIEW_SIGNATURE_NB10;
 738   strcpy ((char *)(Nb10 + 1), mInImageName);
 739
 740
 741   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 742   DataDir = &NtHdr->Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];
 743   DataDir->VirtualAddress = DebugOffset;
 744   DataDir->Size = mCoffOffset - DebugOffset;
 745   if (DataDir->Size == 0) {
 746     // If no debug, null out the directory entry and don't add the .debug section
 747     DataDir->VirtualAddress = 0;
 748     NtHdr->Pe32Plus.FileHeader.NumberOfSections--;
 749   } else {
 750     DataDir->VirtualAddress = DebugOffset;
 751     CreateSectionHeader (".debug", DebugOffset, mCoffOffset - DebugOffset,
 752             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 753             | EFI_IMAGE_SCN_MEM_DISCARDABLE
 754             | EFI_IMAGE_SCN_MEM_READ);
 755
 756   }
 757 }
 758
 759 STATIC
 760 VOID
 761 SetImageSize64 (
 762   VOID
 763   )
 764 {
 765   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
 766
 767   //
 768   // Set image size
 769   //
 770   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 771   NtHdr->Pe32Plus.OptionalHeader.SizeOfImage = mCoffOffset;
 772 }
 773
 774 STATIC
 775 VOID
 776 CleanUp64 (
 777   VOID
 778   )
 779 {
 780   if (mCoffSectionsOffset != NULL) {
 781     free (mCoffSectionsOffset);
 782   }
 783 }
 784
 785