[mirror_edk2.git] / BaseTools / Source / C / Common / BasePeCoff.c

/** @file\r
\r
  Functions to get info and load PE/COFF image.\r
\r
Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>\r
Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>\r
Portions Copyright (c) 2020, Hewlett Packard Enterprise Development LP. All rights reserved.<BR>\r
Portions Copyright (c) 2022, Loongson Technology Corporation Limited. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Common/UefiBaseTypes.h>\r
#include <CommonLib.h>\r
#include <IndustryStandard/PeImage.h>\r
#include "PeCoffLib.h"\r
\r
typedef union {\r
  VOID                         *Header;\r
  EFI_IMAGE_OPTIONAL_HEADER32  *Optional32;\r
  EFI_IMAGE_OPTIONAL_HEADER64  *Optional64;\r
} EFI_IMAGE_OPTIONAL_HEADER_POINTER;\r
\r
STATIC\r
RETURN_STATUS\r
PeCoffLoaderGetPeHeader (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT    *ImageContext,\r
  OUT    EFI_IMAGE_OPTIONAL_HEADER_UNION **PeHdr,\r
  OUT    EFI_TE_IMAGE_HEADER             **TeHdr\r
  );\r
\r
STATIC\r
RETURN_STATUS\r
PeCoffLoaderCheckImageType (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT    *ImageContext,\r
  IN     EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr,\r
  IN     EFI_TE_IMAGE_HEADER             *TeHdr\r
  );\r
\r
STATIC\r
VOID *\r
PeCoffLoaderImageAddress (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext,\r
  IN     UINTN                         Address\r
  );\r
\r
RETURN_STATUS\r
PeCoffLoaderRelocateIa32Image (\r
  IN UINT16      *Reloc,\r
  IN OUT CHAR8   *Fixup,\r
  IN OUT CHAR8   **FixupData,\r
  IN UINT64      Adjust\r
  );\r
\r
\r
RETURN_STATUS\r
PeCoffLoaderRelocateArmImage (\r
  IN UINT16      **Reloc,\r
  IN OUT CHAR8   *Fixup,\r
  IN OUT CHAR8   **FixupData,\r
  IN UINT64      Adjust\r
  );\r
\r
RETURN_STATUS\r
PeCoffLoaderRelocateRiscVImage (\r
  IN UINT16      *Reloc,\r
  IN OUT CHAR8   *Fixup,\r
  IN OUT CHAR8   **FixupData,\r
  IN UINT64      Adjust\r
  );\r
\r
RETURN_STATUS\r
PeCoffLoaderRelocateLoongArch64Image (\r
  IN UINT16      *Reloc,\r
  IN OUT CHAR8   *Fixup,\r
  IN OUT CHAR8   **FixupData,\r
  IN UINT64      Adjust\r
  );\r
\r
STATIC\r
RETURN_STATUS\r
PeCoffLoaderGetPeHeader (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT    *ImageContext,\r
  OUT    EFI_IMAGE_OPTIONAL_HEADER_UNION **PeHdr,\r
  OUT    EFI_TE_IMAGE_HEADER             **TeHdr\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Retrieves the PE or TE Header from a PE/COFF or TE image\r
\r
Arguments:\r
\r
  ImageContext  - The context of the image being loaded\r
\r
  PeHdr         - The buffer in which to return the PE header\r
\r
  TeHdr         - The buffer in which to return the TE header\r
\r
Returns:\r
\r
  RETURN_SUCCESS if the PE or TE Header is read,\r
  Otherwise, the error status from reading the PE/COFF or TE image using the ImageRead function.\r
\r
--*/\r
{\r
  RETURN_STATUS         Status;\r
  EFI_IMAGE_DOS_HEADER  DosHdr;\r
  UINTN                 Size;\r
\r
  ImageContext->IsTeImage = FALSE;\r
  //\r
  // Read the DOS image headers\r
  //\r
  Size = sizeof (EFI_IMAGE_DOS_HEADER);\r
  Status = ImageContext->ImageRead (\r
                          ImageContext->Handle,\r
                          0,\r
                          &Size,\r
                          &DosHdr\r
                          );\r
  if (RETURN_ERROR (Status)) {\r
    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
    return Status;\r
  }\r
\r
  ImageContext->PeCoffHeaderOffset = 0;\r
  if (DosHdr.e_magic == EFI_IMAGE_DOS_SIGNATURE) {\r
    //\r
    // DOS image header is present, so read the PE header after the DOS image header\r
    //\r
    ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew;\r
  }\r
  //\r
  // Get the PE/COFF Header pointer\r
  //\r
  *PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) ((UINTN)ImageContext->Handle + ImageContext->PeCoffHeaderOffset);\r
  if ((*PeHdr)->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
    //\r
    // Check the PE/COFF Header Signature. If not, then try to get a TE header\r
    //\r
    *TeHdr = (EFI_TE_IMAGE_HEADER *)*PeHdr;\r
    if ((*TeHdr)->Signature != EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
      return RETURN_UNSUPPORTED;\r
    }\r
    ImageContext->IsTeImage = TRUE;\r
  }\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
