Initial import.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524

8 files changed, 1525 insertions, 0 deletions

diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoff.c b/MdePkg/Library/BasePeCoffLib/BasePeCoff.c
new file mode 100644
index 0000000000..c7f3354637
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoff.c
@@ -0,0 +1,1019 @@
+/** @file

+  Tiano PE/COFF loader.

+

+  Copyright (c) 2006, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+  Module Name:  PeCoffLoader.c

+

+**/

+

+

+

+

+STATIC

+RETURN_STATUS

+PeCoffLoaderGetPeHeader (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext,

+  OUT    EFI_IMAGE_NT_HEADERS          *PeHdr,

+  OUT    EFI_TE_IMAGE_HEADER           *TeHdr

+  );

+

+STATIC

+RETURN_STATUS

+PeCoffLoaderCheckImageType (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext,

+  IN     EFI_IMAGE_NT_HEADERS          *PeHdr,

+  IN     EFI_TE_IMAGE_HEADER           *TeHdr

+  );

+

+STATIC

+VOID                            *

+PeCoffLoaderImageAddress (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext,

+  IN     UINTN                         Address

+  );

+

+RETURN_STATUS

+PeCoffLoaderRelocateImageEx (

+  IN UINT16      *Reloc,

+  IN OUT CHAR8   *Fixup,

+  IN OUT CHAR8   **FixupData,

+  IN UINT64      Adjust

+  );

+

+

+

+/**

+  Retrieves the PE or TE Header from a PE/COFF or TE image.

+

+  @param  ImageContext The context of the image being loaded.

+  

+  @param  PeHdr The buffer in which to return the PE header.

+  

+  @param  TeHdr The buffer in which to return the TE header.

+

+  @return

+  RETURN_SUCCESS if the PE or TE Header is read,

+  Otherwise, the error status from reading the PE/COFF or TE image using the ImageRead function.

+

+**/

+STATIC

+RETURN_STATUS

+PeCoffLoaderGetPeHeader (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext,

+  OUT    EFI_IMAGE_NT_HEADERS          *PeHdr,

+  OUT    EFI_TE_IMAGE_HEADER           *TeHdr

+  )

