1 /** @file 2 3 Functions to get info and load PE/COFF image. 4 5 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR> 6 Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR> 7 This program and the accompanying materials 8 are licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include <Common/UefiBaseTypes.h> 18 #include <CommonLib.h> 19 #include <IndustryStandard/PeImage.h> 20 #include "PeCoffLib.h" 21 22 typedef union { 23 VOID *Header; 24 EFI_IMAGE_OPTIONAL_HEADER32 *Optional32; 25 EFI_IMAGE_OPTIONAL_HEADER64 *Optional64; 26 } EFI_IMAGE_OPTIONAL_HEADER_POINTER; 27 28 STATIC 29 RETURN_STATUS 30 PeCoffLoaderGetPeHeader ( 31 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 32 OUT EFI_IMAGE_OPTIONAL_HEADER_UNION **PeHdr, 33 OUT EFI_TE_IMAGE_HEADER **TeHdr 34 ); 35 36 STATIC 37 RETURN_STATUS 38 PeCoffLoaderCheckImageType ( 39 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 40 IN EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr, 41 IN EFI_TE_IMAGE_HEADER *TeHdr 42 ); 43 44 STATIC 45 VOID * 46 PeCoffLoaderImageAddress ( 47 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 48 IN UINTN Address 49 ); 50 51 RETURN_STATUS 52 PeCoffLoaderRelocateIa32Image ( 53 IN UINT16 *Reloc, 54 IN OUT CHAR8 *Fixup, 55 IN OUT CHAR8 **FixupData, 56 IN UINT64 Adjust 57 ); 58 59 RETURN_STATUS 60 PeCoffLoaderRelocateIpfImage ( 61 IN UINT16 *Reloc, 62 IN OUT CHAR8 *Fixup, 63 IN OUT CHAR8 **FixupData, 64 IN UINT64 Adjust 65 ); 66 67 RETURN_STATUS 68 PeCoffLoaderRelocateArmImage ( 69 IN UINT16 **Reloc, 70 IN OUT CHAR8 *Fixup, 71 IN OUT CHAR8 **FixupData, 72 IN UINT64 Adjust 73 ); 74 75 STATIC 76 RETURN_STATUS 77 PeCoffLoaderGetPeHeader ( 78 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 79 OUT EFI_IMAGE_OPTIONAL_HEADER_UNION **PeHdr, 80 OUT EFI_TE_IMAGE_HEADER **TeHdr 81 ) 82 /*++ 83 84 Routine Description: 85 86 Retrieves the PE or TE Header from a PE/COFF or TE image 87 88 Arguments: 89 90 ImageContext - The context of the image being loaded 91 92 PeHdr - The buffer in which to return the PE header 93 94 TeHdr - The buffer in which to return the TE header 95 96 Returns: 97 98 RETURN_SUCCESS if the PE or TE Header is read, 99 Otherwise, the error status from reading the PE/COFF or TE image using the ImageRead function. 100 101 --*/ 102 { 103 RETURN_STATUS Status; 104 EFI_IMAGE_DOS_HEADER DosHdr; 105 UINTN Size; 106 107 ImageContext->IsTeImage = FALSE; 108 // 109 // Read the DOS image headers 110 // 111 Size = sizeof (EFI_IMAGE_DOS_HEADER); 112 Status = ImageContext->ImageRead ( 113 ImageContext->Handle, 114 0, 115 &Size, 116 &DosHdr 117 ); 118 if (RETURN_ERROR (Status)) { 119 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 120 return Status; 121 } 122 123 ImageContext->PeCoffHeaderOffset = 0; 124 if (DosHdr.e_magic == EFI_IMAGE_DOS_SIGNATURE) { 125 // 126 // DOS image header is present, so read the PE header after the DOS image header 127 // 128 ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew; 129 } 130 // 131 // Get the PE/COFF Header pointer 132 // 133 *PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) ((UINTN)ImageContext->Handle + ImageContext->PeCoffHeaderOffset); 134 if ((*PeHdr)->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) { 135 // 136 // Check the PE/COFF Header Signature. If not, then try to get a TE header 137 // 138 *TeHdr = (EFI_TE_IMAGE_HEADER *)*PeHdr; 139 if ((*TeHdr)->Signature != EFI_TE_IMAGE_HEADER_SIGNATURE) { 140 return RETURN_UNSUPPORTED; 141 } 142 ImageContext->IsTeImage = TRUE; 143 } 144 145 return RETURN_SUCCESS; 146 } 147 148 STATIC 149 RETURN_STATUS 150 PeCoffLoaderCheckImageType ( 151 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 152 IN EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr, 153 IN EFI_TE_IMAGE_HEADER *TeHdr 154 ) 155 /*++ 156 157 Routine Description: 158 159 Checks the PE or TE header of a PE/COFF or TE image to determine if it supported 160 161 Arguments: 162 163 ImageContext - The context of the image being loaded 164 165 PeHdr - The buffer in which to return the PE header 166 167 TeHdr - The buffer in which to return the TE header 168 169 Returns: 170 171 RETURN_SUCCESS if the PE/COFF or TE image is supported 172 RETURN_UNSUPPORTED of the PE/COFF or TE image is not supported. 173 174 --*/ 175 { 176 // 177 // See if the machine type is supported. 178 // We support a native machine type (IA-32/Itanium-based) 179 // 180 if (ImageContext->IsTeImage == FALSE) { 181 ImageContext->Machine = PeHdr->Pe32.FileHeader.Machine; 182 } else { 183 ImageContext->Machine = TeHdr->Machine; 184 } 185 186 if (ImageContext->Machine != EFI_IMAGE_MACHINE_IA32 && \ 187 ImageContext->Machine != EFI_IMAGE_MACHINE_IA64 && \ 188 ImageContext->Machine != EFI_IMAGE_MACHINE_X64 && \ 189 ImageContext->Machine != EFI_IMAGE_MACHINE_ARMT && \ 190 ImageContext->Machine != EFI_IMAGE_MACHINE_EBC && \ 191 ImageContext->Machine != EFI_IMAGE_MACHINE_AARCH64) { 192 if (ImageContext->Machine == IMAGE_FILE_MACHINE_ARM) { 193 // 194 // There are two types of ARM images. Pure ARM and ARM/Thumb. 195 // If we see the ARM say it is the ARM/Thumb so there is only 196 // a single machine type we need to check for ARM. 197 // 198 ImageContext->Machine = EFI_IMAGE_MACHINE_ARMT; 199 if (ImageContext->IsTeImage == FALSE) { 200 PeHdr->Pe32.FileHeader.Machine = ImageContext->Machine; 201 } else { 202 TeHdr->Machine = ImageContext->Machine; 203 } 204 205 } else { 206 // 207 // unsupported PeImage machine type 208 // 209 return RETURN_UNSUPPORTED; 210 } 211 } 212 213 // 214 // See if the image type is supported. We support EFI Applications, 215 // EFI Boot Service Drivers, EFI Runtime Drivers and EFI SAL Drivers. 216 // 217 if (ImageContext->IsTeImage == FALSE) { 218 ImageContext->ImageType = PeHdr->Pe32.OptionalHeader.Subsystem; 219 } else { 220 ImageContext->ImageType = (UINT16) (TeHdr->Subsystem); 221 } 222 223 if (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION && \ 224 ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER && \ 225 ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER && \ 226 ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER) { 227 // 228 // upsupported PeImage subsystem type 229 // 230 return RETURN_UNSUPPORTED; 231 } 232 233 return RETURN_SUCCESS; 234 } 235 236 RETURN_STATUS 237 EFIAPI 238 PeCoffLoaderGetImageInfo ( 239 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext 240 ) 241 /*++ 242 243 Routine Description: 244 245 Retrieves information on a PE/COFF image 246 247 Arguments: 248 249 This - Calling context 250 ImageContext - The context of the image being loaded 251 252 Returns: 253 254 RETURN_SUCCESS - The information on the PE/COFF image was collected. 255 RETURN_INVALID_PARAMETER - ImageContext is NULL. 256 RETURN_UNSUPPORTED - The PE/COFF image is not supported. 257 Otherwise - The error status from reading the PE/COFF image using the 258 ImageContext->ImageRead() function 259 260 --*/ 261 { 262 RETURN_STATUS Status; 263 EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; 264 EFI_TE_IMAGE_HEADER *TeHdr; 265 EFI_IMAGE_DATA_DIRECTORY *DebugDirectoryEntry; 266 UINTN Size; 267 UINTN Index; 268 UINTN DebugDirectoryEntryRva; 269 UINTN DebugDirectoryEntryFileOffset; 270 UINTN SectionHeaderOffset; 271 EFI_IMAGE_SECTION_HEADER SectionHeader; 272 EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry; 273 EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; 274 275 PeHdr = NULL; 276 TeHdr = NULL; 277 DebugDirectoryEntry = NULL; 278 DebugDirectoryEntryRva = 0; 279 280 if (NULL == ImageContext) { 281 return RETURN_INVALID_PARAMETER; 282 } 283 // 284 // Assume success 285 // 286 ImageContext->ImageError = IMAGE_ERROR_SUCCESS; 287 288 Status = PeCoffLoaderGetPeHeader (ImageContext, &PeHdr, &TeHdr); 289 if (RETURN_ERROR (Status)) { 290 return Status; 291 } 292 293 // 294 // Verify machine type 295 // 296 Status = PeCoffLoaderCheckImageType (ImageContext, PeHdr, TeHdr); 297 if (RETURN_ERROR (Status)) { 298 return Status; 299 } 300 OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); 301 302 // 303 // Retrieve the base address of the image 304 // 305 if (!(ImageContext->IsTeImage)) { 306 if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 307 ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional32->ImageBase; 308 } else { 309 ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional64->ImageBase; 310 } 311 } else { 312 ImageContext->ImageAddress = (PHYSICAL_ADDRESS) (TeHdr->ImageBase + TeHdr->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER)); 313 } 314 // 315 // Initialize the alternate destination address to 0 indicating that it 316 // should not be used. 317 // 318 ImageContext->DestinationAddress = 0; 319 320 // 321 // Initialize the codeview pointer. 322 // 323 ImageContext->CodeView = NULL; 324 ImageContext->PdbPointer = NULL; 325 326 // 327 // Three cases with regards to relocations: 328 // - Image has base relocs, RELOCS_STRIPPED==0 => image is relocatable 329 // - Image has no base relocs, RELOCS_STRIPPED==1 => Image is not relocatable 330 // - Image has no base relocs, RELOCS_STRIPPED==0 => Image is relocatable but 331 // has no base relocs to apply 332 // Obviously having base relocations with RELOCS_STRIPPED==1 is invalid. 333 // 334 // Look at the file header to determine if relocations have been stripped, and 335 // save this info in the image context for later use. 336 // 337 if ((!(ImageContext->IsTeImage)) && ((PeHdr->Pe32.FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) != 0)) { 338 ImageContext->RelocationsStripped = TRUE; 339 } else if ((ImageContext->IsTeImage) && (TeHdr->DataDirectory[0].Size == 0) && (TeHdr->DataDirectory[0].VirtualAddress == 0)) { 340 ImageContext->RelocationsStripped = TRUE; 341 } else { 342 ImageContext->RelocationsStripped = FALSE; 343 } 344 345 if (!(ImageContext->IsTeImage)) { 346 347 if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 348 ImageContext->ImageSize = (UINT64) OptionHeader.Optional32->SizeOfImage; 349 ImageContext->SectionAlignment = OptionHeader.Optional32->SectionAlignment; 350 ImageContext->SizeOfHeaders = OptionHeader.Optional32->SizeOfHeaders; 351 352 // 353 // Modify ImageSize to contain .PDB file name if required and initialize 354 // PdbRVA field... 355 // 356 if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) { 357 DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); 358 DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; 359 } 360 } else { 361 ImageContext->ImageSize = (UINT64) OptionHeader.Optional64->SizeOfImage; 362 ImageContext->SectionAlignment = OptionHeader.Optional64->SectionAlignment; 363 ImageContext->SizeOfHeaders = OptionHeader.Optional64->SizeOfHeaders; 364 365 // 366 // Modify ImageSize to contain .PDB file name if required and initialize 367 // PdbRVA field... 368 // 369 if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) { 370 DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); 371 DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; 372 } 373 } 374 375 if (DebugDirectoryEntryRva != 0) { 376 // 377 // Determine the file offset of the debug directory... This means we walk 378 // the sections to find which section contains the RVA of the debug 379 // directory 380 // 381 DebugDirectoryEntryFileOffset = 0; 382 383 SectionHeaderOffset = (UINTN)( 384 ImageContext->PeCoffHeaderOffset + 385 sizeof (UINT32) + 386 sizeof (EFI_IMAGE_FILE_HEADER) + 387 PeHdr->Pe32.FileHeader.SizeOfOptionalHeader 388 ); 389 390 for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++) { 391 // 392 // Read section header from file 393 // 394 Size = sizeof (EFI_IMAGE_SECTION_HEADER); 395 Status = ImageContext->ImageRead ( 396 ImageContext->Handle, 397 SectionHeaderOffset, 398 &Size, 399 &SectionHeader 400 ); 401 if (RETURN_ERROR (Status)) { 402 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 403 return Status; 404 } 405 406 if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress && 407 DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) { 408 DebugDirectoryEntryFileOffset = 409 DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData; 410 break; 411 } 412 413 SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER); 414 } 415 416 if (DebugDirectoryEntryFileOffset != 0) { 417 for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) { 418 // 419 // Read next debug directory entry 420 // 421 Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); 422 Status = ImageContext->ImageRead ( 423 ImageContext->Handle, 424 DebugDirectoryEntryFileOffset + Index, 425 &Size, 426 &DebugEntry 427 ); 428 if (RETURN_ERROR (Status)) { 429 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 430 return Status; 431 } 432 433 if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) { 434 ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index); 435 if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) { 436 ImageContext->ImageSize += DebugEntry.SizeOfData; 437 } 438 439 return RETURN_SUCCESS; 440 } 441 } 442 } 443 } 444 } else { 445 ImageContext->ImageSize = 0; 446 ImageContext->SectionAlignment = 4096; 447 ImageContext->SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN) TeHdr->BaseOfCode - (UINTN) TeHdr->StrippedSize; 448 449 DebugDirectoryEntry = &TeHdr->DataDirectory[1]; 450 DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; 451 SectionHeaderOffset = (UINTN) (sizeof (EFI_TE_IMAGE_HEADER)); 452 453 DebugDirectoryEntryFileOffset = 0; 454 455 for (Index = 0; Index < TeHdr->NumberOfSections;) { 456 // 457 // Read section header from file 458 // 459 Size = sizeof (EFI_IMAGE_SECTION_HEADER); 460 Status = ImageContext->ImageRead ( 461 ImageContext->Handle, 462 SectionHeaderOffset, 463 &Size, 464 &SectionHeader 465 ); 466 if (RETURN_ERROR (Status)) { 467 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 468 return Status; 469 } 470 471 if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress && 472 DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) { 473 DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva - 474 SectionHeader.VirtualAddress + 475 SectionHeader.PointerToRawData + 476 sizeof (EFI_TE_IMAGE_HEADER) - 477 TeHdr->StrippedSize; 478 479 // 480 // File offset of the debug directory was found, if this is not the last 481 // section, then skip to the last section for calculating the image size. 482 // 483 if (Index < (UINTN) TeHdr->NumberOfSections - 1) { 484 SectionHeaderOffset += (TeHdr->NumberOfSections - 1 - Index) * sizeof (EFI_IMAGE_SECTION_HEADER); 485 Index = TeHdr->NumberOfSections - 1; 486 continue; 487 } 488 } 489 490 // 491 // In Te image header there is not a field to describe the ImageSize. 492 // Actually, the ImageSize equals the RVA plus the VirtualSize of 493 // the last section mapped into memory (Must be rounded up to 494 // a mulitple of Section Alignment). Per the PE/COFF specification, the 495 // section headers in the Section Table must appear in order of the RVA 496 // values for the corresponding sections. So the ImageSize can be determined 497 // by the RVA and the VirtualSize of the last section header in the 498 // Section Table. 499 // 500 if ((++Index) == (UINTN) TeHdr->NumberOfSections) { 501 ImageContext->ImageSize = (SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize + 502 ImageContext->SectionAlignment - 1) & ~(ImageContext->SectionAlignment - 1); 503 } 504 505 SectionHeaderOffset += sizeof (EFI_IMAGE_SECTION_HEADER); 506 } 507 508 if (DebugDirectoryEntryFileOffset != 0) { 509 for (Index = 0; Index < DebugDirectoryEntry->Size; Index += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) { 510 // 511 // Read next debug directory entry 512 // 513 Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); 514 Status = ImageContext->ImageRead ( 515 ImageContext->Handle, 516 DebugDirectoryEntryFileOffset, 517 &Size, 518 &DebugEntry 519 ); 520 if (RETURN_ERROR (Status)) { 521 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 522 return Status; 523 } 524 525 if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) { 526 ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index); 527 return RETURN_SUCCESS; 528 } 529 } 530 } 531 } 532 533 return RETURN_SUCCESS; 534 } 535 536 STATIC 537 VOID * 538 PeCoffLoaderImageAddress ( 539 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, 540 IN UINTN Address 541 ) 542 /*++ 543 544 Routine Description: 545 546 Converts an image address to the loaded address 547 548 Arguments: 549 550 ImageContext - The context of the image being loaded 551 552 Address - The address to be converted to the loaded address 553 554 Returns: 555 556 NULL if the address can not be converted, otherwise, the converted address 557 558 --*/ 559 { 560 if (Address >= ImageContext->ImageSize) { 561 ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS; 562 return NULL; 563 } 564 565 return (UINT8 *) ((UINTN) ImageContext->ImageAddress + Address); 566 } 567 568 RETURN_STATUS 569 EFIAPI 570 PeCoffLoaderRelocateImage ( 571 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext 572 ) 573 /*++ 574 575 Routine Description: 576 577 Relocates a PE/COFF image in memory 578 579 Arguments: 580 581 This - Calling context 582 583 ImageContext - Contains information on the loaded image to relocate 584 585 Returns: 586 587 RETURN_SUCCESS if the PE/COFF image was relocated 588 RETURN_LOAD_ERROR if the image is not a valid PE/COFF image 589 RETURN_UNSUPPORTED not support 590 591 --*/ 592 { 593 RETURN_STATUS Status; 594 EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; 595 EFI_TE_IMAGE_HEADER *TeHdr; 596 EFI_IMAGE_DATA_DIRECTORY *RelocDir; 597 UINT64 Adjust; 598 EFI_IMAGE_BASE_RELOCATION *RelocBase; 599 EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd; 600 UINT16 *Reloc; 601 UINT16 *RelocEnd; 602 CHAR8 *Fixup; 603 CHAR8 *FixupBase; 604 UINT16 *F16; 605 UINT32 *F32; 606 UINT64 *F64; 607 CHAR8 *FixupData; 608 PHYSICAL_ADDRESS BaseAddress; 609 UINT16 MachineType; 610 EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; 611 612 PeHdr = NULL; 613 TeHdr = NULL; 614 // 615 // Assume success 616 // 617 ImageContext->ImageError = IMAGE_ERROR_SUCCESS; 618 619 // 620 // If there are no relocation entries, then we are done 621 // 622 if (ImageContext->RelocationsStripped) { 623 return RETURN_SUCCESS; 624 } 625 626 // 627 // Use DestinationAddress field of ImageContext as the relocation address even if it is 0. 628 // 629 BaseAddress = ImageContext->DestinationAddress; 630 631 if (!(ImageContext->IsTeImage)) { 632 PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN)ImageContext->ImageAddress + 633 ImageContext->PeCoffHeaderOffset); 634 OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); 635 if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 636 Adjust = (UINT64) BaseAddress - OptionHeader.Optional32->ImageBase; 637 OptionHeader.Optional32->ImageBase = (UINT32) BaseAddress; 638 MachineType = ImageContext->Machine; 639 // 640 // Find the relocation block 641 // 642 // Per the PE/COFF spec, you can't assume that a given data directory 643 // is present in the image. You have to check the NumberOfRvaAndSizes in 644 // the optional header to verify a desired directory entry is there. 645 // 646 if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { 647 RelocDir = &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; 648 if ((RelocDir != NULL) && (RelocDir->Size > 0)) { 649 RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); 650 RelocBaseEnd = PeCoffLoaderImageAddress ( 651 ImageContext, 652 RelocDir->VirtualAddress + RelocDir->Size - 1 653 ); 654 if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) { 655 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 656 return RETURN_LOAD_ERROR; 657 } 658 } else { 659 // 660 // Set base and end to bypass processing below. 661 // 662 RelocBase = RelocBaseEnd = 0; 663 } 664 } else { 665 // 666 // Set base and end to bypass processing below. 667 // 668 RelocBase = RelocBaseEnd = 0; 669 } 670 } else { 671 Adjust = (UINT64) BaseAddress - OptionHeader.Optional64->ImageBase; 672 OptionHeader.Optional64->ImageBase = BaseAddress; 673 MachineType = ImageContext->Machine; 674 // 675 // Find the relocation block 676 // 677 // Per the PE/COFF spec, you can't assume that a given data directory 678 // is present in the image. You have to check the NumberOfRvaAndSizes in 679 // the optional header to verify a desired directory entry is there. 680 // 681 if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { 682 RelocDir = &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; 683 if ((RelocDir != NULL) && (RelocDir->Size > 0)) { 684 RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); 685 RelocBaseEnd = PeCoffLoaderImageAddress ( 686 ImageContext, 687 RelocDir->VirtualAddress + RelocDir->Size - 1 688 ); 689 if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) { 690 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 691 return RETURN_LOAD_ERROR; 692 } 693 } else { 694 // 695 // Set base and end to bypass processing below. 696 // 697 RelocBase = RelocBaseEnd = 0; 698 } 699 } else { 700 // 701 // Set base and end to bypass processing below. 702 // 703 RelocBase = RelocBaseEnd = 0; 704 } 705 } 706 } else { 707 TeHdr = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress); 708 Adjust = (UINT64) (BaseAddress - TeHdr->ImageBase); 709 TeHdr->ImageBase = (UINT64) (BaseAddress); 710 MachineType = TeHdr->Machine; 711 712 // 713 // Find the relocation block 714 // 715 RelocDir = &TeHdr->DataDirectory[0]; 716 RelocBase = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)( 717 ImageContext->ImageAddress + 718 RelocDir->VirtualAddress + 719 sizeof(EFI_TE_IMAGE_HEADER) - 720 TeHdr->StrippedSize 721 ); 722 RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *) ((UINTN) RelocBase + (UINTN) RelocDir->Size - 1); 723 } 724 725 // 726 // Run the relocation information and apply the fixups 727 // 728 FixupData = ImageContext->FixupData; 729 while (RelocBase < RelocBaseEnd) { 730 731 Reloc = (UINT16 *) ((CHAR8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION)); 732 RelocEnd = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock); 733 if (!(ImageContext->IsTeImage)) { 734 FixupBase = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress); 735 if (FixupBase == NULL) { 736 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 737 return RETURN_LOAD_ERROR; 738 } 739 } else { 740 FixupBase = (CHAR8 *)(UINTN)(ImageContext->ImageAddress + 741 RelocBase->VirtualAddress + 742 sizeof(EFI_TE_IMAGE_HEADER) - 743 TeHdr->StrippedSize 744 ); 745 } 746 747 if ((CHAR8 *) RelocEnd < (CHAR8 *) ((UINTN) ImageContext->ImageAddress) || 748 (CHAR8 *) RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress + 749 (UINTN)ImageContext->ImageSize)) { 750 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 751 return RETURN_LOAD_ERROR; 752 } 753 754 // 755 // Run this relocation record 756 // 757 while (Reloc < RelocEnd) { 758 759 Fixup = FixupBase + (*Reloc & 0xFFF); 760 switch ((*Reloc) >> 12) { 761 case EFI_IMAGE_REL_BASED_ABSOLUTE: 762 break; 763 764 case EFI_IMAGE_REL_BASED_HIGH: 765 F16 = (UINT16 *) Fixup; 766 *F16 = (UINT16) (*F16 + ((UINT16) ((UINT32) Adjust >> 16))); 767 if (FixupData != NULL) { 768 *(UINT16 *) FixupData = *F16; 769 FixupData = FixupData + sizeof (UINT16); 770 } 771 break; 772 773 case EFI_IMAGE_REL_BASED_LOW: 774 F16 = (UINT16 *) Fixup; 775 *F16 = (UINT16) (*F16 + (UINT16) Adjust); 776 if (FixupData != NULL) { 777 *(UINT16 *) FixupData = *F16; 778 FixupData = FixupData + sizeof (UINT16); 779 } 780 break; 781 782 case EFI_IMAGE_REL_BASED_HIGHLOW: 783 F32 = (UINT32 *) Fixup; 784 *F32 = *F32 + (UINT32) Adjust; 785 if (FixupData != NULL) { 786 FixupData = ALIGN_POINTER (FixupData, sizeof (UINT32)); 787 *(UINT32 *) FixupData = *F32; 788 FixupData = FixupData + sizeof (UINT32); 789 } 790 break; 791 792 case EFI_IMAGE_REL_BASED_DIR64: 793 F64 = (UINT64 *) Fixup; 794 *F64 = *F64 + (UINT64) Adjust; 795 if (FixupData != NULL) { 796 FixupData = ALIGN_POINTER (FixupData, sizeof (UINT64)); 797 *(UINT64 *) FixupData = *F64; 798 FixupData = FixupData + sizeof (UINT64); 799 } 800 break; 801 802 case EFI_IMAGE_REL_BASED_HIGHADJ: 803 // 804 // Return the same EFI_UNSUPPORTED return code as 805 // PeCoffLoaderRelocateImageEx() returns if it does not recognize 806 // the relocation type. 807 // 808 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 809 return RETURN_UNSUPPORTED; 810 811 default: 812 switch (MachineType) { 813 case EFI_IMAGE_MACHINE_IA32: 814 Status = PeCoffLoaderRelocateIa32Image (Reloc, Fixup, &FixupData, Adjust); 815 break; 816 case EFI_IMAGE_MACHINE_ARMT: 817 Status = PeCoffLoaderRelocateArmImage (&Reloc, Fixup, &FixupData, Adjust); 818 break; 819 case EFI_IMAGE_MACHINE_IA64: 820 Status = PeCoffLoaderRelocateIpfImage (Reloc, Fixup, &FixupData, Adjust); 821 break; 822 default: 823 Status = RETURN_UNSUPPORTED; 824 break; 825 } 826 if (RETURN_ERROR (Status)) { 827 ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; 828 return Status; 829 } 830 } 831 832 // 833 // Next relocation record 834 // 835 Reloc += 1; 836 } 837 838 // 839 // Next reloc block 840 // 841 RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd; 842 } 843 844 return RETURN_SUCCESS; 845 } 846 847 RETURN_STATUS 848 EFIAPI 849 PeCoffLoaderLoadImage ( 850 IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext 851 ) 852 /*++ 853 854 Routine Description: 855 856 Loads a PE/COFF image into memory 857 858 Arguments: 859 860 This - Calling context 861 862 ImageContext - Contains information on image to load into memory 863 864 Returns: 865 866 RETURN_SUCCESS if the PE/COFF image was loaded 867 RETURN_BUFFER_TOO_SMALL if the caller did not provide a large enough buffer 868 RETURN_LOAD_ERROR if the image is a runtime driver with no relocations 869 RETURN_INVALID_PARAMETER if the image address is invalid 870 871 --*/ 872 { 873 RETURN_STATUS Status; 874 EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; 875 EFI_TE_IMAGE_HEADER *TeHdr; 876 PE_COFF_LOADER_IMAGE_CONTEXT CheckContext; 877 EFI_IMAGE_SECTION_HEADER *FirstSection; 878 EFI_IMAGE_SECTION_HEADER *Section; 879 UINTN NumberOfSections; 880 UINTN Index; 881 CHAR8 *Base; 882 CHAR8 *End; 883 CHAR8 *MaxEnd; 884 EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; 885 EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; 886 UINTN Size; 887 UINT32 TempDebugEntryRva; 888 EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; 889 890 PeHdr = NULL; 891 TeHdr = NULL; 892 OptionHeader.Header = NULL; 893 // 894 // Assume success 895 // 896 ImageContext->ImageError = IMAGE_ERROR_SUCCESS; 897 898 // 899 // Copy the provided context info into our local version, get what we 900 // can from the original image, and then use that to make sure everything 901 // is legit. 902 // 903 CopyMem (&CheckContext, ImageContext, sizeof (PE_COFF_LOADER_IMAGE_CONTEXT)); 904 905 Status = PeCoffLoaderGetImageInfo (&CheckContext); 906 if (RETURN_ERROR (Status)) { 907 return Status; 908 } 909 910 // 911 // Make sure there is enough allocated space for the image being loaded 912 // 913 if (ImageContext->ImageSize < CheckContext.ImageSize) { 914 ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_SIZE; 915 return RETURN_BUFFER_TOO_SMALL; 916 } 917 918 // 919 // If there's no relocations, then make sure it's not a runtime driver, 920 // and that it's being loaded at the linked address. 921 // 922 if (CheckContext.RelocationsStripped) { 923 // 924 // If the image does not contain relocations and it is a runtime driver 925 // then return an error. 926 // 927 if (CheckContext.ImageType == EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) { 928 ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM; 929 return RETURN_LOAD_ERROR; 930 } 931 // 932 // If the image does not contain relocations, and the requested load address 933 // is not the linked address, then return an error. 934 // 935 if (CheckContext.ImageAddress != ImageContext->ImageAddress) { 936 ImageContext->ImageError = IMAGE_ERROR_INVALID_IMAGE_ADDRESS; 937 return RETURN_INVALID_PARAMETER; 938 } 939 } 940 // 941 // Make sure the allocated space has the proper section alignment 942 // 943 if (!(ImageContext->IsTeImage)) { 944 if ((ImageContext->ImageAddress & (CheckContext.SectionAlignment - 1)) != 0) { 945 ImageContext->ImageError = IMAGE_ERROR_INVALID_SECTION_ALIGNMENT; 946 return RETURN_INVALID_PARAMETER; 947 } 948 } 949 // 950 // Read the entire PE/COFF or TE header into memory 951 // 952 if (!(ImageContext->IsTeImage)) { 953 Status = ImageContext->ImageRead ( 954 ImageContext->Handle, 955 0, 956 &ImageContext->SizeOfHeaders, 957 (VOID *) (UINTN) ImageContext->ImageAddress 958 ); 959 960 PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) 961 ((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset); 962 963 OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); 964 965 FirstSection = (EFI_IMAGE_SECTION_HEADER *) ( 966 (UINTN)ImageContext->ImageAddress + 967 ImageContext->PeCoffHeaderOffset + 968 sizeof(UINT32) + 969 sizeof(EFI_IMAGE_FILE_HEADER) + 970 PeHdr->Pe32.FileHeader.SizeOfOptionalHeader 971 ); 972 NumberOfSections = (UINTN) (PeHdr->Pe32.FileHeader.NumberOfSections); 973 } else { 974 Status = ImageContext->ImageRead ( 975 ImageContext->Handle, 976 0, 977 &ImageContext->SizeOfHeaders, 978 (VOID *) (UINTN) ImageContext->ImageAddress 979 ); 980 981 TeHdr = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress); 982 983 FirstSection = (EFI_IMAGE_SECTION_HEADER *) ( 984 (UINTN)ImageContext->ImageAddress + 985 sizeof(EFI_TE_IMAGE_HEADER) 986 ); 987 NumberOfSections = (UINTN) (TeHdr->NumberOfSections); 988 989 } 990 991 if (RETURN_ERROR (Status)) { 992 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 993 return RETURN_LOAD_ERROR; 994 } 995 996 // 997 // Load each section of the image 998 // 999 Section = FirstSection; 1000 for (Index = 0, MaxEnd = NULL; Index < NumberOfSections; Index++) { 1001 1002 // 1003 // Compute sections address 1004 // 1005 Base = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress); 1006 End = PeCoffLoaderImageAddress ( 1007 ImageContext, 1008 Section->VirtualAddress + Section->Misc.VirtualSize - 1 1009 ); 1010 1011 // 1012 // If the base start or end address resolved to 0, then fail. 1013 // 1014 if ((Base == NULL) || (End == NULL)) { 1015 ImageContext->ImageError = IMAGE_ERROR_SECTION_NOT_LOADED; 1016 return RETURN_LOAD_ERROR; 1017 } 1018 1019 1020 if (ImageContext->IsTeImage) { 1021 Base = (CHAR8 *) ((UINTN) Base + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize); 1022 End = (CHAR8 *) ((UINTN) End + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize); 1023 } 1024 1025 if (End > MaxEnd) { 1026 MaxEnd = End; 1027 } 1028 1029 // 1030 // Read the section 1031 // 1032 Size = (UINTN) Section->Misc.VirtualSize; 1033 if ((Size == 0) || (Size > Section->SizeOfRawData)) { 1034 Size = (UINTN) Section->SizeOfRawData; 1035 } 1036 1037 if (Section->SizeOfRawData) { 1038 if (!(ImageContext->IsTeImage)) { 1039 Status = ImageContext->ImageRead ( 1040 ImageContext->Handle, 1041 Section->PointerToRawData, 1042 &Size, 1043 Base 1044 ); 1045 } else { 1046 Status = ImageContext->ImageRead ( 1047 ImageContext->Handle, 1048 Section->PointerToRawData + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize, 1049 &Size, 1050 Base 1051 ); 1052 } 1053 1054 if (RETURN_ERROR (Status)) { 1055 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 1056 return Status; 1057 } 1058 } 1059 1060 // 1061 // If raw size is less then virt size, zero fill the remaining 1062 // 1063 1064 if (Size < Section->Misc.VirtualSize) { 1065 ZeroMem (Base + Size, Section->Misc.VirtualSize - Size); 1066 } 1067 1068 // 1069 // Next Section 1070 // 1071 Section += 1; 1072 } 1073 1074 // 1075 // Get image's entry point 1076 // 1077 if (!(ImageContext->IsTeImage)) { 1078 ImageContext->EntryPoint = (PHYSICAL_ADDRESS) (UINTN) PeCoffLoaderImageAddress ( 1079 ImageContext, 1080 PeHdr->Pe32.OptionalHeader.AddressOfEntryPoint 1081 ); 1082 } else { 1083 ImageContext->EntryPoint = (PHYSICAL_ADDRESS) ( 1084 (UINTN)ImageContext->ImageAddress + 1085 (UINTN)TeHdr->AddressOfEntryPoint + 1086 (UINTN)sizeof(EFI_TE_IMAGE_HEADER) - 1087 (UINTN) TeHdr->StrippedSize 1088 ); 1089 } 1090 1091 // 1092 // Determine the size of the fixup data 1093 // 1094 // Per the PE/COFF spec, you can't assume that a given data directory 1095 // is present in the image. You have to check the NumberOfRvaAndSizes in 1096 // the optional header to verify a desired directory entry is there. 1097 // 1098 if (!(ImageContext->IsTeImage)) { 1099 if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 1100 if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { 1101 DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) 1102 &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; 1103 ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); 1104 } else { 1105 ImageContext->FixupDataSize = 0; 1106 } 1107 } else { 1108 if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { 1109 DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) 1110 &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; 1111 ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); 1112 } else { 1113 ImageContext->FixupDataSize = 0; 1114 } 1115 } 1116 } else { 1117 DirectoryEntry = &TeHdr->DataDirectory[0]; 1118 ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); 1119 } 1120 // 1121 // Consumer must allocate a buffer for the relocation fixup log. 1122 // Only used for runtime drivers. 1123 // 1124 ImageContext->FixupData = NULL; 1125 1126 // 1127 // Load the Codeview info if present 1128 // 1129 if (ImageContext->DebugDirectoryEntryRva != 0) { 1130 if (!(ImageContext->IsTeImage)) { 1131 DebugEntry = PeCoffLoaderImageAddress ( 1132 ImageContext, 1133 ImageContext->DebugDirectoryEntryRva 1134 ); 1135 } else { 1136 DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)(UINTN)( 1137 ImageContext->ImageAddress + 1138 ImageContext->DebugDirectoryEntryRva + 1139 sizeof(EFI_TE_IMAGE_HEADER) - 1140 TeHdr->StrippedSize 1141 ); 1142 } 1143 1144 if (DebugEntry != NULL) { 1145 TempDebugEntryRva = DebugEntry->RVA; 1146 if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) { 1147 Section--; 1148 if ((UINTN) Section->SizeOfRawData < Section->Misc.VirtualSize) { 1149 TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize; 1150 } else { 1151 TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData; 1152 } 1153 } 1154 1155 if (TempDebugEntryRva != 0) { 1156 if (!(ImageContext->IsTeImage)) { 1157 ImageContext->CodeView = PeCoffLoaderImageAddress (ImageContext, TempDebugEntryRva); 1158 } else { 1159 ImageContext->CodeView = (VOID *)( 1160 (UINTN)ImageContext->ImageAddress + 1161 (UINTN)TempDebugEntryRva + 1162 (UINTN)sizeof(EFI_TE_IMAGE_HEADER) - 1163 (UINTN) TeHdr->StrippedSize 1164 ); 1165 } 1166 1167 if (ImageContext->CodeView == NULL) { 1168 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 1169 return RETURN_LOAD_ERROR; 1170 } 1171 1172 if (DebugEntry->RVA == 0) { 1173 Size = DebugEntry->SizeOfData; 1174 if (!(ImageContext->IsTeImage)) { 1175 Status = ImageContext->ImageRead ( 1176 ImageContext->Handle, 1177 DebugEntry->FileOffset, 1178 &Size, 1179 ImageContext->CodeView 1180 ); 1181 } else { 1182 Status = ImageContext->ImageRead ( 1183 ImageContext->Handle, 1184 DebugEntry->FileOffset + sizeof (EFI_TE_IMAGE_HEADER) - TeHdr->StrippedSize, 1185 &Size, 1186 ImageContext->CodeView 1187 ); 1188 // 1189 // Should we apply fix up to this field according to the size difference between PE and TE? 1190 // Because now we maintain TE header fields unfixed, this field will also remain as they are 1191 // in original PE image. 1192 // 1193 } 1194 1195 if (RETURN_ERROR (Status)) { 1196 ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; 1197 return RETURN_LOAD_ERROR; 1198 } 1199 1200 DebugEntry->RVA = TempDebugEntryRva; 1201 } 1202 1203 switch (*(UINT32 *) ImageContext->CodeView) { 1204 case CODEVIEW_SIGNATURE_NB10: 1205 ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY); 1206 break; 1207 1208 case CODEVIEW_SIGNATURE_RSDS: 1209 ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY); 1210 break; 1211 1212 case CODEVIEW_SIGNATURE_MTOC: 1213 ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY); 1214 1215 default: 1216 break; 1217 } 1218 } 1219 } 1220 } 1221 1222 return Status; 1223 } 1224 1225 /** 1226 Returns a pointer to the PDB file name for a raw PE/COFF image that is not 1227 loaded into system memory with the PE/COFF Loader Library functions. 1228 1229 Returns the PDB file name for the PE/COFF image specified by Pe32Data. If 1230 the PE/COFF image specified by Pe32Data is not a valid, then NULL is 1231 returned. If the PE/COFF image specified by Pe32Data does not contain a 1232 debug directory entry, then NULL is returned. If the debug directory entry 1233 in the PE/COFF image specified by Pe32Data does not contain a PDB file name, 1234 then NULL is returned. 1235 If Pe32Data is NULL, then return NULL. 1236 1237 @param Pe32Data Pointer to the PE/COFF image that is loaded in system 1238 memory. 1239 1240 @return The PDB file name for the PE/COFF image specified by Pe32Data or NULL 1241 if it cannot be retrieved. 1242 1243 **/ 1244 VOID * 1245 EFIAPI 1246 PeCoffLoaderGetPdbPointer ( 1247 IN VOID *Pe32Data 1248 ) 1249 { 1250 EFI_IMAGE_DOS_HEADER *DosHdr; 1251 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; 1252 EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; 1253 EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; 1254 UINTN DirCount; 1255 VOID *CodeViewEntryPointer; 1256 INTN TEImageAdjust; 1257 UINT32 NumberOfRvaAndSizes; 1258 UINT16 Magic; 1259 EFI_IMAGE_SECTION_HEADER *SectionHeader; 1260 UINT32 Index, Index1; 1261 1262 if (Pe32Data == NULL) { 1263 return NULL; 1264 } 1265 1266 TEImageAdjust = 0; 1267 DirectoryEntry = NULL; 1268 DebugEntry = NULL; 1269 NumberOfRvaAndSizes = 0; 1270 Index = 0; 1271 Index1 = 0; 1272 SectionHeader = NULL; 1273 1274 DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data; 1275 if (EFI_IMAGE_DOS_SIGNATURE == DosHdr->e_magic) { 1276 // 1277 // DOS image header is present, so read the PE header after the DOS image header. 1278 // 1279 Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff)); 1280 } else { 1281 // 1282 // DOS image header is not present, so PE header is at the image base. 1283 // 1284 Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data; 1285 } 1286 1287 if (EFI_TE_IMAGE_HEADER_SIGNATURE == Hdr.Te->Signature) { 1288 if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) { 1289 DirectoryEntry = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG]; 1290 TEImageAdjust = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize; 1291 1292 // 1293 // Get the DebugEntry offset in the raw data image. 1294 // 1295 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (Hdr.Te + 1); 1296 Index = Hdr.Te->NumberOfSections; 1297 for (Index1 = 0; Index1 < Index; Index1 ++) { 1298 if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) && 1299 (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { 1300 DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te + 1301 DirectoryEntry->VirtualAddress - 1302 SectionHeader [Index1].VirtualAddress + 1303 SectionHeader [Index1].PointerToRawData + 1304 TEImageAdjust); 1305 break; 1306 } 1307 } 1308 } 1309 } else if (EFI_IMAGE_NT_SIGNATURE == Hdr.Pe32->Signature) { 1310 // 1311 // NOTE: We use Machine field to identify PE32/PE32+, instead of Magic. 1312 // It is due to backward-compatibility, for some system might 1313 // generate PE32+ image with PE32 Magic. 1314 // 1315 switch (Hdr.Pe32->FileHeader.Machine) { 1316 case EFI_IMAGE_MACHINE_IA32: 1317 case EFI_IMAGE_MACHINE_ARMT: 1318 // 1319 // Assume PE32 image with IA32 Machine field. 1320 // 1321 Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC; 1322 break; 1323 case EFI_IMAGE_MACHINE_X64: 1324 case EFI_IMAGE_MACHINE_IPF: 1325 // 1326 // Assume PE32+ image with X64 or IPF Machine field 1327 // 1328 Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC; 1329 break; 1330 default: 1331 // 1332 // For unknow Machine field, use Magic in optional Header 1333 // 1334 Magic = Hdr.Pe32->OptionalHeader.Magic; 1335 } 1336 1337 SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ( 1338 (UINT8 *) Hdr.Pe32 + 1339 sizeof (UINT32) + 1340 sizeof (EFI_IMAGE_FILE_HEADER) + 1341 Hdr.Pe32->FileHeader.SizeOfOptionalHeader 1342 ); 1343 Index = Hdr.Pe32->FileHeader.NumberOfSections; 1344 1345 if (EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC == Magic) { 1346 // 1347 // Use PE32 offset get Debug Directory Entry 1348 // 1349 NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes; 1350 DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); 1351 } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) { 1352 // 1353 // Use PE32+ offset get Debug Directory Entry 1354 // 1355 NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes; 1356 DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); 1357 } 1358 1359 if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG || DirectoryEntry->VirtualAddress == 0) { 1360 DirectoryEntry = NULL; 1361 DebugEntry = NULL; 1362 } else { 1363 // 1364 // Get the DebugEntry offset in the raw data image. 1365 // 1366 for (Index1 = 0; Index1 < Index; Index1 ++) { 1367 if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) && 1368 (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { 1369 DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ( 1370 (UINTN) Pe32Data + 1371 DirectoryEntry->VirtualAddress - 1372 SectionHeader[Index1].VirtualAddress + 1373 SectionHeader[Index1].PointerToRawData); 1374 break; 1375 } 1376 } 1377 } 1378 } else { 1379 return NULL; 1380 } 1381 1382 if (NULL == DebugEntry || NULL == DirectoryEntry) { 1383 return NULL; 1384 } 1385 1386 // 1387 // Scan the directory to find the debug entry. 1388 // 1389 for (DirCount = 0; DirCount < DirectoryEntry->Size; DirCount += sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY), DebugEntry++) { 1390 if (EFI_IMAGE_DEBUG_TYPE_CODEVIEW == DebugEntry->Type) { 1391 if (DebugEntry->SizeOfData > 0) { 1392 // 1393 // Get the DebugEntry offset in the raw data image. 1394 // 1395 CodeViewEntryPointer = NULL; 1396 for (Index1 = 0; Index1 < Index; Index1 ++) { 1397 if ((DebugEntry->RVA >= SectionHeader[Index1].VirtualAddress) && 1398 (DebugEntry->RVA < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { 1399 CodeViewEntryPointer = (VOID *) ( 1400 ((UINTN)Pe32Data) + 1401 (UINTN) DebugEntry->RVA - 1402 SectionHeader[Index1].VirtualAddress + 1403 SectionHeader[Index1].PointerToRawData + 1404 (UINTN)TEImageAdjust); 1405 break; 1406 } 1407 } 1408 if (Index1 >= Index) { 1409 // 1410 // Can't find CodeViewEntryPointer in raw PE/COFF image. 1411 // 1412 continue; 1413 } 1414 switch (* (UINT32 *) CodeViewEntryPointer) { 1415 case CODEVIEW_SIGNATURE_NB10: 1416 return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)); 1417 case CODEVIEW_SIGNATURE_RSDS: 1418 return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY)); 1419 case CODEVIEW_SIGNATURE_MTOC: 1420 return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY)); 1421 default: 1422 break; 1423 } 1424 } 1425 } 1426 } 1427 1428 return NULL; 1429 } 1430 1431 1432 RETURN_STATUS 1433 EFIAPI 1434 PeCoffLoaderGetEntryPoint ( 1435 IN VOID *Pe32Data, 1436 OUT VOID **EntryPoint, 1437 OUT VOID **BaseOfImage 1438 ) 1439 { 1440 EFI_IMAGE_DOS_HEADER *DosHdr; 1441 EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; 1442 1443 DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data; 1444 if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) { 1445 // 1446 // DOS image header is present, so read the PE header after the DOS image header. 1447 // 1448 Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff)); 1449 } else { 1450 // 1451 // DOS image header is not present, so PE header is at the image base. 1452 // 1453 Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)Pe32Data; 1454 } 1455 1456 // 1457 // Calculate the entry point relative to the start of the image. 1458 // AddressOfEntryPoint is common for PE32 & PE32+ 1459 // 1460 if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) { 1461 *BaseOfImage = (VOID *)(UINTN)(Hdr.Te->ImageBase + Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER)); 1462 *EntryPoint = (VOID *)((UINTN)*BaseOfImage + (Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof(EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize); 1463 return RETURN_SUCCESS; 1464 } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) { 1465 *EntryPoint = (VOID *)(UINTN)Hdr.Pe32->OptionalHeader.AddressOfEntryPoint; 1466 if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { 1467 *BaseOfImage = (VOID *)(UINTN)Hdr.Pe32->OptionalHeader.ImageBase; 1468 } else { 1469 *BaseOfImage = (VOID *)(UINTN)Hdr.Pe32Plus->OptionalHeader.ImageBase; 1470 } 1471 *EntryPoint = (VOID *)(UINTN)((UINTN)*EntryPoint + (UINTN)*BaseOfImage); 1472 return RETURN_SUCCESS; 1473 } 1474 1475 return RETURN_UNSUPPORTED; 1476 } 1477
