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