STATIC\r
RETURN_STATUS\r
PeCoffLoaderCheckImageType (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,\r
  IN     EFI_IMAGE_OPTIONAL_HEADER_UNION       *PeHdr,\r
  IN     EFI_TE_IMAGE_HEADER                   *TeHdr\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Checks the PE or TE header of a PE/COFF or TE image to determine if it supported\r
\r
Arguments:\r
\r
  ImageContext  - The context of the image being loaded\r
\r
  PeHdr         - The buffer in which to return the PE header\r
\r
  TeHdr         - The buffer in which to return the TE header\r
\r
Returns:\r
\r
  RETURN_SUCCESS if the PE/COFF or TE image is supported\r
  RETURN_UNSUPPORTED of the PE/COFF or TE image is not supported.\r
\r
--*/\r
{\r
  //\r
  // See if the machine type is supported.\r
  // We support a native machine type (IA-32/Itanium-based)\r
  //\r
  if (ImageContext->IsTeImage == FALSE) {\r
    ImageContext->Machine = PeHdr->Pe32.FileHeader.Machine;\r
  } else {\r
    ImageContext->Machine = TeHdr->Machine;\r
  }\r
\r
  if (ImageContext->Machine != EFI_IMAGE_MACHINE_IA32 && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_X64  && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_ARMT && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_EBC  && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_AARCH64 && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_RISCV64 && \\r
      ImageContext->Machine != EFI_IMAGE_MACHINE_LOONGARCH64) {\r
    if (ImageContext->Machine == IMAGE_FILE_MACHINE_ARM) {\r
      //\r
      // There are two types of ARM images. Pure ARM and ARM/Thumb.\r
      // If we see the ARM say it is the ARM/Thumb so there is only\r
      // a single machine type we need to check for ARM.\r
      //\r
      ImageContext->Machine = EFI_IMAGE_MACHINE_ARMT;\r
      if (ImageContext->IsTeImage == FALSE) {\r
        PeHdr->Pe32.FileHeader.Machine = ImageContext->Machine;\r
      } else {\r
        TeHdr->Machine = ImageContext->Machine;\r
      }\r
\r
    } else {\r
      //\r
      // unsupported PeImage machine type\r
      //\r
      return RETURN_UNSUPPORTED;\r
    }\r
  }\r
\r
  //\r
  // See if the image type is supported.  We support EFI Applications,\r
  // EFI Boot Service Drivers, EFI Runtime Drivers and EFI SAL Drivers.\r
  //\r
  if (ImageContext->IsTeImage == FALSE) {\r
    ImageContext->ImageType = PeHdr->Pe32.OptionalHeader.Subsystem;\r
  } else {\r
    ImageContext->ImageType = (UINT16) (TeHdr->Subsystem);\r
  }\r
\r
  if (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION && \\r
      ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER && \\r
      ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER && \\r
      ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER) {\r
    //\r
    // unsupported PeImage subsystem type\r
    //\r
    return RETURN_UNSUPPORTED;\r
  }\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
RETURN_STATUS\r
EFIAPI\r
PeCoffLoaderGetImageInfo (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT           *ImageContext\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Retrieves information on a PE/COFF image\r
\r
Arguments:\r
\r
  This         - Calling context\r
  ImageContext - The context of the image being loaded\r
\r
Returns:\r
\r
  RETURN_SUCCESS           - The information on the PE/COFF image was collected.\r
  RETURN_INVALID_PARAMETER - ImageContext is NULL.\r
  RETURN_UNSUPPORTED       - The PE/COFF image is not supported.\r
  Otherwise             - The error status from reading the PE/COFF image using the\r
                          ImageContext->ImageRead() function\r
\r
--*/\r
{\r
  RETURN_STATUS                   Status;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr;\r
  EFI_TE_IMAGE_HEADER             *TeHdr;\r
  EFI_IMAGE_DATA_DIRECTORY        *DebugDirectoryEntry;\r
  UINTN                           Size;\r
  UINTN                           Index;\r
  UINTN                           DebugDirectoryEntryRva;\r
  UINTN                           DebugDirectoryEntryFileOffset;\r
  UINTN                           SectionHeaderOffset;\r
  EFI_IMAGE_SECTION_HEADER        SectionHeader;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry;\r
  EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader;\r
\r
  PeHdr = NULL;\r
  TeHdr = NULL;\r
  DebugDirectoryEntry    = NULL;\r
  DebugDirectoryEntryRva = 0;\r
\r
  if (NULL == ImageContext) {\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
  //\r
  // Assume success\r
  //\r
  ImageContext->ImageError  = IMAGE_ERROR_SUCCESS;\r
\r
  Status                    = PeCoffLoaderGetPeHeader (ImageContext, &PeHdr, &TeHdr);\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Verify machine type\r
  //\r
  Status = PeCoffLoaderCheckImageType (ImageContext, PeHdr, TeHdr);\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
  OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader);\r
\r
  //\r
  // Retrieve the base address of the image\r
  //\r
  if (!(ImageContext->IsTeImage)) {\r
    if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
      ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional32->ImageBase;\r
    } else {\r
      ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional64->ImageBase;\r
    }\r
  } else {\r
    ImageContext->ImageAddress = (PHYSICAL_ADDRESS) (TeHdr->ImageBase + TeHdr->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER));\r
  }\r
  //\r
  // Initialize the alternate destination address to 0 indicating that it\r
  // should not be used.\r
  //\r
  ImageContext->DestinationAddress = 0;\r
\r
  //\r
  // Initialize the codeview pointer.\r
  //\r
  ImageContext->CodeView    = NULL;\r
  ImageContext->PdbPointer  = NULL;\r
\r
  //\r
  // Three cases with regards to relocations:\r
  // - Image has base relocs, RELOCS_STRIPPED==0    => image is relocatable\r
  // - Image has no base relocs, RELOCS_STRIPPED==1 => Image is not relocatable\r
  // - Image has no base relocs, RELOCS_STRIPPED==0 => Image is relocatable but\r
  //   has no base relocs to apply\r
  // Obviously having base relocations with RELOCS_STRIPPED==1 is invalid.\r
  //\r
  // Look at the file header to determine if relocations have been stripped, and\r
  // save this info in the image context for later use.\r
  //\r
  if ((!(ImageContext->IsTeImage)) && ((PeHdr->Pe32.FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) != 0)) {\r
    ImageContext->RelocationsStripped = TRUE;\r
  } else if ((ImageContext->IsTeImage) && (TeHdr->DataDirectory[0].Size == 0) && (TeHdr->DataDirectory[0].VirtualAddress == 0)) {\r
    ImageContext->RelocationsStripped = TRUE;\r
  } else {\r
    ImageContext->RelocationsStripped = FALSE;\r
  }\r
\r
  if (!(ImageContext->IsTeImage)) {\r
\r
    if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
      ImageContext->ImageSize         = (UINT64) OptionHeader.Optional32->SizeOfImage;\r
      ImageContext->SectionAlignment  = OptionHeader.Optional32->SectionAlignment;\r
      ImageContext->SizeOfHeaders     = OptionHeader.Optional32->SizeOfHeaders;\r
\r
      //\r
      // Modify ImageSize to contain .PDB file name if required and initialize\r
      // PdbRVA field...\r
      //\r
      if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
        DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
        DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress;\r
      }\r
    } else {\r
      ImageContext->ImageSize         = (UINT64) OptionHeader.Optional64->SizeOfImage;\r
      ImageContext->SectionAlignment  = OptionHeader.Optional64->SectionAlignment;\r
      ImageContext->SizeOfHeaders     = OptionHeader.Optional64->SizeOfHeaders;\r
\r
      //\r
      // Modify ImageSize to contain .PDB file name if required and initialize\r
      // PdbRVA field...\r
      //\r
      if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
        DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
        DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress;\r
      }\r
    }\r
