[mirror_edk2.git] / DuetPkg / EfiLdr / PeLoader.c

/*++\r
\r
Copyright (c) 2006, Intel Corporation                                                         \r
All rights reserved. This program and the accompanying materials                          \r
are licensed and made available under the terms and conditions of the BSD License         \r
which accompanies this distribution.  The full text of the license may be found at        \r
http://opensource.org/licenses/bsd-license.php                                            \r
                                                                                          \r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
\r
Module Name:\r
  PeLoader.c\r
\r
Abstract:\r
\r
Revision History:\r
\r
--*/\r
#include "EfiLdr.h"\r
#include "Debug.h"\r
#include "Support.h"\r
\r
STATIC\r
EFI_STATUS\r
EfiLdrPeCoffLoadPeRelocate (\r
  IN EFILDR_LOADED_IMAGE      *Image,\r
  IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,\r
  IN UINTN                     Adjust,\r
  IN UINTN                    *NumberOfMemoryMapEntries,\r
  IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor\r
  );\r
\r
STATIC\r
EFI_STATUS\r
EfiLdrPeCoffImageRead (\r
    IN VOID                 *FHand,\r
    IN UINTN                Offset,\r
    IN OUT UINTN            ReadSize,\r
    OUT VOID                *Buffer\r
    );\r
\r
STATIC\r
VOID *\r
EfiLdrPeCoffImageAddress (\r
  IN EFILDR_LOADED_IMAGE     *Image,\r
  IN UINTN                   Address\r
  );\r
\r
\r
EFI_STATUS\r
EfiLdrPeCoffSetImageType (\r
  IN OUT EFILDR_LOADED_IMAGE      *Image,\r
  IN UINTN                        ImageType\r
  );\r
\r
EFI_STATUS\r
EfiLdrPeCoffCheckImageMachineType (\r
  IN UINT16           MachineType\r
  );\r
\r
EFI_STATUS\r
EfiLdrGetPeImageInfo (\r
  IN  VOID                    *FHand,\r
  OUT UINT64                  *ImageBase,\r
  OUT UINT32                  *ImageSize\r
  )\r
{\r
  EFI_STATUS                        Status;\r
  EFI_IMAGE_DOS_HEADER              DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION   PeHdr;\r
\r
  ZeroMem (&DosHdr, sizeof(DosHdr));\r
  ZeroMem (&PeHdr, sizeof(PeHdr));\r
\r
  //\r
  // Read image headers\r
  //\r
\r
  EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);\r
  if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);\r
\r
  if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
    return EFI_UNSUPPORTED;\r
  }\r
    \r
  //\r
  // Verify machine type\r
  //\r
\r
  Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);\r
  if (EFI_ERROR(Status)) {\r
    return Status;\r
  }\r
\r
  if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    *ImageBase = (UINT32)PeHdr.Pe32.OptionalHeader.ImageBase;\r
  } else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
    *ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;\r
  } else {\r
    return EFI_UNSUPPORTED;\r
  }\r
  \r
  *ImageSize = PeHdr.Pe32.OptionalHeader.SizeOfImage;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EfiLdrPeCoffLoadPeImage (\r
  IN VOID                     *FHand,\r
  IN EFILDR_LOADED_IMAGE      *Image,\r
  IN UINTN                    *NumberOfMemoryMapEntries,\r
  IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor\r
  )\r
{\r
  EFI_IMAGE_DOS_HEADER            DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;\r
  EFI_IMAGE_SECTION_HEADER        *FirstSection;\r
  EFI_IMAGE_SECTION_HEADER        *Section;\r
  UINTN                           Index;\r
  EFI_STATUS                      Status;\r
  UINT8                           *Base;\r
  UINT8                           *End;\r
  EFI_IMAGE_DATA_DIRECTORY        *DirectoryEntry;\r
  UINTN                           DirCount;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY TempDebugEntry;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;\r
  UINTN                           CodeViewSize;\r
  UINTN                           CodeViewOffset;\r
  UINTN                           CodeViewFileOffset;\r
  UINTN                           OptionalHeaderSize;\r
  UINTN                           PeHeaderSize;\r
  UINT32                          NumberOfRvaAndSizes;\r
  EFI_IMAGE_DATA_DIRECTORY        *DataDirectory;\r
  UINT64                          ImageBase;\r
  CHAR8                           PrintBuffer[256];\r
\r
  ZeroMem (&DosHdr, sizeof(DosHdr));\r
  ZeroMem (&PeHdr, sizeof(PeHdr));\r
\r
  //\r
  // Read image headers\r
  //\r
\r
  EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);\r
  if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
    AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Dos header signature not found\n");\r
    PrintString (PrintBuffer);\r
    PrintHeader ('F');\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);\r
\r
  if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
    AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: PE image header signature not found\n");\r
    PrintString (PrintBuffer);\r
    PrintHeader ('G');\r
    return EFI_UNSUPPORTED;\r
  }\r
    \r
  //\r
  // Set the image subsystem type\r
  //\r
\r
  Status = EfiLdrPeCoffSetImageType (Image, PeHdr.Pe32.OptionalHeader.Subsystem);\r
  if (EFI_ERROR(Status)) {\r
    AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Subsystem type not known\n");\r
    PrintString (PrintBuffer);\r
    PrintHeader ('H');\r
    return Status;\r
  }\r
\r
  //\r
  // Verify machine type\r
  //\r
\r
  Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);\r
  if (EFI_ERROR(Status)) {\r
    AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Incorrect machine type\n");\r
    PrintString (PrintBuffer);\r
    PrintHeader ('I');\r
    return Status;\r
  }\r
\r
  //\r
  // Compute the amount of memory needed to load the image and \r
  // allocate it.  This will include all sections plus the codeview debug info.\r
  // Since the codeview info is actually outside of the image, we calculate\r
  // its size seperately and add it to the total.\r
  //\r
  // Memory starts off as data\r
  //\r