+{

+  RETURN_STATUS            Status;

+  EFI_IMAGE_DOS_HEADER  DosHdr;

+  UINTN                 Size;

+

+  ImageContext->IsTeImage = FALSE;

+  //

+  // Read the DOS image headers

+  //

+  Size = sizeof (EFI_IMAGE_DOS_HEADER);

+  Status = ImageContext->ImageRead (

+                          ImageContext->Handle,

+                          0,

+                          &Size,

+                          &DosHdr

+                          );

+  if (RETURN_ERROR (Status)) {

+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+    return Status;

+  }

+

+  ImageContext->PeCoffHeaderOffset = 0;

+  if (DosHdr.e_magic == EFI_IMAGE_DOS_SIGNATURE) {

+    //

+    // DOS image header is present, so read the PE header after the DOS image header

+    //

+    ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew;

+  }

+  //

+  // Read the PE/COFF Header

+  //

+  Size = sizeof (EFI_IMAGE_NT_HEADERS);

+  Status = ImageContext->ImageRead (

+                          ImageContext->Handle,

+                          ImageContext->PeCoffHeaderOffset,

+                          &Size,

+                          PeHdr

+                          );

+  if (RETURN_ERROR (Status)) {

+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+    return Status;

+  }

+  //

+  // Check the PE/COFF Header Signature. If not, then try to read a TE header

+  //

+  if (PeHdr->Signature != EFI_IMAGE_NT_SIGNATURE) {

+    Size = sizeof (EFI_TE_IMAGE_HEADER);

+    Status = ImageContext->ImageRead (

+                            ImageContext->Handle,

+                            0,

+                            &Size,

+                            TeHdr

+                            );

+    if (TeHdr->Signature != EFI_TE_IMAGE_HEADER_SIGNATURE) {

+      return RETURN_UNSUPPORTED;

+    }

+

+    ImageContext->IsTeImage = TRUE;

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Checks the PE or TE header of a PE/COFF or TE image to determine if it supported.

+

+  @param  ImageContext The context of the image being loaded.

+  

+  @param  PeHdr The buffer in which to return the PE header.

+  

+  @param  TeHdr The buffer in which to return the TE header.

+

+  @retval RETURN_SUCCESS if the PE/COFF or TE image is supported

+  @retval RETURN_UNSUPPORTED of the PE/COFF or TE image is not supported.

+

+**/

+STATIC

+RETURN_STATUS

+PeCoffLoaderCheckImageType (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,

+  IN     EFI_IMAGE_NT_HEADERS                  *PeHdr,

+  IN     EFI_TE_IMAGE_HEADER                   *TeHdr

+  )

+{

+  //

+  // See if the machine type is supported.  We support a native machine type (IA-32/Itanium-based)

+  // and the machine type for the Virtual Machine.

+  //

+  if (ImageContext->IsTeImage == FALSE) {

+    ImageContext->Machine = PeHdr->FileHeader.Machine;

+  } else {

+    ImageContext->Machine = TeHdr->Machine;

+  }

+

+  if (!(EFI_IMAGE_MACHINE_TYPE_SUPPORTED (ImageContext->Machine))) {

+    ImageContext->ImageError = IMAGE_ERROR_INVALID_MACHINE_TYPE;

+    return RETURN_UNSUPPORTED;

+  }

+

+  //

+  // See if the image type is supported.  We support EFI Applications,

+  // EFI Boot Service Drivers, and EFI Runtime Drivers.

+  //

+  if (ImageContext->IsTeImage == FALSE) {

+    ImageContext->ImageType = PeHdr->OptionalHeader.Subsystem;

+  } else {

+    ImageContext->ImageType = (UINT16) (TeHdr->Subsystem);

+  }

+

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Retrieves information on a PE/COFF image.

+

+  @param  This Calling context

+  @param  ImageContext The context of the image being loaded

+

+  @retval  RETURN_SUCCESS The information on the PE/COFF image was collected.

+  @retval  RETURN_INVALID_PARAMETER ImageContext is NULL.

+  @retval  RETURN_UNSUPPORTED The PE/COFF image is not supported.

+  @retval  Otherwise The error status from reading the PE/COFF image using the

+  ImageContext->ImageRead() function

+

+**/

+RETURN_STATUS

+EFIAPI

+PeCoffLoaderGetImageInfo (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT           *ImageContext

+  )

+{

+  RETURN_STATUS                      Status;

+  EFI_IMAGE_NT_HEADERS            PeHdr;

+  EFI_TE_IMAGE_HEADER             TeHdr;

+  EFI_IMAGE_DATA_DIRECTORY        *DebugDirectoryEntry;

+  UINTN                           Size;

+  UINTN                           Index;

+  UINTN                           DebugDirectoryEntryRva;

+  UINTN                           DebugDirectoryEntryFileOffset;

+  UINTN                           SectionHeaderOffset;

+  EFI_IMAGE_SECTION_HEADER        SectionHeader;

+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry;

+

+  if (NULL == ImageContext) {

+    return RETURN_INVALID_PARAMETER;

+  }

+  //

+  // Assume success

+  //

+  ImageContext->ImageError  = IMAGE_ERROR_SUCCESS;

+

+  Status                    = PeCoffLoaderGetPeHeader (ImageContext, &PeHdr, &TeHdr);

+  if (RETURN_ERROR (Status)) {

+    return Status;

+  }

+  //

+  // Verify machine type

+  //

+  Status = PeCoffLoaderCheckImageType (ImageContext, &PeHdr, &TeHdr);

+  if (RETURN_ERROR (Status)) {

+    return Status;

+  }

+  //

+  // Retrieve the base address of the image

+  //

+  if (!(ImageContext->IsTeImage)) {

+    ImageContext->ImageAddress = PeHdr.OptionalHeader.ImageBase;

+  } else {

+    ImageContext->ImageAddress = (PHYSICAL_ADDRESS) (TeHdr.ImageBase);

+  }

+  //

+  // Initialize the alternate destination address to 0 indicating that it

+  // should not be used.

+  //

+  ImageContext->DestinationAddress = 0;

+

+  //

+  // Initialize the codeview pointer.

+  //

+  ImageContext->CodeView    = NULL;

+  ImageContext->PdbPointer  = NULL;

+

+  //

+  // Three cases with regards to relocations:

+  // - Image has base relocs, RELOCS_STRIPPED==0    => image is relocatable

+  // - Image has no base relocs, RELOCS_STRIPPED==1 => Image is not relocatable

+  // - Image has no base relocs, RELOCS_STRIPPED==0 => Image is relocatable but

+  //   has no base relocs to apply

+  // Obviously having base relocations with RELOCS_STRIPPED==1 is invalid.

+  //

+  // Look at the file header to determine if relocations have been stripped, and

+  // save this info in the image context for later use.

+  //

+  if ((!(ImageContext->IsTeImage)) && ((PeHdr.FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) != 0)) {

+    ImageContext->RelocationsStripped = TRUE;

+  } else {

+    ImageContext->RelocationsStripped = FALSE;

+  }

+

+  if (!(ImageContext->IsTeImage)) {

+    ImageContext->ImageSize         = (UINT64) PeHdr.OptionalHeader.SizeOfImage;

+    ImageContext->SectionAlignment  = PeHdr.OptionalHeader.SectionAlignment;

+    ImageContext->SizeOfHeaders     = PeHdr.OptionalHeader.SizeOfHeaders;

+

+    //

+    // Modify ImageSize to contain .PDB file name if required and initialize

+    // PdbRVA field...

+    //

+    if (PeHdr.OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {

+      DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(PeHdr.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);

+

+      DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress;

+

+      //

+      // Determine the file offset of the debug directory...  This means we walk

+      // the sections to find which section contains the RVA of the debug

+      // directory

+      //

+      DebugDirectoryEntryFileOffset = 0;

+

+      SectionHeaderOffset = (UINTN)(

+                               ImageContext->PeCoffHeaderOffset +

+                               sizeof (UINT32) + 

+                               sizeof (EFI_IMAGE_FILE_HEADER) + 

+                               PeHdr.FileHeader.SizeOfOptionalHeader

+                               );

+

+      for (Index = 0; Index < PeHdr.FileHeader.NumberOfSections; Index++) {

+        //

+        // Read section header from file

+        //

+        Size = sizeof (EFI_IMAGE_SECTION_HEADER);

+        Status = ImageContext->ImageRead (

+                                 ImageContext->Handle,

+                                 SectionHeaderOffset,

+                                 &Size,

+                                 &SectionHeader

+                                 );

+        if (RETURN_ERROR (Status)) {

+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+          return Status;

+        }

+

+        if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&

+            DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {

+            DebugDirectoryEntryFileOffset =

+            DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData;

+          break;

+        }

+

+        SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);

+      }

+

+      if (DebugDirectoryEntryFileOffset != 0) {

+        for (Index = 0; Index < DebugDirectoryEntry->Size; Index++) {

+          //

+          // Read next debug directory entry

+          //

+          Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);

+          Status = ImageContext->ImageRead (

+                                   ImageContext->Handle,

+                                   DebugDirectoryEntryFileOffset,

+                                   &Size,

+                                   &DebugEntry

+                                   );

+          if (RETURN_ERROR (Status)) {

+            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+            return Status;

+          }

+

+          if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {

+            ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY));

+            if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) {

+              ImageContext->ImageSize += DebugEntry.SizeOfData;

+            }

+

+            return RETURN_SUCCESS;

+          }

+        }

+      }

+    }

+  } else {

+    ImageContext->ImageSize         = 0;

+    ImageContext->SectionAlignment  = 4096;

+    ImageContext->SizeOfHeaders     = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN) TeHdr.BaseOfCode - (UINTN) TeHdr.StrippedSize;

+

+    DebugDirectoryEntry             = &TeHdr.DataDirectory[1];

+    DebugDirectoryEntryRva          = DebugDirectoryEntry->VirtualAddress;

+    SectionHeaderOffset             = (UINTN) (sizeof (EFI_TE_IMAGE_HEADER));

+

+    DebugDirectoryEntryFileOffset   = 0;

+

+    for (Index = 0; Index < TeHdr.NumberOfSections;) {

+      //

+      // Read section header from file

+      //

+      Size = sizeof (EFI_IMAGE_SECTION_HEADER);

+      Status = ImageContext->ImageRead (

+                               ImageContext->Handle,

+                               SectionHeaderOffset,

+                               &Size,

+                               &SectionHeader

+                               );

+      if (RETURN_ERROR (Status)) {

+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+        return Status;

+      }

+

+      if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&

+          DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {

+        DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva -

+          SectionHeader.VirtualAddress +

+          SectionHeader.PointerToRawData +

+          sizeof (EFI_TE_IMAGE_HEADER) -

+          TeHdr.StrippedSize;

+

+        //

+        // File offset of the debug directory was found, if this is not the last

+        // section, then skip to the last section for calculating the image size.

+        //

+        if (Index < (UINTN) TeHdr.NumberOfSections - 1) {

+          SectionHeaderOffset += (TeHdr.NumberOfSections - 1 - Index) * sizeof (EFI_IMAGE_SECTION_HEADER);

+          Index = TeHdr.NumberOfSections - 1;

+          continue;

+        }

+      }

+

+      //

+      // In Te image header there is not a field to describe the ImageSize.

+      // Actually, the ImageSize equals the RVA plus the VirtualSize of 

+      // the last section mapped into memory (Must be rounded up to 

+      // a mulitple of Section Alignment). Per the PE/COFF specification, the

+      // section headers in the Section Table must appear in order of the RVA

+      // values for the corresponding sections. So the ImageSize can be determined

+      // by the RVA and the VirtualSize of the last section header in the

+      // Section Table.

+      //

+      if ((++Index) == (UINTN) TeHdr.NumberOfSections) {

+        ImageContext->ImageSize = (SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize +

+                                   ImageContext->SectionAlignment - 1) & ~(ImageContext->SectionAlignment - 1);

+      }

+

+      SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);

