DuetPkg/EfiLdr/PeLoader.c

   1 /*++
   2
   3 Copyright (c) 2006, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13   PeLoader.c
  14
  15 Abstract:
  16
  17 Revision History:
  18
  19 --*/
  20 #include "EfiLdr.h"
  21 #include "Debug.h"
  22 #include "Support.h"
  23
  24 STATIC
  25 EFI_STATUS
  26 EfiLdrPeCoffLoadPeRelocate (
  27   IN EFILDR_LOADED_IMAGE      *Image,
  28   IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,
  29   IN UINTN                     Adjust,
  30   IN UINTN                    *NumberOfMemoryMapEntries,
  31   IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor
  32   );
  33
  34 STATIC
  35 EFI_STATUS
  36 EfiLdrPeCoffImageRead (
  37     IN VOID                 *FHand,
  38     IN UINTN                Offset,
  39     IN OUT UINTN            ReadSize,
  40     OUT VOID                *Buffer
  41     );
  42
  43 STATIC
  44 VOID *
  45 EfiLdrPeCoffImageAddress (
  46   IN EFILDR_LOADED_IMAGE     *Image,
  47   IN UINTN                   Address
  48   );
  49
  50
  51 EFI_STATUS
  52 EfiLdrPeCoffSetImageType (
  53   IN OUT EFILDR_LOADED_IMAGE      *Image,
  54   IN UINTN                        ImageType
  55   );
  56
  57 EFI_STATUS
  58 EfiLdrPeCoffCheckImageMachineType (
  59   IN UINT16           MachineType
  60   );
  61
  62 EFI_STATUS
  63 EfiLdrGetPeImageInfo (
  64   IN  VOID                    *FHand,
  65   OUT UINT64                  *ImageBase,
  66   OUT UINT32                  *ImageSize
  67   )
  68 {
  69   EFI_STATUS                        Status;
  70   EFI_IMAGE_DOS_HEADER              DosHdr;
  71   EFI_IMAGE_OPTIONAL_HEADER_UNION   PeHdr;
  72
  73   ZeroMem (&DosHdr, sizeof(DosHdr));
  74   ZeroMem (&PeHdr, sizeof(PeHdr));
  75
  76   //
  77   // Read image headers
  78   //
  79
  80   EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);
  81   if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {
  82     return EFI_UNSUPPORTED;
  83   }
  84
  85   EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);
  86
  87   if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {
  88     return EFI_UNSUPPORTED;
  89   }
  90
  91   //
  92   // Verify machine type
  93   //
  94
  95   Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);
  96   if (EFI_ERROR(Status)) {
  97     return Status;
  98   }
  99
 100   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 101     *ImageBase = (UINT32)PeHdr.Pe32.OptionalHeader.ImageBase;
 102   } else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
 103     *ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;
 104   } else {
 105     return EFI_UNSUPPORTED;
 106   }
 107
 108   *ImageSize = PeHdr.Pe32.OptionalHeader.SizeOfImage;
 109
 110   return EFI_SUCCESS;
 111 }
 112
 113 EFI_STATUS
 114 EfiLdrPeCoffLoadPeImage (
 115   IN VOID                     *FHand,
 116   IN EFILDR_LOADED_IMAGE      *Image,
 117   IN UINTN                    *NumberOfMemoryMapEntries,
 118   IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor
 119   )
 120 {
 121   EFI_IMAGE_DOS_HEADER            DosHdr;
 122   EFI_IMAGE_OPTIONAL_HEADER_UNION PeHdr;
 123   EFI_IMAGE_SECTION_HEADER        *FirstSection;
 124   EFI_IMAGE_SECTION_HEADER        *Section;
 125   UINTN                           Index;
 126   EFI_STATUS                      Status;
 127   UINT8                           *Base;
 128   UINT8                           *End;
 129   EFI_IMAGE_DATA_DIRECTORY        *DirectoryEntry;
 130   UINTN                           DirCount;
 131   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY TempDebugEntry;
 132   EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;
 133   UINTN                           CodeViewSize;
 134   UINTN                           CodeViewOffset;
 135   UINTN                           CodeViewFileOffset;
 136   UINTN                           OptionalHeaderSize;
 137   UINTN                           PeHeaderSize;
 138   UINT32                          NumberOfRvaAndSizes;
 139   EFI_IMAGE_DATA_DIRECTORY        *DataDirectory;
 140   UINT64                          ImageBase;
 141   CHAR8                           PrintBuffer[256];
 142
 143   ZeroMem (&DosHdr, sizeof(DosHdr));
 144   ZeroMem (&PeHdr, sizeof(PeHdr));
 145
 146   //
 147   // Read image headers
 148   //
 149
 150   EfiLdrPeCoffImageRead (FHand, 0, sizeof(DosHdr), &DosHdr);
 151   if (DosHdr.e_magic != EFI_IMAGE_DOS_SIGNATURE) {
 152     AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Dos header signature not found\n");
 153     PrintString (PrintBuffer);
 154     PrintHeader ('F');
 155     return EFI_UNSUPPORTED;
 156   }
 157
 158   EfiLdrPeCoffImageRead (FHand, DosHdr.e_lfanew, sizeof(PeHdr), &PeHdr);
 159
 160   if (PeHdr.Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {
 161     AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: PE image header signature not found\n");
 162     PrintString (PrintBuffer);
 163     PrintHeader ('G');
 164     return EFI_UNSUPPORTED;
 165   }
 166
 167   //
 168   // Set the image subsystem type
 169   //
 170
 171   Status = EfiLdrPeCoffSetImageType (Image, PeHdr.Pe32.OptionalHeader.Subsystem);
 172   if (EFI_ERROR(Status)) {
 173     AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Subsystem type not known\n");
 174     PrintString (PrintBuffer);
 175     PrintHeader ('H');
 176     return Status;
 177   }
 178
 179   //
 180   // Verify machine type
 181   //
 182
 183   Status = EfiLdrPeCoffCheckImageMachineType (PeHdr.Pe32.FileHeader.Machine);
 184   if (EFI_ERROR(Status)) {
 185     AsciiSPrint (PrintBuffer, 256, "PeCoffLoadPeImage: Incorrect machine type\n");
 186     PrintString (PrintBuffer);
 187     PrintHeader ('I');
 188     return Status;
 189   }
 190
 191   //
 192   // Compute the amount of memory needed to load the image and
 193   // allocate it.  This will include all sections plus the codeview debug info.
 194   // Since the codeview info is actually outside of the image, we calculate
 195   // its size seperately and add it to the total.
 196   //
 197   // Memory starts off as data
 198   //
 199
 200   CodeViewSize       = 0;
 201   CodeViewFileOffset = 0;
 202   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 203     DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 204   } else if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {
 205     DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(PeHdr.Pe32Plus.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]);
 206   } else {
 207     return EFI_UNSUPPORTED;
 208   }
 209   for (DirCount = 0;
 210        (DirCount < DirectoryEntry->Size / sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)) && (CodeViewSize == 0);
 211        DirCount++) {
 212     Status = EfiLdrPeCoffImageRead (
 213                FHand,
 214                DirectoryEntry->VirtualAddress + DirCount * sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),
 215                sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY),
 216                &TempDebugEntry
 217                );
 218     if (!EFI_ERROR (Status)) {
 219       if (TempDebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) {
 220         CodeViewSize = TempDebugEntry.SizeOfData;
 221         CodeViewFileOffset = TempDebugEntry.FileOffset;
 222       }
 223     }
 224   }
 225
 226   CodeViewOffset = PeHdr.Pe32.OptionalHeader.SizeOfImage + PeHdr.Pe32.OptionalHeader.SectionAlignment;
 227   Image->NoPages = EFI_SIZE_TO_PAGES (CodeViewOffset + CodeViewSize);
 228
 229   //
 230   // Compute the amount of memory needed to load the image and
 231   // allocate it.  Memory starts off as data
 232   //
 233
 234   Image->ImageBasePage = (EFI_PHYSICAL_ADDRESS)FindSpace (Image->NoPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesCode, EFI_MEMORY_WB);
 235   if (Image->ImageBasePage == 0) {
 236     return EFI_OUT_OF_RESOURCES;
 237   }
 238
 239   if (EFI_ERROR(Status)) {
 240     PrintHeader ('J');
 241     return Status;
 242   }
 243
 244   AsciiSPrint (PrintBuffer, 256, "LoadPe: new image base %lx\n", Image->ImageBasePage);
 245   PrintString (PrintBuffer);
 246   Image->Info.ImageBase = (VOID *)(UINTN)Image->ImageBasePage;
 247   Image->Info.ImageSize = (Image->NoPages << EFI_PAGE_SHIFT) - 1;
 248   Image->ImageBase      = (UINT8 *)(UINTN)Image->ImageBasePage;
 249   Image->ImageEof       = Image->ImageBase + Image->Info.ImageSize;
 250   Image->ImageAdjust    = Image->ImageBase;
 251
 252   //
 253   // Copy the Image header to the base location
 254   //
 255   Status = EfiLdrPeCoffImageRead (
 256              FHand,
 257              0,
 258              PeHdr.Pe32.OptionalHeader.SizeOfHeaders,
 259              Image->ImageBase
 260              );
 261
 262   if (EFI_ERROR(Status)) {
 263     PrintHeader ('K');
 264     return Status;
 265   }
 266
 267   //
 268   // Load each directory of the image into memory...
 269   //  Save the address of the Debug directory for later
 270   //
 271   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 272     NumberOfRvaAndSizes = PeHdr.Pe32.OptionalHeader.NumberOfRvaAndSizes;
 273     DataDirectory = PeHdr.Pe32.OptionalHeader.DataDirectory;
 274   } else {
 275     NumberOfRvaAndSizes = PeHdr.Pe32Plus.OptionalHeader.NumberOfRvaAndSizes;
 276     DataDirectory = PeHdr.Pe32Plus.OptionalHeader.DataDirectory;
 277   }
 278   DebugEntry = NULL;
 279   for (Index = 0; Index < NumberOfRvaAndSizes; Index++) {
 280     if ((DataDirectory[Index].VirtualAddress != 0) && (DataDirectory[Index].Size != 0)) {
 281       Status = EfiLdrPeCoffImageRead (
 282                  FHand,
 283                  DataDirectory[Index].VirtualAddress,
 284                  DataDirectory[Index].Size,
 285                  Image->ImageBase + DataDirectory[Index].VirtualAddress
 286                  );
 287       if (EFI_ERROR(Status)) {
 288         return Status;
 289       }
 290       if (Index == EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {
 291         DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (Image->ImageBase + DataDirectory[Index].VirtualAddress);
 292       }
 293     }
 294   }
 295
 296   //
 297   // Load each section of the image
 298   //
 299
 300   // BUGBUG: change this to use the in memory copy
 301   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 302     OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER32);
 303     PeHeaderSize       = sizeof(EFI_IMAGE_NT_HEADERS32);
 304   } else {
 305     OptionalHeaderSize = sizeof(EFI_IMAGE_OPTIONAL_HEADER64);
 306     PeHeaderSize       = sizeof(EFI_IMAGE_NT_HEADERS64);
 307   }
 308   FirstSection = (EFI_IMAGE_SECTION_HEADER *) (
 309                    Image->ImageBase +
 310                    DosHdr.e_lfanew +
 311                    PeHeaderSize +
 312                    PeHdr.Pe32.FileHeader.SizeOfOptionalHeader -
 313                    OptionalHeaderSize
 314                    );
 315
 316   Section = FirstSection;
 317   for (Index=0; Index < PeHdr.Pe32.FileHeader.NumberOfSections; Index += 1) {
 318
 319     //
 320     // Compute sections address
 321     //
 322
 323     Base = EfiLdrPeCoffImageAddress (Image, (UINTN)Section->VirtualAddress);
 324     End = EfiLdrPeCoffImageAddress (Image, (UINTN)(Section->VirtualAddress + Section->Misc.VirtualSize));
 325
 326     if (EFI_ERROR(Status) || !Base || !End) {
 327 //      DEBUG((D_LOAD|D_ERROR, "LoadPe: Section %d was not loaded\n", Index));
 328     PrintHeader ('L');
 329       return EFI_LOAD_ERROR;
 330     }
 331
 332 //    DEBUG((D_LOAD, "LoadPe: Section %d, loaded at %x\n", Index, Base));
 333
 334     //
 335     // Read the section
 336     //
 337
 338     if (Section->SizeOfRawData) {
 339       Status = EfiLdrPeCoffImageRead (FHand, Section->PointerToRawData, Section->SizeOfRawData, Base);
 340       if (EFI_ERROR(Status)) {
 341 PrintHeader ('M');
 342         return Status;
 343       }
 344     }
 345
 346     //
 347     // If raw size is less then virt size, zero fill the remaining
 348     //
 349
 350     if (Section->SizeOfRawData < Section->Misc.VirtualSize) {
 351       ZeroMem (
 352         Base + Section->SizeOfRawData,
 353         Section->Misc.VirtualSize - Section->SizeOfRawData
 354         );
 355     }
 356
 357     //
 358     // Next Section
 359     //
 360
 361     Section += 1;
 362   }
 363
 364   //
 365   // Copy in CodeView information if it exists
 366   //
 367   if (CodeViewSize != 0) {
 368     Status = EfiLdrPeCoffImageRead (FHand, CodeViewFileOffset, CodeViewSize, Image->ImageBase + CodeViewOffset);
 369     DebugEntry->RVA = (UINT32) (CodeViewOffset);
 370   }
 371
 372   //
 373   // Apply relocations only if needed
 374   //
 375   if (PeHdr.Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {
 376     ImageBase = (UINT64)PeHdr.Pe32.OptionalHeader.ImageBase;
 377   } else {
 378     ImageBase = PeHdr.Pe32Plus.OptionalHeader.ImageBase;
 379   }
 380   if ((UINTN)(Image->ImageBase) != (UINTN) (ImageBase)) {
 381     Status = EfiLdrPeCoffLoadPeRelocate (
 382                Image,
 383                &DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC],
 384                (UINTN) Image->ImageBase - (UINTN)ImageBase,
 385                NumberOfMemoryMapEntries,
 386                EfiMemoryDescriptor
 387                );
 388
 389     if (EFI_ERROR(Status)) {
 390       PrintHeader ('N');
 391       return Status;
 392     }
 393   }
 394
 395   //
 396   // Use exported EFI specific interface if present, else use the image's entry point
 397   //
 398   Image->EntryPoint = (EFI_IMAGE_ENTRY_POINT)(UINTN)
 399                         (EfiLdrPeCoffImageAddress(
 400                            Image,
 401                            PeHdr.Pe32.OptionalHeader.AddressOfEntryPoint
 402                            ));
 403
 404   return Status;
 405 }
 406
 407 STATIC
 408 EFI_STATUS
 409 EfiLdrPeCoffLoadPeRelocate (
 410   IN EFILDR_LOADED_IMAGE      *Image,
 411   IN EFI_IMAGE_DATA_DIRECTORY *RelocDir,
 412   IN UINTN                     Adjust,
 413   IN UINTN                    *NumberOfMemoryMapEntries,
 414   IN EFI_MEMORY_DESCRIPTOR    *EfiMemoryDescriptor
 415   )
 416 {
 417   EFI_IMAGE_BASE_RELOCATION   *RelocBase;
 418   EFI_IMAGE_BASE_RELOCATION   *RelocBaseEnd;
 419   UINT16                      *Reloc;
 420   UINT16                      *RelocEnd;
 421   UINT8                       *Fixup;
 422   UINT8                       *FixupBase;
 423   UINT16                      *F16;
 424   UINT32                      *F32;
 425   UINT64                      *F64;
 426   UINT8                       *FixupData;
 427   UINTN                       NoFixupPages;
 428
 429   //
 430   // Find the relocation block
 431   //
 432
 433   RelocBase = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress);
 434   RelocBaseEnd = EfiLdrPeCoffImageAddress (Image, RelocDir->VirtualAddress + RelocDir->Size);
 435   if (!RelocBase || !RelocBaseEnd) {
 436 PrintHeader ('O');
 437     return EFI_LOAD_ERROR;
 438   }
 439
 440   NoFixupPages = EFI_SIZE_TO_PAGES(RelocDir->Size / sizeof(UINT16) * sizeof(UINTN));
 441   Image->FixupData = (UINT8*) FindSpace (NoFixupPages, NumberOfMemoryMapEntries, EfiMemoryDescriptor, EfiRuntimeServicesData, EFI_MEMORY_WB);
 442   if (Image->FixupData == 0) {
 443     return EFI_OUT_OF_RESOURCES;
 444   }
 445
 446   //
 447   // Run the whole relocation block
 448   //
 449
 450   FixupData = Image->FixupData;
 451   while (RelocBase < RelocBaseEnd) {
 452
 453     Reloc = (UINT16 *) ((UINT8 *) RelocBase + sizeof(EFI_IMAGE_BASE_RELOCATION));
 454     RelocEnd = (UINT16 *) ((UINT8 *) RelocBase + RelocBase->SizeOfBlock);
 455     FixupBase = EfiLdrPeCoffImageAddress (Image, RelocBase->VirtualAddress);
 456     if ((UINT8 *) RelocEnd < Image->ImageBase || (UINT8 *) RelocEnd > Image->ImageEof) {
 457 PrintHeader ('P');
 458       return EFI_LOAD_ERROR;
 459     }
 460
 461     //
 462     // Run this relocation record
 463     //
 464
 465     while (Reloc < RelocEnd) {
 466
 467       Fixup = FixupBase + (*Reloc & 0xFFF);
 468       switch ((*Reloc) >> 12) {
 469
 470       case EFI_IMAGE_REL_BASED_ABSOLUTE:
 471         break;
 472
 473       case EFI_IMAGE_REL_BASED_HIGH:
 474         F16 = (UINT16 *) Fixup;
 475         *F16  = (UINT16) (*F16 + (UINT16)(((UINT32)Adjust) >> 16));
 476         if (FixupData != NULL) {
 477           *(UINT16 *) FixupData = *F16;
 478           FixupData = FixupData + sizeof(UINT16);
 479         }
 480         break;
 481
 482       case EFI_IMAGE_REL_BASED_LOW:
 483         F16 = (UINT16 *) Fixup;
 484         *F16 = *F16 + (UINT16) Adjust;
 485         if (FixupData != NULL) {
 486           *(UINT16 *) FixupData = *F16;
 487           FixupData = FixupData + sizeof(UINT16);
 488         }
 489         break;
 490
 491       case EFI_IMAGE_REL_BASED_HIGHLOW:
 492         F32 = (UINT32 *) Fixup;
 493         *F32 = *F32 + (UINT32) Adjust;
 494         if (FixupData != NULL) {
 495           FixupData = ALIGN_POINTER(FixupData, sizeof(UINT32));
 496           *(UINT32 *) FixupData = *F32;
 497           FixupData = FixupData + sizeof(UINT32);
 498         }
 499         break;
 500
 501       case EFI_IMAGE_REL_BASED_DIR64:
 502         F64 = (UINT64 *) Fixup;
 503         *F64 = *F64 + (UINT64) Adjust;
 504         if (FixupData != NULL) {
 505           FixupData = ALIGN_POINTER(FixupData, sizeof(UINT64));
 506           *(UINT64 *) FixupData = *F64;
 507           FixupData = FixupData + sizeof(UINT64);
 508         }
 509         break;
 510
 511       case EFI_IMAGE_REL_BASED_HIGHADJ:
 512         CpuDeadLoop();                 // BUGBUG: not done
 513         break;
 514
 515       default:
 516 //        DEBUG((D_LOAD|D_ERROR, "PeRelocate: unknown fixed type\n"));
 517 PrintHeader ('Q');
 518         CpuDeadLoop();
 519         return EFI_LOAD_ERROR;
 520       }
 521
 522       // Next reloc record
 523       Reloc += 1;
 524     }
 525
 526     // next reloc block
 527     RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd;
 528   }
 529
 530   //
 531   // Add Fixup data to whole Image (assume Fixup data just below the image), so that there is no hole in the descriptor.
 532   // Because only NoPages or ImageBasePage will be used in EfiLoader(), we update these 2 fields.
 533   //
 534   Image->NoPages += NoFixupPages;
 535   Image->ImageBasePage -= (NoFixupPages << EFI_PAGE_SHIFT);
 536
 537   return EFI_SUCCESS;
 538 }
 539
 540 STATIC
 541 EFI_STATUS
 542 EfiLdrPeCoffImageRead (
 543   IN VOID                 *FHand,
 544   IN UINTN                Offset,
 545   IN OUT UINTN            ReadSize,
 546   OUT VOID                *Buffer
 547   )
 548 {
 549   CopyMem (Buffer, (VOID *)((UINTN)FHand + Offset), ReadSize);
 550
 551   return EFI_SUCCESS;
 552 }
 553
 554 STATIC
 555 VOID *
 556 EfiLdrPeCoffImageAddress (
 557   IN EFILDR_LOADED_IMAGE     *Image,
 558   IN UINTN                   Address
 559   )
 560 {
 561   UINT8        *FixedAddress;
 562
 563   FixedAddress = Image->ImageAdjust + Address;
 564
 565   if ((FixedAddress < Image->ImageBase) || (FixedAddress > Image->ImageEof)) {
 566 //    DEBUG((D_LOAD|D_ERROR, "PeCoffImageAddress: pointer is outside of image\n"));
 567     FixedAddress = NULL;
 568   }
 569
 570 //  DEBUG((
 571 //    D_LOAD,
 572 //    "PeCoffImageAddress: ImageBase %x, ImageEof %x, Address %x, FixedAddress %x\n",
 573 //    Image->ImageBase,
 574 //    Image->ImageEof,
 575 //    Address,
 576 //    FixedAddress
 577 //    ));
 578     return FixedAddress;
 579 }
 580
 581
 582 EFI_STATUS
 583 EfiLdrPeCoffSetImageType (
 584   IN OUT EFILDR_LOADED_IMAGE      *Image,
 585   IN UINTN                        ImageType
 586   )
 587 {
 588   EFI_MEMORY_TYPE                 CodeType;
 589   EFI_MEMORY_TYPE                 DataType;
 590
 591   switch (ImageType) {
 592   case EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION:
 593     CodeType = EfiLoaderCode;
 594     DataType = EfiLoaderData;
 595     break;
 596
 597   case EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER:
 598     CodeType = EfiBootServicesCode;
 599     DataType = EfiBootServicesData;
 600     break;
 601
 602   case EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER:
 603     CodeType = EfiRuntimeServicesCode;
 604     DataType = EfiRuntimeServicesData;
 605     break;
 606
 607   default:
 608     return EFI_INVALID_PARAMETER;
 609   }
 610
 611   Image->Type = ImageType;
 612   Image->Info.ImageCodeType = CodeType;
 613   Image->Info.ImageDataType = DataType;
 614
 615   return EFI_SUCCESS;
 616 }
 617
 618 EFI_STATUS
 619 EfiLdrPeCoffCheckImageMachineType (
 620   IN UINT16           MachineType
 621   )
 622 {
 623   EFI_STATUS          Status;
 624
 625   Status = EFI_UNSUPPORTED;
 626
 627 #if EFI32
 628   if (MachineType == EFI_IMAGE_MACHINE_IA32) {
 629     Status = EFI_SUCCESS;
 630   }
 631 #endif
 632
 633 #if EFIX64
 634   if (MachineType == EFI_IMAGE_MACHINE_X64) {
 635     Status = EFI_SUCCESS;
 636   }
 637 #endif
 638
 639 #if EFI64
 640   if (MachineType == EFI_IMAGE_MACHINE_IA64) {
 641     Status = EFI_SUCCESS;
 642   }
 643 #endif
 644
 645   return Status;
 646 }
 647