MdePkg/Library/BasePeCoffGetEntryPointLib/PeCoffGetEntryPoint.c

   1 /** @file
   2   Provides the services to get the entry point to a PE/COFF image that has either been
   3   loaded into memory or is executing at it's linked address.
   4
   5   Copyright (c) 2006 - 2008, Intel Corporation<BR>
   6   All rights reserved. This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16
  17 #include <Base.h>
  18
  19 #include <Library/PeCoffGetEntryPointLib.h>
  20 #include <Library/DebugLib.h>
  21
  22 #include <IndustryStandard/PeImage.h>
  23
  24 /**
  25   Retrieves and returns a pointer to the entry point to a PE/COFF image that has been loaded
  26   into system memory with the PE/COFF Loader Library functions.
  27
  28   Retrieves the entry point to the PE/COFF image specified by Pe32Data and returns this entry
  29   point in EntryPoint.  If the entry point could not be retrieved from the PE/COFF image, then
  30   return RETURN_INVALID_PARAMETER.  Otherwise return RETURN_SUCCESS.
  31   If Pe32Data is NULL, then ASSERT().
  32   If EntryPoint is NULL, then ASSERT().
  33
  34   @param  Pe32Data                  Pointer to the PE/COFF image that is loaded in system memory.
  35   @param  EntryPoint                Pointer to entry point to the PE/COFF image to return.
  36
  37   @retval RETURN_SUCCESS            EntryPoint was returned.
  38   @retval RETURN_INVALID_PARAMETER  The entry point could not be found in the PE/COFF image.
  39
  40 **/
  41 RETURN_STATUS
  42 EFIAPI
  43 PeCoffLoaderGetEntryPoint (
  44   IN  VOID  *Pe32Data,
  45   OUT VOID  **EntryPoint
  46   )
  47 {
  48   EFI_IMAGE_DOS_HEADER                  *DosHdr;
  49   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
  50
  51   ASSERT (Pe32Data   != NULL);
  52   ASSERT (EntryPoint != NULL);
  53
  54   DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
  55   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
  56     //
  57     // DOS image header is present, so read the PE header after the DOS image header.
  58     //
  59     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
  60   } else {
  61     //
  62     // DOS image header is not present, so PE header is at the image base.
  63     //
  64     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
  65   }
  66
  67   //
  68   // Calculate the entry point relative to the start of the image.
  69   // AddressOfEntryPoint is common for PE32 & PE32+
  70   //
  71   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
  72     *EntryPoint = (VOID *)((UINTN)Pe32Data + (UINTN)(Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof(EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize);
  73     return RETURN_SUCCESS;
  74   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
  75     *EntryPoint = (VOID *)((UINTN)Pe32Data + (UINTN)(Hdr.Pe32->OptionalHeader.AddressOfEntryPoint & 0x0ffffffff));
  76     return RETURN_SUCCESS;
  77   }
  78
  79   return RETURN_UNSUPPORTED;
  80 }
  81
  82
  83 /**
  84   Returns the machine type of a PE/COFF image.
  85
  86   Returns the machine type from the PE/COFF image specified by Pe32Data.
  87   If Pe32Data is NULL, then ASSERT().
  88
  89   @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system
  90                      memory.
  91
  92   @return Machine type or zero if not a valid iamge.
  93
  94 **/
  95 UINT16
  96 EFIAPI
  97 PeCoffLoaderGetMachineType (
  98   IN VOID  *Pe32Data
  99   )
 100 {
 101   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;
 102   EFI_IMAGE_DOS_HEADER                 *DosHdr;
 103
 104   ASSERT (Pe32Data != NULL);
 105
 106   DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
 107   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
 108     //
 109     // DOS image header is present, so read the PE header after the DOS image header.
 110     //
 111     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
 112   } else {
 113     //
 114     // DOS image header is not present, so PE header is at the image base.
 115     //
 116     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
 117   }
 118
 119   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 120     return Hdr.Te->Machine;
 121   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE)  {
 122     return Hdr.Pe32->FileHeader.Machine;
 123   }
 124
 125   return 0x0000;
 126 }
 127
 128 /**
 129   Returns a pointer to the PDB file name for a PE/COFF image that has been
 130   loaded into system memory with the PE/COFF Loader Library functions.
 131
 132   Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If
 133   the PE/COFF image specified by Pe32Data is not a valid, then NULL is
 134   returned.  If the PE/COFF image specified by Pe32Data does not contain a
 135   debug directory entry, then NULL is returned.  If the debug directory entry
 136   in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
 137   then NULL is returned.
 138   If Pe32Data is NULL, then ASSERT().
 139
 140   @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system
 141                      memory.
 142
 143   @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL
 144           if it cannot be retrieved.
 145
 146 **/
 147 VOID *
 148 EFIAPI
 149 PeCoffLoaderGetPdbPointer (
 150   IN VOID  *Pe32Data
 151   )
 152 {
 153   EFI_IMAGE_DOS_HEADER                  *DosHdr;
 154   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
 155   EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;
 156   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;
 157   UINTN                                 DirCount;
 158   VOID                                  *CodeViewEntryPointer;
 159   INTN                                  TEImageAdjust;
 160   UINT32                                NumberOfRvaAndSizes;
 161   UINT16                                Magic;
 162
 163   ASSERT (Pe32Data   != NULL);
 164
 165   TEImageAdjust       = 0;
 166   DirectoryEntry      = NULL;
 167   DebugEntry          = NULL;
 168   NumberOfRvaAndSizes = 0;
 169
 170   DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
 171   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
 172     //
 173     // DOS image header is present, so read the PE header after the DOS image header.
 174     //
 175     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff));
 176   } else {
 177     //
 178     // DOS image header is not present, so PE header is at the image base.
 179     //
 180     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
 181   }
 182
 183   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 184     if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {
 185       DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];
 186       TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;
 187       DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +
 188                     Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +
 189                     TEImageAdjust);
 190     }
 191   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
 192     //
 193     // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.
 194     //       It is due to backward-compatibility, for some system might
 195     //       generate PE32+ image with PE32 Magic.
 196     //
 197     switch (Hdr.Pe32->FileHeader.Machine) {
 198     case EFI_IMAGE_MACHINE_IA32:
 199       //
 200       // Assume PE32 image with IA32 Machine field.
 201       //
 202       Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 203       break;
 204     case EFI_IMAGE_MACHINE_X64:
 205     case EFI_IMAGE_MACHINE_IPF:
 206       //
 207       // Assume PE32+ image with X64 or IPF Machine field
 208       //
 209       Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 210       break;
 211     default:
 212       //
 213       // For unknow Machine field, use Magic in optional Header
 214       //
 215       Magic = Hdr.Pe32->OptionalHeader.Magic;
 216     }
 217
 218     if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 219       //
 220       // Use PE32 offset get Debug Directory Entry
 221       //
 222       NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
 223       DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 224       DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
 225     } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
 226       //
 227       // Use PE32+ offset get Debug Directory Entry
 228       //
 229       NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
 230       DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 231       DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
 232     }
 233
 234     if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
 235       DirectoryEntry = NULL;
 236       DebugEntry = NULL;
 237     }
 238   } else {
 239     return NULL;
 240   }
 241
 242   if (DebugEntry == NULL || DirectoryEntry == NULL) {
 243     return NULL;
 244   }
 245
 246   //
 247   // Scan the directory to find the debug entry.
 248   //
 249   for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) {
 250     if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
 251       if (DebugEntry->SizeOfData > 0) {
 252         CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);
 253         switch (* (UINT32 *) CodeViewEntryPointer) {
 254         case CODEVIEW_SIGNATURE_NB10:
 255           return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));
 256         case CODEVIEW_SIGNATURE_RSDS:
 257           return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));
 258         default:
 259           break;
 260         }
 261       }
 262     }
 263   }
 264
 265   return NULL;
 266 }
 267
 268