+    }

+

+    if (DebugDirectoryEntryFileOffset != 0) {

+      for (Index = 0; Index < DebugDirectoryEntry->Size; Index++) {

+        //

+        // Read next debug directory entry

+        //

+        Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);

+        Status = ImageContext->ImageRead (

+                                 ImageContext->Handle,

+                                 DebugDirectoryEntryFileOffset,

+                                 &Size,

+                                 &DebugEntry

+                                 );

+        if (RETURN_ERROR (Status)) {

+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+          return Status;

+        }

+

+        if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {

+          ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY));

+          return RETURN_SUCCESS;

+        }

+      }

+    }

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Converts an image address to the loaded address.

+

+  @param  ImageContext The context of the image being loaded.

+  

+  @param  Address The address to be converted to the loaded address.

+

+  @return NULL if the address can not be converted, otherwise, the converted address

+

+**/

+STATIC

+VOID *

+PeCoffLoaderImageAddress (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,

+  IN     UINTN                                 Address

+  )

+{

+  if (Address >= ImageContext->ImageSize) {

+    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;

+    return NULL;

+  }

+

+  return (CHAR8 *) ((UINTN) ImageContext->ImageAddress + Address);

+}

+

+/**

+  Relocates a PE/COFF image in memory.

+

+  @param  This Calling context.

+  

+  @param  ImageContext Contains information on the loaded image to relocate.

+

+  @retval RETURN_SUCCESS      if the PE/COFF image was relocated.

+  @retval RETURN_LOAD_ERROR   if the image is not a valid PE/COFF image.

+  @retval RETURN_UNSUPPORTED  not support.

+

+**/

+RETURN_STATUS

+EFIAPI

+PeCoffLoaderRelocateImage (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext

+  )

+{

+  RETURN_STATUS             Status;

+  EFI_IMAGE_NT_HEADERS      *PeHdr;

+  EFI_TE_IMAGE_HEADER       *TeHdr;

+  EFI_IMAGE_DATA_DIRECTORY  *RelocDir;

+  UINT64                    Adjust;

+  EFI_IMAGE_BASE_RELOCATION *RelocBase;

+  EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd;

+  UINT16                    *Reloc;

+  UINT16                    *RelocEnd;

+  CHAR8                     *Fixup;

+  CHAR8                     *FixupBase;

+  UINT16                    *F16;

+  UINT32                    *F32;

+  CHAR8                     *FixupData;

+  PHYSICAL_ADDRESS          BaseAddress;

+

+  PeHdr = NULL;

+  TeHdr = NULL;

+  //

+  // Assume success

+  //

+  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;

+

+  //

+  // If there are no relocation entries, then we are done

+  //

+  if (ImageContext->RelocationsStripped) {

+    return RETURN_SUCCESS;

+  }

+

+  //

+  // If the destination address is not 0, use that rather than the

+  // image address as the relocation target.

+  //

+  if (ImageContext->DestinationAddress) {

+    BaseAddress = ImageContext->DestinationAddress;

+  } else {

+    BaseAddress = ImageContext->ImageAddress;

+  }

+

+  if (!(ImageContext->IsTeImage)) {

+    PeHdr = (EFI_IMAGE_NT_HEADERS *)((UINTN)ImageContext->ImageAddress + 

+                                            ImageContext->PeCoffHeaderOffset);

+    Adjust = (UINT64) BaseAddress - PeHdr->OptionalHeader.ImageBase;

+    PeHdr->OptionalHeader.ImageBase = (UINTN)BaseAddress;

+

+    //

+    // Find the relocation block

+    //

+    // Per the PE/COFF spec, you can't assume that a given data directory

+    // is present in the image. You have to check the NumberOfRvaAndSizes in

+    // the optional header to verify a desired directory entry is there.

+    //

+    if (PeHdr->OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {

+      RelocDir  = &PeHdr->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];

+      RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress);

+      RelocBaseEnd = PeCoffLoaderImageAddress (

+                      ImageContext,

+                      RelocDir->VirtualAddress + RelocDir->Size - 1

+                      );

+    } else {

+      //

+      // Set base and end to bypass processing below.

+      //

+      RelocBase = RelocBaseEnd = 0;

+    }

+  } else {

+    TeHdr             = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress);

+    Adjust            = (UINT64) (BaseAddress - TeHdr->ImageBase);

+    TeHdr->ImageBase  = (UINT64) (BaseAddress);

+

+    //

+    // Find the relocation block

+    //

+    RelocDir = &TeHdr->DataDirectory[0];

+    RelocBase = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)(

+		                                ImageContext->ImageAddress + 

+		                                RelocDir->VirtualAddress +

+		                                sizeof(EFI_TE_IMAGE_HEADER) - 

+		                                TeHdr->StrippedSize

+		                                );

+    RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *) ((UINTN) RelocBase + (UINTN) RelocDir->Size - 1);

+  }

+  

+  //

+  // Run the relocation information and apply the fixups

+  //

+  FixupData = ImageContext->FixupData;

+  while (RelocBase < RelocBaseEnd) {

+

+    Reloc     = (UINT16 *) ((CHAR8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION));

+    RelocEnd  = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock);

+    if (!(ImageContext->IsTeImage)) {

+      FixupBase = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress);

+    } else {

+      FixupBase = (CHAR8 *)(UINTN)(ImageContext->ImageAddress +

+	  	              RelocBase->VirtualAddress +

+	  	              sizeof(EFI_TE_IMAGE_HEADER) - 

+	  	              TeHdr->StrippedSize

+	  	              );

+    }

+

+    if ((CHAR8 *) RelocEnd < (CHAR8 *) ((UINTN) ImageContext->ImageAddress) ||

+        (CHAR8 *) RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress + 

+          (UINTN)ImageContext->ImageSize)) {

+      ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;

+      return RETURN_LOAD_ERROR;

+    }