\r
  CodeViewSize       = 0;\r
  CodeViewFileOffset = 0;\r
  if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
  } else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
    DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
  } else {\r
    return EFI_UNSUPPORTED;\r
  }\r
  for (DirCount = 0; \r
       (DirCount < DirectoryEntry->Size / sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) && (CodeViewSize == 0);\r
       DirCount++) {\r
    Status = EfiLdrPeCoffImageRead (\r
               FHand, \r
               DirectoryEntry->VirtualAddress + DirCount * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),\r
               sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),\r
               &TempDebugEntry\r
               );\r
    if (!EFI_ERROR (Status)) {\r
      if (TempDebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {\r
        CodeViewSize = TempDebugEntry.SizeOfData;\r
        CodeViewFileOffset = TempDebugEntry.FileOffset;\r
      }\r
    }\r
  }\r
    \r
  CodeViewOffset = PeHdr.Pe32.OptionalHeader.SizeOfImage + PeHdr.Pe32.OptionalHeader.SectionAlignment;\r
  Image->NoPages = EFI_SIZE_TO_PAGES (CodeViewOffset + CodeViewSize);\r
\r
  //\r
  // Compute the amount of memory needed to load the image and \r
  // allocate it.  Memory starts off as data\r
  //\r
\r
  Image->ImageBasePage = (EFI_PHYSICAL_ADDRESS)FindSpace (Image->NoPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesCode, EFI_MEMORY_WB);\r
  if (Image->ImageBasePage == 0) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  if (EFI_ERROR(Status)) {\r
    PrintHeader ('J');\r
    return Status;\r
  }\r
\r
  AsciiSPrint (PrintBuffer, 256, "LoadPe: new image base %lx\n", Image->ImageBasePage);\r
  PrintString (PrintBuffer);\r
  Image->Info.ImageBase = (VOID *)(UINTN)Image->ImageBasePage;\r
  Image->Info.ImageSize = (Image->NoPages << EFI_PAGE_SHIFT) - 1;\r
  Image->ImageBase      = (UINT8 *)(UINTN)Image->ImageBasePage;\r
  Image->ImageEof       = Image->ImageBase + Image->Info.ImageSize;\r
  Image->ImageAdjust    = Image->ImageBase;\r
\r
  //\r
  // Copy the Image header to the base location\r
  //\r
  Status = EfiLdrPeCoffImageRead (\r
             FHand, \r
             0, \r
             PeHdr.Pe32.OptionalHeader.SizeOfHeaders, \r
             Image->ImageBase\r
             );\r
\r
  if (EFI_ERROR(Status)) {\r
    PrintHeader ('K');\r
    return Status;\r
  }\r
\r
  //\r
  // Load each directory of the image into memory... \r
  //  Save the address of the Debug directory for later\r
  //\r
  if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    NumberOfRvaAndSizes = PeHdr.Pe32.OptionalHeader.NumberOfRvaAndSizes;\r
    DataDirectory = PeHdr.Pe32.OptionalHeader.DataDirectory;\r
  } else {\r
    NumberOfRvaAndSizes = PeHdr.Pe32Plus.OptionalHeader.NumberOfRvaAndSizes;\r
    DataDirectory = PeHdr.Pe32Plus.OptionalHeader.DataDirectory;\r
  }\r
  DebugEntry = NULL;\r
  for (Index = 0; Index < NumberOfRvaAndSizes; Index++) {\r
    if ((DataDirectory[Index].VirtualAddress != 0) && (DataDirectory[Index].Size != 0)) {\r
      Status = EfiLdrPeCoffImageRead (\r
                 FHand,\r
                 DataDirectory[Index].VirtualAddress,\r
                 DataDirectory[Index].Size,\r
                 Image->ImageBase + DataDirectory[Index].VirtualAddress\r
                 );\r
      if (EFI_ERROR(Status)) {\r
        return Status;\r
      }\r
      if (Index == EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
        DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (Image->ImageBase + DataDirectory[Index].VirtualAddress);\r
      }\r
    }\r
  }\r
\r
  //\r
  // Load each section of the image\r
  //\r
\r
  // BUGBUG: change this to use the in memory copy\r
  if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER32);\r
    PeHeaderSize       = sizeof(EFI_IMAGE_NT_HEADERS32);\r
  } else {\r
    OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER64);\r
    PeHeaderSize       = sizeof(EFI_IMAGE_NT_HEADERS64);\r
  }\r
  FirstSection = (EFI_IMAGE_SECTION_HEADER *) (\r
                   Image->ImageBase +\r
                   DosHdr.e_lfanew + \r
                   PeHeaderSize + \r
                   PeHdr.Pe32.FileHeader.SizeOfOptionalHeader - \r
                   OptionalHeaderSize\r
                   );\r
\r
  Section = FirstSection;\r
  for (Index=0; Index < PeHdr.Pe32.FileHeader.NumberOfSections; Index += 1) {\r
\r
    //\r
    // Compute sections address\r
    //\r
\r
    Base = EfiLdrPeCoffImageAddress (Image, (UINTN)Section->VirtualAddress);\r
    End = EfiLdrPeCoffImageAddress (Image, (UINTN)(Section->VirtualAddress + Section->Misc.VirtualSize));\r
        \r
    if (EFI_ERROR(Status) || !Base || !End) {\r
//      DEBUG((D_LOAD|D_ERROR, "LoadPe: Section %d was not loaded\n", Index));\r
    PrintHeader ('L');\r
      return EFI_LOAD_ERROR;\r
    }\r
\r
//    DEBUG((D_LOAD, "LoadPe: Section %d, loaded at %x\n", Index, Base));\r
\r
    //\r
    // Read the section\r
    //\r
 \r
    if (Section->SizeOfRawData) {\r
      Status = EfiLdrPeCoffImageRead (FHand, Section->PointerToRawData, Section->SizeOfRawData, Base);\r
      if (EFI_ERROR(Status)) {\r
PrintHeader ('M');\r
        return Status;\r
      }\r
    }\r
\r
    //\r
    // If raw size is less then virt size, zero fill the remaining\r
    //\r
\r
    if (Section->SizeOfRawData < Section->Misc.VirtualSize) {\r
      ZeroMem (\r
        Base + Section->SizeOfRawData, \r
        Section->Misc.VirtualSize - Section->SizeOfRawData\r
        );\r
    }\r
\r
    //\r
    // Next Section\r
    //\r
\r
    Section += 1;\r
  }\r
