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