+

+    //

+    // Run this relocation record

+    //

+    while (Reloc < RelocEnd) {

+

+      Fixup = FixupBase + (*Reloc & 0xFFF);

+      switch ((*Reloc) >> 12) {

+      case EFI_IMAGE_REL_BASED_ABSOLUTE:

+        break;

+

+      case EFI_IMAGE_REL_BASED_HIGH:

+        F16   = (UINT16 *) Fixup;

+        *F16  = (UINT16) ((*F16 << 16) + (UINT16) Adjust);

+        if (FixupData != NULL) {

+          *(UINT16 *) FixupData = *F16;

+          FixupData             = FixupData + sizeof (UINT16);

+        }

+        break;

+

+      case EFI_IMAGE_REL_BASED_LOW:

+        F16   = (UINT16 *) Fixup;

+        *F16  = (UINT16) (*F16 + (UINT16) Adjust);

+        if (FixupData != NULL) {

+          *(UINT16 *) FixupData = *F16;

+          FixupData             = FixupData + sizeof (UINT16);

+        }

+        break;

+

+      case EFI_IMAGE_REL_BASED_HIGHLOW:

+        F32   = (UINT32 *) Fixup;

+        *F32  = *F32 + (UINT32) Adjust;

+        if (FixupData != NULL) {

+          FixupData             = ALIGN_POINTER (FixupData, sizeof (UINT32));

+          *(UINT32 *) FixupData = *F32;

+          FixupData             = FixupData + sizeof (UINT32);

+        }

+        break;

+

+      case EFI_IMAGE_REL_BASED_HIGHADJ:

+        //

+        // Return the same EFI_UNSUPPORTED return code as

+        // PeCoffLoaderRelocateImageEx() returns if it does not recognize

+        // the relocation type.

+        //

+        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;

+        return RETURN_UNSUPPORTED;

+

+      default:

+        Status = PeCoffLoaderRelocateImageEx (Reloc, Fixup, &FixupData, Adjust);

+        if (RETURN_ERROR (Status)) {

+          ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;

+          return Status;

+        }

+      }

+

+      //

+      // Next relocation record

+      //

+      Reloc += 1;

+    }

+

+    //

+    // Next reloc block

+    //

+    RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;

+  }

+

+  return RETURN_SUCCESS;

+}

+

+/**

+  Loads a PE/COFF image into memory.

+

+  @param  This Calling context.

+  

+  @param  ImageContext Contains information on image to load into memory.

+

+  @retval RETURN_SUCCESS            if the PE/COFF image was loaded.

+  @retval RETURN_BUFFER_TOO_SMALL   if the caller did not provide a large enough buffer.

+  @retval RETURN_LOAD_ERROR         if the image is a runtime driver with no relocations.

+  @retval RETURN_INVALID_PARAMETER  if the image address is invalid.

+

+**/

+RETURN_STATUS

+EFIAPI

+PeCoffLoaderLoadImage (

+  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext

+  )

+{

+  RETURN_STATUS                            Status;

+  EFI_IMAGE_NT_HEADERS                  *PeHdr;

+  EFI_TE_IMAGE_HEADER                   *TeHdr;

+  PE_COFF_LOADER_IMAGE_CONTEXT  CheckContext;

+  EFI_IMAGE_SECTION_HEADER              *FirstSection;

+  EFI_IMAGE_SECTION_HEADER              *Section;

+  UINTN                                 NumberOfSections;

+  UINTN                                 Index;

+  CHAR8                                 *Base;

+  CHAR8                                 *End;

+  CHAR8                                 *MaxEnd;

+  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;

+  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;

+  UINTN                                 Size;

+  UINT32                                TempDebugEntryRva;

+

+  PeHdr = NULL;

+  TeHdr = NULL;

+  //

+  // Assume success

+  //

+  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;

+

+  //

+  // Copy the provided context info into our local version, get what we

+  // can from the original image, and then use that to make sure everything

+  // is legit.

+  //

+  CopyMem (&CheckContext, ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));

+

+  Status = PeCoffLoaderGetImageInfo (&CheckContext);

+  if (RETURN_ERROR (Status)) {

+    return Status;

+  }

+

+  //

+  // Make sure there is enough allocated space for the image being loaded

+  //

+  if (ImageContext->ImageSize < CheckContext.ImageSize) {

+    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_SIZE;

+    return RETURN_BUFFER_TOO_SMALL;

+  }

+

+  //

+  // If there's no relocations, then make sure it's not a runtime driver,

+  // and that it's being loaded at the linked address.

+  //

