mirror of https://github.com/acidanthera/audk.git
Remove unused library class EdkPeCoffLoaderX64Lib and library instance EdkPeCoffLoaderX64Lib, because current BasePeCoffLib can supports IA32, EBC, & X64 images all.
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@2070 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lgao4
parent
4afc6a7bf2
commit
83a4143f53
|
|
@ -1,940 +0,0 @@
|
|||
/*++
|
||||
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EdkPeCoffLoaderX64.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Wrap the Base PE/COFF loader with the PE COFF Protocol
|
||||
|
||||
|
||||
--*/
|
||||
|
||||
#define IMAGE_64_MACHINE_TYPE_SUPPORTED(Machine) \
|
||||
((Machine) == EFI_IMAGE_MACHINE_IA32 || \
|
||||
(Machine) == EFI_IMAGE_MACHINE_X64 || \
|
||||
(Machine) == EFI_IMAGE_MACHINE_EBC)
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
PeCoffLoader64GetPeHeader (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
OUT EFI_IMAGE_NT_HEADERS64 *PeHdr
|
||||
);
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
PeCoffLoader64CheckImageType (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
IN EFI_IMAGE_NT_HEADERS64 *PeHdr
|
||||
);
|
||||
|
||||
STATIC
|
||||
VOID *
|
||||
PeCoffLoader64ImageAddress (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
IN UINTN Address
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64GetImageInfo (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64RelocateImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64LoadImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64UnloadImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoader64RelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
);
|
||||
|
||||
EFI_PEI_PE_COFF_LOADER_PROTOCOL mPeCoffLoaderX64 = {
|
||||
PeCoffLoader64GetImageInfo,
|
||||
PeCoffLoader64LoadImage,
|
||||
PeCoffLoader64RelocateImage,
|
||||
PeCoffLoader64UnloadImage
|
||||
};
|
||||
|
||||
STATIC
|
||||
EFI_STATUS
|
||||
PeCoffLoader64GetPeHeader (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
OUT EFI_IMAGE_NT_HEADERS64 *PeHdr
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Retrieves the PE Header from a PE/COFF image
|
||||
|
||||
Arguments:
|
||||
ImageContext - The context of the image being loaded
|
||||
PeHdr - The buffer in which to return the PE header
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS if the PE Header is read,
|
||||
Otherwise, the error status from reading the PE/COFF image using the ImageRead function.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_IMAGE_DOS_HEADER DosHdr;
|
||||
UINTN Size;
|
||||
|
||||
//
|
||||
// Read the DOS image headers
|
||||
//
|
||||
Size = sizeof (EFI_IMAGE_DOS_HEADER);
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
0,
|
||||
&Size,
|
||||
&DosHdr
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return Status;
|
||||
}
|
||||
|
||||
ImageContext->PeCoffHeaderOffset = 0;
|
||||
if (DosHdr.e_magic == EFI_IMAGE_DOS_SIGNATURE) {
|
||||
//
|
||||
// DOS image header is present, so read the PE header after the DOS image header
|
||||
//
|
||||
ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew;
|
||||
}
|
||||
|
||||
//
|
||||
// Read the PE/COFF Header
|
||||
//
|
||||
Size = sizeof (EFI_IMAGE_NT_HEADERS64);
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
ImageContext->PeCoffHeaderOffset,
|
||||
&Size,
|
||||
PeHdr
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return Status;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
static
|
||||
EFI_STATUS
|
||||
PeCoffLoader64CheckImageType (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
IN EFI_IMAGE_NT_HEADERS64 *PeHdr
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Checks the PE header of a PE/COFF image to determine if it supported
|
||||
|
||||
Arguments:
|
||||
ImageContext - The context of the image being loaded
|
||||
PeHdr - The buffer in which to return the PE header
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS if the PE/COFF image is supported
|
||||
EFI_UNSUPPORTED of the PE/COFF image is not supported.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Check the PE/COFF Header SIgnature
|
||||
//
|
||||
if (PeHdr->Signature != EFI_IMAGE_NT_SIGNATURE) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_PE_HEADER_SIGNATURE;
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
//
|
||||
// See if the machine type is supported. We support a native machine type (IA-32/Itanium-based)
|
||||
// and the machine type for the Virtual Machine.
|
||||
//
|
||||
ImageContext->Machine = PeHdr->FileHeader.Machine;
|
||||
if (!(IMAGE_64_MACHINE_TYPE_SUPPORTED (ImageContext->Machine))) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_MACHINE_TYPE;
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
//
|
||||
// See if the image type is supported. We support EFI Applications,
|
||||
// EFI Boot Service Drivers, and EFI Runtime Drivers.
|
||||
//
|
||||
ImageContext->ImageType = PeHdr->OptionalHeader.Subsystem;
|
||||
switch (ImageContext->ImageType) {
|
||||
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
|
||||
ImageContext->ImageCodeMemoryType = EfiLoaderCode;
|
||||
ImageContext->ImageDataMemoryType = EfiLoaderData;
|
||||
break;
|
||||
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
|
||||
ImageContext->ImageCodeMemoryType = EfiBootServicesCode;
|
||||
ImageContext->ImageDataMemoryType = EfiBootServicesData;
|
||||
break;
|
||||
|
||||
case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
|
||||
case EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER:
|
||||
ImageContext->ImageCodeMemoryType = EfiRuntimeServicesCode;
|
||||
ImageContext->ImageDataMemoryType = EfiRuntimeServicesData;
|
||||
break;
|
||||
|
||||
default:
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64GetImageInfo (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Retrieves information on a PE/COFF image
|
||||
|
||||
Arguments:
|
||||
ImageContext - The context of the image being loaded
|
||||
PeHdr - The buffer in which to return the PE header
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS if the information on the PE/COFF image was collected.
|
||||
EFI_UNSUPPORTED of the PE/COFF image is not supported.
|
||||
Otherwise, the error status from reading the PE/COFF image using the
|
||||
ImageContext->ImageRead() function
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_IMAGE_NT_HEADERS64 PeHdr;
|
||||
EFI_IMAGE_DATA_DIRECTORY *DebugDirectoryEntry;
|
||||
UINTN Size;
|
||||
UINTN Index;
|
||||
UINTN DebugDirectoryEntryRva;
|
||||
UINTN DebugDirectoryEntryFileOffset;
|
||||
UINTN SectionHeaderOffset;
|
||||
EFI_IMAGE_SECTION_HEADER SectionHeader;
|
||||
EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry;
|
||||
|
||||
if (NULL == ImageContext) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// Assume success
|
||||
//
|
||||
ImageContext->ImageError = IMAGE_ERROR_SUCCESS;
|
||||
|
||||
Status = PeCoffLoader64GetPeHeader (ImageContext, &PeHdr);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Verify machine type
|
||||
//
|
||||
Status = PeCoffLoader64CheckImageType (ImageContext, &PeHdr);
|
||||
if (EFI_ERROR(Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Retrieve the base address of the image
|
||||
//
|
||||
ImageContext->ImageAddress = PeHdr.OptionalHeader.ImageBase;
|
||||
|
||||
//
|
||||
// Initialize the alternate destination address to 0 indicating that it
|
||||
// should not be used.
|
||||
//
|
||||
ImageContext->DestinationAddress = 0;
|
||||
|
||||
//
|
||||
// Initialize the codeview pointer.
|
||||
//
|
||||
ImageContext->CodeView = NULL;
|
||||
ImageContext->PdbPointer = NULL;
|
||||
|
||||
//
|
||||
// Three cases with regards to relocations:
|
||||
// - Image has base relocs, RELOCS_STRIPPED==0 => image is relocatable
|
||||
// - Image has no base relocs, RELOCS_STRIPPED==1 => Image is not relocatable
|
||||
// - Image has no base relocs, RELOCS_STRIPPED==0 => Image is relocatable but
|
||||
// has no base relocs to apply
|
||||
// Obviously having base relocations with RELOCS_STRIPPED==1 is invalid.
|
||||
//
|
||||
// Look at the file header to determine if relocations have been stripped, and
|
||||
// save this info in the image context for later use.
|
||||
//
|
||||
if (PeHdr.FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) {
|
||||
ImageContext->RelocationsStripped = TRUE;
|
||||
} else {
|
||||
ImageContext->RelocationsStripped = FALSE;
|
||||
}
|
||||
|
||||
ImageContext->ImageSize = (UINT64)PeHdr.OptionalHeader.SizeOfImage;
|
||||
ImageContext->SectionAlignment = PeHdr.OptionalHeader.SectionAlignment;
|
||||
ImageContext->SizeOfHeaders = PeHdr.OptionalHeader.SizeOfHeaders;
|
||||
|
||||
//
|
||||
// Modify ImageSize to contain .PDB file name if required and initialize
|
||||
// PdbRVA field...
|
||||
//
|
||||
|
||||
if (PeHdr.OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
|
||||
DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)
|
||||
&(PeHdr.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
|
||||
|
||||
DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress;
|
||||
|
||||
//
|
||||
// Determine the file offset of the debug directory... This means we walk
|
||||
// the sections to find which section contains the RVA of the debug
|
||||
// directory
|
||||
//
|
||||
|
||||
DebugDirectoryEntryFileOffset = 0;
|
||||
|
||||
SectionHeaderOffset = (UINTN) (
|
||||
ImageContext->PeCoffHeaderOffset +
|
||||
sizeof (UINT32) +
|
||||
sizeof (EFI_IMAGE_FILE_HEADER) +
|
||||
PeHdr.FileHeader.SizeOfOptionalHeader
|
||||
);
|
||||
|
||||
for (Index = 0; Index < PeHdr.FileHeader.NumberOfSections; Index += 1) {
|
||||
//
|
||||
// Read section header from file
|
||||
//
|
||||
Size = sizeof (EFI_IMAGE_SECTION_HEADER);
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
SectionHeaderOffset,
|
||||
&Size,
|
||||
&SectionHeader
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return Status;
|
||||
}
|
||||
|
||||
if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress &&
|
||||
DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) {
|
||||
DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData;
|
||||
break;
|
||||
}
|
||||
|
||||
SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER);
|
||||
}
|
||||
|
||||
if (DebugDirectoryEntryFileOffset != 0) {
|
||||
for (Index = 0; Index < DebugDirectoryEntry->Size; Index++) {
|
||||
//
|
||||
// Read next debug directory entry
|
||||
//
|
||||
Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
DebugDirectoryEntryFileOffset,
|
||||
&Size,
|
||||
&DebugEntry
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return Status;
|
||||
}
|
||||
if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
|
||||
ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY));
|
||||
if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) {
|
||||
ImageContext->ImageSize += DebugEntry.SizeOfData;
|
||||
}
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
static
|
||||
VOID *
|
||||
PeCoffLoader64ImageAddress (
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext,
|
||||
IN UINTN Address
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Converts an image address to the loaded address
|
||||
|
||||
Arguments:
|
||||
ImageContext - The context of the image being loaded
|
||||
Address - The address to be converted to the loaded address
|
||||
|
||||
Returns:
|
||||
NULL if the address can not be converted, otherwise, the converted address
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Address >= ImageContext->ImageSize) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;
|
||||
return NULL;
|
||||
}
|
||||
return (CHAR8 *)((UINTN)ImageContext->ImageAddress + Address);
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64RelocateImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Relocates a PE/COFF image in memory
|
||||
|
||||
Arguments:
|
||||
ImageContext - Contains information on the loaded image to relocate
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS if the PE/COFF image was relocated
|
||||
EFI_LOAD_ERROR if the image is not a valid PE/COFF image
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_IMAGE_NT_HEADERS64 *PeHdr;
|
||||
EFI_IMAGE_DATA_DIRECTORY *RelocDir;
|
||||
IN UINT64 Adjust;
|
||||
EFI_IMAGE_BASE_RELOCATION *RelocBase;
|
||||
EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd;
|
||||
UINT16 *Reloc;
|
||||
UINT16 *RelocEnd;
|
||||
CHAR8 *Fixup;
|
||||
CHAR8 *FixupBase;
|
||||
UINT16 *F16;
|
||||
UINT32 *F32;
|
||||
CHAR8 *FixupData;
|
||||
EFI_PHYSICAL_ADDRESS BaseAddress;
|
||||
|
||||
|
||||
//
|
||||
// Assume success
|
||||
//
|
||||
ImageContext->ImageError = IMAGE_ERROR_SUCCESS;
|
||||
|
||||
//
|
||||
// If there are no relocation entries, then we are done
|
||||
//
|
||||
if (ImageContext->RelocationsStripped) {
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
//
|
||||
// If the destination address is not 0, use that rather than the
|
||||
// image address as the relocation target.
|
||||
//
|
||||
if (ImageContext->DestinationAddress) {
|
||||
BaseAddress = ImageContext->DestinationAddress;
|
||||
} else {
|
||||
BaseAddress = ImageContext->ImageAddress;
|
||||
}
|
||||
PeHdr = (EFI_IMAGE_NT_HEADERS64 *)((UINTN)ImageContext->ImageAddress +
|
||||
ImageContext->PeCoffHeaderOffset);
|
||||
Adjust = (UINT64) BaseAddress - PeHdr->OptionalHeader.ImageBase;
|
||||
|
||||
PeHdr->OptionalHeader.ImageBase = (UINTN) BaseAddress;
|
||||
|
||||
//
|
||||
// Find the relocation block
|
||||
//
|
||||
// Per the PE/COFF spec, you can't assume that a given data directory
|
||||
// is present in the image. You have to check the NumberOfRvaAndSizes in
|
||||
// the optional header to verify a desired directory entry is there.
|
||||
//
|
||||
if (PeHdr->OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {
|
||||
RelocDir = &PeHdr->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
|
||||
RelocBase = PeCoffLoader64ImageAddress (ImageContext, RelocDir->VirtualAddress);
|
||||
RelocBaseEnd = PeCoffLoader64ImageAddress (
|
||||
ImageContext,
|
||||
RelocDir->VirtualAddress + RelocDir->Size - 1
|
||||
);
|
||||
} else {
|
||||
//
|
||||
// Set base and end to bypass processing below.
|
||||
//
|
||||
RelocBase = RelocBaseEnd = 0;
|
||||
}
|
||||
//
|
||||
// Run the relocation information and apply the fixups
|
||||
//
|
||||
FixupData = ImageContext->FixupData;
|
||||
while (RelocBase < RelocBaseEnd) {
|
||||
|
||||
Reloc = (UINT16 *) ((CHAR8 *) RelocBase + sizeof(EFI_IMAGE_BASE_RELOCATION));
|
||||
RelocEnd = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock);
|
||||
FixupBase = PeCoffLoader64ImageAddress (ImageContext, RelocBase->VirtualAddress);
|
||||
if ((CHAR8 *) RelocEnd < (CHAR8 *)((UINTN)ImageContext->ImageAddress) ||
|
||||
(CHAR8 *) RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress +
|
||||
(UINTN)ImageContext->ImageSize)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
//
|
||||
// Run this relocation record
|
||||
//
|
||||
while (Reloc < RelocEnd) {
|
||||
|
||||
Fixup = FixupBase + (*Reloc & 0xFFF);
|
||||
switch ((*Reloc) >> 12) {
|
||||
case EFI_IMAGE_REL_BASED_ABSOLUTE:
|
||||
break;
|
||||
case EFI_IMAGE_REL_BASED_HIGH:
|
||||
F16 = (UINT16 *) Fixup;
|
||||
*F16 = (UINT16) (*F16 + ((UINT16) ((UINT32) Adjust >> 16)));
|
||||
if (FixupData != NULL) {
|
||||
*(UINT16 *) FixupData = *F16;
|
||||
FixupData = FixupData + sizeof(UINT16);
|
||||
}
|
||||
break;
|
||||
case EFI_IMAGE_REL_BASED_LOW:
|
||||
F16 = (UINT16 *) Fixup;
|
||||
*F16 = (UINT16)(*F16 + (UINT16) Adjust);
|
||||
if (FixupData != NULL) {
|
||||
*(UINT16 *) FixupData = *F16;
|
||||
FixupData = FixupData + sizeof(UINT16);
|
||||
}
|
||||
break;
|
||||
case EFI_IMAGE_REL_BASED_HIGHLOW:
|
||||
F32 = (UINT32 *) Fixup;
|
||||
*F32 = *F32 + (UINT32) Adjust;
|
||||
if (FixupData != NULL) {
|
||||
FixupData = ALIGN_POINTER(FixupData, sizeof(UINT32));
|
||||
*(UINT32 *) FixupData = *F32;
|
||||
FixupData = FixupData + sizeof(UINT32);
|
||||
}
|
||||
break;
|
||||
case EFI_IMAGE_REL_BASED_HIGHADJ:
|
||||
// Return the same EFI_UNSUPPORTED return code as
|
||||
// PeCoffLoader64RelocateImageEx() returns if it does not recognize
|
||||
// the relocation type.
|
||||
//
|
||||
ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
|
||||
return EFI_UNSUPPORTED;
|
||||
default:
|
||||
Status = PeCoffLoader64RelocateImageEx (Reloc, Fixup, &FixupData, Adjust);
|
||||
if (EFI_ERROR (Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION;
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Next relocation record
|
||||
//
|
||||
Reloc += 1;
|
||||
}
|
||||
|
||||
//
|
||||
// Next reloc block
|
||||
//
|
||||
RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoader64RelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Performs an IA-32 specific relocation fixup
|
||||
|
||||
Arguments:
|
||||
Reloc - Pointer to the relocation record
|
||||
Fixup - Pointer to the address to fix up
|
||||
FixupData - Pointer to a buffer to log the fixups
|
||||
Adjust - The offset to adjust the fixup
|
||||
|
||||
Returns:
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT64 *F64;
|
||||
|
||||
switch ((*Reloc) >> 12) {
|
||||
|
||||
case EFI_IMAGE_REL_BASED_DIR64:
|
||||
F64 = (UINT64 *) Fixup;
|
||||
*F64 = *F64 + (UINT64) Adjust;
|
||||
if (*FixupData != NULL) {
|
||||
*FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));
|
||||
*(UINT64 *)(*FixupData) = *F64;
|
||||
*FixupData = *FixupData + sizeof(UINT64);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64LoadImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Loads a PE/COFF image into memory
|
||||
|
||||
Arguments:
|
||||
ImageContext - Contains information on image to load into memory
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS if the PE/COFF image was loaded
|
||||
EFI_BUFFER_TOO_SMALL if the caller did not provide a large enough buffer
|
||||
EFI_LOAD_ERROR if the image is a runtime driver with no relocations
|
||||
EFI_INVALID_PARAMETER if the image address is invalid
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_IMAGE_NT_HEADERS64 *PeHdr;
|
||||
PE_COFF_LOADER_IMAGE_CONTEXT CheckContext;
|
||||
EFI_IMAGE_SECTION_HEADER *FirstSection;
|
||||
EFI_IMAGE_SECTION_HEADER *Section;
|
||||
UINTN Index;
|
||||
CHAR8 *Base;
|
||||
CHAR8 *End;
|
||||
CHAR8 *MaxEnd;
|
||||
EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry;
|
||||
EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;
|
||||
UINTN Size;
|
||||
UINT32 TempDebugEntryRva;
|
||||
|
||||
//
|
||||
// Assume success
|
||||
//
|
||||
ImageContext->ImageError = IMAGE_ERROR_SUCCESS;
|
||||
|
||||
//
|
||||
// Copy the provided context info into our local version, get what we
|
||||
// can from the original image, and then use that to make sure everything
|
||||
// is legit.
|
||||
//
|
||||
CopyMem (
|
||||
&CheckContext,
|
||||
ImageContext,
|
||||
sizeof (PE_COFF_LOADER_IMAGE_CONTEXT)
|
||||
);
|
||||
|
||||
Status = PeCoffLoader64GetImageInfo (
|
||||
This,
|
||||
&CheckContext
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
//
|
||||
// Make sure there is enough allocated space for the image being loaded
|
||||
//
|
||||
if (ImageContext->ImageSize < CheckContext.ImageSize) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_SIZE;
|
||||
return EFI_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
//
|
||||
// If there's no relocations, then make sure it's not a runtime driver,
|
||||
// and that it's being loaded at the linked address.
|
||||
//
|
||||
if (CheckContext.RelocationsStripped == TRUE) {
|
||||
//
|
||||
// If the image does not contain relocations and it is a runtime driver
|
||||
// then return an error.
|
||||
//
|
||||
if (CheckContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
//
|
||||
// If the image does not contain relocations, and the requested load address
|
||||
// is not the linked address, then return an error.
|
||||
//
|
||||
if (CheckContext.ImageAddress != ImageContext->ImageAddress) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS;
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Make sure the allocated space has the proper section alignment
|
||||
//
|
||||
if ((ImageContext->ImageAddress & (CheckContext.SectionAlignment - 1)) != 0) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_INVALID_SECTION_ALIGNMENT;
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
//
|
||||
// Read the entire PE/COFF header into memory
|
||||
//
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
0,
|
||||
&ImageContext->SizeOfHeaders,
|
||||
(VOID *)(UINTN)ImageContext->ImageAddress
|
||||
);
|
||||
if (EFI_ERROR(Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
PeHdr = (EFI_IMAGE_NT_HEADERS64 *)
|
||||
((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset);
|
||||
|
||||
//
|
||||
// Load each section of the image
|
||||
//
|
||||
FirstSection = (EFI_IMAGE_SECTION_HEADER *) (
|
||||
(UINTN)ImageContext->ImageAddress +
|
||||
ImageContext->PeCoffHeaderOffset +
|
||||
sizeof(UINT32) +
|
||||
sizeof(EFI_IMAGE_FILE_HEADER) +
|
||||
PeHdr->FileHeader.SizeOfOptionalHeader
|
||||
);
|
||||
|
||||
Section = FirstSection;
|
||||
for ( Index=0, MaxEnd = NULL;
|
||||
Index < PeHdr->FileHeader.NumberOfSections;
|
||||
Index += 1) {
|
||||
|
||||
//
|
||||
// Compute sections address
|
||||
//
|
||||
Base = PeCoffLoader64ImageAddress (ImageContext, Section->VirtualAddress);
|
||||
End = PeCoffLoader64ImageAddress (
|
||||
ImageContext,
|
||||
Section->VirtualAddress + Section->Misc.VirtualSize - 1);
|
||||
if (End > MaxEnd) {
|
||||
MaxEnd = End;
|
||||
}
|
||||
//
|
||||
// If the base start or end address resolved to 0, then fail.
|
||||
//
|
||||
if (!Base || !End) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_SECTION_NOT_LOADED;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
//
|
||||
// Read the section, we can resume the length of PE image can't
|
||||
// exceed the max 32bit integer
|
||||
//
|
||||
Size = (UINTN) Section->Misc.VirtualSize;
|
||||
if ((Size == 0) || (Size > Section->SizeOfRawData)) {
|
||||
Size = (UINTN) Section->SizeOfRawData;
|
||||
}
|
||||
if (Section->SizeOfRawData) {
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
Section->PointerToRawData,
|
||||
&Size,
|
||||
Base);
|
||||
if (EFI_ERROR(Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return Status;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// If raw size is less then virt size, zero fill the remaining
|
||||
//
|
||||
|
||||
if (Size < Section->Misc.VirtualSize) {
|
||||
ZeroMem (Base + Size, Section->Misc.VirtualSize - (UINTN)Size);
|
||||
}
|
||||
|
||||
//
|
||||
// Next Section
|
||||
//
|
||||
Section += 1;
|
||||
}
|
||||
|
||||
//
|
||||
// Get image's entry point
|
||||
//
|
||||
ImageContext->EntryPoint =
|
||||
(EFI_PHYSICAL_ADDRESS) (UINTN) PeCoffLoader64ImageAddress (
|
||||
ImageContext,
|
||||
PeHdr->OptionalHeader.AddressOfEntryPoint
|
||||
);
|
||||
|
||||
//
|
||||
// Determine the size of the fixup data
|
||||
//
|
||||
// Per the PE/COFF spec, you can't assume that a given data directory
|
||||
// is present in the image. You have to check the NumberOfRvaAndSizes in
|
||||
// the optional header to verify a desired directory entry is there.
|
||||
//
|
||||
if (PeHdr->OptionalHeader.NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {
|
||||
DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)
|
||||
&PeHdr->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];
|
||||
ImageContext->FixupDataSize =
|
||||
DirectoryEntry->Size / sizeof(UINT16) * sizeof(UINTN);
|
||||
} else {
|
||||
ImageContext->FixupDataSize = 0;
|
||||
}
|
||||
//
|
||||
// Consumer must allocate a buffer for the relocation fixup log.
|
||||
// Only used for runtime drivers.
|
||||
//
|
||||
ImageContext->FixupData = NULL;
|
||||
|
||||
//
|
||||
// Load the Codeview info if present
|
||||
//
|
||||
if (ImageContext->DebugDirectoryEntryRva != 0) {
|
||||
DebugEntry = PeCoffLoader64ImageAddress (
|
||||
ImageContext,
|
||||
ImageContext->DebugDirectoryEntryRva
|
||||
);
|
||||
if (DebugEntry != NULL) {
|
||||
TempDebugEntryRva = DebugEntry->RVA;
|
||||
if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) {
|
||||
Section--;
|
||||
if ((UINTN) Section->SizeOfRawData < Section->Misc.VirtualSize) {
|
||||
TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize;
|
||||
} else {
|
||||
TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData;
|
||||
}
|
||||
}
|
||||
if (TempDebugEntryRva != 0) {
|
||||
ImageContext->CodeView = PeCoffLoader64ImageAddress (ImageContext, TempDebugEntryRva);
|
||||
if (ImageContext->CodeView == NULL) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
if (DebugEntry->RVA == 0) {
|
||||
Size = (UINTN) DebugEntry->SizeOfData;
|
||||
Status = ImageContext->ImageRead (
|
||||
ImageContext->Handle,
|
||||
DebugEntry->FileOffset,
|
||||
&Size,
|
||||
ImageContext->CodeView
|
||||
);
|
||||
if (EFI_ERROR(Status)) {
|
||||
ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ;
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
DebugEntry->RVA = TempDebugEntryRva;
|
||||
}
|
||||
|
||||
switch (* (UINT32 *) ImageContext->CodeView) {
|
||||
case CODEVIEW_SIGNATURE_NB10:
|
||||
ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY);
|
||||
break;
|
||||
case CODEVIEW_SIGNATURE_RSDS:
|
||||
ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
PeCoffLoader64UnloadImage (
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL *This,
|
||||
IN PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Unload of images is not supported
|
||||
|
||||
Arguments:
|
||||
ImageContext - The image to unload
|
||||
|
||||
Returns:
|
||||
EFI_SUCCESS
|
||||
|
||||
--*/
|
||||
{
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_PEI_PE_COFF_LOADER_PROTOCOL *
|
||||
EFIAPI
|
||||
GetPeCoffLoaderX64Protocol (
|
||||
)
|
||||
{
|
||||
return &mPeCoffLoaderX64;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1,46 +0,0 @@
|
|||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<ModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0">
|
||||
<MsaHeader>
|
||||
<ModuleName>EdkPeCoffLoaderX64Lib</ModuleName>
|
||||
<ModuleType>PEIM</ModuleType>
|
||||
<GuidValue>6aac37f2-7b46-4ef3-8645-c24800a3d410</GuidValue>
|
||||
<Version>1.0</Version>
|
||||
<Abstract>EdkPeCoffLoaderX64Lib library instance</Abstract>
|
||||
<Description>This library provides PeCoffLoader protocol to support PE64 image.</Description>
|
||||
<Copyright>Copyright (c) 2006, Intel Corporation.</Copyright>
|
||||
<License>All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.</License>
|
||||
<Specification>FRAMEWORK_BUILD_PACKAGING_SPECIFICATION 0x00000052</Specification>
|
||||
</MsaHeader>
|
||||
<ModuleDefinitions>
|
||||
<SupportedArchitectures>IA32 X64 IPF EBC</SupportedArchitectures>
|
||||
<BinaryModule>false</BinaryModule>
|
||||
<OutputFileBasename>EdkPeCoffLoaderX64Lib</OutputFileBasename>
|
||||
</ModuleDefinitions>
|
||||
<LibraryClassDefinitions>
|
||||
<LibraryClass Usage="ALWAYS_PRODUCED">
|
||||
<Keyword>EdkPeCoffLoaderX64Lib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>BaseMemoryLib</Keyword>
|
||||
</LibraryClass>
|
||||
<LibraryClass Usage="ALWAYS_CONSUMED">
|
||||
<Keyword>PeCoffLib</Keyword>
|
||||
</LibraryClass>
|
||||
</LibraryClassDefinitions>
|
||||
<SourceFiles>
|
||||
<Filename>EdkPeCoffLoaderX64.c</Filename>
|
||||
</SourceFiles>
|
||||
<PackageDependencies>
|
||||
<Package PackageGuid="5e0e9358-46b6-4ae2-8218-4ab8b9bbdcec"/>
|
||||
<Package PackageGuid="68169ab0-d41b-4009-9060-292c253ac43d"/>
|
||||
</PackageDependencies>
|
||||
<Externs>
|
||||
<Specification>EFI_SPECIFICATION_VERSION 0x00020000</Specification>
|
||||
<Specification>EDK_RELEASE_VERSION 0x00020000</Specification>
|
||||
</Externs>
|
||||
</ModuleSurfaceArea>
|
||||
Loading…
Reference in New Issue