\r
  //\r
  // Copy in CodeView information if it exists\r
  //\r
  if (CodeViewSize != 0) {\r
    Status = EfiLdrPeCoffImageRead (FHand, CodeViewFileOffset, CodeViewSize, Image->ImageBase + CodeViewOffset);\r
    DebugEntry->RVA = (UINT32) (CodeViewOffset);\r
  }\r
\r
  //\r
  // Apply relocations only if needed\r
  //\r
  if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    ImageBase = (UINT64)PeHdr.Pe32.OptionalHeader.ImageBase;\r
  } else {\r
    ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;\r
  }\r
  if ((UINTN)(Image->ImageBase) != (UINTN) (ImageBase)) {\r
    Status = EfiLdrPeCoffLoadPeRelocate (\r
               Image,\r
               &DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC],\r
               (UINTN) Image->ImageBase - (UINTN)ImageBase,\r
               NumberOfMemoryMapEntries,\r
               EfiMemoryDescriptor\r
               );\r
\r
    if (EFI_ERROR(Status)) {\r
      PrintHeader ('N');\r
      return Status;\r
    }\r
  }\r
\r
  //\r
  // Use exported EFI specific interface if present, else use the image's entry point\r
  //\r
  Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)\r
                        (EfiLdrPeCoffImageAddress(\r
                           Image, \r
                           PeHdr.Pe32.OptionalHeader.AddressOfEntryPoint\r
                           ));\r
\r
  return Status;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EfiLdrPeCoffLoadPeRelocate (\r
  IN EFILDR_LOADED_IMAGE      *Image,\r
  IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,\r
  IN UINTN                     Adjust,\r
  IN UINTN                    *NumberOfMemoryMapEntries,\r
  IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor\r
  )\r
{\r
  EFI_IMAGE_BASE_RELOCATION   *RelocBase;\r
  EFI_IMAGE_BASE_RELOCATION   *RelocBaseEnd;\r
  UINT16                      *Reloc;\r
  UINT16                      *RelocEnd;\r
  UINT8                       *Fixup;\r
  UINT8                       *FixupBase;\r
  UINT16                      *F16;\r
  UINT32                      *F32;\r
  UINT64                      *F64;\r
  UINT8                       *FixupData;\r
  UINTN                       NoFixupPages;\r
\r
  //\r
  // Find the relocation block\r
  //\r
\r
  RelocBase = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress);\r
  RelocBaseEnd = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress + RelocDir->Size);\r
  if (!RelocBase || !RelocBaseEnd) {\r
PrintHeader ('O');\r
    return EFI_LOAD_ERROR;\r
  }\r
\r
  NoFixupPages = EFI_SIZE_TO_PAGES(RelocDir->Size / sizeof(UINT16) * sizeof(UINTN));\r
  Image->FixupData = (UINT8*) FindSpace (NoFixupPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesData, EFI_MEMORY_WB);\r
  if (Image->FixupData == 0) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // Run the whole relocation block\r
  //\r
\r
  FixupData = Image->FixupData;\r
  while (RelocBase < RelocBaseEnd) {\r
           \r
    Reloc = (UINT16 *) ((UINT8 *) RelocBase + sizeof(EFI_IMAGE_BASE_RELOCATION));\r
    RelocEnd = (UINT16 *) ((UINT8 *) RelocBase + RelocBase->SizeOfBlock);\r
    FixupBase = EfiLdrPeCoffImageAddress (Image, RelocBase->VirtualAddress);\r
    if ((UINT8 *) RelocEnd < Image->ImageBase || (UINT8 *) RelocEnd > Image->ImageEof) {\r
PrintHeader ('P');\r
      return EFI_LOAD_ERROR;\r
    }\r
\r
    //\r
    // Run this relocation record\r
    //\r
\r
    while (Reloc < RelocEnd) {\r
\r
      Fixup = FixupBase + (*Reloc & 0xFFF);\r
      switch ((*Reloc) >> 12) {\r
\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 = *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
        CpuDeadLoop();                 // BUGBUG: not done\r
        break;\r
\r
      default:\r
//        DEBUG((D_LOAD|D_ERROR, "PeRelocate: unknown fixed type\n"));\r
PrintHeader ('Q');\r
        CpuDeadLoop();\r
        return EFI_LOAD_ERROR;\r
      }\r
\r
      // Next reloc record\r
      Reloc += 1;\r
    }\r
\r
    // next reloc block\r
    RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;\r
  }\r
\r
  //\r
  // Add Fixup data to whole Image (assume Fixup data just below the image), so that there is no hole in the descriptor.\r
  // Because only NoPages or ImageBasePage will be used in EfiLoader(), we update these 2 fields.\r
  //\r
  Image->NoPages += NoFixupPages;\r
  Image->ImageBasePage -= (NoFixupPages << EFI_PAGE_SHIFT);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