+  if (CheckContext.RelocationsStripped) {

+    //

+    // If the image does not contain relocations and it is a runtime driver

+    // then return an error.

+    //

+    if (CheckContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {

+      ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;

+      return RETURN_LOAD_ERROR;

+    }

+    //

+    // If the image does not contain relocations, and the requested load address

+    // is not the linked address, then return an error.

+    //

+    if (CheckContext.ImageAddress != ImageContext->ImageAddress) {

+      ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;

+      return RETURN_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Make sure the allocated space has the proper section alignment

+  //

+  if (!(ImageContext->IsTeImage)) {

+    if ((ImageContext->ImageAddress & (CheckContext.SectionAlignment - 1)) != 0) {

+      ImageContext->ImageError = IMAGE_ERROR_INVALID_SECTION_ALIGNMENT;

+      return RETURN_INVALID_PARAMETER;

+    }

+  }

+  //

+  // Read the entire PE/COFF or TE header into memory

+  //

+  if (!(ImageContext->IsTeImage)) {

+    Status = ImageContext->ImageRead (

+                            ImageContext->Handle,

+                            0,

+                            &ImageContext->SizeOfHeaders,

+                            (VOID *) (UINTN) ImageContext->ImageAddress

+                            );

+

+    PeHdr = (EFI_IMAGE_NT_HEADERS *)

+      ((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset);

+

+    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (

+                      (UINTN)ImageContext->ImageAddress +

+                      ImageContext->PeCoffHeaderOffset +

+                      sizeof(UINT32) + 

+                      sizeof(EFI_IMAGE_FILE_HEADER) + 

+                      PeHdr->FileHeader.SizeOfOptionalHeader

+      );

+    NumberOfSections = (UINTN) (PeHdr->FileHeader.NumberOfSections);

+  } else {

+    Status = ImageContext->ImageRead (

+                            ImageContext->Handle,

+                            0,

+                            &ImageContext->SizeOfHeaders,

+                            (void *) (UINTN) ImageContext->ImageAddress

+                            );

+

+    TeHdr             = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress);

+

+    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (

+		      (UINTN)ImageContext->ImageAddress +

+		      sizeof(EFI_TE_IMAGE_HEADER)

+		      );

+    NumberOfSections  = (UINTN) (TeHdr->NumberOfSections);

+

+  }

+

+  if (RETURN_ERROR (Status)) {

+    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+    return RETURN_LOAD_ERROR;

+  }

+

+  //

+  // Load each section of the image

+  //

+  Section = FirstSection;

+  for (Index = 0, MaxEnd = NULL; Index < NumberOfSections; Index++) {

+

+    //

+    // Compute sections address

+    //

+    Base = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress);

+    End = PeCoffLoaderImageAddress (

+            ImageContext,

+            Section->VirtualAddress + Section->Misc.VirtualSize - 1

+            );

+    if (ImageContext->IsTeImage) {

+      Base  = (CHAR8 *) ((UINTN) Base + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize);

+      End   = (CHAR8 *) ((UINTN) End + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize);

+    }

+

+    if (End > MaxEnd) {

+      MaxEnd = End;

+    }

+    //

+    // If the base start or end address resolved to 0, then fail.

+    //

+    if ((Base == NULL) || (End == NULL)) {

+      ImageContext->ImageError = IMAGE_ERROR_SECTION_NOT_LOADED;

+      return RETURN_LOAD_ERROR;

+    }

+

+    //

+    // Read the section

+    //

+    Size = (UINTN) Section->Misc.VirtualSize;

+    if ((Size == 0) || (Size > Section->SizeOfRawData)) {

+      Size = (UINTN) Section->SizeOfRawData;

+    }

+

+    if (Section->SizeOfRawData) {

+      if (!(ImageContext->IsTeImage)) {

+        Status = ImageContext->ImageRead (

+                                ImageContext->Handle,

+                                Section->PointerToRawData,

+                                &Size,

+                                Base

+                                );

+      } else {

+        Status = ImageContext->ImageRead (

+                                ImageContext->Handle,

+                                Section->PointerToRawData + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize,

+                                &Size,

+                                Base

+                                );

+      }

+

+      if (RETURN_ERROR (Status)) {

+        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+        return Status;

+      }

+    }

+

+    //

+    // If raw size is less then virt size, zero fill the remaining

+    //

+

+    if (Size < Section->Misc.VirtualSize) {

+      ZeroMem (Base + Size, Section->Misc.VirtualSize - Size);

+    }

+

+    //

+    // Next Section

+    //

+    Section += 1;

+  }

+

+  //

+  // Get image's entry point

+  //

+  if (!(ImageContext->IsTeImage)) {

+    ImageContext->EntryPoint = (PHYSICAL_ADDRESS) (UINTN) PeCoffLoaderImageAddress (

+                                                                ImageContext,

+                                                                PeHdr->OptionalHeader.AddressOfEntryPoint

+                                                                );

+  } else {

+    ImageContext->EntryPoint =  (PHYSICAL_ADDRESS) (

+		                   (UINTN)ImageContext->ImageAddress +

+		                   (UINTN)TeHdr->AddressOfEntryPoint +

+		                   (UINTN)sizeof(EFI_TE_IMAGE_HEADER) -

+          (UINTN) TeHdr->StrippedSize

+      );

+  }

+

+  //

+  // Determine the size of the fixup data

+  //

+  // Per the PE/COFF spec, you can't assume that a given data directory

+  // is present in the image. You have to check the NumberOfRvaAndSizes in

+  // the optional header to verify a desired directory entry is there.

+  //

+  if (!(ImageContext->IsTeImage)) {

+    if (PeHdr->OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {

+      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)

+        &PeHdr->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];

+      ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN);

+    } else {

+      ImageContext->FixupDataSize = 0;

+    }

+  } else {

+    DirectoryEntry              = &TeHdr->DataDirectory[0];

+    ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN);

+  }

+  //

+  // Consumer must allocate a buffer for the relocation fixup log.

+  // Only used for runtime drivers.

+  //

+  ImageContext->FixupData = NULL;

+

+  //

+  // Load the Codeview info if present

+  //

+  if (ImageContext->DebugDirectoryEntryRva != 0) {

+    if (!(ImageContext->IsTeImage)) {

+      DebugEntry = PeCoffLoaderImageAddress (

+                    ImageContext,

+                    ImageContext->DebugDirectoryEntryRva

+                    );

+    } else {

+      DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)(UINTN)(

+	  	                                         ImageContext->ImageAddress +

+	  	                                         ImageContext->DebugDirectoryEntryRva +

+	  	                                         sizeof(EFI_TE_IMAGE_HEADER) -

+	  	                                         TeHdr->StrippedSize

+	  	                                         );

+    }

+

+    if (DebugEntry != NULL) {

+      TempDebugEntryRva = DebugEntry->RVA;

+      if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) {

+        Section--;

+        if ((UINTN) Section->SizeOfRawData < Section->Misc.VirtualSize) {

+          TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize;

+        } else {

+          TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData;

+        }

+      }

+

+      if (TempDebugEntryRva != 0) {

+        if (!(ImageContext->IsTeImage)) {

+          ImageContext->CodeView = PeCoffLoaderImageAddress (ImageContext, TempDebugEntryRva);

+        } else {

+          ImageContext->CodeView = (VOID *)(

+		  	              (UINTN)ImageContext->ImageAddress +

+		  	              (UINTN)TempDebugEntryRva +

+		  	              (UINTN)sizeof(EFI_TE_IMAGE_HEADER) -

+                (UINTN) TeHdr->StrippedSize

+            );

+        }

+

+        if (ImageContext->CodeView == NULL) {

+          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+          return RETURN_LOAD_ERROR;

+        }

+

+        if (DebugEntry->RVA == 0) {

+          Size = DebugEntry->SizeOfData;

+          if (!(ImageContext->IsTeImage)) {

+            Status = ImageContext->ImageRead (

+                                    ImageContext->Handle,

+                                    DebugEntry->FileOffset,

+                                    &Size,

+                                    ImageContext->CodeView

+                                    );

+          } else {

+            Status = ImageContext->ImageRead (

+                                    ImageContext->Handle,

+                                    DebugEntry->FileOffset + sizeof (EFI_TE_IMAGE_HEADER) - TeHdr->StrippedSize,

+                                    &Size,

+                                    ImageContext->CodeView

+                                    );

+            //

+            // Should we apply fix up to this field according to the size difference between PE and TE?

+            // Because now we maintain TE header fields unfixed, this field will also remain as they are

+            // in original PE image.

+            //

+          }

+

+          if (RETURN_ERROR (Status)) {

+            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;

+            return RETURN_LOAD_ERROR;

+          }

+

+          DebugEntry->RVA = TempDebugEntryRva;

+        }

+

+        switch (*(UINT32 *) ImageContext->CodeView) {

+        case CODEVIEW_SIGNATURE_NB10:

+          ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY);

+          break;

+

+        case CODEVIEW_SIGNATURE_RSDS:

+          ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY);

