BaseTools/Source/C/GenFw/Elf32Convert.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 "Elf32Convert.h"
  36
  37 STATIC
  38 VOID
  39 ScanSections32 (
  40   VOID
  41   );
  42
  43 STATIC
  44 BOOLEAN
  45 WriteSections32 (
  46   SECTION_FILTER_TYPES  FilterType
  47   );
  48
  49 STATIC
  50 VOID
  51 WriteRelocations32 (
  52   VOID
  53   );
  54
  55 STATIC
  56 VOID
  57 WriteDebug32 (
  58   VOID
  59   );
  60
  61 STATIC
  62 VOID
  63 SetImageSize32 (
  64   VOID
  65   );
  66
  67 STATIC
  68 VOID
  69 CleanUp32 (
  70   VOID
  71   );
  72
  73 //
  74 // Rename ELF32 strucutres to common names to help when porting to ELF64.
  75 //
  76 typedef Elf32_Shdr Elf_Shdr;
  77 typedef Elf32_Ehdr Elf_Ehdr;
  78 typedef Elf32_Rel Elf_Rel;
  79 typedef Elf32_Sym Elf_Sym;
  80 typedef Elf32_Phdr Elf_Phdr;
  81 typedef Elf32_Dyn Elf_Dyn;
  82 #define ELFCLASS ELFCLASS32
  83 #define ELF_R_TYPE(r) ELF32_R_TYPE(r)
  84 #define ELF_R_SYM(r) ELF32_R_SYM(r)
  85
  86 //
  87 // Well known ELF structures.
  88 //
  89 STATIC Elf_Ehdr *mEhdr;
  90 STATIC Elf_Shdr *mShdrBase;
  91 STATIC Elf_Phdr *mPhdrBase;
  92
  93 //
  94 // Coff information
  95 //
  96 STATIC const UINT32 mCoffAlignment = 0x20;
  97
  98 //
  99 // PE section alignment.
 100 //
 101 STATIC const UINT16 mCoffNbrSections = 5;
 102
 103 //
 104 // ELF sections to offset in Coff file.
 105 //
 106 STATIC UINT32 *mCoffSectionsOffset = NULL;
 107
 108 //
 109 // Offsets in COFF file
 110 //
 111 STATIC UINT32 mNtHdrOffset;
 112 STATIC UINT32 mTextOffset;
 113 STATIC UINT32 mDataOffset;
 114 STATIC UINT32 mHiiRsrcOffset;
 115 STATIC UINT32 mRelocOffset;
 116
 117 //
 118 // Initialization Function
 119 //
 120 BOOLEAN
 121 InitializeElf32 (
 122   UINT8               *FileBuffer,
 123   ELF_FUNCTION_TABLE  *ElfFunctions
 124   )
 125 {
 126   //
 127   // Initialize data pointer and structures.
 128   //
 129   mEhdr = (Elf_Ehdr*) FileBuffer;
 130
 131   //
 132   // Check the ELF32 specific header information.
 133   //
 134   if (mEhdr->e_ident[EI_CLASS] != ELFCLASS32) {
 135     Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFCLASS32");
 136     return FALSE;
 137   }
 138   if (mEhdr->e_ident[EI_DATA] != ELFDATA2LSB) {
 139     Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");
 140     return FALSE;
 141   }
 142   if ((mEhdr->e_type != ET_EXEC) && (mEhdr->e_type != ET_DYN)) {
 143     Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");
 144     return FALSE;
 145   }
 146   if (!((mEhdr->e_machine == EM_386) || (mEhdr->e_machine == EM_ARM))) {
 147     Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_386 or EM_ARM");
 148     return FALSE;
 149   }
 150   if (mEhdr->e_version != EV_CURRENT) {
 151     Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) mEhdr->e_version, EV_CURRENT);
 152     return FALSE;
 153   }
 154
 155   //
 156   // Update section header pointers
 157   //
 158   mShdrBase  = (Elf_Shdr *)((UINT8 *)mEhdr + mEhdr->e_shoff);
 159   mPhdrBase = (Elf_Phdr *)((UINT8 *)mEhdr + mEhdr->e_phoff);
 160
 161   //
 162   // Create COFF Section offset buffer and zero.
 163   //
 164   mCoffSectionsOffset = (UINT32 *)malloc(mEhdr->e_shnum * sizeof (UINT32));
 165   memset(mCoffSectionsOffset, 0, mEhdr->e_shnum * sizeof(UINT32));
 166
 167   //
 168   // Fill in function pointers.
 169   //
 170   ElfFunctions->ScanSections = ScanSections32;
 171   ElfFunctions->WriteSections = WriteSections32;
 172   ElfFunctions->WriteRelocations = WriteRelocations32;
 173   ElfFunctions->WriteDebug = WriteDebug32;
 174   ElfFunctions->SetImageSize = SetImageSize32;
 175   ElfFunctions->CleanUp = CleanUp32;
 176
 177   return TRUE;
 178 }
 179
 180
 181 //
 182 // Header by Index functions
 183 //
 184 STATIC
 185 Elf_Shdr*
 186 GetShdrByIndex (
 187   UINT32 Num
 188   )
 189 {
 190   if (Num >= mEhdr->e_shnum)
 191     return NULL;
 192   return (Elf_Shdr*)((UINT8*)mShdrBase + Num * mEhdr->e_shentsize);
 193 }
 194
 195 STATIC
 196 Elf_Phdr*
 197 GetPhdrByIndex (
 198   UINT32 num
 199   )
 200 {
 201   if (num >= mEhdr->e_phnum) {
 202     return NULL;
 203   }
 204
 205   return (Elf_Phdr *)((UINT8*)mPhdrBase + num * mEhdr->e_phentsize);
 206 }
 207
 208 STATIC
 209 UINT32
 210 CoffAlign (
 211   UINT32 Offset
 212   )
 213 {
 214   return (Offset + mCoffAlignment - 1) & ~(mCoffAlignment - 1);
 215 }
 216
 217 //
 218 // filter functions
 219 //
 220 STATIC
 221 BOOLEAN
 222 IsTextShdr (
 223   Elf_Shdr *Shdr
 224   )
 225 {
 226   return (BOOLEAN) ((Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC);
 227 }
 228
 229 STATIC
 230 BOOLEAN
 231 IsHiiRsrcShdr (
 232   Elf_Shdr *Shdr
 233   )
 234 {
 235   Elf_Shdr *Namedr = GetShdrByIndex(mEhdr->e_shstrndx);
 236
 237   return (BOOLEAN) (strcmp((CHAR8*)mEhdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0);
 238 }
 239
 240 STATIC
 241 BOOLEAN
 242 IsDataShdr (
 243   Elf_Shdr *Shdr
 244   )
 245 {
 246   if (IsHiiRsrcShdr(Shdr)) {
 247     return FALSE;
 248   }
 249   return (BOOLEAN) (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);
 250 }
 251
 252 //
 253 // Elf functions interface implementation
 254 //
 255
 256 STATIC
 257 VOID
 258 ScanSections32 (
 259   VOID
 260   )
 261 {
 262   UINT32                          i;
 263   EFI_IMAGE_DOS_HEADER            *DosHdr;
 264   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
 265   UINT32                          CoffEntry;
 266
 267   CoffEntry = 0;
 268   mCoffOffset = 0;
 269
 270   //
 271   // Coff file start with a DOS header.
 272   //
 273   mCoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;
 274   mNtHdrOffset = mCoffOffset;
 275   switch (mEhdr->e_machine) {
 276   case EM_386:
 277   case EM_ARM:
 278     mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);
 279   break;
 280   default:
 281     VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)mEhdr->e_machine);
 282     mCoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);
 283   break;
 284   }
 285
 286   mTableOffset = mCoffOffset;
 287   mCoffOffset += mCoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);
 288
 289   //
 290   // First text sections.
 291   //
 292   mCoffOffset = CoffAlign(mCoffOffset);
 293   mTextOffset = mCoffOffset;
 294   for (i = 0; i < mEhdr->e_shnum; i++) {
 295     Elf_Shdr *shdr = GetShdrByIndex(i);
 296     if (IsTextShdr(shdr)) {
 297       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 298         // the alignment field is valid
 299         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 300           // if the section address is aligned we must align PE/COFF
 301           mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
 302         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 303           // ARM RVCT tools have behavior outside of the ELF specification to try
 304           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 305           // then the section needs to preserve sh_addr MOD sh_addralign.
 306           // Normally doing nothing here works great.
 307           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 308         }
 309       }
 310
 311       /* Relocate entry.  */
 312       if ((mEhdr->e_entry >= shdr->sh_addr) &&
 313           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
 314         CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
 315       }
 316       mCoffSectionsOffset[i] = mCoffOffset;
 317       mCoffOffset += shdr->sh_size;
 318     }
 319   }
 320
 321   if (mEhdr->e_machine != EM_ARM) {
 322     mCoffOffset = CoffAlign(mCoffOffset);
 323   }
 324
 325   //
 326   //  Then data sections.
 327   //
 328   mDataOffset = mCoffOffset;
 329   for (i = 0; i < mEhdr->e_shnum; i++) {
 330     Elf_Shdr *shdr = GetShdrByIndex(i);
 331     if (IsDataShdr(shdr)) {
 332       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 333         // the alignment field is valid
 334         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 335           // if the section address is aligned we must align PE/COFF
 336           mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
 337         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 338           // ARM RVCT tools have behavior outside of the ELF specification to try
 339           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 340           // then the section needs to preserve sh_addr MOD sh_addralign.
 341           // Normally doing nothing here works great.
 342           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 343         }
 344       }
 345       mCoffSectionsOffset[i] = mCoffOffset;
 346       mCoffOffset += shdr->sh_size;
 347     }
 348   }
 349   mCoffOffset = CoffAlign(mCoffOffset);
 350
 351   //
 352   //  The HII resource sections.
 353   //
 354   mHiiRsrcOffset = mCoffOffset;
 355   for (i = 0; i < mEhdr->e_shnum; i++) {
 356     Elf_Shdr *shdr = GetShdrByIndex(i);
 357     if (IsHiiRsrcShdr(shdr)) {
 358       if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {
 359         // the alignment field is valid
 360         if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {
 361           // if the section address is aligned we must align PE/COFF
 362           mCoffOffset = (mCoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);
 363         } else if ((shdr->sh_addr % shdr->sh_addralign) != (mCoffOffset % shdr->sh_addralign)) {
 364           // ARM RVCT tools have behavior outside of the ELF specification to try
 365           // and make images smaller.  If sh_addr is not aligned to sh_addralign
 366           // then the section needs to preserve sh_addr MOD sh_addralign.
 367           // Normally doing nothing here works great.
 368           Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");
 369         }
 370       }
 371       if (shdr->sh_size != 0) {
 372         mCoffSectionsOffset[i] = mCoffOffset;
 373         mCoffOffset += shdr->sh_size;
 374         mCoffOffset = CoffAlign(mCoffOffset);
 375         SetHiiResourceHeader ((UINT8*) mEhdr + shdr->sh_offset, mHiiRsrcOffset);
 376       }
 377       break;
 378     }
 379   }
 380
 381   mRelocOffset = mCoffOffset;
 382
 383   //
 384   // Allocate base Coff file.  Will be expanded later for relocations.
 385   //
 386   mCoffFile = (UINT8 *)malloc(mCoffOffset);
 387   memset(mCoffFile, 0, mCoffOffset);
 388
 389   //
 390   // Fill headers.
 391   //
 392   DosHdr = (EFI_IMAGE_DOS_HEADER *)mCoffFile;
 393   DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;
 394   DosHdr->e_lfanew = mNtHdrOffset;
 395
 396   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(mCoffFile + mNtHdrOffset);
 397
 398   NtHdr->Pe32.Signature = EFI_IMAGE_NT_SIGNATURE;
 399
 400   switch (mEhdr->e_machine) {
 401   case EM_386:
 402     NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;
 403     NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 404     break;
 405   case EM_ARM:
 406     NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_ARMT;
 407     NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 408     break;
 409   default:
 410     VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)mEhdr->e_machine);
 411     NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;
 412     NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 413   }
 414
 415   NtHdr->Pe32.FileHeader.NumberOfSections = mCoffNbrSections;
 416   NtHdr->Pe32.FileHeader.TimeDateStamp = (UINT32) time(NULL);
 417   mImageTimeStamp = NtHdr->Pe32.FileHeader.TimeDateStamp;
 418   NtHdr->Pe32.FileHeader.PointerToSymbolTable = 0;
 419   NtHdr->Pe32.FileHeader.NumberOfSymbols = 0;
 420   NtHdr->Pe32.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32.OptionalHeader);
 421   NtHdr->Pe32.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE
 422     | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED
 423     | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED
 424     | EFI_IMAGE_FILE_32BIT_MACHINE;
 425
 426   NtHdr->Pe32.OptionalHeader.SizeOfCode = mDataOffset - mTextOffset;
 427   NtHdr->Pe32.OptionalHeader.SizeOfInitializedData = mRelocOffset - mDataOffset;
 428   NtHdr->Pe32.OptionalHeader.SizeOfUninitializedData = 0;
 429   NtHdr->Pe32.OptionalHeader.AddressOfEntryPoint = CoffEntry;
 430
 431   NtHdr->Pe32.OptionalHeader.BaseOfCode = mTextOffset;
 432
 433   NtHdr->Pe32.OptionalHeader.BaseOfData = mDataOffset;
 434   NtHdr->Pe32.OptionalHeader.ImageBase = 0;
 435   NtHdr->Pe32.OptionalHeader.SectionAlignment = mCoffAlignment;
 436   NtHdr->Pe32.OptionalHeader.FileAlignment = mCoffAlignment;
 437   NtHdr->Pe32.OptionalHeader.SizeOfImage = 0;
 438
 439   NtHdr->Pe32.OptionalHeader.SizeOfHeaders = mTextOffset;
 440   NtHdr->Pe32.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;
 441
 442   //
 443   // Section headers.
 444   //
 445   if ((mDataOffset - mTextOffset) > 0) {
 446     CreateSectionHeader (".text", mTextOffset, mDataOffset - mTextOffset,
 447             EFI_IMAGE_SCN_CNT_CODE
 448             | EFI_IMAGE_SCN_MEM_EXECUTE
 449             | EFI_IMAGE_SCN_MEM_READ);
 450   } else {
 451     // Don't make a section of size 0.
 452     NtHdr->Pe32.FileHeader.NumberOfSections--;
 453   }
 454
 455   if ((mHiiRsrcOffset - mDataOffset) > 0) {
 456     CreateSectionHeader (".data", mDataOffset, mHiiRsrcOffset - mDataOffset,
 457             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 458             | EFI_IMAGE_SCN_MEM_WRITE
 459             | EFI_IMAGE_SCN_MEM_READ);
 460   } else {
 461     // Don't make a section of size 0.
 462     NtHdr->Pe32.FileHeader.NumberOfSections--;
 463   }
 464
 465   if ((mRelocOffset - mHiiRsrcOffset) > 0) {
 466     CreateSectionHeader (".rsrc", mHiiRsrcOffset, mRelocOffset - mHiiRsrcOffset,
 467             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 468             | EFI_IMAGE_SCN_MEM_READ);
 469
 470     NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = mRelocOffset - mHiiRsrcOffset;
 471     NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = mHiiRsrcOffset;
 472   } else {
 473     // Don't make a section of size 0.
 474     NtHdr->Pe32.FileHeader.NumberOfSections--;
 475   }
 476
 477 }
 478
 479 STATIC
 480 BOOLEAN
 481 WriteSections32 (
 482   SECTION_FILTER_TYPES  FilterType
 483   )
 484 {
 485   UINT32      Idx;
 486   Elf_Shdr    *SecShdr;
 487   UINT32      SecOffset;
 488   BOOLEAN     (*Filter)(Elf_Shdr *);
 489
 490   //
 491   // Initialize filter pointer
 492   //
 493   switch (FilterType) {
 494     case SECTION_TEXT:
 495       Filter = IsTextShdr;
 496       break;
 497     case SECTION_HII:
 498       Filter = IsHiiRsrcShdr;
 499       break;
 500     case SECTION_DATA:
 501       Filter = IsDataShdr;
 502       break;
 503     default:
 504       return FALSE;
 505   }
 506
 507   //
 508   // First: copy sections.
 509   //
 510   for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
 511     Elf_Shdr *Shdr = GetShdrByIndex(Idx);
 512     if ((*Filter)(Shdr)) {
 513       switch (Shdr->sh_type) {
 514       case SHT_PROGBITS:
 515         /* Copy.  */
 516         memcpy(mCoffFile + mCoffSectionsOffset[Idx],
 517               (UINT8*)mEhdr + Shdr->sh_offset,
 518               Shdr->sh_size);
 519         break;
 520
 521       case SHT_NOBITS:
 522         memset(mCoffFile + mCoffSectionsOffset[Idx], 0, Shdr->sh_size);
 523         break;
 524
 525       default:
 526         //
 527         //  Ignore for unkown section type.
 528         //
 529         VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);
 530         break;
 531       }
 532     }
 533   }
 534
 535   //
 536   // Second: apply relocations.
 537   //
 538   for (Idx = 0; Idx < mEhdr->e_shnum; Idx++) {
 539     //
 540     // Determine if this is a relocation section.
 541     //
 542     Elf_Shdr *RelShdr = GetShdrByIndex(Idx);
 543     if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {
 544       continue;
 545     }
 546
 547     //
 548     // Relocation section found.  Now extract section information that the relocations
 549     // apply to in the ELF data and the new COFF data.
 550     //
 551     SecShdr = GetShdrByIndex(RelShdr->sh_info);
 552     SecOffset = mCoffSectionsOffset[RelShdr->sh_info];
 553
 554     //
 555     // Only process relocations for the current filter type.
 556     //
 557     if (RelShdr->sh_type == SHT_REL && (*Filter)(SecShdr)) {
 558       UINT32 RelOffset;
 559
 560       //
 561       // Determine the symbol table referenced by the relocation data.
 562       //
 563       Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);
 564       UINT8 *Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
 565
 566       //
 567       // Process all relocation entries for this section.
 568       //
 569       for (RelOffset = 0; RelOffset < RelShdr->sh_size; RelOffset += RelShdr->sh_entsize) {
 570         //
 571         // Set pointer to relocation entry
 572         //
 573         Elf_Rel *Rel = (Elf_Rel *)((UINT8*)mEhdr + RelShdr->sh_offset + RelOffset);
 574
 575         //
 576         // Set pointer to symbol table entry associated with the relocation entry.
 577         //
 578         Elf_Sym *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
 579
 580         Elf_Shdr *SymShdr;
 581         UINT8 *Targ;
 582         UINT16 Address;
 583
 584         //
 585         // Check section header index found in symbol table and get the section
 586         // header location.
 587         //
 588         if (Sym->st_shndx == SHN_UNDEF
 589             || Sym->st_shndx == SHN_ABS
 590             || Sym->st_shndx > mEhdr->e_shnum) {
 591           Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);
 592         }
 593         SymShdr = GetShdrByIndex(Sym->st_shndx);
 594
 595         //
 596         // Convert the relocation data to a pointer into the coff file.
 597         //
 598         // Note:
 599         //   r_offset is the virtual address of the storage unit to be relocated.
 600         //   sh_addr is the virtual address for the base of the section.
 601         //
 602         Targ = mCoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);
 603
 604         //
 605         // Determine how to handle each relocation type based on the machine type.
 606         //
 607         if (mEhdr->e_machine == EM_386) {
 608           switch (ELF_R_TYPE(Rel->r_info)) {
 609           case R_386_NONE:
 610             break;
 611           case R_386_32:
 612             //
 613             // Absolute relocation.
 614             //  Converts Targ from a absolute virtual address to the absolute
 615             //  COFF address.
 616             //
 617             *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr
 618               + mCoffSectionsOffset[Sym->st_shndx];
 619             break;
 620           case R_386_PC32:
 621             //
 622             // Relative relocation: Symbol - Ip + Addend
 623             //
 624             *(UINT32 *)Targ = *(UINT32 *)Targ
 625               + (mCoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)
 626               - (SecOffset - SecShdr->sh_addr);
 627             break;
 628           default:
 629             Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_386 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
 630           }
 631         } else if (mEhdr->e_machine == EM_ARM) {
 632           switch (ELF32_R_TYPE(Rel->r_info)) {
 633           case R_ARM_RBASE:
 634             // No relocation - no action required
 635
 636           case R_ARM_PC24:
 637           case R_ARM_XPC25:
 638           case R_ARM_THM_PC22:
 639           case R_ARM_THM_JUMP19:
 640           case R_ARM_CALL:
 641           case R_ARM_JMP24:
 642             // Thease are all PC-relative relocations and don't require modification
 643             // GCC does not seem to have the concept of a application that just needs to get relocated.
 644             break;
 645
 646           case R_ARM_THM_MOVW_ABS_NC:
 647             // MOVW is only lower 16-bits of the addres
 648             Address = (UINT16)(Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]);
 649             ThumbMovtImmediatePatch ((UINT16 *)Targ, Address);
 650             break;
 651
 652           case R_ARM_THM_MOVT_ABS:
 653             // MOVT is only upper 16-bits of the addres
 654             Address = (UINT16)((Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]) >> 16);
 655             ThumbMovtImmediatePatch ((UINT16 *)Targ, Address);
 656             break;
 657
 658           case R_ARM_ABS32:
 659           case R_ARM_RABS32:
 660             //
 661             // Absolute relocation.
 662             //
 663             *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx];
 664             break;
 665
 666           default:
 667             Error (NULL, 0, 3000, "Invalid", "WriteSections (): %s unsupported ELF EM_ARM relocation 0x%x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));
 668           }
 669         }
 670       }
 671     }
 672   }
 673
 674   return TRUE;
 675 }
 676
 677 STATIC
 678 VOID
 679 WriteRelocations32 (
 680   VOID
 681   )
 682 {
 683   UINT32                           Index;
 684   EFI_IMAGE_OPTIONAL_HEADER_UNION  *NtHdr;
 685   EFI_IMAGE_DATA_DIRECTORY         *Dir;
 686   BOOLEAN                          FoundRelocations;
 687   Elf_Dyn                          *Dyn;
 688   Elf_Rel                          *Rel;
 689   UINTN                            RelElementSize;
 690   UINTN                            RelSize;
 691   UINTN                            RelOffset;
 692   UINTN                            K;
 693   UINT8                            *Targ;
 694   Elf32_Phdr                       *DynamicSegment;
 695   Elf32_Phdr                       *TargetSegment;
 696   Elf_Sym                          *Sym;
 697   Elf_Shdr                         *SymtabShdr;
 698   UINT8                            *Symtab;
 699
 700
 701   for (Index = 0, FoundRelocations = FALSE; Index < mEhdr->e_shnum; Index++) {
 702     Elf_Shdr *RelShdr = GetShdrByIndex(Index);
 703     if ((RelShdr->sh_type == SHT_REL) || (RelShdr->sh_type == SHT_RELA)) {
 704       Elf_Shdr *SecShdr = GetShdrByIndex (RelShdr->sh_info);
 705       if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {
 706         UINT32 RelIdx;
 707
 708         SymtabShdr = GetShdrByIndex (RelShdr->sh_link);
 709         Symtab = (UINT8*)mEhdr + SymtabShdr->sh_offset;
 710         FoundRelocations = TRUE;
 711         for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {
 712           Elf_Rel  *Rel = (Elf_Rel *)((UINT8*)mEhdr + RelShdr->sh_offset + RelIdx);
 713           Elf_Shdr *SymShdr;
 714
 715           Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);
 716           SymShdr = GetShdrByIndex (Sym->st_shndx);
 717
 718           if (mEhdr->e_machine == EM_386) {
 719             switch (ELF_R_TYPE(Rel->r_info)) {
 720             case R_386_NONE:
 721             case R_386_PC32:
 722               //
 723               // No fixup entry required.
 724               //
 725               break;
 726             case R_386_32:
 727               //
 728               // Creates a relative relocation entry from the absolute entry.
 729               //
 730               CoffAddFixup(mCoffSectionsOffset[RelShdr->sh_info]
 731               + (Rel->r_offset - SecShdr->sh_addr),
 732               EFI_IMAGE_REL_BASED_HIGHLOW);
 733               break;
 734             default:
 735               Error (NULL, 0, 3000, "Invalid", "%s unsupported ELF EM_386 relocation 0x%x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));
 736             }
 737           } else if (mEhdr->e_machine == EM_ARM) {
 738             switch (ELF32_R_TYPE(Rel->r_info)) {
 739             case R_ARM_RBASE:
 740               // No relocation - no action required
 741             case R_ARM_PC24:
 742             case R_ARM_XPC25:
 743             case R_ARM_THM_PC22:
 744             case R_ARM_THM_JUMP19:
 745             case R_ARM_CALL:
 746             case R_ARM_JMP24:
 747               // Thease are all PC-relative relocations and don't require modification
 748               break;
 749
 750             case R_ARM_THM_MOVW_ABS_NC:
 751               CoffAddFixup (
 752                 mCoffSectionsOffset[RelShdr->sh_info]
 753                 + (Rel->r_offset - SecShdr->sh_addr),
 754                 EFI_IMAGE_REL_BASED_ARM_THUMB_MOVW
 755                 );
 756               break;
 757
 758             case R_ARM_THM_MOVT_ABS:
 759               CoffAddFixup (
 760                 mCoffSectionsOffset[RelShdr->sh_info]
 761                 + (Rel->r_offset - SecShdr->sh_addr),
 762                 EFI_IMAGE_REL_BASED_ARM_THUMB_MOVT
 763                 );
 764
 765               // The relocation entry needs to contain the lower 16-bits so we can do math
 766               CoffAddFixupEntry ((UINT16)(Sym->st_value - SymShdr->sh_addr + mCoffSectionsOffset[Sym->st_shndx]));
 767               break;
 768
 769             case R_ARM_ABS32:
 770             case R_ARM_RABS32:
 771               CoffAddFixup (
 772                 mCoffSectionsOffset[RelShdr->sh_info]
 773                 + (Rel->r_offset - SecShdr->sh_addr),
 774                 EFI_IMAGE_REL_BASED_HIGHLOW
 775                 );
 776               break;
 777
 778            default:
 779               Error (NULL, 0, 3000, "Invalid", "WriteRelocations(): %s unsupported ELF EM_ARM relocation 0x%x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));
 780             }
 781           } else {
 782             Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) mEhdr->e_machine);
 783           }
 784         }
 785       }
 786     }
 787   }
 788
 789   if (!FoundRelocations && (mEhdr->e_machine == EM_ARM)) {
 790     /* Try again, but look for PT_DYNAMIC instead of SHT_REL */
 791
 792     for (Index = 0; Index < mEhdr->e_phnum; Index++) {
 793       RelElementSize = 0;
 794       RelSize = 0;
 795       RelOffset = 0;
 796
 797       DynamicSegment = GetPhdrByIndex (Index);
 798
 799       if (DynamicSegment->p_type == PT_DYNAMIC) {
 800         Dyn = (Elf32_Dyn *) ((UINT8 *)mEhdr + DynamicSegment->p_offset);
 801
 802         while (Dyn->d_tag != DT_NULL) {
 803           switch (Dyn->d_tag) {
 804             case  DT_REL:
 805               RelOffset = Dyn->d_un.d_val;
 806               break;
 807
 808             case  DT_RELSZ:
 809               RelSize = Dyn->d_un.d_val;
 810               break;
 811
 812             case  DT_RELENT:
 813               RelElementSize = Dyn->d_un.d_val;
 814               break;
 815
 816             default:
 817               break;
 818           }
 819           Dyn++;
 820         }
 821         if (( RelOffset == 0 ) || ( RelSize == 0 ) || ( RelElementSize == 0 )) {
 822           Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations.", mInImageName);
 823         }
 824
 825         for (K = 0; K < RelSize; K += RelElementSize) {
 826
 827           if (DynamicSegment->p_paddr == 0) {
 828             // Older versions of the ARM ELF (SWS ESPC 0003 B-02) specification define DT_REL
 829             // as an offset in the dynamic segment. p_paddr is defined to be zero for ARM tools
 830             Rel = (Elf32_Rel *) ((UINT8 *) mEhdr + DynamicSegment->p_offset + RelOffset + K);
 831           } else {
 832             // This is how it reads in the generic ELF specification
 833             Rel = (Elf32_Rel *) ((UINT8 *) mEhdr + RelOffset + K);
 834           }
 835
 836           switch (ELF32_R_TYPE (Rel->r_info)) {
 837           case  R_ARM_RBASE:
 838             break;
 839
 840           case  R_ARM_RABS32:
 841             TargetSegment = GetPhdrByIndex (ELF32_R_SYM (Rel->r_info) - 1);
 842
 843             // Note: r_offset in a memory address.  Convert it to a pointer in the coff file.
 844             Targ = mCoffFile + mCoffSectionsOffset[ ELF32_R_SYM( Rel->r_info ) ] + Rel->r_offset - TargetSegment->p_vaddr;
 845
 846             *(UINT32 *)Targ = *(UINT32 *)Targ + mCoffSectionsOffset [ELF32_R_SYM( Rel->r_info )];
 847
 848             CoffAddFixup (mCoffSectionsOffset[ELF32_R_SYM (Rel->r_info)] + (Rel->r_offset - TargetSegment->p_vaddr), EFI_IMAGE_REL_BASED_HIGHLOW);
 849             break;
 850
 851           default:
 852             Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations, unkown type %d.", mInImageName, ELF32_R_TYPE (Rel->r_info));
 853             break;
 854           }
 855         }
 856         break;
 857       }
 858     }
 859   }
 860
 861   //
 862   // Pad by adding empty entries.
 863   //
 864   while (mCoffOffset & (mCoffAlignment - 1)) {
 865     CoffAddFixupEntry(0);
 866   }
 867
 868   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 869   Dir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
 870   Dir->Size = mCoffOffset - mRelocOffset;
 871   if (Dir->Size == 0) {
 872     // If no relocations, null out the directory entry and don't add the .reloc section
 873     Dir->VirtualAddress = 0;
 874     NtHdr->Pe32.FileHeader.NumberOfSections--;
 875   } else {
 876     Dir->VirtualAddress = mRelocOffset;
 877     CreateSectionHeader (".reloc", mRelocOffset, mCoffOffset - mRelocOffset,
 878             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 879             | EFI_IMAGE_SCN_MEM_DISCARDABLE
 880             | EFI_IMAGE_SCN_MEM_READ);
 881   }
 882
 883 }
 884
 885 STATIC
 886 VOID
 887 WriteDebug32 (
 888   VOID
 889   )
 890 {
 891   UINT32                              Len;
 892   UINT32                              DebugOffset;
 893   EFI_IMAGE_OPTIONAL_HEADER_UNION     *NtHdr;
 894   EFI_IMAGE_DATA_DIRECTORY            *DataDir;
 895   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY     *Dir;
 896   EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;
 897
 898   Len = strlen(mInImageName) + 1;
 899   DebugOffset = mCoffOffset;
 900
 901   mCoffOffset += sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)
 902     + sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)
 903     + Len;
 904   mCoffOffset = CoffAlign(mCoffOffset);
 905
 906   mCoffFile = realloc(mCoffFile, mCoffOffset);
 907   memset(mCoffFile + DebugOffset, 0, mCoffOffset - DebugOffset);
 908
 909   Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(mCoffFile + DebugOffset);
 910   Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;
 911   Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;
 912   Dir->RVA = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
 913   Dir->FileOffset = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
 914
 915   Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);
 916   Nb10->Signature = CODEVIEW_SIGNATURE_NB10;
 917   strcpy ((char *)(Nb10 + 1), mInImageName);
 918
 919
 920   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 921   DataDir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];
 922   DataDir->VirtualAddress = DebugOffset;
 923   DataDir->Size = mCoffOffset - DebugOffset;
 924   if (DataDir->Size == 0) {
 925     // If no debug, null out the directory entry and don't add the .debug section
 926     DataDir->VirtualAddress = 0;
 927     NtHdr->Pe32.FileHeader.NumberOfSections--;
 928   } else {
 929     DataDir->VirtualAddress = DebugOffset;
 930     CreateSectionHeader (".debug", DebugOffset, mCoffOffset - DebugOffset,
 931             EFI_IMAGE_SCN_CNT_INITIALIZED_DATA
 932             | EFI_IMAGE_SCN_MEM_DISCARDABLE
 933             | EFI_IMAGE_SCN_MEM_READ);
 934
 935   }
 936 }
 937
 938 STATIC
 939 VOID
 940 SetImageSize32 (
 941   VOID
 942   )
 943 {
 944   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
 945
 946   //
 947   // Set image size
 948   //
 949   NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(mCoffFile + mNtHdrOffset);
 950   NtHdr->Pe32.OptionalHeader.SizeOfImage = mCoffOffset;
 951 }
 952
 953 STATIC
 954 VOID
 955 CleanUp32 (
 956   VOID
 957   )
 958 {
 959   if (mCoffSectionsOffset != NULL) {
 960     free (mCoffSectionsOffset);
 961   }
 962 }
 963
 964