EfiLdrPeCoffImageRead (\r
  IN VOID                 *FHand,\r
  IN UINTN                Offset,\r
  IN OUT UINTN            ReadSize,\r
  OUT VOID                *Buffer\r
  )\r
{\r
  CopyMem (Buffer, (VOID *)((UINTN)FHand + Offset), ReadSize);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
VOID *\r
EfiLdrPeCoffImageAddress (\r
  IN EFILDR_LOADED_IMAGE     *Image,\r
  IN UINTN                   Address\r
  )\r
{\r
  UINT8        *FixedAddress;\r
\r
  FixedAddress = Image->ImageAdjust + Address;\r
\r
  if ((FixedAddress < Image->ImageBase) || (FixedAddress > Image->ImageEof)) {\r
//    DEBUG((D_LOAD|D_ERROR, "PeCoffImageAddress: pointer is outside of image\n"));\r
    FixedAddress = NULL;\r
  }\r
\r
//  DEBUG((\r
//    D_LOAD,\r
//    "PeCoffImageAddress: ImageBase %x, ImageEof %x, Address %x, FixedAddress %x\n", \r
//    Image->ImageBase,\r
//    Image->ImageEof,\r
//    Address,\r
//    FixedAddress\r
//    ));\r
    return FixedAddress;\r
}\r
\r
\r
EFI_STATUS\r
EfiLdrPeCoffSetImageType (\r
  IN OUT EFILDR_LOADED_IMAGE      *Image,\r
  IN UINTN                        ImageType\r
  )\r
{\r
  EFI_MEMORY_TYPE                 CodeType;\r
  EFI_MEMORY_TYPE                 DataType;\r
\r
  switch (ImageType) {\r
  case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:\r
    CodeType = EfiLoaderCode;\r
    DataType = EfiLoaderData;\r
    break;\r
\r
  case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:\r
    CodeType = EfiBootServicesCode;\r
    DataType = EfiBootServicesData;\r
    break;\r
\r
  case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:\r
    CodeType = EfiRuntimeServicesCode;\r
    DataType = EfiRuntimeServicesData;\r
    break;\r
\r
  default:\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  Image->Type = ImageType;\r
  Image->Info.ImageCodeType = CodeType;    \r
  Image->Info.ImageDataType = DataType;\r
\r
  return EFI_SUCCESS;\r
}\r
\r
EFI_STATUS\r
EfiLdrPeCoffCheckImageMachineType (\r
  IN UINT16           MachineType\r
  )\r
{\r
  EFI_STATUS          Status;\r
\r
  Status = EFI_UNSUPPORTED;\r
\r
#if EFI32\r
  if (MachineType == EFI_IMAGE_MACHINE_IA32) {\r
    Status = EFI_SUCCESS;\r
  }\r
#endif\r
\r
#if EFIX64\r
  if (MachineType == EFI_IMAGE_MACHINE_X64) {\r
    Status = EFI_SUCCESS;\r
  }\r
#endif\r
\r
#if EFI64\r
  if (MachineType == EFI_IMAGE_MACHINE_IA64) {\r
    Status = EFI_SUCCESS;\r
  }\r
#endif\r
\r
  return Status;\r
}\r
\r
Commit	Line	Data
9071550e	1	/*++\r
	2	\r
	3	Copyright (c) 2006, Intel Corporation \r
	4	All rights reserved. This program and the accompanying materials \r
	5	are licensed and made available under the terms and conditions of the BSD License \r
	6	which accompanies this distribution. The full text of the license may be found at \r
	7	http://opensource.org/licenses/bsd-license.php \r
	8	\r
	9	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, \r
	10	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. \r
	11	\r
	12	Module Name:\r
	13	PeLoader.c\r
	14	\r
	15	Abstract:\r
	16	\r
	17	Revision History:\r
	18	\r
	19	--*/\r
	20	#include "EfiLdr.h"\r
	21	#include "Debug.h"\r
	22	#include "Support.h"\r
	23	\r
	24	STATIC\r
	25	EFI_STATUS\r
	26	EfiLdrPeCoffLoadPeRelocate (\r
	27	IN EFILDR_LOADED_IMAGE *Image,\r
	28	IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,\r
	29	IN UINTN Adjust,\r
	30	IN UINTN *NumberOfMemoryMapEntries,\r
	31	IN EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor\r
	32	);\r
	33	\r
	34	STATIC\r
	35	EFI_STATUS\r
	36	EfiLdrPeCoffImageRead (\r
	37	IN VOID *FHand,\r
	38	IN UINTN Offset,\r
	39	IN OUT UINTN ReadSize,\r
	40	OUT VOID *Buffer\r
	41	);\r
	42	\r
	43	STATIC\r
	44	VOID *\r
	45	EfiLdrPeCoffImageAddress (\r
	46	IN EFILDR_LOADED_IMAGE *Image,\r
	47	IN UINTN Address\r
	48	);\r
	49	\r
	50	\r
	51	EFI_STATUS\r
	52	EfiLdrPeCoffSetImageType (\r
	53	IN OUT EFILDR_LOADED_IMAGE *Image,\r
	54	IN UINTN ImageType\r
	55	);\r
	56	\r
	57	EFI_STATUS\r
	58	EfiLdrPeCoffCheckImageMachineType (\r
	59	IN UINT16 MachineType\r
	60	);\r
	61	\r
	62	EFI_STATUS\r
	63	EfiLdrGetPeImageInfo (\r
	64	IN VOID *FHand,\r
65	OUT UINT64 *ImageBase,\r
66	OUT UINT32 *ImageSize\r
67	)\r
68	{\r
69	EFI_STATUS Status;\r
70	EFI_IMAGE_DOS_HEADER DosHdr;\r
71	EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;\r
72	\r
73	ZeroMem (&DosHdr, sizeof(DosHdr));\r
74	ZeroMem (&PeHdr, sizeof(PeHdr));\r
75	\r
76	//\r
77	// Read image headers\r
78	//\r
79	\r
80	EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);\r
81	if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
82	return EFI_UNSUPPORTED;\r
83	}\r
84	\r
85	EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);\r
86	\r
87	if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
88	return EFI_UNSUPPORTED;\r
89	}\r
90	\r
91	//\r
92	// Verify machine type\r
93	//\r
94	\r
95	Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);\r
96	if (EFI_ERROR(Status)) {\r
97	return Status;\r
98	}\r
99	\r
100	if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
101	*ImageBase = (UINT32)PeHdr.Pe32.OptionalHeader.ImageBase;\r
102	} else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
103	*ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;\r
104	} else {\r
105	return EFI_UNSUPPORTED;\r
106	}\r
107	\r
108	*ImageSize = PeHdr.Pe32.OptionalHeader.SizeOfImage;\r
109	\r
110	return EFI_SUCCESS;\r
111	}\r
112	\r
113	EFI_STATUS\r
114	EfiLdrPeCoffLoadPeImage (\r
115	IN VOID *FHand,\r
116	IN EFILDR_LOADED_IMAGE *Image,\r
117	IN UINTN *NumberOfMemoryMapEntries,\r
118	IN EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor\r
119	)\r
120	{\r
121	EFI_IMAGE_DOS_HEADER DosHdr;\r
122	EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;\r
123	EFI_IMAGE_SECTION_HEADER *FirstSection;\r
124	EFI_IMAGE_SECTION_HEADER *Section;\r
125	UINTN Index;\r
126	EFI_STATUS Status;\r
127	UINT8 *Base;\r
128	UINT8 *End;\r
129	EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry;\r
130	UINTN DirCount;\r
131	EFI_IMAGE_DEBUG_DIRECTORY_ENTRY TempDebugEntry;\r
132	EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;\r
133	UINTN CodeViewSize;\r
134	UINTN CodeViewOffset;\r
135	UINTN CodeViewFileOffset;\r
136	UINTN OptionalHeaderSize;\r
137	UINTN PeHeaderSize;\r
138	UINT32 NumberOfRvaAndSizes;\r
139	EFI_IMAGE_DATA_DIRECTORY *DataDirectory;\r
140	UINT64 ImageBase;\r
3da85e63	141	CHAR8 PrintBuffer[256];\r
9071550e	142	\r
	143	ZeroMem (&DosHdr, sizeof(DosHdr));\r
	144	ZeroMem (&PeHdr, sizeof(PeHdr));\r
	145	\r
	146	//\r
	147	// Read image headers\r
	148	//\r
	149	\r
	150	EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);\r
	151	if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
