MdePkg/Library/BasePeCoffGetEntryPointLib/PeCoffGetEntryPoint.c

   1 /** @file
   2   Tiano PE/COFF loader.
   3
   4   Copyright (c) 2006 - 2007, 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
  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                  *DosHeader;
  49   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Header;
  50
  51   ASSERT (Pe32Data   != NULL);
  52   ASSERT (EntryPoint != NULL);
  53
  54   DosHeader = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
  55   if (DosHeader->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     Header.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHeader->e_lfanew) & 0x0ffff));
  60   } else {
  61     //
  62     // DOS image header is not present, so PE header is at the image base.
  63     //
  64     Header.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   *EntryPoint = (VOID *)((UINTN)Pe32Data + (UINTN)(Header.Pe32->OptionalHeader.AddressOfEntryPoint & 0x0ffffffff));
  72   return RETURN_SUCCESS;
  73 }
  74
  75
  76 /**
  77   Returns the machine type of a PE/COFF image.
  78
  79   Returns the machine type from the PE/COFF image specified by Pe32Data.
  80   If Pe32Data is NULL, then ASSERT().
  81
  82   @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system
  83                      memory.
  84
  85   @return Machine type or zero if not a valid iamge.
  86
  87 **/
  88 UINT16
  89 EFIAPI
  90 PeCoffLoaderGetMachineType (
  91   IN VOID  *Pe32Data
  92   )
  93 {
  94   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION  Hdr;
  95   EFI_IMAGE_DOS_HEADER                 *DosHdr;
  96
  97   DosHdr = (EFI_IMAGE_DOS_HEADER  *)Pe32Data;
  98   if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
  99     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)Pe32Data + DosHdr->e_lfanew);
 100   } else {
 101     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)Pe32Data);
 102   }
 103
 104   if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE)  {
 105     return Hdr.Pe32->FileHeader.Machine;
 106   }
 107
 108   return 0x0000;
 109 }
 110
 111 /**
 112   Returns a pointer to the PDB file name for a PE/COFF image that has been
 113   loaded into system memory with the PE/COFF Loader Library functions.
 114
 115   Returns the PDB file name for the PE/COFF image specified by Pe32Data.  If
 116   the PE/COFF image specified by Pe32Data is not a valid, then NULL is
 117   returned.  If the PE/COFF image specified by Pe32Data does not contain a
 118   debug directory entry, then NULL is returned.  If the debug directory entry
 119   in the PE/COFF image specified by Pe32Data does not contain a PDB file name,
 120   then NULL is returned.
 121   If Pe32Data is NULL, then ASSERT().
 122
 123   @param  Pe32Data   Pointer to the PE/COFF image that is loaded in system
 124                      memory.
 125
 126   @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL
 127           if it cannot be retrieved.
 128
 129 **/
 130 VOID *
 131 EFIAPI
 132 PeCoffLoaderGetPdbPointer (
 133   IN VOID  *Pe32Data
 134   )
 135 {
 136   EFI_IMAGE_DOS_HEADER                  *DosHeader;
 137   EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION   Hdr;
 138   EFI_IMAGE_DATA_DIRECTORY              *DirectoryEntry;
 139   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY       *DebugEntry;
 140   UINTN                                 DirCount;
 141   VOID                                  *CodeViewEntryPointer;
 142   INTN                                  TEImageAdjust;
 143   UINT32                                NumberOfRvaAndSizes;
 144   UINT16                                Magic;
 145
 146   ASSERT (Pe32Data   != NULL);
 147
 148   TEImageAdjust       = 0;
 149   DirectoryEntry      = NULL;
 150   DebugEntry          = NULL;
 151   NumberOfRvaAndSizes = 0;
 152
 153   DosHeader = (EFI_IMAGE_DOS_HEADER *)Pe32Data;
 154   if (DosHeader->e_magic == EFI_IMAGE_DOS_SIGNATURE) {
 155     //
 156     // DOS image header is present, so read the PE header after the DOS image header.
 157     //
 158     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHeader->e_lfanew) & 0x0ffff));
 159   } else {
 160     //
 161     // DOS image header is not present, so PE header is at the image base.
 162     //
 163     Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data;
 164   }
 165
 166   if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {
 167     if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) {
 168       DirectoryEntry  = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG];
 169       TEImageAdjust   = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize;
 170       DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te +
 171                     Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress +
 172                     TEImageAdjust);
 173     }
 174   } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) {
 175     //
 176     // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic.
 177     //       It is due to backward-compatibility, for some system might
 178     //       generate PE32+ image with PE32 Magic.
 179     //
 180     switch (Hdr.Pe32->FileHeader.Machine) {
 181     case EFI_IMAGE_MACHINE_IA32:
 182       //
 183       // Assume PE32 image with IA32 Machine field.
 184       //
 185       Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;
 186       break;
 187     case EFI_IMAGE_MACHINE_X64:
 188     case EFI_IMAGE_MACHINE_IPF:
 189       //
 190       // Assume PE32+ image with X64 or IPF Machine field
 191       //
 192       Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;
 193       break;
 194     default:
 195       //
 196       // For unknow Machine field, use Magic in optional Header
 197       //
 198       Magic = Hdr.Pe32->OptionalHeader.Magic;
 199     }
 200
 201     if (Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 202       //
 203       // Use PE32 offset get Debug Directory Entry
 204       //
 205       NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes;
 206       DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 207       DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
 208     } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
 209       //
 210       // Use PE32+ offset get Debug Directory Entry
 211       //
 212       NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes;
 213       DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 214       DebugEntry     = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ((UINTN) Pe32Data + DirectoryEntry->VirtualAddress);
 215     }
 216
 217     if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
 218       DirectoryEntry = NULL;
 219       DebugEntry = NULL;
 220     }
 221   } else {
 222     return NULL;
 223   }
 224
 225   if (DebugEntry == NULL || DirectoryEntry == NULL) {
 226     return NULL;
 227   }
 228
 229   for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount++, DebugEntry++) {
 230     if (DebugEntry->Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
 231       if (DebugEntry->SizeOfData > 0) {
 232         CodeViewEntryPointer = (VOID *) ((UINTN) DebugEntry->RVA + ((UINTN)Pe32Data) + (UINTN)TEImageAdjust);
 233         switch (* (UINT32 *) CodeViewEntryPointer) {
 234         case CODEVIEW_SIGNATURE_NB10:
 235           return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY));
 236         case CODEVIEW_SIGNATURE_RSDS:
 237           return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY));
 238         default:
 239           break;
 240         }
 241       }
 242     }
 243   }
 244
 245   return NULL;
 246 }
 247
 248