\r
    if (DebugDirectoryEntryRva != 0) {\r
      //\r
      // Determine the file offset of the debug directory...  This means we walk\r
      // the sections to find which section contains the RVA of the debug\r
      // directory\r
      //\r
      DebugDirectoryEntryFileOffset = 0;\r
\r
      SectionHeaderOffset = (UINTN)(\r
                               ImageContext->PeCoffHeaderOffset +\r
                               sizeof (UINT32) +\r
                               sizeof (EFI_IMAGE_FILE_HEADER) +\r
                               PeHdr->Pe32.FileHeader.SizeOfOptionalHeader\r
                               );\r
\r
      for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++) {\r
        //\r
        // Read section header from file\r
        //\r
        Size = sizeof (EFI_IMAGE_SECTION_HEADER);\r
        Status = ImageContext->ImageRead (\r
                                 ImageContext->Handle,\r
                                 SectionHeaderOffset,\r
                                 &Size,\r
                                 &SectionHeader\r
                                 );\r
        if (RETURN_ERROR (Status)) {\r
          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
          return Status;\r
        }\r
\r
        if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&\r
            DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {\r
            DebugDirectoryEntryFileOffset =\r
            DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData;\r
          break;\r
        }\r
\r
        SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);\r
      }\r
\r
      if (DebugDirectoryEntryFileOffset != 0) {\r
        for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) {\r
          //\r
          // Read next debug directory entry\r
          //\r
          Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
          Status = ImageContext->ImageRead (\r
                                   ImageContext->Handle,\r
                                   DebugDirectoryEntryFileOffset + Index,\r
                                   &Size,\r
                                   &DebugEntry\r
                                   );\r
          if (RETURN_ERROR (Status)) {\r
            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
            return Status;\r
          }\r
\r
          if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {\r
            ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index);\r
            if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) {\r
              ImageContext->ImageSize += DebugEntry.SizeOfData;\r
            }\r
\r
            return RETURN_SUCCESS;\r
          }\r
        }\r
      }\r
    }\r
  } else {\r
    ImageContext->ImageSize         = 0;\r
    ImageContext->SectionAlignment  = 4096;\r
    ImageContext->SizeOfHeaders     = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN) TeHdr->BaseOfCode - (UINTN) TeHdr->StrippedSize;\r
\r
    DebugDirectoryEntry             = &TeHdr->DataDirectory[1];\r
    DebugDirectoryEntryRva          = DebugDirectoryEntry->VirtualAddress;\r
    SectionHeaderOffset             = (UINTN) (sizeof (EFI_TE_IMAGE_HEADER));\r
\r
    DebugDirectoryEntryFileOffset   = 0;\r
\r
    for (Index = 0; Index < TeHdr->NumberOfSections;) {\r
      //\r
      // Read section header from file\r
      //\r
      Size = sizeof (EFI_IMAGE_SECTION_HEADER);\r
      Status = ImageContext->ImageRead (\r
                               ImageContext->Handle,\r
                               SectionHeaderOffset,\r
                               &Size,\r
                               &SectionHeader\r
                               );\r
      if (RETURN_ERROR (Status)) {\r
        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
        return Status;\r
      }\r
\r
      if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&\r
          DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {\r
        DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva -\r
          SectionHeader.VirtualAddress +\r
          SectionHeader.PointerToRawData +\r
          sizeof (EFI_TE_IMAGE_HEADER) -\r
          TeHdr->StrippedSize;\r
\r
        //\r
        // File offset of the debug directory was found, if this is not the last\r
        // section, then skip to the last section for calculating the image size.\r
        //\r
        if (Index < (UINTN) TeHdr->NumberOfSections - 1) {\r
          SectionHeaderOffset += (TeHdr->NumberOfSections - 1 - Index) * sizeof (EFI_IMAGE_SECTION_HEADER);\r
          Index = TeHdr->NumberOfSections - 1;\r
          continue;\r
        }\r
      }\r
\r
      //\r
      // In Te image header there is not a field to describe the ImageSize.\r
      // Actually, the ImageSize equals the RVA plus the VirtualSize of\r
      // the last section mapped into memory (Must be rounded up to\r
      // a multiple of Section Alignment). Per the PE/COFF specification, the\r
      // section headers in the Section Table must appear in order of the RVA\r
      // values for the corresponding sections. So the ImageSize can be determined\r
      // by the RVA and the VirtualSize of the last section header in the\r
      // Section Table.\r
      //\r
      if ((++Index) == (UINTN) TeHdr->NumberOfSections) {\r
        ImageContext->ImageSize = (SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize +\r
                                   ImageContext->SectionAlignment - 1) & ~(ImageContext->SectionAlignment - 1);\r
      }\r
\r
      SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);\r
    }\r
\r
    if (DebugDirectoryEntryFileOffset != 0) {\r
      for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) {\r
        //\r
        // Read next debug directory entry\r
        //\r
        Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
        Status = ImageContext->ImageRead (\r
                                 ImageContext->Handle,\r
                                 DebugDirectoryEntryFileOffset,\r
                                 &Size,\r
                                 &DebugEntry\r
                                 );\r
        if (RETURN_ERROR (Status)) {\r
          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
          return Status;\r
        }\r
\r
        if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {\r
          ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index);\r
          return RETURN_SUCCESS;\r
        }\r
      }\r
    }\r
  }\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