3da85e63	152	AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Dos header signature not found\n");\r
	153	PrintString (PrintBuffer);\r
	154	PrintHeader ('F');\r
9071550e	155	return EFI_UNSUPPORTED;\r
	156	}\r
	157	\r
	158	EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);\r
	159	\r
	160	if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
3da85e63	161	AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: PE image header signature not found\n");\r
	162	PrintString (PrintBuffer);\r
	163	PrintHeader ('G');\r
9071550e	164	return EFI_UNSUPPORTED;\r
	165	}\r
	166	\r
	167	//\r
	168	// Set the image subsystem type\r
	169	//\r
	170	\r
	171	Status = EfiLdrPeCoffSetImageType (Image, PeHdr.Pe32.OptionalHeader.Subsystem);\r
	172	if (EFI_ERROR(Status)) {\r
3da85e63	173	AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Subsystem type not known\n");\r
	174	PrintString (PrintBuffer);\r
	175	PrintHeader ('H');\r
9071550e	176	return Status;\r
	177	}\r
	178	\r
	179	//\r
	180	// Verify machine type\r
	181	//\r
	182	\r
	183	Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);\r
	184	if (EFI_ERROR(Status)) {\r
3da85e63	185	AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Incorrect machine type\n");\r
	186	PrintString (PrintBuffer);\r
	187	PrintHeader ('I');\r
9071550e	188	return Status;\r
	189	}\r
	190	\r
	191	//\r
	192	// Compute the amount of memory needed to load the image and \r
	193	// allocate it. This will include all sections plus the codeview debug info.\r
	194	// Since the codeview info is actually outside of the image, we calculate\r
	195	// its size seperately and add it to the total.\r
	196	//\r
	197	// Memory starts off as data\r
	198	//\r
	199	\r
	200	CodeViewSize = 0;\r
	201	CodeViewFileOffset = 0;\r
	202	if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
	203	DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
	204	} else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
	205	DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);\r
	206	} else {\r
	207	return EFI_UNSUPPORTED;\r
	208	}\r
	209	for (DirCount = 0; \r
	210	(DirCount < DirectoryEntry->Size / sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) && (CodeViewSize == 0);\r
	211	DirCount++) {\r
	212	Status = EfiLdrPeCoffImageRead (\r
	213	FHand, \r
	214	DirectoryEntry->VirtualAddress + DirCount * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),\r
	215	sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),\r
	216	&TempDebugEntry\r
	217	);\r
	218	if (!EFI_ERROR (Status)) {\r
	219	if (TempDebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {\r
	220	CodeViewSize = TempDebugEntry.SizeOfData;\r
	221	CodeViewFileOffset = TempDebugEntry.FileOffset;\r
	222	}\r
	223	}\r
	224	}\r
	225	\r
	226	CodeViewOffset = PeHdr.Pe32.OptionalHeader.SizeOfImage + PeHdr.Pe32.OptionalHeader.SectionAlignment;\r
	227	Image->NoPages = EFI_SIZE_TO_PAGES (CodeViewOffset + CodeViewSize);\r
	228	\r
	229	//\r
	230	// Compute the amount of memory needed to load the image and \r
	231	// allocate it. Memory starts off as data\r
	232	//\r
	233	\r
	234	Image->ImageBasePage = (EFI_PHYSICAL_ADDRESS)FindSpace (Image->NoPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesCode, EFI_MEMORY_WB);\r
	235	if (Image->ImageBasePage == 0) {\r
	236	return EFI_OUT_OF_RESOURCES;\r
	237	}\r
	238	\r
	239	if (EFI_ERROR(Status)) {\r
3da85e63	240	PrintHeader ('J');\r
9071550e	241	return Status;\r
	242	}\r
	243	\r
