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