STATIC\r
VOID *\r
PeCoffLoaderImageAddress (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT          *ImageContext,\r
  IN     UINTN                                 Address\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Converts an image address to the loaded address\r
\r
Arguments:\r
\r
  ImageContext  - The context of the image being loaded\r
\r
  Address       - The address to be converted to the loaded address\r
\r
Returns:\r
\r
  NULL if the address can not be converted, otherwise, the converted address\r
\r
--*/\r
{\r
  if (Address >= ImageContext->ImageSize) {\r
    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;\r
    return NULL;\r
  }\r
\r
  return (UINT8 *) ((UINTN) ImageContext->ImageAddress + Address);\r
}\r
\r
RETURN_STATUS\r
EFIAPI\r
PeCoffLoaderRelocateImage (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Relocates a PE/COFF image in memory\r
\r
Arguments:\r
\r
  This         - Calling context\r
\r
  ImageContext - Contains information on the loaded image to relocate\r
\r
Returns:\r
\r
  RETURN_SUCCESS      if the PE/COFF image was relocated\r
  RETURN_LOAD_ERROR   if the image is not a valid PE/COFF image\r
  RETURN_UNSUPPORTED  not support\r
\r
--*/\r
{\r
  RETURN_STATUS                         Status;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION       *PeHdr;\r
  EFI_TE_IMAGE_HEADER                   *TeHdr;\r
  EFI_IMAGE_DATA_DIRECTORY              *RelocDir;\r
  UINT64                                Adjust;\r
  EFI_IMAGE_BASE_RELOCATION             *RelocBase;\r
  EFI_IMAGE_BASE_RELOCATION             *RelocBaseEnd;\r
  UINT16                                *Reloc;\r
  UINT16                                *RelocEnd;\r
  CHAR8                                 *Fixup;\r
  CHAR8                                 *FixupBase;\r
  UINT16                                *F16;\r
  UINT32                                *F32;\r
  UINT64                                *F64;\r
  CHAR8                                 *FixupData;\r
  PHYSICAL_ADDRESS                      BaseAddress;\r
  UINT16                                MachineType;\r
  EFI_IMAGE_OPTIONAL_HEADER_POINTER     OptionHeader;\r
\r
  PeHdr = NULL;\r
  TeHdr = NULL;\r
  //\r
  // Assume success\r
  //\r
  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;\r
\r
  //\r
  // If there are no relocation entries, then we are done\r
  //\r
  if (ImageContext->RelocationsStripped) {\r
    return RETURN_SUCCESS;\r
  }\r
\r
  //\r
  // Use DestinationAddress field of ImageContext as the relocation address even if it is 0.\r
  //\r
  BaseAddress = ImageContext->DestinationAddress;\r
\r
  if (!(ImageContext->IsTeImage)) {\r
    PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN)ImageContext->ImageAddress +\r
                                            ImageContext->PeCoffHeaderOffset);\r
    OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader);\r
    if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
      Adjust = (UINT64) BaseAddress - OptionHeader.Optional32->ImageBase;\r
      OptionHeader.Optional32->ImageBase = (UINT32) BaseAddress;\r
      MachineType = ImageContext->Machine;\r
      //\r
      // Find the relocation block\r
      //\r
      // Per the PE/COFF spec, you can't assume that a given data directory\r
      // is present in the image. You have to check the NumberOfRvaAndSizes in\r
      // the optional header to verify a desired directory entry is there.\r
      //\r
      if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
        RelocDir  = &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
        if ((RelocDir != NULL) && (RelocDir->Size > 0)) {\r
          RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress);\r
          RelocBaseEnd = PeCoffLoaderImageAddress (\r
                           ImageContext,\r
                           RelocDir->VirtualAddress + RelocDir->Size - 1\r
                           );\r
          if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) {\r
            ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
            return RETURN_LOAD_ERROR;\r
          }\r
        } else {\r
          //\r
          // Set base and end to bypass processing below.\r
          //\r
          RelocBase = RelocBaseEnd = 0;\r
        }\r
      } else {\r
        //\r
        // Set base and end to bypass processing below.\r
        //\r
        RelocBase = RelocBaseEnd = 0;\r
      }\r
    } else {\r
      Adjust = (UINT64) BaseAddress - OptionHeader.Optional64->ImageBase;\r
      OptionHeader.Optional64->ImageBase = BaseAddress;\r
      MachineType = ImageContext->Machine;\r
      //\r
      // Find the relocation block\r
      //\r
      // Per the PE/COFF spec, you can't assume that a given data directory\r
      // is present in the image. You have to check the NumberOfRvaAndSizes in\r
      // the optional header to verify a desired directory entry is there.\r
      //\r
      if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
        RelocDir  = &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
        if ((RelocDir != NULL) && (RelocDir->Size > 0)) {\r
          RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress);\r
          RelocBaseEnd = PeCoffLoaderImageAddress (\r
                           ImageContext,\r
                           RelocDir->VirtualAddress + RelocDir->Size - 1\r
                          );\r
          if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) {\r
            ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
            return RETURN_LOAD_ERROR;\r
          }\r
        } else {\r
          //\r
          // Set base and end to bypass processing below.\r
          //\r
          RelocBase = RelocBaseEnd = 0;\r
        }\r
      } else {\r
        //\r
        // Set base and end to bypass processing below.\r
        //\r
        RelocBase = RelocBaseEnd = 0;\r
      }\r
    }\r
  } else {\r
    TeHdr             = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress);\r
    Adjust            = (UINT64) (BaseAddress - TeHdr->ImageBase);\r
    TeHdr->ImageBase  = (UINT64) (BaseAddress);\r
    MachineType = TeHdr->Machine;\r
\r
    //\r
    // Find the relocation block\r
    //\r
    RelocDir = &TeHdr->DataDirectory[0];\r
    RelocBase = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)(\r
                                    ImageContext->ImageAddress +\r
                                    RelocDir->VirtualAddress +\r
                                    sizeof(EFI_TE_IMAGE_HEADER) -\r
                                    TeHdr->StrippedSize\r
                                    );\r
    RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *) ((UINTN) RelocBase + (UINTN) RelocDir->Size - 1);\r
  }\r
\r
  //\r
  // Run the relocation information and apply the fixups\r
  //\r
  FixupData = ImageContext->FixupData;\r
  while (RelocBase < RelocBaseEnd) {\r
\r
    Reloc     = (UINT16 *) ((CHAR8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION));\r
    RelocEnd  = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock);\r
    if (!(ImageContext->IsTeImage)) {\r
      FixupBase = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress);\r
      if (FixupBase == NULL) {\r
        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
        return RETURN_LOAD_ERROR;\r
      }\r
    } else {\r
      FixupBase = (CHAR8 *)(UINTN)(ImageContext->ImageAddress +\r
                    RelocBase->VirtualAddress +\r
                    sizeof(EFI_TE_IMAGE_HEADER) -\r
                    TeHdr->StrippedSize\r
                    );\r
    }\r