+          break;

+

+        default:

+          break;

+        }

+      }

+    }

+  }

+

+  return Status;

+}

diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.mbd b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.mbd
new file mode 100644
index 0000000000..7e8def950d
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.mbd
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+Copyright (c) 2006, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+-->

+<LibraryModuleBuildDescription xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0  http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">

+  <MbdLibHeader>

+    <BaseName>BasePeCoffLib</BaseName>

+    <Guid>556f5d10-7309-4af4-b80a-8196bd60946f</Guid>

+    <Version>0</Version>

+    <Description>FIX ME!</Description>

+    <Copyright>Copyright (c) 2004 - 2005, Intel Corporation</Copyright>

+    <License>

+      All rights reserved. This program and the accompanying materials

+      are licensed and made available under the terms and conditions of the BSD License

+      which accompanies this distribution.  The full text of the license may be found at

+      http://opensource.org/licenses/bsd-license.php

+      THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+      WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+    </License>

+    <Created>2006-03-09 23:16</Created>

+    <Modified>2006-03-19 15:17</Modified>

+  </MbdLibHeader>

+</LibraryModuleBuildDescription>

diff --git a/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.msa b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.msa
new file mode 100644
index 0000000000..534558c7fa
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/BasePeCoffLib.msa
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="UTF-8"?>

+<!--

+Copyright (c) 2006, Intel Corporation

+All rights reserved. This program and the accompanying materials

+are licensed and made available under the terms and conditions of the BSD License

+which accompanies this distribution.  The full text of the license may be found at

+http://opensource.org/licenses/bsd-license.php

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+-->

+<LibraryModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0  http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">

+  <MsaLibHeader>

+    <BaseName>BasePeCoffLib</BaseName>

+    <ModuleType>BASE</ModuleType>

+    <ComponentType>LIBRARY</ComponentType>

+    <Guid>556f5d10-7309-4af4-b80a-8196bd60946f</Guid>

+    <Version>0</Version>

+    <Abstract>Component description file for the PEI library.</Abstract>

+    <Description>FIX ME!</Description>

+    <Copyright>Copyright (c) 2004 - 2005, Intel Corporation</Copyright>

+    <License>

+      All rights reserved. This program and the accompanying materials

+      are licensed and made available under the terms and conditions of the BSD License

+      which accompanies this distribution.  The full text of the license may be found at

+      http://opensource.org/licenses/bsd-license.php

+      THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+      WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+    </License>

+    <Specification>0</Specification>

+    <Created>2006-03-09 23:16</Created>

+    <Updated>2006-03-19 15:17</Updated>

+  </MsaLibHeader>

+  <LibraryClassDefinitions>

+    <LibraryClass Usage="ALWAYS_PRODUCED">PeCoffLib</LibraryClass>

+    <LibraryClass Usage="ALWAYS_CONSUMED">BaseMemoryLib</LibraryClass>

+  </LibraryClassDefinitions>

+  <SourceFiles>

+    <Filename>BasePeCoff.c</Filename>

+    <Arch ArchType="IA32">

+      <Filename>ia32\PeCoffLoaderEx.c</Filename>

+    </Arch>

+    <Arch ArchType="X64">

+      <Filename>x64\PeCoffLoaderEx.c</Filename>

+    </Arch>

+    <Arch ArchType="IPF">

+      <Filename>ipf\PeCoffLoaderEx.c</Filename>

+    </Arch>

+    <Arch ArchType="EBC">

+      <Filename>ebc\PeCoffLoaderEx.c</Filename>

+    </Arch>

+  </SourceFiles>

+  <Includes>

+    <PackageName>MdePkg</PackageName>

+  </Includes>

+</LibraryModuleSurfaceArea>

diff --git a/MdePkg/Library/BasePeCoffLib/Ebc/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/Ebc/PeCoffLoaderEx.c
new file mode 100644
index 0000000000..6cfc566bd4
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/Ebc/PeCoffLoaderEx.c
@@ -0,0 +1,43 @@
+/** @file

+  EBC Specific relocation fixups.

+

+  Copyright (c) 2006, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+  Module Name:  PeCoffLoaderEx.c

+

+**/

+

+

+

+

+/**

+  Performs an IA-32 specific relocation fixup.

+

+  @param  Reloc Pointer to the relocation record.

+

+  @param  Fixup Pointer to the address to fix up.

+

+  @param  FixupData Pointer to a buffer to log the fixups.

+

+  @param  Adjust The offset to adjust the fixup.

+

+  @retval  EFI_UNSUPPORTED Unsupported now.

+

+**/

+RETURN_STATUS

+PeCoffLoaderRelocateImageEx (

+  IN UINT16      *Reloc,

+  IN OUT CHAR8   *Fixup,

+  IN OUT CHAR8   **FixupData,

+  IN UINT64      Adjust

+  )

+{

+  return RETURN_UNSUPPORTED;

+}

diff --git a/MdePkg/Library/BasePeCoffLib/Ia32/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/Ia32/PeCoffLoaderEx.c
new file mode 100644
index 0000000000..4ee64c2b36
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/Ia32/PeCoffLoaderEx.c
@@ -0,0 +1,44 @@
+/** @file

+  IA-32 Specific relocation fixups.

+

+  Copyright (c) 2006, Intel Corporation<BR>

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+  Module Name:  PeCoffLoaderEx.c

+

+**/

+

+

+

+

+

+/**

+  Performs an IA-32 specific relocation fixup.

+

+  @param  Reloc Pointer to the relocation record.

+

+  @param  Fixup Pointer to the address to fix up.

+

+  @param  FixupData Pointer to a buffer to log the fixups.

+

+  @param  Adjust The offset to adjust the fixup.

+

+  @retval  EFI_UNSUPPORTED Unsupported now.

+

+**/

+RETURN_STATUS

+PeCoffLoaderRelocateImageEx (

+  IN UINT16      *Reloc,

+  IN OUT CHAR8   *Fixup,

+  IN OUT CHAR8   **FixupData,

+  IN UINT64      Adjust

+  )

+{

+  return RETURN_UNSUPPORTED;

+}

