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