\r
    if ((CHAR8 *) RelocEnd < (CHAR8 *) ((UINTN) ImageContext->ImageAddress) ||\r
        (CHAR8 *) RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress +\r
          (UINTN)ImageContext->ImageSize)) {\r
      ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
      return RETURN_LOAD_ERROR;\r
    }\r
\r
    //\r
    // Run this relocation record\r
    //\r
    while (Reloc < RelocEnd) {\r
\r
      Fixup = FixupBase + (*Reloc & 0xFFF);\r
      switch ((*Reloc) >> 12) {\r
      case EFI_IMAGE_REL_BASED_ABSOLUTE:\r
        break;\r
\r
      case EFI_IMAGE_REL_BASED_HIGH:\r
        F16   = (UINT16 *) Fixup;\r
        *F16 = (UINT16) (*F16 + ((UINT16) ((UINT32) Adjust >> 16)));\r
        if (FixupData != NULL) {\r
          *(UINT16 *) FixupData = *F16;\r
          FixupData             = FixupData + sizeof (UINT16);\r
        }\r
        break;\r
\r
      case EFI_IMAGE_REL_BASED_LOW:\r
        F16   = (UINT16 *) Fixup;\r
        *F16  = (UINT16) (*F16 + (UINT16) Adjust);\r
        if (FixupData != NULL) {\r
          *(UINT16 *) FixupData = *F16;\r
          FixupData             = FixupData + sizeof (UINT16);\r
        }\r
        break;\r
\r
      case EFI_IMAGE_REL_BASED_HIGHLOW:\r
        F32   = (UINT32 *) Fixup;\r
        *F32  = *F32 + (UINT32) Adjust;\r
        if (FixupData != NULL) {\r
          FixupData             = ALIGN_POINTER (FixupData, sizeof (UINT32));\r
          *(UINT32 *) FixupData = *F32;\r
          FixupData             = FixupData + sizeof (UINT32);\r
        }\r
        break;\r
\r
      case EFI_IMAGE_REL_BASED_DIR64:\r
        F64   = (UINT64 *) Fixup;\r
        *F64  = *F64 + (UINT64) Adjust;\r
        if (FixupData != NULL) {\r
          FixupData             = ALIGN_POINTER (FixupData, sizeof (UINT64));\r
          *(UINT64 *) FixupData = *F64;\r
          FixupData             = FixupData + sizeof (UINT64);\r
        }\r
        break;\r
\r
      case EFI_IMAGE_REL_BASED_HIGHADJ:\r
        //\r
        // Return the same EFI_UNSUPPORTED return code as\r
        // PeCoffLoaderRelocateImageEx() returns if it does not recognize\r
        // the relocation type.\r
        //\r
        ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
        return RETURN_UNSUPPORTED;\r
\r
      default:\r
        switch (MachineType) {\r
        case EFI_IMAGE_MACHINE_IA32:\r
          Status = PeCoffLoaderRelocateIa32Image (Reloc, Fixup, &FixupData, Adjust);\r
          break;\r
        case EFI_IMAGE_MACHINE_ARMT:\r
          Status = PeCoffLoaderRelocateArmImage (&Reloc, Fixup, &FixupData, Adjust);\r
          break;\r
        case EFI_IMAGE_MACHINE_RISCV64:\r
          Status = PeCoffLoaderRelocateRiscVImage (Reloc, Fixup, &FixupData, Adjust);\r
          break;\r
        case EFI_IMAGE_MACHINE_LOONGARCH64:\r
          Status = PeCoffLoaderRelocateLoongArch64Image (Reloc, Fixup, &FixupData, Adjust);\r
          break;\r
        default:\r
          Status = RETURN_UNSUPPORTED;\r
          break;\r
        }\r
        if (RETURN_ERROR (Status)) {\r
          ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;\r
          return Status;\r
        }\r
      }\r
\r
      //\r
      // Next relocation record\r
      //\r
      Reloc += 1;\r
    }\r
\r
    //\r
    // Next reloc block\r
    //\r
    RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;\r
  }\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