3da85e63	244	AsciiSPrint (PrintBuffer, 256, "LoadPe: new image base %lx\n", Image->ImageBasePage);\r
3da85e63	245	PrintString (PrintBuffer);\r
9071550e	246	Image->Info.ImageBase = (VOID *)(UINTN)Image->ImageBasePage;\r
	247	Image->Info.ImageSize = (Image->NoPages << EFI_PAGE_SHIFT) - 1;\r
	248	Image->ImageBase = (UINT8 *)(UINTN)Image->ImageBasePage;\r
	249	Image->ImageEof = Image->ImageBase + Image->Info.ImageSize;\r
	250	Image->ImageAdjust = Image->ImageBase;\r
	251	\r
	252	//\r
	253	// Copy the Image header to the base location\r
	254	//\r
	255	Status = EfiLdrPeCoffImageRead (\r
	256	FHand, \r
	257	0, \r
	258	PeHdr.Pe32.OptionalHeader.SizeOfHeaders, \r
	259	Image->ImageBase\r
	260	);\r
	261	\r
	262	if (EFI_ERROR(Status)) {\r
3da85e63	263	PrintHeader ('K');\r
9071550e	264	return Status;\r
	265	}\r
	266	\r
	267	//\r
	268	// Load each directory of the image into memory... \r
	269	// Save the address of the Debug directory for later\r
	270	//\r
	271	if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
	272	NumberOfRvaAndSizes = PeHdr.Pe32.OptionalHeader.NumberOfRvaAndSizes;\r
	273	DataDirectory = PeHdr.Pe32.OptionalHeader.DataDirectory;\r
	274	} else {\r
	275	NumberOfRvaAndSizes = PeHdr.Pe32Plus.OptionalHeader.NumberOfRvaAndSizes;\r
	276	DataDirectory = PeHdr.Pe32Plus.OptionalHeader.DataDirectory;\r
	277	}\r
	278	DebugEntry = NULL;\r
	279	for (Index = 0; Index < NumberOfRvaAndSizes; Index++) {\r
	280	if ((DataDirectory[Index].VirtualAddress != 0) && (DataDirectory[Index].Size != 0)) {\r
	281	Status = EfiLdrPeCoffImageRead (\r
	282	FHand,\r
	283	DataDirectory[Index].VirtualAddress,\r
	284	DataDirectory[Index].Size,\r
	285	Image->ImageBase + DataDirectory[Index].VirtualAddress\r
	286	);\r
	287	if (EFI_ERROR(Status)) {\r
	288	return Status;\r
	289	}\r
	290	if (Index == EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
	291	DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (Image->ImageBase + DataDirectory[Index].VirtualAddress);\r
	292	}\r
	293	}\r
	294	}\r
	295	\r
	296	//\r
	297	// Load each section of the image\r
	298	//\r
	299	\r
	300	// BUGBUG: change this to use the in memory copy\r
	301	if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
	302	OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER32);\r
	303	PeHeaderSize = sizeof(EFI_IMAGE_NT_HEADERS32);\r
	304	} else {\r
	305	OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER64);\r
	306	PeHeaderSize = sizeof(EFI_IMAGE_NT_HEADERS64);\r
	307	}\r
	308	FirstSection = (EFI_IMAGE_SECTION_HEADER *) (\r
	309	Image->ImageBase +\r
	310	DosHdr.e_lfanew + \r
	311	PeHeaderSize + \r
	312	PeHdr.Pe32.FileHeader.SizeOfOptionalHeader - \r
	313	OptionalHeaderSize\r
	314	);\r
	315	\r
	316	Section = FirstSection;\r
	317	for (Index=0; Index < PeHdr.Pe32.FileHeader.NumberOfSections; Index += 1) {\r
	318	\r
	319	//\r
	320	// Compute sections address\r
	321	//\r
	322	\r
	323	Base = EfiLdrPeCoffImageAddress (Image, (UINTN)Section->VirtualAddress);\r
	324	End = EfiLdrPeCoffImageAddress (Image, (UINTN)(Section->VirtualAddress + Section->Misc.VirtualSize));\r
	325	\r
	326	if (EFI_ERROR(Status) \|\| !Base \|\| !End) {\r
	327	// DEBUG((D_LOAD\|D_ERROR, "LoadPe: Section %d was not loaded\n", Index));\r
3da85e63	328	PrintHeader ('L');\r
9071550e	329	return EFI_LOAD_ERROR;\r
	330	}\r
	331	\r
	332	// DEBUG((D_LOAD, "LoadPe: Section %d, loaded at %x\n", Index, Base));\r
	333	\r
	334	//\r
	335	// Read the section\r
	336	//\r
	337	\r
	338	if (Section->SizeOfRawData) {\r
	339	Status = EfiLdrPeCoffImageRead (FHand, Section->PointerToRawData, Section->SizeOfRawData, Base);\r
	340	if (EFI_ERROR(Status)) {\r
	341	PrintHeader ('M');\r
	342	return Status;\r
	343	}\r
	344	}\r
	345	\r
	346	//\r
	347	// If raw size is less then virt size, zero fill the remaining\r
	348	//\r
	349	\r
	350	if (Section->SizeOfRawData < Section->Misc.VirtualSize) {\r
	351	ZeroMem (\r
	352	Base + Section->SizeOfRawData, \r
	353	Section->Misc.VirtualSize - Section->SizeOfRawData\r
	354	);\r
	355	}\r
	356	\r
	357	//\r
	358	// Next Section\r
	359	//\r
	360	\r
	361	Section += 1;\r
	362	}\r
	363	\r
	364	//\r
	365	// Copy in CodeView information if it exists\r
	366	//\r
	367	if (CodeViewSize != 0) {\r
	368	Status = EfiLdrPeCoffImageRead (FHand, CodeViewFileOffset, CodeViewSize, Image->ImageBase + CodeViewOffset);\r
	369	DebugEntry->RVA = (UINT32) (CodeViewOffset);\r
	370	}\r
	371	\r
	372	//\r
	373	// Apply relocations only if needed\r
	374	//\r
	375	if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
	376	ImageBase = (UINT64)PeHdr.Pe32.OptionalHeader.ImageBase;\r
	377	} else {\r
	378	ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;\r
	379	}\r
	380	if ((UINTN)(Image->ImageBase) != (UINTN) (ImageBase)) {\r
	381	Status = EfiLdrPeCoffLoadPeRelocate (\r
	382	Image,\r
	383	&DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC],\r
	384	(UINTN) Image->ImageBase - (UINTN)ImageBase,\r
	385	NumberOfMemoryMapEntries,\r
	386	EfiMemoryDescriptor\r
	387	);\r
	388	\r
	389	if (EFI_ERROR(Status)) {\r
3da85e63	390	PrintHeader ('N');\r
9071550e	391	return Status;\r
	392	}\r
	393	}\r
	394	\r
	395	//\r
	396	// Use exported EFI specific interface if present, else use the image's entry point\r
	397	//\r
	398	Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)\r
	399	(EfiLdrPeCoffImageAddress(\r
	400	Image, \r
	401	PeHdr.Pe32.OptionalHeader.AddressOfEntryPoint\r
	402	));\r
	403	\r
	404	return Status;\r
	405	}\r
	406	\r
	407	STATIC\r
	408	EFI_STATUS\r
	409	EfiLdrPeCoffLoadPeRelocate (\r
	410	IN EFILDR_LOADED_IMAGE *Image,\r
	411	IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,\r
	412	IN UINTN Adjust,\r
	413	IN UINTN *NumberOfMemoryMapEntries,\r
	414	IN EFI_MEMORY_DESCRIPTOR *EfiMemoryDescriptor\r
	415	)\r
	416	{\r
	417	EFI_IMAGE_BASE_RELOCATION *RelocBase;\r
	418	EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd;\r
	419	UINT16 *Reloc;\r
	420	UINT16 *RelocEnd;\r
	421	UINT8 *Fixup;\r
	422	UINT8 *FixupBase;\r
	423	UINT16 *F16;\r
	424	UINT32 *F32;\r
	425	UINT64 *F64;\r
	426	UINT8 *FixupData;\r
	427	UINTN NoFixupPages;\r
	428	\r
	429	//\r
	430	// Find the relocation block\r
	431	//\r
	432	\r
	433	RelocBase = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress);\r
	434	RelocBaseEnd = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress + RelocDir->Size);\r
	435	if (!RelocBase \|\| !RelocBaseEnd) {\r
	436	PrintHeader ('O');\r
	437	return EFI_LOAD_ERROR;\r
	438	}\r
	439	\r
	440	NoFixupPages = EFI_SIZE_TO_PAGES(RelocDir->Size / sizeof(UINT16) * sizeof(UINTN));\r
	441	Image->FixupData = (UINT8*) FindSpace (NoFixupPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesData, EFI_MEMORY_WB);\r
	442	if (Image->FixupData == 0) {\r
	443	return EFI_OUT_OF_RESOURCES;\r
	444	}\r
	445	\r
	446	//\r
	447	// Run the whole relocation block\r
	448	//\r
	449	\r
	450	FixupData = Image->FixupData;\r
	451	while (RelocBase < RelocBaseEnd) {\r
	452	\r
	453	Reloc = (UINT16 ) ((UINT8 ) RelocBase + sizeof(EFI_IMAGE_BASE_RELOCATION));\r
	454	RelocEnd = (UINT16 ) ((UINT8 ) RelocBase + RelocBase->SizeOfBlock);\r
455	FixupBase = EfiLdrPeCoffImageAddress (Image, RelocBase->VirtualAddress);\r
456	if ((UINT8 ) RelocEnd < Image->ImageBase \|\| (UINT8 ) RelocEnd > Image->ImageEof) {\r
457	PrintHeader ('P');\r
458	return EFI_LOAD_ERROR;\r
459	}\r
460	\r
461	//\r
462	// Run this relocation record\r
463	//\r
464	\r
465	while (Reloc < RelocEnd) {\r
466	\r
467	Fixup = FixupBase + (*Reloc & 0xFFF);\r
468	switch ((*Reloc) >> 12) {\r
469	\r
470	case EFI_IMAGE_REL_BASED_ABSOLUTE:\r
471	break;\r
472	\r
473	case EFI_IMAGE_REL_BASED_HIGH:\r
474	F16 = (UINT16 *) Fixup;\r
475	F16 = (UINT16) (F16 + (UINT16)(((UINT32)Adjust) >> 16));\r
476	if (FixupData != NULL) {\r
477	(UINT16 ) FixupData = *F16;\r
478	FixupData = FixupData + sizeof(UINT16);\r
479	}\r
480	break;\r
481	\r
482	case EFI_IMAGE_REL_BASED_LOW:\r
483	F16 = (UINT16 *) Fixup;\r
484	F16 = F16 + (UINT16) Adjust;\r
485	if (FixupData != NULL) {\r
486	(UINT16 ) FixupData = *F16;\r
487	FixupData = FixupData + sizeof(UINT16);\r
488	}\r
489	break;\r
490	\r
491	case EFI_IMAGE_REL_BASED_HIGHLOW:\r
492	F32 = (UINT32 *) Fixup;\r
493	F32 = F32 + (UINT32) Adjust;\r
494	if (FixupData != NULL) {\r
495	FixupData = ALIGN_POINTER(FixupData, sizeof(UINT32));\r
496	(UINT32 ) FixupData = *F32;\r
497	FixupData = FixupData + sizeof(UINT32);\r
498	}\r
499	break;\r
500	\r
501	case EFI_IMAGE_REL_BASED_DIR64:\r
502	F64 = (UINT64 *) Fixup;\r
503	F64 = F64 + (UINT64) Adjust;\r
504	if (FixupData != NULL) {\r
505	FixupData = ALIGN_POINTER(FixupData, sizeof(UINT64));\r
506	(UINT64 ) FixupData = *F64;\r
507	FixupData = FixupData + sizeof(UINT64);\r
508	}\r
509	break;\r
510	\r
511	case EFI_IMAGE_REL_BASED_HIGHADJ:\r
512	CpuDeadLoop(); // BUGBUG: not done\r
513	break;\r
514	\r
515	default:\r
516	// DEBUG((D_LOAD\|D_ERROR, "PeRelocate: unknown fixed type\n"));\r
517	PrintHeader ('Q');\r
518	CpuDeadLoop();\r
519	return EFI_LOAD_ERROR;\r
520	}\r
521	\r
522	// Next reloc record\r
523	Reloc += 1;\r
524	}\r
525	\r
526	// next reloc block\r
527	RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;\r
528	}\r
529	\r
530	//\r
531	// Add Fixup data to whole Image (assume Fixup data just below the image), so that there is no hole in the descriptor.\r
532	// Because only NoPages or ImageBasePage will be used in EfiLoader(), we update these 2 fields.\r
533	//\r
534	Image->NoPages += NoFixupPages;\r
535	Image->ImageBasePage -= (NoFixupPages << EFI_PAGE_SHIFT);\r
536	\r
537	return EFI_SUCCESS;\r
538	}\r
539	\r
540	STATIC\r
541	EFI_STATUS\r
542	EfiLdrPeCoffImageRead (\r
543	IN VOID *FHand,\r
544	IN UINTN Offset,\r
545	IN OUT UINTN ReadSize,\r
546	OUT VOID *Buffer\r
547	)\r
548	{\r
549	CopyMem (Buffer, (VOID *)((UINTN)FHand + Offset), ReadSize);\r
550	\r
551	return EFI_SUCCESS;\r
552	}\r
553	\r
554	STATIC\r
555	VOID *\r
556	EfiLdrPeCoffImageAddress (\r
557	IN EFILDR_LOADED_IMAGE *Image,\r
558	IN UINTN Address\r
559	)\r
560	{\r
561	UINT8 *FixedAddress;\r
562	\r
563	FixedAddress = Image->ImageAdjust + Address;\r
564	\r
565	if ((FixedAddress < Image->ImageBase) \|\| (FixedAddress > Image->ImageEof)) {\r
566	// DEBUG((D_LOAD\|D_ERROR, "PeCoffImageAddress: pointer is outside of image\n"));\r
567	FixedAddress = NULL;\r
568	}\r
569	\r
570	// DEBUG((\r
571	// D_LOAD,\r
572	// "PeCoffImageAddress: ImageBase %x, ImageEof %x, Address %x, FixedAddress %x\n", \r
573	// Image->ImageBase,\r
574	// Image->ImageEof,\r
575	// Address,\r
576	// FixedAddress\r
577	// ));\r
578	return FixedAddress;\r
579	}\r
580	\r
581	\r
582	EFI_STATUS\r
583	EfiLdrPeCoffSetImageType (\r
584	IN OUT EFILDR_LOADED_IMAGE *Image,\r
585	IN UINTN ImageType\r
586	)\r
587	{\r
588	EFI_MEMORY_TYPE CodeType;\r
589	EFI_MEMORY_TYPE DataType;\r
590	\r
591	switch (ImageType) {\r
592	case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:\r
593	CodeType = EfiLoaderCode;\r
594	DataType = EfiLoaderData;\r
595	break;\r
596	\r
597	case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:\r
598	CodeType = EfiBootServicesCode;\r
599	DataType = EfiBootServicesData;\r
600	break;\r
601	\r
602	case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:\r
603	CodeType = EfiRuntimeServicesCode;\r
604	DataType = EfiRuntimeServicesData;\r
605	break;\r
606	\r
607	default:\r
608	return EFI_INVALID_PARAMETER;\r
609	}\r
610	\r
611	Image->Type = ImageType;\r
612	Image->Info.ImageCodeType = CodeType; \r
613	Image->Info.ImageDataType = DataType;\r
614	\r
615	return EFI_SUCCESS;\r
616	}\r
617	\r
618	EFI_STATUS\r
619	EfiLdrPeCoffCheckImageMachineType (\r
620	IN UINT16 MachineType\r
621	)\r
622	{\r
623	EFI_STATUS Status;\r
624	\r
625	Status = EFI_UNSUPPORTED;\r
626	\r
627	#if EFI32\r
628	if (MachineType == EFI_IMAGE_MACHINE_IA32) {\r
629	Status = EFI_SUCCESS;\r
630	}\r
631	#endif\r
632	\r
633	#if EFIX64\r
634	if (MachineType == EFI_IMAGE_MACHINE_X64) {\r
635	Status = EFI_SUCCESS;\r
636	}\r
637	#endif\r
638	\r
639	#if EFI64\r
640	if (MachineType == EFI_IMAGE_MACHINE_IA64) {\r
641	Status = EFI_SUCCESS;\r
642	}\r
643	#endif\r
644	\r
645	return Status;\r
646	}\r
647	\r