diff --git a/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c
new file mode 100644
index 0000000000..d35231e9cd
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/Ipf/PeCoffLoaderEx.c
@@ -0,0 +1,230 @@
+/** @file

+  Fixes Intel Itanium(TM) specific relocation types.

+

+  Copyright (c) 2006, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+  Module Name:  PeCoffLoaderEx.c

+

+**/

+

+

+

+

+

+#define EXT_IMM64(Value, Address, Size, InstPos, ValPos)  \

+    Value |= (((UINT64)((*(Address) >> InstPos) & (((UINT64)1 << Size) - 1))) << ValPos)

+

+#define INS_IMM64(Value, Address, Size, InstPos, ValPos)  \

+    *(UINT32*)Address = (*(UINT32*)Address & ~(((1 << Size) - 1) << InstPos)) | \

+          ((UINT32)((((UINT64)Value >> ValPos) & (((UINT64)1 << Size) - 1))) << InstPos)

+

+#define IMM64_IMM7B_INST_WORD_X         3  

+#define IMM64_IMM7B_SIZE_X              7  

+#define IMM64_IMM7B_INST_WORD_POS_X     4  

+#define IMM64_IMM7B_VAL_POS_X           0  

+

+#define IMM64_IMM9D_INST_WORD_X         3  

+#define IMM64_IMM9D_SIZE_X              9  

+#define IMM64_IMM9D_INST_WORD_POS_X     18  

+#define IMM64_IMM9D_VAL_POS_X           7  

+

+#define IMM64_IMM5C_INST_WORD_X         3  

+#define IMM64_IMM5C_SIZE_X              5  

+#define IMM64_IMM5C_INST_WORD_POS_X     13  

+#define IMM64_IMM5C_VAL_POS_X           16  

+

+#define IMM64_IC_INST_WORD_X            3  

+#define IMM64_IC_SIZE_X                 1  

+#define IMM64_IC_INST_WORD_POS_X        12  

+#define IMM64_IC_VAL_POS_X              21  

+

+#define IMM64_IMM41a_INST_WORD_X        1  

+#define IMM64_IMM41a_SIZE_X             10  

+#define IMM64_IMM41a_INST_WORD_POS_X    14  

+#define IMM64_IMM41a_VAL_POS_X          22  

+

+#define IMM64_IMM41b_INST_WORD_X        1  

+#define IMM64_IMM41b_SIZE_X             8  

+#define IMM64_IMM41b_INST_WORD_POS_X    24  

+#define IMM64_IMM41b_VAL_POS_X          32  

+

+#define IMM64_IMM41c_INST_WORD_X        2  

+#define IMM64_IMM41c_SIZE_X             23  

+#define IMM64_IMM41c_INST_WORD_POS_X    0  

+#define IMM64_IMM41c_VAL_POS_X          40  

+

+#define IMM64_SIGN_INST_WORD_X          3  

+#define IMM64_SIGN_SIZE_X               1  

+#define IMM64_SIGN_INST_WORD_POS_X      27  

+#define IMM64_SIGN_VAL_POS_X            63  

+

+/**

+  Performs an Itanium-based specific relocation fixup.

+

+  @param  Reloc Pointer to the relocation record.

+  

+  @param  Fixup Pointer to the address to fix up.

+  

+  @param  FixupData Pointer to a buffer to log the fixups.

+  

+  @param  Adjust The offset to adjust the fixup.

+

+  @return Status code.

+

+**/

+RETURN_STATUS

+PeCoffLoaderRelocateImageEx (

+  IN UINT16      *Reloc,

+  IN OUT CHAR8   *Fixup, 

+  IN OUT CHAR8   **FixupData,

+  IN UINT64      Adjust

+  )

+{

+  UINT64      *F64;

+  UINT64      FixupVal;

+

+  switch ((*Reloc) >> 12) {

+

+    case EFI_IMAGE_REL_BASED_DIR64:

+      F64 = (UINT64 *) Fixup;

+      *F64 = *F64 + (UINT64) Adjust;

+      if (*FixupData != NULL) {

+        *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));

+        *(UINT64 *)(*FixupData) = *F64;

+        *FixupData = *FixupData + sizeof(UINT64);

+      }

+      break;

+

+    case EFI_IMAGE_REL_BASED_IA64_IMM64:

+

+      //

+      // Align it to bundle address before fixing up the

+      // 64-bit immediate value of the movl instruction.

+      //

+

+      Fixup = (CHAR8 *)((UINTN) Fixup & (UINTN) ~(15));

+      FixupVal = (UINT64)0;

+                       

+      // 

+      // Extract the lower 32 bits of IMM64 from bundle

+      //

+      EXT_IMM64(FixupVal,

+                (UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X,

+                IMM64_IMM7B_SIZE_X,

+                IMM64_IMM7B_INST_WORD_POS_X,

+                IMM64_IMM7B_VAL_POS_X

+                );

+

+      EXT_IMM64(FixupVal,

+                (UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X,

+                IMM64_IMM9D_SIZE_X,

+                IMM64_IMM9D_INST_WORD_POS_X,

+                IMM64_IMM9D_VAL_POS_X

+                );

+

+      EXT_IMM64(FixupVal,

+                (UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X,

+                IMM64_IMM5C_SIZE_X,

+                IMM64_IMM5C_INST_WORD_POS_X,

+                IMM64_IMM5C_VAL_POS_X

+                );

+

+      EXT_IMM64(FixupVal,

+                (UINT32 *)Fixup + IMM64_IC_INST_WORD_X,

+                IMM64_IC_SIZE_X,

+                IMM64_IC_INST_WORD_POS_X,

+                IMM64_IC_VAL_POS_X

+                );

+

+      EXT_IMM64(FixupVal,

+                (UINT32 *)Fixup + IMM64_IMM41a_INST_WORD_X,

+                IMM64_IMM41a_SIZE_X,

+                IMM64_IMM41a_INST_WORD_POS_X,

+                IMM64_IMM41a_VAL_POS_X

+                );

+                       

+      // 

+      // Update 64-bit address

+      //

+      FixupVal += Adjust;

+

+      // 

+      // Insert IMM64 into bundle

+      //

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X),

+                IMM64_IMM7B_SIZE_X,

+                IMM64_IMM7B_INST_WORD_POS_X,

+                IMM64_IMM7B_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X),

+                IMM64_IMM9D_SIZE_X,

+                IMM64_IMM9D_INST_WORD_POS_X,

+                IMM64_IMM9D_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X),

+                IMM64_IMM5C_SIZE_X,

+                IMM64_IMM5C_INST_WORD_POS_X,

+                IMM64_IMM5C_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IC_INST_WORD_X),

+                IMM64_IC_SIZE_X,

+                IMM64_IC_INST_WORD_POS_X,

+                IMM64_IC_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM41a_INST_WORD_X),