RETURN_STATUS\r
EFIAPI\r
PeCoffLoaderLoadImage (\r
  IN OUT PE_COFF_LOADER_IMAGE_CONTEXT  *ImageContext\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Loads a PE/COFF image into memory\r
\r
Arguments:\r
\r
  This         - Calling context\r
\r
  ImageContext - Contains information on image to load into memory\r
\r
Returns:\r
\r
  RETURN_SUCCESS            if the PE/COFF image was loaded\r
  RETURN_BUFFER_TOO_SMALL   if the caller did not provide a large enough buffer\r
  RETURN_LOAD_ERROR         if the image is a runtime driver with no relocations\r
  RETURN_INVALID_PARAMETER  if the image address is invalid\r
\r
--*/\r
{\r
  RETURN_STATUS                         Status;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION       *PeHdr;\r
  EFI_TE_IMAGE_HEADER                   *TeHdr;\r
  PE_COFF_LOADER_IMAGE_CONTEXT          CheckContext;\r
  EFI_IMAGE_SECTION_HEADER              *FirstSection;\r
  EFI_IMAGE_SECTION_HEADER              *Section;\r
  UINTN                                 NumberOfSections;\r
  UINTN                                 Index;\r
  CHAR8                                 *Base;\r
  CHAR8                                 *End;\r
  CHAR8                                 *MaxEnd;\r
  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;\r
  UINTN                                 Size;\r
  UINT32                                TempDebugEntryRva;\r
  EFI_IMAGE_OPTIONAL_HEADER_POINTER     OptionHeader;\r
\r
  PeHdr = NULL;\r
  TeHdr = NULL;\r
  OptionHeader.Header = NULL;\r
  //\r
  // Assume success\r
  //\r
  ImageContext->ImageError = IMAGE_ERROR_SUCCESS;\r
\r
  //\r
  // Copy the provided context info into our local version, get what we\r
  // can from the original image, and then use that to make sure everything\r
  // is legit.\r
  //\r
  CopyMem (&CheckContext, ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT));\r
\r
  Status = PeCoffLoaderGetImageInfo (&CheckContext);\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  //\r
  // Make sure there is enough allocated space for the image being loaded\r
  //\r
  if (ImageContext->ImageSize < CheckContext.ImageSize) {\r
    ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_SIZE;\r
    return RETURN_BUFFER_TOO_SMALL;\r
  }\r
\r
  //\r
  // If there's no relocations, then make sure it's not a runtime driver,\r
  // and that it's being loaded at the linked address.\r
  //\r
  if (CheckContext.RelocationsStripped) {\r
    //\r
    // If the image does not contain relocations and it is a runtime driver\r
    // then return an error.\r
    //\r
    if (CheckContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {\r
      ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;\r
      return RETURN_LOAD_ERROR;\r
    }\r
    //\r
    // If the image does not contain relocations, and the requested load address\r
    // is not the linked address, then return an error.\r
    //\r
    if (CheckContext.ImageAddress != ImageContext->ImageAddress) {\r
      ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;\r
      return RETURN_INVALID_PARAMETER;\r
    }\r
  }\r
  //\r
  // Make sure the allocated space has the proper section alignment\r
  //\r
  if (!(ImageContext->IsTeImage)) {\r
    if ((ImageContext->ImageAddress & (CheckContext.SectionAlignment - 1)) != 0) {\r
      ImageContext->ImageError = IMAGE_ERROR_INVALID_SECTION_ALIGNMENT;\r
      return RETURN_INVALID_PARAMETER;\r
    }\r
  }\r
  //\r
  // Read the entire PE/COFF or TE header into memory\r
  //\r
  if (!(ImageContext->IsTeImage)) {\r
    Status = ImageContext->ImageRead (\r
                            ImageContext->Handle,\r
                            0,\r
                            &ImageContext->SizeOfHeaders,\r
                            (VOID *) (UINTN) ImageContext->ImageAddress\r
                            );\r
\r
    PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)\r
      ((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset);\r
\r
    OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader);\r
\r
    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (\r
                      (UINTN)ImageContext->ImageAddress +\r
                      ImageContext->PeCoffHeaderOffset +\r
                      sizeof(UINT32) +\r
                      sizeof(EFI_IMAGE_FILE_HEADER) +\r
                      PeHdr->Pe32.FileHeader.SizeOfOptionalHeader\r
      );\r
    NumberOfSections = (UINTN) (PeHdr->Pe32.FileHeader.NumberOfSections);\r
  } else {\r
    Status = ImageContext->ImageRead (\r
                            ImageContext->Handle,\r
                            0,\r
                            &ImageContext->SizeOfHeaders,\r
                            (VOID *) (UINTN) ImageContext->ImageAddress\r
                            );\r
\r
    TeHdr             = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress);\r
\r
    FirstSection = (EFI_IMAGE_SECTION_HEADER *) (\r
          (UINTN)ImageContext->ImageAddress +\r
          sizeof(EFI_TE_IMAGE_HEADER)\r
          );\r
    NumberOfSections  = (UINTN) (TeHdr->NumberOfSections);\r
\r
  }\r
\r
  if (RETURN_ERROR (Status)) {\r
    ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
    return RETURN_LOAD_ERROR;\r
  }\r
\r
  //\r
  // Load each section of the image\r
  //\r
  Section = FirstSection;\r
  for (Index = 0, MaxEnd = NULL; Index < NumberOfSections; Index++) {\r
\r
    //\r
    // Compute sections address\r
    //\r
    Base = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress);\r
    End = PeCoffLoaderImageAddress (\r
            ImageContext,\r
            Section->VirtualAddress + Section->Misc.VirtualSize - 1\r
            );\r
\r
    //\r
    // If the base start or end address resolved to 0, then fail.\r
    //\r
    if ((Base == NULL) || (End == NULL)) {\r
      ImageContext->ImageError = IMAGE_ERROR_SECTION_NOT_LOADED;\r
      return RETURN_LOAD_ERROR;\r
    }\r
\r
\r
    if (ImageContext->IsTeImage) {\r
      Base  = (CHAR8 *) ((UINTN) Base + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize);\r
      End   = (CHAR8 *) ((UINTN) End + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize);\r
    }\r
\r
    if (End > MaxEnd) {\r
      MaxEnd = End;\r
    }\r
\r
    //\r
    // Read the section\r
    //\r
    Size = (UINTN) Section->Misc.VirtualSize;\r
    if ((Size == 0) || (Size > Section->SizeOfRawData)) {\r
      Size = (UINTN) Section->SizeOfRawData;\r
    }\r
\r
    if (Section->SizeOfRawData) {\r
      if (!(ImageContext->IsTeImage)) {\r
        Status = ImageContext->ImageRead (\r
                                ImageContext->Handle,\r
                                Section->PointerToRawData,\r
                                &Size,\r
                                Base\r
                                );\r
      } else {\r
        Status = ImageContext->ImageRead (\r
                                ImageContext->Handle,\r
                                Section->PointerToRawData + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize,\r
                                &Size,\r
                                Base\r
                                );\r
      }\r
\r
      if (RETURN_ERROR (Status)) {\r
        ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // If raw size is less then virt size, zero fill the remaining\r
    //\r
\r
    if (Size < Section->Misc.VirtualSize) {\r
      ZeroMem (Base + Size, Section->Misc.VirtualSize - Size);\r
    }\r
\r
    //\r
    // Next Section\r
    //\r
    Section += 1;\r
  }\r
\r
  //\r
  // Get image's entry point\r
  //\r
  if (!(ImageContext->IsTeImage)) {\r
    ImageContext->EntryPoint = (PHYSICAL_ADDRESS) (UINTN) PeCoffLoaderImageAddress (\r
                                                                ImageContext,\r
                                                                PeHdr->Pe32.OptionalHeader.AddressOfEntryPoint\r
                                                                );\r
  } else {\r
    ImageContext->EntryPoint = (UINTN)ImageContext->ImageAddress +\r
                               (UINTN)TeHdr->AddressOfEntryPoint +\r
                               (UINTN)sizeof(EFI_TE_IMAGE_HEADER) -\r
                               (UINTN) TeHdr->StrippedSize;\r
  }\r
\r
  //\r
  // Determine the size of the fixup data\r
  //\r
  // Per the PE/COFF spec, you can't assume that a given data directory\r
  // is present in the image. You have to check the NumberOfRvaAndSizes in\r
  // the optional header to verify a desired directory entry is there.\r
  //\r
  if (!(ImageContext->IsTeImage)) {\r
    if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
      if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
        DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)\r
          &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
        ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN);\r
      } else {\r
        ImageContext->FixupDataSize = 0;\r
      }\r
    } else {\r
      if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
        DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)\r
          &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
        ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN);\r
      } else {\r
        ImageContext->FixupDataSize = 0;\r
      }\r
    }\r
  } else {\r
    DirectoryEntry              = &TeHdr->DataDirectory[0];\r
    ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN);\r
  }\r
  //\r
  // Consumer must allocate a buffer for the relocation fixup log.\r
  // Only used for runtime drivers.\r
  //\r
  ImageContext->FixupData = NULL;\r
\r
  //\r
  // Load the Codeview info if present\r
  //\r
  if (ImageContext->DebugDirectoryEntryRva != 0) {\r
    if (!(ImageContext->IsTeImage)) {\r
      DebugEntry = PeCoffLoaderImageAddress (\r
                    ImageContext,\r
                    ImageContext->DebugDirectoryEntryRva\r
                    );\r
    } else {\r
      DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)(UINTN)(\r
                                               ImageContext->ImageAddress +\r
                                               ImageContext->DebugDirectoryEntryRva +\r
                                               sizeof(EFI_TE_IMAGE_HEADER) -\r
                                               TeHdr->StrippedSize\r
                                               );\r
    }\r
\r
    if (DebugEntry != NULL) {\r
      TempDebugEntryRva = DebugEntry->RVA;\r
      if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) {\r
        Section--;\r
        if ((UINTN) Section->SizeOfRawData < Section->Misc.VirtualSize) {\r
          TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize;\r
        } else {\r
          TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData;\r
        }\r
      }\r
\r
      if (TempDebugEntryRva != 0) {\r
        if (!(ImageContext->IsTeImage)) {\r
          ImageContext->CodeView = PeCoffLoaderImageAddress (ImageContext, TempDebugEntryRva);\r
        } else {\r
          ImageContext->CodeView = (VOID *)(\r
                      (UINTN)ImageContext->ImageAddress +\r
                      (UINTN)TempDebugEntryRva +\r
                      (UINTN)sizeof(EFI_TE_IMAGE_HEADER) -\r
                (UINTN) TeHdr->StrippedSize\r
            );\r
        }\r
\r
        if (ImageContext->CodeView == NULL) {\r
          ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
          return RETURN_LOAD_ERROR;\r
        }\r
\r
        if (DebugEntry->RVA == 0) {\r
          Size = DebugEntry->SizeOfData;\r
          if (!(ImageContext->IsTeImage)) {\r
            Status = ImageContext->ImageRead (\r
                                    ImageContext->Handle,\r
                                    DebugEntry->FileOffset,\r
                                    &Size,\r
                                    ImageContext->CodeView\r
                                    );\r
          } else {\r
            Status = ImageContext->ImageRead (\r
                                    ImageContext->Handle,\r
                                    DebugEntry->FileOffset + sizeof (EFI_TE_IMAGE_HEADER) - TeHdr->StrippedSize,\r
                                    &Size,\r
                                    ImageContext->CodeView\r
                                    );\r
            //\r
            // Should we apply fix up to this field according to the size difference between PE and TE?\r
            // Because now we maintain TE header fields unfixed, this field will also remain as they are\r
            // in original PE image.\r
            //\r
          }\r
\r
          if (RETURN_ERROR (Status)) {\r
            ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;\r
            return RETURN_LOAD_ERROR;\r
          }\r
\r
          DebugEntry->RVA = TempDebugEntryRva;\r
        }\r
\r
        switch (*(UINT32 *) ImageContext->CodeView) {\r
        case CODEVIEW_SIGNATURE_NB10:\r
          ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY);\r
          break;\r
\r
        case CODEVIEW_SIGNATURE_RSDS:\r
          ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY);\r
          break;\r
\r
        case CODEVIEW_SIGNATURE_MTOC:\r
          ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY);\r
\r
        default:\r
          break;\r
        }\r
      }\r
    }\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Returns a pointer to the PDB file name for a raw PE/COFF image that is not\r
  loaded into system memory with the PE/COFF Loader Library functions.\r
\r
  Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If\r
  the PE/COFF image specified by Pe32Data is not a valid, then NULL is\r
  returned.  If the PE/COFF image specified by Pe32Data does not contain a\r
  debug directory entry, then NULL is returned.  If the debug directory entry\r
  in the PE/COFF image specified by Pe32Data does not contain a PDB file name,\r
  then NULL is returned.\r
  If Pe32Data is NULL, then return NULL.\r
\r
  @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system\r
                     memory.\r
\r
  @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL\r
          if it cannot be retrieved.\r
\r
**/\r
VOID *\r
EFIAPI\r
PeCoffLoaderGetPdbPointer (\r
  IN VOID  *Pe32Data\r
  )\r
{\r
  EFI_IMAGE_DOS_HEADER                  *DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;\r
  EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;\r
  UINTN                                 DirCount;\r
  VOID                                  *CodeViewEntryPointer;\r
  INTN                                  TEImageAdjust;\r
  UINT32                                NumberOfRvaAndSizes;\r
  UINT16                                Magic;\r
  EFI_IMAGE_SECTION_HEADER              *SectionHeader;\r
  UINT32                                Index, Index1;\r
\r
  if (Pe32Data == NULL) {\r
    return NULL;\r
  }\r
\r
  TEImageAdjust       = 0;\r
  DirectoryEntry      = NULL;\r
  DebugEntry          = NULL;\r
  NumberOfRvaAndSizes = 0;\r
  Index               = 0;\r
  Index1              = 0;\r
  SectionHeader       = NULL;\r
\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;\r
  if (EFI_IMAGE_DOS_SIGNATURE == DosHdr->e_magic) {\r
    //\r
    // DOS image header is present, so read the PE header after the DOS image header.\r
    //\r
    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));\r
  } else {\r
    //\r
    // DOS image header is not present, so PE header is at the image base.\r
    //\r
    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;\r
  }\r