+                IMM64_IMM41a_SIZE_X,

+                IMM64_IMM41a_INST_WORD_POS_X,

+                IMM64_IMM41a_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM41b_INST_WORD_X),

+                IMM64_IMM41b_SIZE_X,

+                IMM64_IMM41b_INST_WORD_POS_X,

+                IMM64_IMM41b_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_IMM41c_INST_WORD_X),

+                IMM64_IMM41c_SIZE_X,

+                IMM64_IMM41c_INST_WORD_POS_X,

+                IMM64_IMM41c_VAL_POS_X

+                );

+

+      INS_IMM64(FixupVal,

+                ((UINT32 *)Fixup + IMM64_SIGN_INST_WORD_X),

+                IMM64_SIGN_SIZE_X,

+                IMM64_SIGN_INST_WORD_POS_X,

+                IMM64_SIGN_VAL_POS_X

+                );

+

+      F64 = (UINT64 *) Fixup;

+      if (*FixupData != NULL) {

+        *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));

+        *(UINT64 *)(*FixupData) = *F64;

+        *FixupData = *FixupData + sizeof(UINT64);

+      }

+      break;

+

+    default:

+      return RETURN_UNSUPPORTED;

+  }

+

+  return RETURN_SUCCESS;

+}

diff --git a/MdePkg/Library/BasePeCoffLib/build.xml b/MdePkg/Library/BasePeCoffLib/build.xml
new file mode 100644
index 0000000000..0aff39d00b
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/build.xml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?><!-- Copyright (c) 2006, Intel Corporation 

+All rights reserved. This program and the accompanying materials 

+are licensed and made available under the terms and conditions of the BSD License 

+which accompanies this distribution.  The full text of the license may be found at  

+http://opensource.org/licenses/bsd-license.php 

+

+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 

+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.-->

+<project basedir="." default="BasePeCoffLib"><!--Apply external ANT tasks-->

+   <taskdef resource="GenBuild.tasks"/>

+   <taskdef resource="net/sf/antcontrib/antlib.xml"/>

+   <property environment="env"/>

+   <property name="WORKSPACE_DIR" value="${env.WORKSPACE}"/>

+   <import file="${WORKSPACE_DIR}\Tools\Conf\BuildMacro.xml"/><!--MODULE_RELATIVE PATH is relative to PACKAGE_DIR-->

+   <property name="MODULE_RELATIVE_PATH" value="Library\BasePeCoffLib"/>

+   <property name="MODULE_DIR" value="${PACKAGE_DIR}\${MODULE_RELATIVE_PATH}"/>

+   <property name="COMMON_FILE" value="${WORKSPACE_DIR}\Tools\Conf\Common.xml"/>

+   <target name="BasePeCoffLib">

+      <GenBuild baseName="BasePeCoffLib" mbdFilename="${MODULE_DIR}\BasePeCoffLib.mbd" msaFilename="${MODULE_DIR}\BasePeCoffLib.msa"/>

+   </target>

+   <target depends="BasePeCoffLib_clean" name="clean"/>

+   <target depends="BasePeCoffLib_cleanall" name="cleanall"/>

+   <target name="BasePeCoffLib_clean">

+      <OutputDirSetup baseName="BasePeCoffLib" mbdFilename="${MODULE_DIR}\BasePeCoffLib.mbd" msaFilename="${MODULE_DIR}\BasePeCoffLib.msa"/>

+      <if>

+         <available file="${DEST_DIR_OUTPUT}\BasePeCoffLib_build.xml"/>

+         <then>

+            <ant antfile="${DEST_DIR_OUTPUT}\BasePeCoffLib_build.xml" target="clean"/>

+         </then>

+      </if>

+      <delete dir="${DEST_DIR_OUTPUT}" excludes="*.xml"/>

+   </target>

+   <target name="BasePeCoffLib_cleanall">

+      <OutputDirSetup baseName="BasePeCoffLib" mbdFilename="${MODULE_DIR}\BasePeCoffLib.mbd" msaFilename="${MODULE_DIR}\BasePeCoffLib.msa"/>

+      <if>

+         <available file="${DEST_DIR_OUTPUT}\BasePeCoffLib_build.xml"/>

+         <then>

+            <ant antfile="${DEST_DIR_OUTPUT}\BasePeCoffLib_build.xml" target="cleanall"/>

+         </then>

+      </if>

+      <delete dir="${DEST_DIR_OUTPUT}"/>

+      <delete dir="${DEST_DIR_DEBUG}"/>

+      <delete>

+         <fileset dir="${BIN_DIR}" includes="**BasePeCoffLib*"/>

+      </delete>

+   </target>

+</project>
\ No newline at end of file
diff --git a/MdePkg/Library/BasePeCoffLib/x64/PeCoffLoaderEx.c b/MdePkg/Library/BasePeCoffLib/x64/PeCoffLoaderEx.c
new file mode 100644
index 0000000000..7648447f71
--- /dev/null
+++ b/MdePkg/Library/BasePeCoffLib/x64/PeCoffLoaderEx.c
@@ -0,0 +1,56 @@
+/** @file

+  x64 Specific relocation fixups.

+

+  Copyright (c) 2006, Intel Corporation

+  All rights reserved. This program and the accompanying materials

+  are licensed and made available under the terms and conditions of the BSD License

+  which accompanies this distribution.  The full text of the license may be found at

+  http://opensource.org/licenses/bsd-license.php

+

+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,

+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.

+

+  Module Name:  PeCoffLoaderEx.c

+

+**/

+

+

+

+

+/**

+  Performs an x64 specific relocation fixup.

+

+  @param  Reloc Pointer to the relocation record

+  @param  Fixup Pointer to the address to fix up

+  @param  FixupData Pointer to a buffer to log the fixups

+  @param  Adjust The offset to adjust the fixup

+

+**/

+RETURN_STATUS

+PeCoffLoaderRelocateImageEx (

+  IN UINT16      *Reloc,

+  IN OUT CHAR8   *Fixup, 

+  IN OUT CHAR8   **FixupData,

+  IN UINT64      Adjust

+  )

+{

+  UINT64      *F64;

+

+  switch ((*Reloc) >> 12) {

+

+    case EFI_IMAGE_REL_BASED_DIR64:

+      F64 = (UINT64 *) Fixup;

+      *F64 = *F64 + (UINT64) Adjust;

+      if (*FixupData != NULL) {

+        *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));

+        *(UINT64 *)(*FixupData) = *F64;

+        *FixupData = *FixupData + sizeof(UINT64);

+      }

+      break;

+

+    default:

+      return RETURN_UNSUPPORTED;

+  }

+

+  return RETURN_SUCCESS;

+}