\r
  if (EFI_TE_IMAGE_HEADER_SIGNATURE == Hdr.Te->Signature) {\r
    if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {\r
      DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];\r
      TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;\r
\r
      //\r
      // Get the DebugEntry offset in the raw data image.\r
      //\r
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (Hdr.Te + 1);\r
      Index = Hdr.Te->NumberOfSections;\r
      for (Index1 = 0; Index1 < Index; Index1 ++) {\r
        if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) &&\r
           (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) {\r
          DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +\r
                        DirectoryEntry->VirtualAddress -\r
                        SectionHeader [Index1].VirtualAddress +\r
                        SectionHeader [Index1].PointerToRawData +\r
                        TEImageAdjust);\r
          break;\r
        }\r
      }\r
    }\r
  } else if (EFI_IMAGE_NT_SIGNATURE == Hdr.Pe32->Signature) {\r
    //\r
    // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.\r
    //       It is due to backward-compatibility, for some system might\r
    //       generate PE32+ image with PE32 Magic.\r
    //\r
    switch (Hdr.Pe32->FileHeader.Machine) {\r
    case EFI_IMAGE_MACHINE_IA32:\r
    case EFI_IMAGE_MACHINE_ARMT:\r
      //\r
      // Assume PE32 image with IA32 Machine field.\r
      //\r
      Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;\r
      break;\r
    case EFI_IMAGE_MACHINE_X64:\r
      //\r
      // Assume PE32+ image with X64 Machine field\r
      //\r
      Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
      break;\r
    default:\r
      //\r
      // For unknown Machine field, use Magic in optional Header\r
      //\r
      Magic = Hdr.Pe32->OptionalHeader.Magic;\r
    }\r
\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (\r
                       (UINT8 *) Hdr.Pe32 +\r
                       sizeof (UINT32) +\r
                       sizeof (EFI_IMAGE_FILE_HEADER) +\r
                       Hdr.Pe32->FileHeader.SizeOfOptionalHeader\r
                       );\r
    Index = Hdr.Pe32->FileHeader.NumberOfSections;\r
\r
    if (EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC == Magic) {\r
      //\r
      // Use PE32 offset get Debug Directory Entry\r
      //\r
      NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;\r
      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
    } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
      //\r
      // Use PE32+ offset get Debug Directory Entry\r
      //\r
      NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;\r
      DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
    }\r
\r
    if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG || DirectoryEntry->VirtualAddress == 0) {\r
      DirectoryEntry = NULL;\r
      DebugEntry = NULL;\r
    } else {\r
      //\r
      // Get the DebugEntry offset in the raw data image.\r
      //\r
      for (Index1 = 0; Index1 < Index; Index1 ++) {\r
        if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) &&\r
           (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) {\r
          DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (\r
                       (UINTN) Pe32Data +\r
                       DirectoryEntry->VirtualAddress -\r
                       SectionHeader[Index1].VirtualAddress +\r
                       SectionHeader[Index1].PointerToRawData);\r
          break;\r
        }\r
      }\r
    }\r
  } else {\r
    return NULL;\r
  }\r
\r
  if (NULL == DebugEntry || NULL == DirectoryEntry) {\r
    return NULL;\r
  }\r
\r
  //\r
  // Scan the directory to find the debug entry.\r
  //\r
  for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {\r
    if (EFI_IMAGE_DEBUG_TYPE_CODEVIEW == DebugEntry->Type) {\r
      if (DebugEntry->SizeOfData > 0) {\r
        //\r
        // Get the DebugEntry offset in the raw data image.\r
        //\r
        CodeViewEntryPointer = NULL;\r
        for (Index1 = 0; Index1 < Index; Index1 ++) {\r
          if ((DebugEntry->RVA >= SectionHeader[Index1].VirtualAddress) &&\r
             (DebugEntry->RVA < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) {\r
            CodeViewEntryPointer = (VOID *) (\r
                                   ((UINTN)Pe32Data) +\r
                                   (UINTN) DebugEntry->RVA -\r
                                   SectionHeader[Index1].VirtualAddress +\r
                                   SectionHeader[Index1].PointerToRawData +\r
                                   (UINTN)TEImageAdjust);\r
            break;\r
          }\r
        }\r
        if (Index1 >= Index) {\r
          //\r
          // Can't find CodeViewEntryPointer in raw PE/COFF image.\r
          //\r
          continue;\r
        }\r
        switch (* (UINT32 *) CodeViewEntryPointer) {\r
        case CODEVIEW_SIGNATURE_NB10:\r
          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));\r
        case CODEVIEW_SIGNATURE_RSDS:\r
          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));\r
        case CODEVIEW_SIGNATURE_MTOC:\r
          return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY));\r
        default:\r
          break;\r
        }\r
      }\r
    }\r
  }\r
\r
  return NULL;\r
}\r
\r
\r
RETURN_STATUS\r
EFIAPI\r
PeCoffLoaderGetEntryPoint (\r
  IN  VOID  *Pe32Data,\r
  OUT VOID  **EntryPoint,\r
  OUT VOID  **BaseOfImage\r
  )\r
{\r
  EFI_IMAGE_DOS_HEADER                  *DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;\r
\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;\r
  if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {\r
    //\r
    // DOS image header is present, so read the PE header after the DOS image header.\r
    //\r
    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));\r
  } else {\r
    //\r
    // DOS image header is not present, so PE header is at the image base.\r
    //\r
    Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;\r
  }\r
\r
  //\r
  // Calculate the entry point relative to the start of the image.\r
  // AddressOfEntryPoint is common for PE32 & PE32+\r
  //\r
  if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
    *BaseOfImage = (VOID *)(UINTN)(Hdr.Te->ImageBase + Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER));\r
    *EntryPoint = (VOID *)((UINTN)*BaseOfImage + (Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof(EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize);\r
    return RETURN_SUCCESS;\r
  } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {\r
    *EntryPoint = (VOID *)(UINTN)Hdr.Pe32->OptionalHeader.AddressOfEntryPoint;\r
    if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
      *BaseOfImage = (VOID *)(UINTN)Hdr.Pe32->OptionalHeader.ImageBase;\r
    } else {\r
      *BaseOfImage = (VOID *)(UINTN)Hdr.Pe32Plus->OptionalHeader.ImageBase;\r
    }\r
    *EntryPoint = (VOID *)(UINTN)((UINTN)*EntryPoint + (UINTN)*BaseOfImage);\r
    return RETURN_SUCCESS;\r
  }\r
\r
  return RETURN_UNSUPPORTED;\r
}\r