Sync basetools' source and binary files with r1707 of the basetools project.

[mirror_edk2.git] / BaseTools / Source / C / GenFw / GenFw.c

/** @file\r
\r
Copyright (c) 2004 - 2009, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
    GenFw.c\r
\r
Abstract:\r
\r
    Converts a pe32+ image to an FW, Te image type, or other specific image.\r
\r
**/\r
\r
#include "WinNtInclude.h"\r
\r
#ifndef __GNUC__\r
#include <windows.h>\r
#include <io.h>\r
#endif\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <time.h>\r
#include <ctype.h>\r
\r
#include <Common/UefiBaseTypes.h>\r
#include <IndustryStandard/PeImage.h>\r
\r
//\r
// Acpi Table definition\r
//\r
#include <IndustryStandard/Acpi.h>\r
#include <IndustryStandard/Acpi1_0.h>\r
#include <IndustryStandard/Acpi2_0.h>\r
#include <IndustryStandard/Acpi3_0.h>\r
#include <IndustryStandard/MemoryMappedConfigurationSpaceAccessTable.h>\r
\r
#include "CommonLib.h"\r
#include "PeCoffLib.h"\r
#include "ParseInf.h"\r
#include "EfiUtilityMsgs.h"\r
\r
#include "elf_common.h"\r
#include "elf32.h"\r
#include "elf64.h"\r
\r
\r
//\r
// Version of this utility\r
//\r
#define UTILITY_NAME "GenFw"\r
#define UTILITY_MAJOR_VERSION 0\r
#define UTILITY_MINOR_VERSION 2\r
\r
//\r
// Action for this tool.\r
//\r
#define FW_DUMMY_IMAGE       0\r
#define FW_EFI_IMAGE         1\r
#define FW_TE_IMAGE          2\r
#define FW_ACPI_IMAGE        3\r
#define FW_BIN_IMAGE         4\r
#define FW_ZERO_DEBUG_IMAGE  5\r
#define FW_SET_STAMP_IMAGE   6\r
#define FW_MCI_IMAGE         7\r
#define FW_MERGE_IMAGE       8\r
#define FW_RELOC_STRIPEED_IMAGE 9\r
\r
#define DUMP_TE_HEADER       0x11\r
\r
#define DEFAULT_MC_PAD_BYTE_VALUE  0xFF\r
#define DEFAULT_MC_ALIGNMENT       16\r
\r
#ifndef _MAX_PATH\r
#define _MAX_PATH 500\r
#endif\r
\r
#define STATUS_IGNORE        0xA\r
//\r
// Structure definition for a microcode header\r
//\r
typedef struct {\r
  UINT32  HeaderVersion;\r
  UINT32  PatchId;\r
  UINT32  Date;\r
  UINT32  CpuId;\r
  UINT32  Checksum;\r
  UINT32  LoaderVersion;\r
  UINT32  PlatformId;\r
  UINT32  DataSize;   // if 0, then TotalSize = 2048, and TotalSize field is invalid\r
  UINT32  TotalSize;  // number of bytes\r
  UINT32  Reserved[3];\r
} MICROCODE_IMAGE_HEADER;\r
\r
STATIC CHAR8 *mInImageName;\r
\r
STATIC\r
EFI_STATUS\r
ZeroDebugData (\r
  IN OUT UINT8   *FileBuffer,\r
  BOOLEAN        ZeroDebug\r
  );\r
\r
STATIC\r
EFI_STATUS\r
SetStamp (\r
  IN OUT UINT8  *FileBuffer,\r
  IN     CHAR8  *TimeStamp\r
  );\r
\r
STATIC\r
STATUS\r
MicrocodeReadData (\r
  FILE          *InFptr,\r
  UINT32        *Data\r
  );\r
\r
STATIC\r
VOID\r
Version (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Print out version information for this utility.\r
\r
Arguments:\r
\r
  None\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  fprintf (stdout, "%s Version %d.%d\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION);\r
}\r
\r
STATIC\r
VOID\r
Usage (\r
  VOID\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Print Help message.\r
\r
Arguments:\r
\r
  VOID\r
\r
Returns:\r
\r
  None\r
\r
--*/\r
{\r
  //\r
  // Summary usage\r
  //\r
  fprintf (stdout, "\nUsage: %s [options] <input_file>\n\n", UTILITY_NAME);\r
\r
  //\r
  // Copyright declaration\r
  //\r
  fprintf (stdout, "Copyright (c) 2007, Intel Corporation. All rights reserved.\n\n");\r
\r
  //\r
  // Details Option\r
  //\r
  fprintf (stdout, "Options:\n");\r
  fprintf (stdout, "  -o FileName, --outputfile FileName\n\\r
                        File will be created to store the ouput content.\n");\r
  fprintf (stdout, "  -e EFI_FILETYPE, --efiImage EFI_FILETYPE\n\\r
                        Create Efi Image. EFI_FILETYPE is one of BASE, SEC,\n\\r
                        PEI_CORE, PEIM, DXE_CORE, DXE_DRIVER, UEFI_APPLICATION,\n\\r
                        DXE_SAL_DRIVER, UEFI_DRIVER, DXE_RUNTIME_DRIVER, \n\\r
                        DXE_SMM_DRIVER, SECURITY_CORE, COMBINED_PEIM_DRIVER, \n\\r
                        PIC_PEIM, RELOCATABLE_PEIM, BS_DRIVER, RT_DRIVER,\n\\r
                        APPLICATION, SAL_RT_DRIVER to support all module types\n\\r
                        It can only be used together with --keepexceptiontable,\n\\r
                        --keepzeropending, -r, -o option.It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -c, --acpi            Create Acpi table.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -t, --terse           Create Te Image.\n\\r
                        It can only be used together with --keepexceptiontable,\n\\r
                        --keepzeropending, -r, -o option.It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -u, --dump            Dump TeImage Header.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -z, --zero            Zero the Debug Data Fields in the PE input image file.\n\\r
                        It also zeros the time stamp fields.\n\\r
                        This option can be used to compare the binary efi image.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -b, --exe2bin         Convert the input EXE to the output BIN file.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");;\r
  fprintf (stdout, "  -l, --stripped        Relocation info stripped from the input PE or TE image.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -s timedate, --stamp timedate\n\\r
                        timedate format is \"yyyy-mm-dd 00:00:00\". if timedata \n\\r
                        is set to NOW, current system time is used. The support\n\\r
                        date scope is 1970-1-1 8:0:0 ~ 2038-1-19 3:14:07\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o, -r option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -m, --mcifile         Convert input microcode txt file to microcode bin file.\n\\r
                        It can't be combined with other action options\n\\r
                        except for -o option. It is a action option.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -j, --join            Combine multi microcode bin files to one file.\n\\r
                        It can be specified with -a, -p, -o option.\n\\r
                        No other options can be combined with it.\n\\r
                        If it is combined with other action options, the later\n\\r
                        input action option will override the previous one.\n");\r
  fprintf (stdout, "  -a NUM, --align NUM   NUM is one HEX or DEC format alignment value.\n\\r
                        This option is only used together with -j option.\n");  \r
  fprintf (stdout, "  -p NUM, --pad NUM     NUM is one HEX or DEC format padding value.\n\\r
                        This option is only used together with -j option.\n");\r
  fprintf (stdout, "  --keepexceptiontable  Don't clear exception table.\n\\r
                        This option can be used together with -e or -t.\n\\r
                        It doesn't work for other options.\n");\r
  fprintf (stdout, "  --keepzeropending     Don't strip zero pending of .reloc.\n\\r
                        This option can be used together with -e or -t.\n\\r
                        It doesn't work for other options.\n");\r
  fprintf (stdout, "  -r, --replace         Overwrite the input file with the output content.\n\\r
                        If more input files are specified,\n\\r
                        the last input file will be as the output file.\n");\r
  fprintf (stdout, "  -v, --verbose         Turn on verbose output with informational messages.\n");\r
  fprintf (stdout, "  -q, --quiet           Disable all messages except key message and fatal error\n");\r
  fprintf (stdout, "  -d, --debug level     Enable debug messages, at input debug level.\n");\r
  fprintf (stdout, "  --version             Show program's version number and exit\n");\r
  fprintf (stdout, "  -h, --help            Show this help message and exit\n");\r
}\r
\r
STATIC\r
STATUS\r
CheckAcpiTable (\r
  VOID      *AcpiTable,\r
  UINT32    Length\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Check Acpi Table\r
\r
Arguments:\r
\r
  AcpiTable     Buffer for AcpiSection\r
  Length        AcpiSection Length\r
\r
Returns:\r
\r
  0             success\r
  non-zero      otherwise\r
\r
--*/\r
{\r
  EFI_ACPI_DESCRIPTION_HEADER                   *AcpiHeader;\r
  EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE  *Facs;\r
  UINT32                                        ExpectedLength;\r
\r
  AcpiHeader = (EFI_ACPI_DESCRIPTION_HEADER *)AcpiTable;\r
\r
  //\r
  // Generic check for AcpiTable length.\r
  //\r
  if (AcpiHeader->Length > Length) {\r
    Error (NULL, 0, 3000, "Invalid", "AcpiTable length check failed.", NULL);\r
    return STATUS_ERROR;\r
  }\r
\r
  //\r
  // Currently, we only check must-have tables: FADT, FACS, DSDT,\r
  // and some important tables: MADT, MCFG.\r
  //\r
  switch (AcpiHeader->Signature) {\r
\r
  //\r
  // "FACP" Fixed ACPI Description Table\r
  //\r
  case EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_SIGNATURE:\r
    switch (AcpiHeader->Revision) {\r
    case EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION:\r
      ExpectedLength = sizeof(EFI_ACPI_1_0_FIXED_ACPI_DESCRIPTION_TABLE);\r
      break;\r
    case EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION:\r
      ExpectedLength = sizeof(EFI_ACPI_2_0_FIXED_ACPI_DESCRIPTION_TABLE);\r
      break;\r
    case EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION:\r
      ExpectedLength = sizeof(EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE);\r
      break;\r
    default:\r
      if (AcpiHeader->Revision > EFI_ACPI_3_0_FIXED_ACPI_DESCRIPTION_TABLE_REVISION) {\r
        ExpectedLength = AcpiHeader->Length;\r
        break;\r
      }\r
      Error (NULL, 0, 3000, "Invalid", "FACP revision check failed.");\r
      return STATUS_ERROR;\r
    }\r
    if (ExpectedLength != AcpiHeader->Length) {\r
      Error (NULL, 0, 3000, "Invalid", "FACP length check failed.");\r
      return STATUS_ERROR;\r
    }\r
    break;\r
\r
  //\r
  // "FACS" Firmware ACPI Control Structure\r
  //\r
  case EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_SIGNATURE:\r
    Facs = (EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE *)AcpiTable;\r
    if (Facs->Version > EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION) {\r
      break;\r
    }\r
    if ((Facs->Version != EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION) &&\r
        (Facs->Version != EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION) &&\r
        (Facs->Version != EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE_VERSION)){\r
      Error (NULL, 0, 3000, "Invalid", "FACS version check failed.");\r
      return STATUS_ERROR;\r
    }\r
    if ((Facs->Length != sizeof(EFI_ACPI_1_0_FIRMWARE_ACPI_CONTROL_STRUCTURE)) &&\r
        (Facs->Length != sizeof(EFI_ACPI_2_0_FIRMWARE_ACPI_CONTROL_STRUCTURE)) &&\r
        (Facs->Length != sizeof(EFI_ACPI_3_0_FIRMWARE_ACPI_CONTROL_STRUCTURE))) {\r
      Error (NULL, 0, 3000, "Invalid", "FACS length check failed.");\r
      return STATUS_ERROR;\r
    }\r
    break;\r
\r
  //\r
  // "DSDT" Differentiated System Description Table\r
  //\r
  case EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_SIGNATURE:\r
    if (AcpiHeader->Revision > EFI_ACPI_3_0_DIFFERENTIATED_SYSTEM_DESCRIPTION_TABLE_REVISION) {\r
      break;\r
    }\r
    if (AcpiHeader->Length <= sizeof(EFI_ACPI_DESCRIPTION_HEADER)) {\r
      Error (NULL, 0, 3000, "Invalid", "DSDT length check failed.");\r
      return STATUS_ERROR;\r
    }\r
    break;\r
\r
  //\r
  // "APIC" Multiple APIC Description Table\r
  //\r
  case EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_SIGNATURE:\r
    if (AcpiHeader->Revision > EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION) {\r
      break;\r
    }\r
    if ((AcpiHeader->Revision != EFI_ACPI_1_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION) &&\r
        (AcpiHeader->Revision != EFI_ACPI_2_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION) &&\r
        (AcpiHeader->Revision != EFI_ACPI_3_0_MULTIPLE_APIC_DESCRIPTION_TABLE_REVISION)) {\r
      Error (NULL, 0, 3000, "Invalid", "APIC revision check failed.");\r
      return STATUS_ERROR;\r
    }\r
    if (AcpiHeader->Length <= sizeof(EFI_ACPI_DESCRIPTION_HEADER) + sizeof(UINT32) + sizeof(UINT32)) {\r
      Error (NULL, 0, 3000, "Invalid", "APIC length check failed.");\r
      return STATUS_ERROR;\r
    }\r
    break;\r
\r
  //\r
  // "MCFG" PCI Express Memory Mapped Configuration Space Base Address Description Table\r
  //\r
  case EFI_ACPI_3_0_PCI_EXPRESS_MEMORY_MAPPED_CONFIGURATION_SPACE_BASE_ADDRESS_DESCRIPTION_TABLE_SIGNATURE:\r
    if (AcpiHeader->Revision > EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_SPACE_ACCESS_TABLE_REVISION) {\r
      break;\r
    }\r
    if (AcpiHeader->Revision != EFI_ACPI_MEMORY_MAPPED_CONFIGURATION_SPACE_ACCESS_TABLE_REVISION) {\r
      Error (NULL, 0, 3000, "Invalid", "MCFG revision check failed.");\r
      return STATUS_ERROR;\r
    }\r
    if (AcpiHeader->Length <= sizeof(EFI_ACPI_DESCRIPTION_HEADER) + sizeof(UINT64)) {\r
      Error (NULL, 0, 3000, "Invalid", "MCFG length check failed.");\r
      return STATUS_ERROR;\r
    }\r
    break;\r
\r
  //\r
  // Other table pass check\r
  //\r
  default:\r
    break;\r
  }\r
\r
  return STATUS_SUCCESS;\r
}\r
\r
\r
INTN\r
IsElfHeader(\r
  UINT8  *FileBuffer\r
)\r
{\r
  return (FileBuffer[EI_MAG0] == ELFMAG0\r
    && FileBuffer[EI_MAG1] == ELFMAG1\r
    && FileBuffer[EI_MAG2] == ELFMAG2\r
    && FileBuffer[EI_MAG3] == ELFMAG3);\r
}\r
\r
typedef Elf32_Shdr Elf_Shdr;\r
typedef Elf32_Ehdr Elf_Ehdr;\r
typedef Elf32_Rel Elf_Rel;\r
typedef Elf32_Sym Elf_Sym;\r
typedef Elf32_Phdr Elf_Phdr;\r
typedef Elf32_Dyn Elf_Dyn;\r
\r
#define ELFCLASS ELFCLASS32\r
#define ELF_R_TYPE(r) ELF32_R_TYPE(r)\r
#define ELF_R_SYM(r) ELF32_R_SYM(r)\r
\r
//\r
// Well known ELF structures.\r
//\r
Elf_Ehdr *Ehdr;\r
Elf_Shdr *ShdrBase;\r
Elf_Phdr *gPhdrBase;\r
\r
//\r
// PE section alignment.\r
//\r
const UINT32 CoffAlignment = 0x20;\r
const UINT16 CoffNbrSections = 4;\r
\r
//\r
// Current offset in coff file.\r
//\r
UINT32 CoffOffset;\r
\r
//\r
// Result Coff file in memory.\r
//\r
UINT8 *CoffFile = NULL;\r
//\r
// ELF sections to offset in Coff file.\r
//\r
UINT32 *CoffSectionsOffset = NULL;\r
\r
//\r
// Offset in Coff file of headers and sections.\r
//\r
UINT32 NtHdrOffset;\r
UINT32 TableOffset;\r
UINT32 TextOffset;\r
UINT32 DataOffset;\r
UINT32 RelocOffset;\r
\r
EFI_IMAGE_BASE_RELOCATION *CoffBaseRel;\r
UINT16 *CoffEntryRel;\r
\r
UINT32\r
CoffAlign(\r
  UINT32 Offset\r
  )\r
{\r
  return (Offset + CoffAlignment - 1) & ~(CoffAlignment - 1);\r
}\r
\r
Elf_Shdr *\r
GetShdrByIndex(\r
  UINT32 Num\r
  )\r
{\r
  if (Num >= Ehdr->e_shnum)\r
    return NULL;\r
  return (Elf_Shdr*)((UINT8*)ShdrBase + Num * Ehdr->e_shentsize);\r
}\r
\r
INTN\r
CheckElfHeader(\r
  VOID\r
  )\r
{\r
  //\r
  // Note: Magic has already been tested.\r
  //\r
  if (Ehdr->e_ident[EI_CLASS] != ELFCLASS) {\r
    Error (NULL, 0, 3000, "Unsupported", "%s needs to be ported for 64-bit ELF.", mInImageName);\r
    return 0;\r
  }\r
  if (Ehdr->e_ident[EI_DATA] != ELFDATA2LSB) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF EI_DATA not ELFDATA2LSB");\r
    return 0;\r
  }\r
  if ((Ehdr->e_type != ET_EXEC) && (Ehdr->e_type != ET_DYN)) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_type not ET_EXEC or ET_DYN");\r
    return 0;\r
  }\r
  if (!((Ehdr->e_machine == EM_386) || (Ehdr->e_machine == EM_ARM))) { \r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_machine not EM_386 or EM_ARM");\r
    return 0;\r
  }\r
  if (Ehdr->e_version != EV_CURRENT) {\r
    Error (NULL, 0, 3000, "Unsupported", "ELF e_version (%u) not EV_CURRENT (%d)", (unsigned) Ehdr->e_version, EV_CURRENT);\r
    return 0;\r
  }\r
\r
  //\r
  // Find the section header table\r
  //\r
  ShdrBase  = (Elf_Shdr *)((UINT8 *)Ehdr + Ehdr->e_shoff);\r
  gPhdrBase = (Elf_Phdr *)((UINT8 *)Ehdr + Ehdr->e_phoff);\r
\r
  CoffSectionsOffset = (UINT32 *)malloc(Ehdr->e_shnum * sizeof (UINT32));\r
\r
  memset(CoffSectionsOffset, 0, Ehdr->e_shnum * sizeof(UINT32));\r
  return 1;\r
}\r
\r
int\r
IsTextShdr(\r
  Elf_Shdr *Shdr\r
  )\r
{\r
  return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == SHF_ALLOC;\r
}\r
\r
int\r
IsDataShdr(\r
  Elf_Shdr *Shdr\r
  )\r
{\r
  return (Shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) == (SHF_ALLOC | SHF_WRITE);\r
}\r
\r
VOID\r
CreateSectionHeader(\r
  const CHAR8 *Name,\r
  UINT32      Offset,\r
  UINT32      Size,\r
  UINT32      Flags\r
  )\r
{\r
  EFI_IMAGE_SECTION_HEADER *Hdr;\r
  Hdr = (EFI_IMAGE_SECTION_HEADER*)(CoffFile + TableOffset);\r
\r
  strcpy((char *)Hdr->Name, Name);\r
  Hdr->Misc.VirtualSize = Size;\r
  Hdr->VirtualAddress = Offset;\r
  Hdr->SizeOfRawData = Size;\r
  Hdr->PointerToRawData = Offset;\r
  Hdr->PointerToRelocations = 0;\r
  Hdr->PointerToLinenumbers = 0;\r
  Hdr->NumberOfRelocations = 0;\r
  Hdr->NumberOfLinenumbers = 0;\r
  Hdr->Characteristics = Flags;\r
\r
  TableOffset += sizeof (EFI_IMAGE_SECTION_HEADER);\r
}\r
\r
VOID\r
ScanSections(\r
  VOID\r
  )\r
{\r
  UINT32                          i;\r
  EFI_IMAGE_DOS_HEADER            *DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;\r
  UINT32                          CoffEntry;\r
\r
  CoffEntry = 0;\r
  CoffOffset = 0;\r
\r
  //\r
  // Coff file start with a DOS header.\r
  //\r
  CoffOffset = sizeof(EFI_IMAGE_DOS_HEADER) + 0x40;\r
  NtHdrOffset = CoffOffset;\r
  switch (Ehdr->e_machine) {\r
  case EM_386:\r
  case EM_ARM:\r
    CoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);\r
	break;\r
  case EM_X86_64:\r
  case EM_IA_64:\r
	CoffOffset += sizeof (EFI_IMAGE_NT_HEADERS64);\r
	break;\r
  default:\r
    VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)Ehdr->e_machine);\r
	CoffOffset += sizeof (EFI_IMAGE_NT_HEADERS32);\r
	break;\r
  }\r
\r
  TableOffset = CoffOffset;\r
  CoffOffset += CoffNbrSections * sizeof(EFI_IMAGE_SECTION_HEADER);\r
\r
  //\r
  // First text sections.\r
  //\r
  CoffOffset = CoffAlign(CoffOffset);\r
  TextOffset = CoffOffset;\r
  for (i = 0; i < Ehdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (IsTextShdr(shdr)) {\r
      if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {\r
        // the alignment field is valid\r
        if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {\r
          // if the section address is aligned we must align PE/COFF \r
          CoffOffset = (CoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);\r
        } else if ((shdr->sh_addr % shdr->sh_addralign) != (CoffOffset % shdr->sh_addralign)) {\r
          // ARM RVCT tools have behavior outside of the ELF specification to try \r
          // and make images smaller.  If sh_addr is not aligned to sh_addralign \r
          // then the section needs to preserve sh_addr MOD sh_addralign. \r
          // Normally doing nothing here works great.\r
          Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");\r
        }\r
      }\r
      \r
      /* Relocate entry.  */\r
      if ((Ehdr->e_entry >= shdr->sh_addr) &&\r
          (Ehdr->e_entry < shdr->sh_addr + shdr->sh_size)) {\r
        CoffEntry = CoffOffset + Ehdr->e_entry - shdr->sh_addr;\r
      }\r
      CoffSectionsOffset[i] = CoffOffset;\r
      CoffOffset += shdr->sh_size;\r
    }\r
  }\r
\r
  if (Ehdr->e_machine != EM_ARM) {\r
    CoffOffset = CoffAlign(CoffOffset);\r
  }\r
\r
  //\r
  //  Then data sections.\r
  //\r
  DataOffset = CoffOffset;\r
  for (i = 0; i < Ehdr->e_shnum; i++) {\r
    Elf_Shdr *shdr = GetShdrByIndex(i);\r
    if (IsDataShdr(shdr)) {\r
      if ((shdr->sh_addralign != 0) && (shdr->sh_addralign != 1)) {\r
        // the alignment field is valid\r
        if ((shdr->sh_addr & (shdr->sh_addralign - 1)) == 0) {\r
          // if the section address is aligned we must align PE/COFF \r
          CoffOffset = (CoffOffset + shdr->sh_addralign - 1) & ~(shdr->sh_addralign - 1);\r
        } else if ((shdr->sh_addr % shdr->sh_addralign) != (CoffOffset % shdr->sh_addralign)) {\r
          // ARM RVCT tools have behavior outside of the ELF specification to try \r
          // and make images smaller.  If sh_addr is not aligned to sh_addralign \r
          // then the section needs to preserve sh_addr MOD sh_addralign. \r
          // Normally doing nothing here works great.\r
          Error (NULL, 0, 3000, "Invalid", "Unsupported section alignment.");\r
        }\r
      }\r
\r
      CoffSectionsOffset[i] = CoffOffset;\r
      CoffOffset += shdr->sh_size;\r
    }\r
  }\r
  CoffOffset = CoffAlign(CoffOffset);\r
\r
  RelocOffset = CoffOffset;\r
\r
  //\r
  // Allocate base Coff file.  Will be expanded later for relocations.\r
  //\r
  CoffFile = (UINT8 *)malloc(CoffOffset);\r
  memset(CoffFile, 0, CoffOffset);\r
\r
  //\r
  // Fill headers.\r
  //\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)CoffFile;\r
  DosHdr->e_magic = EFI_IMAGE_DOS_SIGNATURE;\r
  DosHdr->e_lfanew = NtHdrOffset;\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION*)(CoffFile + NtHdrOffset);\r
\r
  NtHdr->Pe32.Signature = EFI_IMAGE_NT_SIGNATURE;\r
\r
  switch (Ehdr->e_machine) {\r
  case EM_386:\r
    NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;\r
    NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;\r
    break;\r
  case EM_X86_64:\r
    NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_X64;\r
    NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
    break;\r
  case EM_IA_64:\r
    NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IPF;\r
    NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC;\r
    break;\r
  case EM_ARM:\r
    NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_ARMT;\r
    NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;\r
    break;\r
  default:\r
    VerboseMsg ("%s unknown e_machine type. Assume IA-32", (UINTN)Ehdr->e_machine);\r
    NtHdr->Pe32.FileHeader.Machine = EFI_IMAGE_MACHINE_IA32;\r
    NtHdr->Pe32.OptionalHeader.Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC;\r
  }\r
\r
  NtHdr->Pe32.FileHeader.NumberOfSections = CoffNbrSections;\r
  NtHdr->Pe32.FileHeader.TimeDateStamp = (UINT32) time(NULL);\r
  NtHdr->Pe32.FileHeader.PointerToSymbolTable = 0;\r
  NtHdr->Pe32.FileHeader.NumberOfSymbols = 0;\r
  NtHdr->Pe32.FileHeader.SizeOfOptionalHeader = sizeof(NtHdr->Pe32.OptionalHeader);\r
  NtHdr->Pe32.FileHeader.Characteristics = EFI_IMAGE_FILE_EXECUTABLE_IMAGE\r
    | EFI_IMAGE_FILE_LINE_NUMS_STRIPPED\r
    | EFI_IMAGE_FILE_LOCAL_SYMS_STRIPPED\r
    | EFI_IMAGE_FILE_32BIT_MACHINE;\r
\r
  NtHdr->Pe32.OptionalHeader.SizeOfCode = DataOffset - TextOffset;\r
  NtHdr->Pe32.OptionalHeader.SizeOfInitializedData = RelocOffset - DataOffset;\r
  NtHdr->Pe32.OptionalHeader.SizeOfUninitializedData = 0;\r
  NtHdr->Pe32.OptionalHeader.AddressOfEntryPoint = CoffEntry;\r
\r
  NtHdr->Pe32.OptionalHeader.BaseOfCode = TextOffset;\r
\r
  NtHdr->Pe32.OptionalHeader.BaseOfData = DataOffset;\r
  NtHdr->Pe32.OptionalHeader.ImageBase = 0;\r
  NtHdr->Pe32.OptionalHeader.SectionAlignment = CoffAlignment;\r
  NtHdr->Pe32.OptionalHeader.FileAlignment = CoffAlignment;\r
  NtHdr->Pe32.OptionalHeader.SizeOfImage = 0;\r
\r
  NtHdr->Pe32.OptionalHeader.SizeOfHeaders = TextOffset;\r
  NtHdr->Pe32.OptionalHeader.NumberOfRvaAndSizes = EFI_IMAGE_NUMBER_OF_DIRECTORY_ENTRIES;\r
\r
  //\r
  // Section headers.\r
  //\r
  if ((DataOffset - TextOffset) > 0) {\r
    CreateSectionHeader (".text", TextOffset, DataOffset - TextOffset,\r
            EFI_IMAGE_SCN_CNT_CODE\r
            | EFI_IMAGE_SCN_MEM_EXECUTE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  } else {\r
    // Don't make a section of size 0. \r
    NtHdr->Pe32.FileHeader.NumberOfSections--;\r
  }\r
\r
  if ((RelocOffset - TextOffset) > 0) {\r
    CreateSectionHeader (".data", DataOffset, RelocOffset - DataOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_WRITE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  } else {\r
    // Don't make a section of size 0. \r
    NtHdr->Pe32.FileHeader.NumberOfSections--;\r
  }\r
}\r
\r
VOID\r
WriteSections(\r
  int   (*Filter)(Elf_Shdr *)\r
  )\r
{\r
  UINT32      Idx;\r
  Elf_Shdr  *SecShdr;\r
  UINT32      SecOffset;\r
\r
  //\r
  // First: copy sections.\r
  //\r
  for (Idx = 0; Idx < Ehdr->e_shnum; Idx++) {\r
    Elf_Shdr *Shdr = GetShdrByIndex(Idx);\r
    if ((*Filter)(Shdr)) {\r
      switch (Shdr->sh_type) {\r
      case SHT_PROGBITS:\r
        /* Copy.  */\r
        memcpy(CoffFile + CoffSectionsOffset[Idx],\r
              (UINT8*)Ehdr + Shdr->sh_offset,\r
              Shdr->sh_size);\r
        break;\r
      \r
      case SHT_NOBITS:\r
        memset(CoffFile + CoffSectionsOffset[Idx], 0, Shdr->sh_size);\r
        break;\r
      \r
      default:\r
        //\r
        //  Ignore for unkown section type.\r
        //\r
        VerboseMsg ("%s unknown section type %x. We directly copy this section into Coff file", mInImageName, (unsigned)Shdr->sh_type);\r
        break;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Second: apply relocations.\r
  //\r
  for (Idx = 0; Idx < Ehdr->e_shnum; Idx++) {\r
    Elf_Shdr *RelShdr = GetShdrByIndex(Idx);\r
    if (RelShdr->sh_type != SHT_REL)\r
      continue;\r
    SecShdr = GetShdrByIndex(RelShdr->sh_info);\r
    SecOffset = CoffSectionsOffset[RelShdr->sh_info];\r
    if (RelShdr->sh_type == SHT_REL && (*Filter)(SecShdr)) {\r
      UINT32 RelIdx;\r
      Elf_Shdr *SymtabShdr = GetShdrByIndex(RelShdr->sh_link);\r
      UINT8 *Symtab = (UINT8*)Ehdr + SymtabShdr->sh_offset;\r
\r
      for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {\r
        Elf_Rel *Rel = (Elf_Rel *)((UINT8*)Ehdr + RelShdr->sh_offset + RelIdx);\r
        Elf_Sym *Sym = (Elf_Sym *)(Symtab + ELF_R_SYM(Rel->r_info) * SymtabShdr->sh_entsize);\r
        Elf_Shdr *SymShdr;\r
        UINT8 *Targ;\r
\r
        if (Sym->st_shndx == SHN_UNDEF\r
            || Sym->st_shndx == SHN_ABS\r
            || Sym->st_shndx > Ehdr->e_shnum) {\r
          Error (NULL, 0, 3000, "Invalid", "%s bad symbol definition.", mInImageName);\r
        }\r
        SymShdr = GetShdrByIndex(Sym->st_shndx);\r
\r
        //\r
        // Note: r_offset in a memory address.\r
        //  Convert it to a pointer in the coff file.\r
        //\r
        Targ = CoffFile + SecOffset + (Rel->r_offset - SecShdr->sh_addr);\r
\r
        if (Ehdr->e_machine == EM_386) {\r
          switch (ELF_R_TYPE(Rel->r_info)) {\r
          case R_386_NONE:\r
            break;\r
          case R_386_32:\r
            //\r
            // Absolute relocation.\r
            //\r
            *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr\r
              + CoffSectionsOffset[Sym->st_shndx];\r
            break;\r
          case R_386_PC32:\r
            //\r
            // Relative relocation: Symbol - Ip + Addend\r
            //\r
            *(UINT32 *)Targ = *(UINT32 *)Targ\r
              + (CoffSectionsOffset[Sym->st_shndx] - SymShdr->sh_addr)\r
              - (SecOffset - SecShdr->sh_addr);\r
            break;\r
          default:\r
            Error (NULL, 0, 3000, "Invalid", "%s unhandled section type %x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
          }\r
        } else if (Ehdr->e_machine == EM_ARM) {\r
          switch (ELF32_R_TYPE(Rel->r_info)) {\r
          case R_ARM_RBASE:   // No relocation - no action required\r
          case R_ARM_PC24:    // PC-relative relocations don't require modification\r
          case R_ARM_XPC25:   // PC-relative relocations don't require modification\r
            break;\r
          case R_ARM_ABS32:\r
          case R_ARM_RABS32:\r
            //\r
            // Absolute relocation.\r
            //\r
            *(UINT32 *)Targ = *(UINT32 *)Targ - SymShdr->sh_addr + CoffSectionsOffset[Sym->st_shndx];\r
            break;\r
          default:\r
            Error (NULL, 0, 3000, "Invalid", "%s unhandled section type %x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));\r
          }\r
        }\r
      }\r
    }\r
  }\r
}\r
\r
VOID\r
CoffAddFixupEntry(\r
  UINT16 Val\r
  )\r
{\r
  *CoffEntryRel = Val;\r
  CoffEntryRel++;\r
  CoffBaseRel->SizeOfBlock += 2;\r
  CoffOffset += 2;\r
}\r
\r
VOID\r
CoffAddFixup(\r
  UINT32 Offset,\r
  UINT8  Type\r
  )\r
{\r
  if (CoffBaseRel == NULL\r
      || CoffBaseRel->VirtualAddress != (Offset & ~0xfff)) {\r
    if (CoffBaseRel != NULL) {\r
      //\r
      // Add a null entry (is it required ?)\r
      //\r
      CoffAddFixupEntry (0);\r
      //\r
      // Pad for alignment.\r
      //\r
      if (CoffOffset % 4 != 0)\r
        CoffAddFixupEntry (0);\r
    }\r
\r
    CoffFile = realloc\r
      (CoffFile,\r
       CoffOffset + sizeof(EFI_IMAGE_BASE_RELOCATION) + 2*0x1000);\r
    memset(CoffFile + CoffOffset, 0,\r
     sizeof(EFI_IMAGE_BASE_RELOCATION) + 2*0x1000);\r
\r
    CoffBaseRel = (EFI_IMAGE_BASE_RELOCATION*)(CoffFile + CoffOffset);\r
    CoffBaseRel->VirtualAddress = Offset & ~0xfff;\r
    CoffBaseRel->SizeOfBlock = sizeof(EFI_IMAGE_BASE_RELOCATION);\r
\r
    CoffEntryRel = (UINT16 *)(CoffBaseRel + 1);\r
    CoffOffset += sizeof(EFI_IMAGE_BASE_RELOCATION);\r
  }\r
\r
  //\r
  // Fill the entry.\r
  //\r
  CoffAddFixupEntry((UINT16) ((Type << 12) | (Offset & 0xfff)));\r
}\r
\r
\r
Elf_Phdr *\r
GetPhdrByIndex (\r
  UINT32 num\r
  )\r
{\r
  if (num >= Ehdr->e_phnum) {\r
    return NULL;\r
  }\r
  \r
  return (Elf32_Phdr *)((UINT8*)gPhdrBase + num * Ehdr->e_phentsize);\r
}\r
\r
\r
VOID\r
WriteRelocations(\r
  VOID\r
  )\r
{\r
  UINT32                           Index;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION  *NtHdr;\r
  EFI_IMAGE_DATA_DIRECTORY         *Dir;\r
  BOOLEAN                          FoundRelocations;\r
  Elf_Dyn                          *Dyn;\r
  Elf_Rel                          *Rel;\r
  UINTN                            RelElementSize;\r
  UINTN                            RelSize;\r
  UINTN                            RelOffset;\r
  UINTN                            K;\r
  UINT8                            *Targ;\r
  Elf32_Phdr                       *DynamicSegment;\r
  Elf32_Phdr                       *TargetSegment;\r
\r
  for (Index = 0, FoundRelocations = FALSE; Index < Ehdr->e_shnum; Index++) {\r
    Elf_Shdr *RelShdr = GetShdrByIndex(Index);\r
    if (RelShdr->sh_type == SHT_REL) {\r
      Elf_Shdr *SecShdr = GetShdrByIndex(RelShdr->sh_info);\r
      if (IsTextShdr(SecShdr) || IsDataShdr(SecShdr)) {\r
        UINT32 RelIdx;\r
        FoundRelocations = TRUE;\r
        for (RelIdx = 0; RelIdx < RelShdr->sh_size; RelIdx += RelShdr->sh_entsize) {\r
          Elf_Rel *Rel = (Elf_Rel *)\r
            ((UINT8*)Ehdr + RelShdr->sh_offset + RelIdx);\r
          \r
          if (Ehdr->e_machine == EM_386) { \r
            switch (ELF_R_TYPE(Rel->r_info)) {\r
            case R_386_NONE:\r
            case R_386_PC32:\r
              break;\r
            case R_386_32:\r
              CoffAddFixup(CoffSectionsOffset[RelShdr->sh_info]\r
              + (Rel->r_offset - SecShdr->sh_addr),\r
              EFI_IMAGE_REL_BASED_HIGHLOW);\r
              break;\r
            default:\r
              Error (NULL, 0, 3000, "Invalid", "%s unhandled section type %x.", mInImageName, (unsigned) ELF_R_TYPE(Rel->r_info));\r
            }\r
          } else if (Ehdr->e_machine == EM_ARM) {\r
            switch (ELF32_R_TYPE(Rel->r_info)) {\r
            case R_ARM_RBASE:\r
            case R_ARM_PC24:\r
            case R_ARM_XPC25:\r
              break;\r
            case R_ARM_ABS32:\r
            case R_ARM_RABS32:\r
              CoffAddFixup (\r
                CoffSectionsOffset[RelShdr->sh_info]\r
                + (Rel->r_offset - SecShdr->sh_addr),\r
                EFI_IMAGE_REL_BASED_HIGHLOW\r
                );\r
              break;\r
            default:\r
              Error (NULL, 0, 3000, "Invalid", "%s unhandled section type %x.", mInImageName, (unsigned) ELF32_R_TYPE(Rel->r_info));\r
            }\r
          } else {\r
            Error (NULL, 0, 3000, "Not Supported", "This tool does not support relocations for ELF with e_machine %u (processor type).", (unsigned) Ehdr->e_machine);\r
          }\r
        }\r
      }\r
    }\r
  }\r
\r
  if (!FoundRelocations && (Ehdr->e_machine == EM_ARM)) {\r
    /* Try again, but look for PT_DYNAMIC instead of SHT_REL */\r
\r
    for (Index = 0; Index < Ehdr->e_phnum; Index++) {\r
      RelElementSize = 0;\r
      RelSize = 0;\r
      RelOffset = 0;\r
\r
      DynamicSegment = GetPhdrByIndex (Index);\r
\r
      if (DynamicSegment->p_type == PT_DYNAMIC) {\r
        Dyn = (Elf32_Dyn *) ((UINT8 *)Ehdr + DynamicSegment->p_offset);\r
\r
        while (Dyn->d_tag != DT_NULL) {\r
          switch (Dyn->d_tag) {\r
            case  DT_REL:\r
              RelOffset = Dyn->d_un.d_val;\r
              break;\r
\r
            case  DT_RELSZ:\r
              RelSize = Dyn->d_un.d_val;\r
              break;\r
\r
            case  DT_RELENT:\r
              RelElementSize = Dyn->d_un.d_val;\r
              break;\r
          }\r
          Dyn++;\r
        }\r
        if (( RelOffset == 0 ) || ( RelSize == 0 ) || ( RelElementSize == 0 )) {\r
          Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations.", mInImageName);\r
        }\r
\r
        for (K = 0; K < RelSize; K += RelElementSize) {\r
\r
          Rel = (Elf32_Rel *) ((UINT8 *) Ehdr + DynamicSegment->p_offset + RelOffset + K);\r
\r
          switch (ELF32_R_TYPE (Rel->r_info)) {\r
          case  R_ARM_RBASE:\r
            break;\r
          case  R_ARM_RABS32:\r
            TargetSegment = GetPhdrByIndex (ELF32_R_SYM (Rel->r_info) - 1);\r
\r
            // Note: r_offset in a memory address.  Convert it to a pointer in the coff file.\r
            Targ = CoffFile + CoffSectionsOffset[ ELF32_R_SYM( Rel->r_info ) ] + Rel->r_offset - TargetSegment->p_vaddr;\r
\r
            *(UINT32 *)Targ = *(UINT32 *)Targ + CoffSectionsOffset [ELF32_R_SYM( Rel->r_info )];\r
\r
            CoffAddFixup (CoffSectionsOffset[ELF32_R_SYM (Rel->r_info)] + (Rel->r_offset - TargetSegment->p_vaddr), EFI_IMAGE_REL_BASED_HIGHLOW);\r
            break;\r
          default:\r
            Error (NULL, 0, 3000, "Invalid", "%s bad ARM dynamic relocations, unkown type.", mInImageName);\r
          }\r
        }\r
        break;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Pad by adding empty entries.\r
  //\r
  while (CoffOffset & (CoffAlignment - 1)) {\r
    CoffAddFixupEntry(0);\r
  }\r
\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(CoffFile + NtHdrOffset);\r
  Dir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC];\r
  Dir->Size = CoffOffset - RelocOffset;\r
  if (Dir->Size == 0) {\r
    // If no relocations, null out the directory entry and don't add the .reloc section\r
    Dir->VirtualAddress = 0;\r
    NtHdr->Pe32.FileHeader.NumberOfSections--;\r
  } else {\r
    Dir->VirtualAddress = RelocOffset;\r
    CreateSectionHeader (".reloc", RelocOffset, CoffOffset - RelocOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_DISCARDABLE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
  }\r
\r
}\r
\r
VOID\r
WriteDebug(\r
  VOID\r
  )\r
{\r
  UINT32                              Len;\r
  UINT32                              DebugOffset;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION     *NtHdr;\r
  EFI_IMAGE_DATA_DIRECTORY            *DataDir;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY     *Dir;\r
  EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY *Nb10;\r
\r
  Len = strlen(mInImageName) + 1;\r
  DebugOffset = CoffOffset;\r
\r
  CoffOffset += sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY)\r
    + sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)\r
    + Len;\r
  CoffOffset = CoffAlign(CoffOffset);\r
\r
  CoffFile = realloc(CoffFile, CoffOffset);\r
  memset(CoffFile + DebugOffset, 0, CoffOffset - DebugOffset);\r
\r
  Dir = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY*)(CoffFile + DebugOffset);\r
  Dir->Type = EFI_IMAGE_DEBUG_TYPE_CODEVIEW;\r
  Dir->SizeOfData = sizeof(EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY) + Len;\r
  Dir->RVA = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
  Dir->FileOffset = DebugOffset + sizeof(EFI_IMAGE_DEBUG_DIRECTORY_ENTRY);\r
\r
  Nb10 = (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY*)(Dir + 1);\r
  Nb10->Signature = CODEVIEW_SIGNATURE_NB10;\r
  strcpy ((char *)(Nb10 + 1), mInImageName);\r
\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(CoffFile + NtHdrOffset);\r
  DataDir = &NtHdr->Pe32.OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG];\r
  DataDir->VirtualAddress = DebugOffset;\r
  DataDir->Size = CoffOffset - DebugOffset;\r
  if (DataDir->Size == 0) {\r
    // If no debug, null out the directory entry and don't add the .debug section\r
    DataDir->VirtualAddress = 0;\r
    NtHdr->Pe32.FileHeader.NumberOfSections--;\r
  } else {\r
    DataDir->VirtualAddress = DebugOffset;\r
    CreateSectionHeader (".debug", DebugOffset, CoffOffset - DebugOffset,\r
            EFI_IMAGE_SCN_CNT_INITIALIZED_DATA\r
            | EFI_IMAGE_SCN_MEM_DISCARDABLE\r
            | EFI_IMAGE_SCN_MEM_READ);\r
\r
  }\r
}\r
\r
VOID\r
ConvertElf (\r
  UINT8  **FileBuffer,\r
  UINT32 *FileLength\r
  )\r
{\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;\r
\r
  //\r
  // Check header, read section table.\r
  //\r
  Ehdr = (Elf32_Ehdr*)*FileBuffer;\r
  if (!CheckElfHeader())\r
    return;\r
\r
  VerboseMsg ("Check Efl Image Header");\r
  //\r
  // Compute sections new address.\r
  //\r
  \r
  ScanSections();\r
\r
  VerboseMsg ("Compute sections new address.");\r
\r
  //\r
  // Write and relocate sections.\r
  //\r
  WriteSections(IsTextShdr);\r
  WriteSections(IsDataShdr);\r
  VerboseMsg ("Write and relocate sections.");\r
\r
  //\r
  // Translate and write relocations.\r
  //\r
  WriteRelocations();\r
  VerboseMsg ("Translate and write relocations.");\r
\r
  //\r
  // Write debug info.\r
  //\r
  WriteDebug();\r
  VerboseMsg ("Write debug info.");\r
\r
  NtHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(CoffFile + NtHdrOffset);\r
  NtHdr->Pe32.OptionalHeader.SizeOfImage = CoffOffset;\r
\r
  //\r
  // Replace.\r
  //\r
  free(*FileBuffer);\r
  *FileBuffer = CoffFile;\r
  *FileLength = CoffOffset;\r
\r
  //\r
  // Free memory space\r
  //\r
  if (CoffSectionsOffset != NULL) {\r
    free (CoffSectionsOffset);\r
  }\r
}\r
\r
void\r
ZeroXdataSection (\r
 IN     CHAR8                 *ImageName,\r
 IN OUT UINT8                 *FileBuffer,\r
 IN EFI_IMAGE_SECTION_HEADER  *SectionHeader,\r
 IN     UINT32                 SectionTotalNumber\r
  )\r
{\r
  FILE   *fpMapFile;\r
  CHAR8  MapFileName[_MAX_PATH];\r
  CHAR8  Line [MAX_LINE_LEN];\r
  CHAR8  KeyWord [MAX_LINE_LEN];\r
  CHAR8  SectionName [MAX_LINE_LEN];\r
  UINT32 FunctionType = 0;\r
  unsigned SectionOffset = 0;\r
  unsigned SectionLength = 0;\r
  unsigned SectionNumber = 0;\r
  CHAR8  *PdbPointer;\r
  INT32  Index;\r
  UINT32 Index2;\r
\r
  for (Index2 = 0; Index2 < SectionTotalNumber; Index2++) {\r
    if (stricmp ((char *)SectionHeader[Index2].Name, ".zdata") == 0) {\r
      //\r
      // try to zero the customized .zdata section, which is mapped to .xdata\r
      //\r
      memset (FileBuffer + SectionHeader[Index2].PointerToRawData, 0, SectionHeader[Index2].SizeOfRawData);\r
      DebugMsg (NULL, 0, 9, NULL, "Zero the .xdata section for PE image at Offset 0x%x and Length 0x%x", (unsigned) SectionHeader[Index2].PointerToRawData, (unsigned) SectionHeader[Index2].SizeOfRawData);\r
      return;\r
    }\r
  }\r
  //\r
  // Try to get PDB file name\r
  //\r
  PdbPointer = (CHAR8  *) PeCoffLoaderGetPdbPointer (FileBuffer);\r
  if (PdbPointer != NULL) {\r
    strcpy (MapFileName, PdbPointer);\r
  } else {\r
    strcpy (MapFileName, ImageName);\r
  }\r
\r
  //\r
  // Construct map file name\r
  //\r
  Index = strlen (MapFileName) - 1;\r
  while (Index >= 0 && MapFileName[Index] != '.') {\r
    Index --;\r
  }\r
  if (Index < 0) {\r
    //\r
    // don't know how to costruct map file\r
    //\r
    return;\r
  }\r
\r
  //\r
  // fill map file postfix\r
  //\r
  MapFileName[Index + 1] = 'm';\r
  MapFileName[Index + 2] = 'a';\r
  MapFileName[Index + 3] = 'p';\r
  MapFileName[Index + 4] = '\0';\r
\r
  //\r
  // try opening Map File\r
  //\r
  fpMapFile = fopen (MapFileName, "r");\r
  if (fpMapFile == NULL) {\r
    //\r
    // Can't open Map file. Maybe it doesn't exist.\r
    //\r
    return;\r
  }\r
\r
  //\r
  // Output Functions information into Fv Map file\r
  //\r
  while (fgets (Line, MAX_LINE_LEN, fpMapFile) != NULL) {\r
    //\r
    // Skip blank line\r
    //\r
    if (Line[0] == 0x0a) {\r
      if (FunctionType != 0) {\r
        //\r
        // read all section table data\r
        //\r
        FunctionType = 0;\r
        break;\r
      }\r
      FunctionType = 0;\r
      continue;\r
    }\r
\r
    //\r
    // By Start keyword\r
    //\r
    if (FunctionType == 0) {\r
      sscanf (Line, "%s", KeyWord);\r
      if (stricmp (KeyWord, "Start") == 0) {\r
        //\r
        // function list\r
        //\r
        FunctionType = 1;\r
      }\r
      continue;\r
    }\r
    //\r
    // Printf Function Information\r
    //\r
    if (FunctionType == 1) {\r
      sscanf (Line, "%x:%x %xH %s", &SectionNumber, &SectionOffset, &SectionLength, SectionName);\r
      if (stricmp (SectionName, ".xdata") == 0) {\r
        FunctionType = 2;\r
        break;\r
      }\r
    }\r
  }\r
\r
  if (FunctionType != 2) {\r
    //\r
    // no .xdata section is found\r
    //\r
    fclose (fpMapFile);\r
    return;\r
  }\r
\r
  //\r
  // Zero .xdata Section data\r
  //\r
  memset (FileBuffer + SectionHeader[SectionNumber-1].PointerToRawData + SectionOffset, 0, SectionLength);\r
  DebugMsg (NULL, 0, 9, NULL, "Zero the .xdata section for PE image at Offset 0x%x and Length 0x%x", (unsigned) SectionHeader[SectionNumber-1].PointerToRawData + SectionOffset, SectionLength);\r
  fclose (fpMapFile);\r
  return;\r
}\r
\r
int\r
main (\r
  int  argc,\r
  char *argv[]\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Main function.\r
\r
Arguments:\r
\r
  argc - Number of command line parameters.\r
  argv - Array of pointers to command line parameter strings.\r
\r
Returns:\r
  STATUS_SUCCESS - Utility exits successfully.\r
  STATUS_ERROR   - Some error occurred during execution.\r
\r
--*/\r
{\r
  UINT32                           Type;\r
  UINT32                           InputFileNum;\r
  CHAR8                            **InputFileName;\r
  char                             *OutImageName;\r
  char                             *ModuleType;\r
  CHAR8                            *TimeStamp;\r
  UINT32                           OutImageType;\r
  FILE                             *fpIn;\r
  FILE                             *fpOut;\r
  FILE                             *fpInOut;\r
  UINT32                           Data;\r
  UINT32                           *DataPointer;\r
  UINT32                           *OldDataPointer;\r
  UINT32                           CheckSum;\r
  UINT32                           Index;\r
  UINT32                           Index1;\r
  UINT32                           Index2;\r
  UINT64                           Temp64;\r
  UINT32                           MciAlignment;\r
  UINT8                            MciPadValue;\r
  UINT32                           AllignedRelocSize;\r
  UINT8                            *FileBuffer;\r
  UINT32                           FileLength;\r
  UINT8                            *OutputFileBuffer;\r
  UINT32                           OutputFileLength;\r
  RUNTIME_FUNCTION                 *RuntimeFunction;\r
  UNWIND_INFO                      *UnwindInfo;\r
  STATUS                           Status;\r
  BOOLEAN                          ReplaceFlag;\r
  BOOLEAN                          KeepExceptionTableFlag;\r
  BOOLEAN                          KeepZeroPendingFlag;\r
  UINT64                           LogLevel;\r
  EFI_TE_IMAGE_HEADER              TEImageHeader;\r
  EFI_TE_IMAGE_HEADER              *TeHdr;\r
  EFI_IMAGE_SECTION_HEADER         *SectionHeader;\r
  EFI_IMAGE_DOS_HEADER             *DosHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER_UNION  *PeHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER32      *Optional32;\r
  EFI_IMAGE_OPTIONAL_HEADER64      *Optional64;\r
  EFI_IMAGE_DOS_HEADER             BackupDosHdr;\r
  MICROCODE_IMAGE_HEADER           *MciHeader;\r
\r
  SetUtilityName (UTILITY_NAME);\r
\r
  //\r
  // Assign to fix compile warning\r
  //\r
  InputFileNum      = 0;\r
  InputFileName     = NULL;\r
  mInImageName      = NULL;\r
  OutImageName      = NULL;\r
  ModuleType        = NULL;\r
  OutImageType      = FW_DUMMY_IMAGE;\r
  Type              = 0;\r
  Status            = STATUS_SUCCESS;\r
  FileBuffer        = NULL;\r
  fpIn              = NULL;\r
  fpOut             = NULL;\r
  fpInOut           = NULL;\r
  TimeStamp         = NULL;\r
  MciAlignment      = DEFAULT_MC_ALIGNMENT;\r
  MciPadValue       = DEFAULT_MC_PAD_BYTE_VALUE;\r
  FileLength        = 0;\r
  MciHeader         = NULL;\r
  CheckSum          = 0;\r
  ReplaceFlag       = FALSE;\r
  LogLevel          = 0;\r
  OutputFileBuffer  = NULL;\r
  OutputFileLength  = 0;\r
  Optional32        = NULL;\r
  Optional64        = NULL;\r
  KeepExceptionTableFlag = FALSE;\r
  KeepZeroPendingFlag    = FALSE;\r
\r
  if (argc == 1) {\r
    Error (NULL, 0, 1001, "Missing options", "No input options.");\r
    Usage ();\r
    return STATUS_ERROR;\r
  }\r
\r
  argc --;\r
  argv ++;\r
\r
  if ((stricmp (argv[0], "-h") == 0) || (stricmp (argv[0], "--help") == 0)) {\r
    Version ();\r
    Usage ();\r
    return STATUS_SUCCESS;\r
  }\r
\r
  if (stricmp (argv[0], "--version") == 0) {\r
    Version ();\r
    return STATUS_SUCCESS;\r
  }\r
\r
  while (argc > 0) {\r
    if ((stricmp (argv[0], "-o") == 0) || (stricmp (argv[0], "--outputfile") == 0)) {\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "Output file name is missing for -o option");\r
        goto Finish;\r
      }\r
      OutImageName = argv[1];\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-e") == 0) || (stricmp (argv[0], "--efiImage") == 0)) {\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "Module Type is missing for -o option");\r
        goto Finish;\r
      }\r
      ModuleType = argv[1];\r
      if (OutImageType != FW_TE_IMAGE) {\r
        OutImageType = FW_EFI_IMAGE;\r
      }\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-l") == 0) || (stricmp (argv[0], "--stripped") == 0)) {\r
      OutImageType = FW_RELOC_STRIPEED_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-c") == 0) || (stricmp (argv[0], "--acpi") == 0)) {\r
      OutImageType = FW_ACPI_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-t") == 0) || (stricmp (argv[0], "--terse") == 0)) {\r
      OutImageType = FW_TE_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-u") == 0) || (stricmp (argv[0], "--dump") == 0)) {\r
      OutImageType = DUMP_TE_HEADER;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-b") == 0) || (stricmp (argv[0], "--exe2bin") == 0)) {\r
      OutImageType = FW_BIN_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-z") == 0) || (stricmp (argv[0], "--zero") == 0)) {\r
      OutImageType = FW_ZERO_DEBUG_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-s") == 0) || (stricmp (argv[0], "--stamp") == 0)) {\r
      OutImageType = FW_SET_STAMP_IMAGE;\r
      if (argv[1] == NULL || argv[1][0] == '-') {\r
        Error (NULL, 0, 1003, "Invalid option value", "time stamp is missing for -s option");\r
        goto Finish;\r
      }\r
      TimeStamp = argv[1];\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-r") == 0) || (stricmp (argv[0], "--replace") == 0)) {\r
      ReplaceFlag = TRUE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if (stricmp (argv[0], "--keepexceptiontable") == 0) {\r
      KeepExceptionTableFlag = TRUE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if (stricmp (argv[0], "--keepzeropending") == 0) {\r
      KeepZeroPendingFlag = TRUE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-m") == 0) || (stricmp (argv[0], "--mcifile") == 0)) {\r
      OutImageType = FW_MCI_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-j") == 0) || (stricmp (argv[0], "--join") == 0)) {\r
      OutImageType = FW_MERGE_IMAGE;\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-a") == 0) || (stricmp (argv[0], "--align") == 0)) {\r
      if (AsciiStringToUint64 (argv[1], FALSE, &Temp64) != EFI_SUCCESS) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
        goto Finish;\r
      }\r
      MciAlignment = (UINT32) Temp64;\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-p") == 0) || (stricmp (argv[0], "--pad") == 0)) {\r
      if (AsciiStringToUint64 (argv[1], FALSE, &Temp64) != EFI_SUCCESS) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
        goto Finish;\r
      }\r
      MciPadValue = (UINT8) Temp64;\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-v") == 0) || (stricmp (argv[0], "--verbose") == 0)) {\r
      SetPrintLevel (VERBOSE_LOG_LEVEL);\r
      VerboseMsg ("Verbose output Mode Set!");\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-q") == 0) || (stricmp (argv[0], "--quiet") == 0)) {\r
      SetPrintLevel (KEY_LOG_LEVEL);\r
      KeyMsg ("Quiet output Mode Set!");\r
      argc --;\r
      argv ++;\r
      continue;\r
    }\r
\r
    if ((stricmp (argv[0], "-d") == 0) || (stricmp (argv[0], "--debug") == 0)) {\r
      Status = AsciiStringToUint64 (argv[1], FALSE, &LogLevel);\r
      if (EFI_ERROR (Status)) {\r
        Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[0], argv[1]);\r
        goto Finish;\r
      }\r
      if (LogLevel > 9) {\r
        Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, currnt input level is %d", (int) LogLevel);\r
        goto Finish;\r
      }\r
      SetPrintLevel (LogLevel);\r
      DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[1]);\r
      argc -= 2;\r
      argv += 2;\r
      continue;\r
    }\r
    \r
    if (argv[0][0] == '-') {\r
      Error (NULL, 0, 1000, "Unknown option", argv[0]);\r
      goto Finish;\r
    }\r
    //\r
    // Get Input file name\r
    //\r
    if ((InputFileNum == 0) && (InputFileName == NULL)) {\r
      InputFileName = (CHAR8 **) malloc (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *));\r
      if (InputFileName == NULL) {\r
        Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
        goto Finish;\r
      }\r
\r
      memset (InputFileName, 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));\r
    } else if (InputFileNum % MAXIMUM_INPUT_FILE_NUM == 0) {\r
      //\r
      // InputFileName buffer too small, need to realloc\r
      //\r
      InputFileName = (CHAR8 **) realloc (\r
                                  InputFileName,\r
                                  (InputFileNum + MAXIMUM_INPUT_FILE_NUM) * sizeof (CHAR8 *)\r
                                  );\r
\r
      if (InputFileName == NULL) {\r
        Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
        goto Finish;\r
      }\r
\r
      memset (&(InputFileName[InputFileNum]), 0, (MAXIMUM_INPUT_FILE_NUM * sizeof (CHAR8 *)));\r
    }\r
\r
    InputFileName [InputFileNum ++] = argv[0];\r
    argc --;\r
    argv ++;\r
  }\r
\r
  VerboseMsg ("%s tool start.", UTILITY_NAME);\r
\r
  if (OutImageType == FW_DUMMY_IMAGE) {\r
    Error (NULL, 0, 1001, "Missing option", "No create file action specified; pls specify -e, -c or -t option to create efi image, or acpi table or TeImage!");\r
    if (ReplaceFlag) {\r
      Error (NULL, 0, 1001, "Missing option", "-r option is not supported as the independent option. It can be used together with other create file option specified at the above.");\r
    }\r
    goto Finish;\r
  }\r
\r
  //\r
  // check input files\r
  //\r
  if (InputFileNum == 0) {\r
    Error (NULL, 0, 1001, "Missing option", "Input files");\r
    goto Finish;\r
  }\r
\r
  //\r
  // Combine MciBinary files to one file\r
  //\r
  if ((OutImageType == FW_MERGE_IMAGE) && ReplaceFlag) {\r
    Error (NULL, 0, 1002, "Conflicting option", "-r replace option cannot be used with -j merge files option.");\r
    goto Finish;\r
  }\r
\r
  //\r
  // Input image file\r
  //\r
  mInImageName = InputFileName [InputFileNum - 1];\r
  VerboseMsg ("the input file name is %s", mInImageName);\r
\r
  //\r
  // Action will be taken for the input file.\r
  //\r
  switch (OutImageType) {\r
  case FW_EFI_IMAGE:\r
    VerboseMsg ("Create efi image on module type %s based on the input PE image.", ModuleType);\r
    break;\r
  case FW_TE_IMAGE:\r
    VerboseMsg ("Create Te Image based on the input PE image.");\r
    break;\r
  case FW_ACPI_IMAGE:\r
    VerboseMsg ("Get acpi table data from the input PE image.");\r
    break;\r
  case FW_RELOC_STRIPEED_IMAGE:\r
    VerboseMsg ("Remove relocation section from Pe or Te image.");\r
    break;\r
  case FW_BIN_IMAGE:\r
    VerboseMsg ("Convert the input EXE to the output BIN file.");\r
    break;\r
  case FW_ZERO_DEBUG_IMAGE:\r
    VerboseMsg ("Zero the Debug Data Fields and Time Stamp in input PE image.");\r
    break;\r
  case FW_SET_STAMP_IMAGE:\r
    VerboseMsg ("Set new time stamp %s in the input PE image.", TimeStamp);\r
    break;\r
  case DUMP_TE_HEADER:\r
    VerboseMsg ("Dump the TE header information of the input TE image.");\r
    break;\r
  case FW_MCI_IMAGE:\r
    VerboseMsg ("Conver input MicroCode.txt file to MicroCode.bin file.");\r
    break;\r
  case FW_MERGE_IMAGE:\r
    VerboseMsg ("Combine the input multi microcode bin files to one bin file.");\r
    break;\r
  default:\r
    break;\r
  }\r
\r
  if (ReplaceFlag) {\r
    VerboseMsg ("Overwrite the input file with the output content.");\r
  }\r
\r
  //\r
  // Open output file and Write image into the output file.\r
  //\r
  if (OutImageName != NULL) {\r
    fpOut = fopen (OutImageName, "rb");\r
    if (fpOut != NULL) {\r
      OutputFileLength = _filelength (fileno (fpOut));\r
      OutputFileBuffer = malloc (OutputFileLength);\r
      if (OutputFileBuffer == NULL) {\r
        Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
        fclose (fpOut);\r
        fpOut = NULL;\r
        goto Finish;\r
      }\r
      fread (OutputFileBuffer, 1, OutputFileLength, fpOut);\r
      fclose (fpOut);\r
    }\r
    fpOut = fopen (OutImageName, "wb");\r
    if (!fpOut) {\r
      Error (NULL, 0, 0001, "Error opening output file", OutImageName);\r
      goto Finish;\r
    }\r
    VerboseMsg ("Output file name is %s", OutImageName);\r
  } else if (!ReplaceFlag) {\r
    if (OutImageType == DUMP_TE_HEADER) {\r
      fpOut = stdout;\r
    } else {\r
      Error (NULL, 0, 1001, "Missing option", "output file");\r
      goto Finish;\r
    }\r
  }\r
\r
  //\r
  // Combine MciBinary files to one file\r
  //\r
  if (OutImageType == FW_MERGE_IMAGE) {\r
    for (Index = 0; Index < InputFileNum; Index ++) {\r
      fpIn = fopen (InputFileName [Index], "rb");\r
      if (!fpIn) {\r
        Error (NULL, 0, 0001, "Error opening file", InputFileName [Index]);\r
        goto Finish;\r
      }\r
\r
      FileLength = _filelength (fileno (fpIn));\r
      FileBuffer = malloc (FileLength);\r
      if (FileBuffer == NULL) {\r
        Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
        fclose (fpIn);\r
        goto Finish;\r
      }\r
\r
      fread (FileBuffer, 1, FileLength, fpIn);\r
      fclose (fpIn);\r
      //\r
      // write input file to out file\r
      //\r
      fwrite (FileBuffer, 1, FileLength, fpOut);\r
      //\r
      // write pad value to out file.\r
      //\r
      while (FileLength ++ % MciAlignment != 0) {\r
        fwrite (&MciPadValue, 1, 1, fpOut);\r
      }\r
      //\r
      // free allocated memory space\r
      //\r
      free (FileBuffer);\r
      FileBuffer = NULL;\r
    }\r
    //\r
    // Done successfully\r
    //\r
    goto Finish;\r
  }\r
\r
  //\r
  // Convert MicroCode.txt file to MicroCode.bin file\r
  //\r
  if (OutImageType == FW_MCI_IMAGE) {\r
    fpIn = fopen (mInImageName, "r");\r
    if (!fpIn) {\r
      Error (NULL, 0, 0001, "Error opening file", mInImageName);\r
      goto Finish;\r
    }\r
\r
    //\r
    // The first pass is to determine\r
    // how much data is in the file so we can allocate a working buffer.\r
    //\r
    FileLength = 0;\r
    do {\r
      Status = MicrocodeReadData (fpIn, &Data);\r
      if (Status == STATUS_SUCCESS) {\r
        FileLength += sizeof (Data);\r
      }\r
      if (Status == STATUS_IGNORE) {\r
        Status = STATUS_SUCCESS;\r
      }\r
    } while (Status == STATUS_SUCCESS);\r
    //\r
    // Error if no data.\r
    //\r
    if (FileLength == 0) {\r
      Error (NULL, 0, 3000, "Invalid", "no parseable data found in file %s", mInImageName);\r
      goto Finish;\r
    }\r
    if (FileLength < sizeof (MICROCODE_IMAGE_HEADER)) {\r
      Error (NULL, 0, 3000, "Invalid", "amount of parseable data in %s is insufficient to contain a microcode header", mInImageName);\r
      goto Finish;\r
    }\r
\r
    //\r
    // Allocate a buffer for the data\r
    //\r
    FileBuffer = malloc (FileLength);\r
    if (FileBuffer == NULL) {\r
      Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
      goto Finish;\r
    }\r
    //\r
    // Re-read the file, storing the data into our buffer\r
    //\r
    fseek (fpIn, 0, SEEK_SET);\r
    DataPointer = (UINT32 *) FileBuffer;\r
    OldDataPointer = DataPointer;\r
    do {\r
      OldDataPointer = DataPointer;\r
      Status = MicrocodeReadData (fpIn, DataPointer++);\r
      if (Status == STATUS_IGNORE) {\r
        DataPointer = OldDataPointer;\r
        Status = STATUS_SUCCESS;\r
      }\r
    } while (Status == STATUS_SUCCESS);\r
    //\r
    // close input file after read data\r
    //\r
    fclose (fpIn);\r
\r
    //\r
    // Can't do much checking on the header because, per the spec, the\r
    // DataSize field may be 0, which means DataSize = 2000 and TotalSize = 2K,\r
    // and the TotalSize field is invalid (actually missing). Thus we can't\r
    // even verify the Reserved fields are 0.\r
    //\r
    MciHeader = (MICROCODE_IMAGE_HEADER *) FileBuffer;\r
    if (MciHeader->DataSize == 0) {\r
      Index = 2048;\r
    } else {\r
      Index = MciHeader->TotalSize;\r
    }\r
\r
    if (Index != FileLength) {\r
      Error (NULL, 0, 3000, "Invalid", "file length of %s (0x%x) does not equal expected TotalSize: 0x%04X.", mInImageName, (unsigned) FileLength, (unsigned) Index);\r
      goto Finish;\r
    }\r
\r
    //\r
    // Checksum the contents\r
    //\r
    DataPointer = (UINT32 *) FileBuffer;\r
    CheckSum  = 0;\r
    Index     = 0;\r
    while (Index < FileLength) {\r
      CheckSum    += *DataPointer;\r
      DataPointer ++;\r
      Index       += sizeof (*DataPointer);\r
    }\r
    if (CheckSum != 0) {\r
      Error (NULL, 0, 3000, "Invalid", "checksum (0x%x) failed on file %s.", (unsigned) CheckSum, mInImageName);\r
      goto Finish;\r
    }\r
    //\r
    // Open the output file and write the buffer contents\r
    //\r
    if (fpOut != NULL) {\r
      if (fwrite (FileBuffer, FileLength, 1, fpOut) != 1) {\r
        Error (NULL, 0, 0002, "Error writing file", OutImageName);\r
        goto Finish;\r
      }\r
    }\r
\r
    if (ReplaceFlag) {\r
      fpInOut = fopen (mInImageName, "wb");\r
      if (fpInOut != NULL) {\r
        Error (NULL, 0, 0001, "Error opening file", mInImageName);\r
        goto Finish;\r
      }\r
      if (fwrite (FileBuffer, FileLength, 1, fpInOut) != 1) {\r
        Error (NULL, 0, 0002, "Error writing file", mInImageName);\r
        goto Finish;\r
      }\r
    }\r
    VerboseMsg ("the size of output file is %u bytes", (unsigned) FileLength);\r
    //\r
    //  Convert Mci.TXT to Mci.bin file successfully\r
    //\r
    goto Finish;\r
  }\r
\r
  //\r
  // Open input file and read file data into file buffer.\r
  //\r
  fpIn = fopen (mInImageName, "rb");\r
  if (!fpIn) {\r
    Error (NULL, 0, 0001, "Error opening file", mInImageName);\r
    goto Finish;\r
  }\r
\r
  FileLength = _filelength (fileno (fpIn));\r
  FileBuffer = malloc (FileLength);\r
  if (FileBuffer == NULL) {\r
    Error (NULL, 0, 4001, "Resource", "memory cannot be allocated!");\r
    fclose (fpIn);\r
    goto Finish;\r
  }\r
\r
  fread (FileBuffer, 1, FileLength, fpIn);\r
  fclose (fpIn);\r
\r
  DebugMsg (NULL, 0, 9, "input file info", "the input file size is %u bytes", (unsigned) FileLength);\r
\r
  //\r
  // Replace file\r
  //\r
  if (ReplaceFlag) {\r
    fpInOut = fopen (mInImageName, "wb");\r
    if (!fpInOut) {\r
      Error (NULL, 0, 0001, "Error opening file", mInImageName);\r
      goto Finish;\r
    }\r
  }\r
  //\r
  // Dump TeImage Header into output file.\r
  //\r
  if (OutImageType == DUMP_TE_HEADER) {\r
    memcpy (&TEImageHeader, FileBuffer, sizeof (TEImageHeader));\r
    if (TEImageHeader.Signature != EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
      Error (NULL, 0, 3000, "Invalid", "TE header signature of file %s is not correct.", mInImageName);\r
      goto Finish;\r
    }\r
    if (fpInOut != NULL) {\r
      fprintf (fpInOut, "Dump of file %s\n\n", mInImageName);\r
      fprintf (fpInOut, "TE IMAGE HEADER VALUES\n");\r
      fprintf (fpInOut, "%17X machine\n", TEImageHeader.Machine);\r
      fprintf (fpInOut, "%17X number of sections\n", TEImageHeader.NumberOfSections);\r
      fprintf (fpInOut, "%17X subsystems\n", TEImageHeader.Subsystem);\r
      fprintf (fpInOut, "%17X stripped size\n", TEImageHeader.StrippedSize);\r
      fprintf (fpInOut, "%17X entry point\n", (unsigned) TEImageHeader.AddressOfEntryPoint);\r
      fprintf (fpInOut, "%17X base of code\n", (unsigned) TEImageHeader.BaseOfCode);\r
      fprintf (fpInOut, "%17llX image base\n", (unsigned long long)TEImageHeader.ImageBase);\r
      fprintf (fpInOut, "%17X [%8X] RVA [size] of Base Relocation Directory\n", (unsigned) TEImageHeader.DataDirectory[0].VirtualAddress, (unsigned) TEImageHeader.DataDirectory[0].Size);\r
      fprintf (fpInOut, "%17X [%8X] RVA [size] of Debug Directory\n", (unsigned) TEImageHeader.DataDirectory[1].VirtualAddress, (unsigned) TEImageHeader.DataDirectory[1].Size);\r
    }\r
\r
    if (fpOut != NULL) {\r
      fprintf (fpOut, "Dump of file %s\n\n", mInImageName);\r
      fprintf (fpOut, "TE IMAGE HEADER VALUES\n");\r
      fprintf (fpOut, "%17X machine\n", TEImageHeader.Machine);\r
      fprintf (fpOut, "%17X number of sections\n", TEImageHeader.NumberOfSections);\r
      fprintf (fpOut, "%17X subsystems\n", TEImageHeader.Subsystem);\r
      fprintf (fpOut, "%17X stripped size\n", TEImageHeader.StrippedSize);\r
      fprintf (fpOut, "%17X entry point\n", (unsigned) TEImageHeader.AddressOfEntryPoint);\r
      fprintf (fpOut, "%17X base of code\n", (unsigned) TEImageHeader.BaseOfCode);\r
      fprintf (fpOut, "%17llX image base\n", (unsigned long long)TEImageHeader.ImageBase);\r
      fprintf (fpOut, "%17X [%8X] RVA [size] of Base Relocation Directory\n", (unsigned) TEImageHeader.DataDirectory[0].VirtualAddress, (unsigned) TEImageHeader.DataDirectory[0].Size);\r
      fprintf (fpOut, "%17X [%8X] RVA [size] of Debug Directory\n", (unsigned) TEImageHeader.DataDirectory[1].VirtualAddress, (unsigned) TEImageHeader.DataDirectory[1].Size);\r
    }\r
    goto Finish;\r
  }\r
\r
  //\r
  // Following code to convert dll to efi image or te image.\r
  // Get new image type\r
  //\r
  if ((OutImageType == FW_EFI_IMAGE) || (OutImageType == FW_TE_IMAGE)) {\r
    if (ModuleType == NULL) {\r
      if (OutImageType == FW_EFI_IMAGE) {\r
        Error (NULL, 0, 1001, "Missing option", "EFI_FILETYPE");\r
        goto Finish;\r
      } else if (OutImageType == FW_TE_IMAGE) {\r
        //\r
        // Default TE Image Type is Boot service driver\r
        //\r
        Type = EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;\r
        VerboseMsg ("Efi Image subsystem type is efi boot service driver.");\r
      }\r
    } else {\r
      if (stricmp (ModuleType, "BASE") == 0 ||\r
          stricmp (ModuleType, "SEC") == 0 ||\r
          stricmp (ModuleType, "SECURITY_CORE") == 0 ||\r
          stricmp (ModuleType, "PEI_CORE") == 0 ||\r
          stricmp (ModuleType, "PEIM") == 0 ||\r
          stricmp (ModuleType, "COMBINED_PEIM_DRIVER") == 0 ||\r
          stricmp (ModuleType, "PIC_PEIM") == 0 ||\r
          stricmp (ModuleType, "RELOCATABLE_PEIM") == 0 ||\r
          stricmp (ModuleType, "DXE_CORE") == 0 ||\r
          stricmp (ModuleType, "BS_DRIVER") == 0  ||\r
          stricmp (ModuleType, "DXE_DRIVER") == 0 ||\r
          stricmp (ModuleType, "DXE_SMM_DRIVER") == 0  ||\r
          stricmp (ModuleType, "UEFI_DRIVER") == 0 ||\r
          stricmp (ModuleType, "SMM_DRIVER") == 0 ||\r
          stricmp (ModuleType, "SMM_CORE") == 0) {\r
        Type = EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER;\r
        VerboseMsg ("Efi Image subsystem type is efi boot service driver.");\r
\r
      } else if (stricmp (ModuleType, "UEFI_APPLICATION") == 0 ||\r
                 stricmp (ModuleType, "APPLICATION") == 0) {\r
        Type = EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION;\r
        VerboseMsg ("Efi Image subsystem type is efi application.");\r
\r
      } else if (stricmp (ModuleType, "DXE_RUNTIME_DRIVER") == 0 ||\r
                 stricmp (ModuleType, "RT_DRIVER") == 0) {\r
        Type = EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER;\r
        VerboseMsg ("Efi Image subsystem type is efi runtime driver.");\r
\r
      } else if (stricmp (ModuleType, "DXE_SAL_DRIVER") == 0 ||\r
                 stricmp (ModuleType, "SAL_RT_DRIVER") == 0) {\r
        Type = EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER;\r
        VerboseMsg ("Efi Image subsystem type is efi sal runtime driver.");\r
\r
      } else {\r
        Error (NULL, 0, 1003, "Invalid option value", "EFI_FILETYPE = %s", ModuleType);\r
        goto Finish;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Convert EFL image to PeImage\r
  //\r
  if (IsElfHeader(FileBuffer)) {\r
    VerboseMsg ("Convert the input ELF Image to Pe Image");\r
    ConvertElf(&FileBuffer, &FileLength);\r
  }\r
\r
  //\r
  // Remove reloc section from PE or TE image\r
  //\r
  if (OutImageType == FW_RELOC_STRIPEED_IMAGE) {\r
    //\r
    // Check TeImage\r
    //\r
    TeHdr = (EFI_TE_IMAGE_HEADER *) FileBuffer;\r
    if (TeHdr->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (TeHdr + 1);\r
      for (Index = 0; Index < TeHdr->NumberOfSections; Index ++, SectionHeader ++) {\r
        if (strcmp ((char *)SectionHeader->Name, ".reloc") == 0) {\r
          //\r
          // Check the reloc section is in the end of image.\r
          //\r
          if ((SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData) ==\r
            (FileLength + TeHdr->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER))) {\r
            //\r
            // Remove .reloc section and update TeImage Header\r
            //\r
            FileLength = FileLength - SectionHeader->SizeOfRawData;\r
            SectionHeader->SizeOfRawData = 0;\r
            SectionHeader->Misc.VirtualSize = 0;\r
            TeHdr->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;\r
            TeHdr->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size           = 0;\r
            break;\r
          }\r
        }\r
      }\r
    } else {\r
      //\r
      // Check PE Image\r
      //\r
      DosHdr = (EFI_IMAGE_DOS_HEADER *) FileBuffer;\r
      if (DosHdr->e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
        PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer);\r
        if (PeHdr->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
          Error (NULL, 0, 3000, "Invalid", "TE and DOS header signatures were not found in %s image.", mInImageName);\r
          goto Finish;\r
        }\r
        DosHdr = NULL;\r
      } else {\r
        PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + DosHdr->e_lfanew);\r
        if (PeHdr->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
          Error (NULL, 0, 3000, "Invalid", "PE header signature was not found in %s image.", mInImageName);\r
          goto Finish;\r
        }\r
      }\r
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
      for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {\r
        if (strcmp ((char *)SectionHeader->Name, ".reloc") == 0) {\r
          //\r
          // Check the reloc section is in the end of image.\r
          //\r
          if ((SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData) == FileLength) {\r
            //\r
            // Remove .reloc section and update PeImage Header\r
            //\r
            FileLength = FileLength - SectionHeader->SizeOfRawData;\r
\r
            PeHdr->Pe32.FileHeader.Characteristics |= EFI_IMAGE_FILE_RELOCS_STRIPPED;\r
            if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
              Optional32 = (EFI_IMAGE_OPTIONAL_HEADER32 *)&PeHdr->Pe32.OptionalHeader;\r
              Optional32->SizeOfImage -= SectionHeader->SizeOfRawData;\r
              Optional32->SizeOfInitializedData -= SectionHeader->SizeOfRawData;\r
              if (Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
                Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;\r
                Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = 0;\r
              }\r
            }\r
            if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
              Optional64 = (EFI_IMAGE_OPTIONAL_HEADER64 *)&PeHdr->Pe32.OptionalHeader;\r
              Optional64->SizeOfImage -= SectionHeader->SizeOfRawData;\r
              Optional64->SizeOfInitializedData -= SectionHeader->SizeOfRawData;\r
              if (Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
                Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;\r
                Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = 0;\r
              }\r
            }\r
            SectionHeader->Misc.VirtualSize = 0;\r
            SectionHeader->SizeOfRawData = 0;\r
            break;\r
          }\r
        }\r
      }\r
    }\r
    //\r
    // Write file\r
    //\r
    goto WriteFile;\r
  }\r
  //\r
  // Read the dos & pe hdrs of the image\r
  //\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)FileBuffer;\r
  if (DosHdr->e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
    // NO DOS header, check for PE/COFF header\r
    PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer);\r
    if (PeHdr->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
      Error (NULL, 0, 3000, "Invalid", "DOS header signature was not found in %s image.", mInImageName);\r
      goto Finish;\r
    }\r
    DosHdr = NULL;\r
  } else {\r
\r
    PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)(FileBuffer + DosHdr->e_lfanew);\r
    if (PeHdr->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) {\r
      Error (NULL, 0, 3000, "Invalid", "PE header signature was not found in %s image.", mInImageName);\r
      goto Finish;\r
    }\r
  }\r
  \r
  if (PeHdr->Pe32.FileHeader.Machine == IMAGE_FILE_MACHINE_ARM) {\r
    // Some tools kick out IMAGE_FILE_MACHINE_ARM (0x1c0) vs IMAGE_FILE_MACHINE_ARMT (0x1c2)\r
    // so patch back to the offical UEFI value.\r
    PeHdr->Pe32.FileHeader.Machine = IMAGE_FILE_MACHINE_ARMT;\r
  }\r
\r
  //\r
  // Extract bin data from Pe image.\r
  //\r
  if (OutImageType == FW_BIN_IMAGE) {\r
    if (FileLength < PeHdr->Pe32.OptionalHeader.SizeOfHeaders) {\r
      Error (NULL, 0, 3000, "Invalid", "FileSize of %s is not a legal size.", mInImageName);\r
      goto Finish;\r
    }\r
    //\r
    // Output bin data from exe file\r
    //\r
    if (fpOut != NULL) {\r
      fwrite (FileBuffer + PeHdr->Pe32.OptionalHeader.SizeOfHeaders, 1, FileLength - PeHdr->Pe32.OptionalHeader.SizeOfHeaders, fpOut);\r
    }\r
    if (fpInOut != NULL) {\r
      fwrite (FileBuffer + PeHdr->Pe32.OptionalHeader.SizeOfHeaders, 1, FileLength - PeHdr->Pe32.OptionalHeader.SizeOfHeaders, fpInOut);\r
    }\r
    VerboseMsg ("the size of output file is %u bytes", (unsigned) (FileLength - PeHdr->Pe32.OptionalHeader.SizeOfHeaders));\r
    goto Finish;\r
  }\r
\r
  //\r
  // Zero Debug Information of Pe Image\r
  //\r
  if (OutImageType == FW_ZERO_DEBUG_IMAGE) {\r
    Status = ZeroDebugData (FileBuffer, TRUE);\r
    if (EFI_ERROR (Status)) {\r
      Error (NULL, 0, 3000, "Invalid", "Zero DebugData Error status is 0x%x", (int) Status);\r
      goto Finish;\r
    }\r
\r
    if (fpOut != NULL) {\r
      fwrite (FileBuffer, 1, FileLength, fpOut);\r
    }\r
    if (fpInOut != NULL) {\r
      fwrite (FileBuffer, 1, FileLength, fpInOut);\r
    }\r
    VerboseMsg ("the size of output file is %u bytes", (unsigned) FileLength);\r
    goto Finish;\r
  }\r
\r
  //\r
  // Set Time Stamp of Pe Image\r
  //\r
  if (OutImageType == FW_SET_STAMP_IMAGE) {\r
    Status = SetStamp (FileBuffer, TimeStamp);\r
    if (EFI_ERROR (Status)) {\r
      goto Finish;\r
    }\r
\r
    if (fpOut != NULL) {\r
      fwrite (FileBuffer, 1, FileLength, fpOut);\r
    }\r
    if (fpInOut != NULL) {\r
      fwrite (FileBuffer, 1, FileLength, fpInOut);\r
    }\r
    VerboseMsg ("the size of output file is %u bytes", (unsigned) FileLength);\r
    goto Finish;\r
  }\r
\r
  //\r
  // Extract acpi data from pe image.\r
  //\r
  if (OutImageType == FW_ACPI_IMAGE) {\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
    for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {\r
      if (strcmp ((char *)SectionHeader->Name, ".data") == 0 || strcmp ((char *)SectionHeader->Name, ".sdata") == 0) {\r
        //\r
        // Check Acpi Table\r
        //\r
        if (SectionHeader->Misc.VirtualSize < SectionHeader->SizeOfRawData) {\r
          FileLength = SectionHeader->Misc.VirtualSize;\r
        } else {\r
          FileLength = SectionHeader->SizeOfRawData;\r
        }\r
\r
        if (CheckAcpiTable (FileBuffer + SectionHeader->PointerToRawData, FileLength) != STATUS_SUCCESS) {\r
          Error (NULL, 0, 3000, "Invalid", "ACPI table check failed in %s.", mInImageName);\r
          goto Finish;\r
        }\r
\r
        //\r
        // Output Apci data to file\r
        //\r
        if (fpOut != NULL) {\r
          fwrite (FileBuffer + SectionHeader->PointerToRawData, 1, FileLength, fpOut);\r
        }\r
        if (fpInOut != NULL) {\r
          fwrite (FileBuffer + SectionHeader->PointerToRawData, 1, FileLength, fpInOut);\r
        }\r
        VerboseMsg ("the size of output file is %u bytes", (unsigned) FileLength);\r
        goto Finish;\r
      }\r
    }\r
    Error (NULL, 0, 3000, "Invalid", "failed to get ACPI table from %s.", mInImageName);\r
    goto Finish;\r
  }\r
  //\r
  // Zero all unused fields of the DOS header\r
  //\r
  if (DosHdr != NULL) {\r
    memcpy (&BackupDosHdr, DosHdr, sizeof (EFI_IMAGE_DOS_HEADER));\r
    memset (DosHdr, 0, sizeof (EFI_IMAGE_DOS_HEADER));\r
    DosHdr->e_magic  = BackupDosHdr.e_magic;\r
    DosHdr->e_lfanew = BackupDosHdr.e_lfanew;\r
  \r
    for (Index = sizeof (EFI_IMAGE_DOS_HEADER); Index < (UINT32 ) DosHdr->e_lfanew; Index++) {\r
      FileBuffer[Index] = (UINT8) DosHdr->e_cp;\r
    }\r
  }\r
\r
  //\r
  // Initialize TeImage Header\r
  //\r
  memset (&TEImageHeader, 0, sizeof (EFI_TE_IMAGE_HEADER));\r
  TEImageHeader.Signature        = EFI_TE_IMAGE_HEADER_SIGNATURE;\r
  TEImageHeader.Machine          = PeHdr->Pe32.FileHeader.Machine;\r
  TEImageHeader.NumberOfSections = (UINT8) PeHdr->Pe32.FileHeader.NumberOfSections;\r
  TEImageHeader.StrippedSize     = (UINT16) ((UINTN) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader) - (UINTN) FileBuffer);\r
  TEImageHeader.Subsystem        = (UINT8) Type;\r
  \r
  //\r
  // Patch the PE header\r
  //\r
  PeHdr->Pe32.OptionalHeader.Subsystem = (UINT16) Type;\r
\r
  if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) {\r
    Optional32 = (EFI_IMAGE_OPTIONAL_HEADER32 *)&PeHdr->Pe32.OptionalHeader;\r
    Optional32->MajorLinkerVersion          = 0;\r
    Optional32->MinorLinkerVersion          = 0;\r
    Optional32->MajorOperatingSystemVersion = 0;\r
    Optional32->MinorOperatingSystemVersion = 0;\r
    Optional32->MajorImageVersion           = 0;\r
    Optional32->MinorImageVersion           = 0;\r
    Optional32->MajorSubsystemVersion       = 0;\r
    Optional32->MinorSubsystemVersion       = 0;\r
    Optional32->Win32VersionValue           = 0;\r
    Optional32->CheckSum                    = 0;\r
    Optional32->SizeOfStackReserve = 0;\r
    Optional32->SizeOfStackCommit  = 0;\r
    Optional32->SizeOfHeapReserve  = 0;\r
    Optional32->SizeOfHeapCommit   = 0;\r
\r
    TEImageHeader.AddressOfEntryPoint = Optional32->AddressOfEntryPoint;\r
    TEImageHeader.BaseOfCode          = Optional32->BaseOfCode;\r
    TEImageHeader.ImageBase           = (UINT64) (Optional32->ImageBase);\r
\r
    if (Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;\r
    }\r
\r
    if (Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].Size = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size;\r
    }\r
\r
    //\r
    // Zero .pdata section data.\r
    //\r
    if (!KeepExceptionTableFlag && Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION &&\r
        Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress != 0 &&\r
        Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size != 0) {\r
      SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
      for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++, SectionHeader++) {\r
        if (SectionHeader->VirtualAddress == Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress) {\r
          //\r
          // Zero .pdata Section data\r
          //\r
          memset (FileBuffer + SectionHeader->PointerToRawData, 0, SectionHeader->SizeOfRawData);\r
          //\r
          // Zero .pdata Section header name\r
          //\r
          memset (SectionHeader->Name, 0, sizeof (SectionHeader->Name));\r
          //\r
          // Zero Execption Table\r
          //\r
          Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0;\r
          Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size           = 0;\r
          DebugMsg (NULL, 0, 9, "Zero the .pdata section for PE image", NULL);\r
          break;\r
        }\r
      }\r
    }\r
\r
    //\r
    // Strip zero padding at the end of the .reloc section\r
    //\r
    if (!KeepZeroPendingFlag && Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
      if (Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size != 0) {\r
        SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
        for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++, SectionHeader++) {\r
          //\r
          // Look for the Section Header that starts as the same virtual address as the Base Relocation Data Directory\r
          //\r
          if (SectionHeader->VirtualAddress == Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress) {\r
            SectionHeader->Misc.VirtualSize = Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;\r
            AllignedRelocSize = (Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size + Optional32->FileAlignment - 1) & (~(Optional32->FileAlignment - 1));\r
            //\r
            // Check to see if there is zero padding at the end of the base relocations\r
            //\r
            if (AllignedRelocSize < SectionHeader->SizeOfRawData) {\r
              //\r
              // Check to see if the base relocations are at the end of the file\r
              //\r
              if (SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData == Optional32->SizeOfImage) {\r
                //\r
                // All the required conditions are met to strip the zero padding of the end of the base relocations section\r
                //\r
                Optional32->SizeOfImage -= (SectionHeader->SizeOfRawData - AllignedRelocSize);\r
                Optional32->SizeOfInitializedData -= (SectionHeader->SizeOfRawData - AllignedRelocSize);\r
                SectionHeader->SizeOfRawData = AllignedRelocSize;\r
                FileLength = Optional32->SizeOfImage;\r
                DebugMsg (NULL, 0, 9, "Remove the zero padding bytes at the end of the base relocations", "The size of padding bytes is %u", (unsigned) (SectionHeader->SizeOfRawData - AllignedRelocSize));\r
              }\r
            }\r
          }\r
        }\r
      }\r
    }\r
  } else if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) {\r
    Optional64 = (EFI_IMAGE_OPTIONAL_HEADER64 *)&PeHdr->Pe32.OptionalHeader;\r
    Optional64->MajorLinkerVersion          = 0;\r
    Optional64->MinorLinkerVersion          = 0;\r
    Optional64->MajorOperatingSystemVersion = 0;\r
    Optional64->MinorOperatingSystemVersion = 0;\r
    Optional64->MajorImageVersion           = 0;\r
    Optional64->MinorImageVersion           = 0;\r
    Optional64->MajorSubsystemVersion       = 0;\r
    Optional64->MinorSubsystemVersion       = 0;\r
    Optional64->Win32VersionValue           = 0;\r
    Optional64->CheckSum                    = 0;\r
    Optional64->SizeOfStackReserve = 0;\r
    Optional64->SizeOfStackCommit  = 0;\r
    Optional64->SizeOfHeapReserve  = 0;\r
    Optional64->SizeOfHeapCommit   = 0;\r
\r
    TEImageHeader.AddressOfEntryPoint = Optional64->AddressOfEntryPoint;\r
    TEImageHeader.BaseOfCode          = Optional64->BaseOfCode;\r
    TEImageHeader.ImageBase           = (UINT64) (Optional64->ImageBase);\r
\r
    if (Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;\r
    }\r
\r
    if (Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].Size = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size;\r
    }\r
\r
    //\r
    // Zero the .pdata section for X64 machine and don't check the Debug Directory is empty\r
    // For Itaninum and X64 Image, remove .pdata section.\r
    //\r
    if ((!KeepExceptionTableFlag && PeHdr->Pe32.FileHeader.Machine == IMAGE_FILE_MACHINE_X64) || PeHdr->Pe32.FileHeader.Machine == IMAGE_FILE_MACHINE_IA64) {\r
      if (Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION &&\r
          Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress != 0 &&\r
          Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size != 0) {\r
        SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
        for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++, SectionHeader++) {\r
          if (SectionHeader->VirtualAddress == Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress) {\r
            //\r
            // Zero .pdata Section header name\r
            //\r
            memset (SectionHeader->Name, 0, sizeof (SectionHeader->Name));\r
\r
            RuntimeFunction = (RUNTIME_FUNCTION *)(FileBuffer + SectionHeader->PointerToRawData);\r
            for (Index1 = 0; Index1 < Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size / sizeof (RUNTIME_FUNCTION); Index1++, RuntimeFunction++) {\r
              SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
              for (Index2 = 0; Index2 < PeHdr->Pe32.FileHeader.NumberOfSections; Index2++, SectionHeader++) {\r
                if (RuntimeFunction->UnwindInfoAddress > SectionHeader->VirtualAddress && RuntimeFunction->UnwindInfoAddress < (SectionHeader->VirtualAddress + SectionHeader->SizeOfRawData)) {\r
                  UnwindInfo = (UNWIND_INFO *)(FileBuffer + SectionHeader->PointerToRawData + (RuntimeFunction->UnwindInfoAddress - SectionHeader->VirtualAddress));\r
                  if (UnwindInfo->Version == 1) {\r
                    memset (UnwindInfo + 1, 0, UnwindInfo->CountOfUnwindCodes * sizeof (UINT16));\r
                    memset (UnwindInfo, 0, sizeof (UNWIND_INFO));\r
                  }\r
                }\r
              }\r
              memset (RuntimeFunction, 0, sizeof (RUNTIME_FUNCTION));\r
            }\r
            //\r
            // Zero Execption Table\r
            //\r
            Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size = 0;\r
            Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress = 0;\r
            DebugMsg (NULL, 0, 9, "Zero the .pdata section if the machine type is X64 for PE32+ image", NULL);\r
            break;\r
          }\r
        }\r
      }\r
    }\r
\r
    //\r
    // Strip zero padding at the end of the .reloc section\r
    //\r
    if (!KeepZeroPendingFlag && Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) {\r
      if (Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size != 0) {\r
        SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
        for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++, SectionHeader++) {\r
          //\r
          // Look for the Section Header that starts as the same virtual address as the Base Relocation Data Directory\r
          //\r
          if (SectionHeader->VirtualAddress == Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress) {\r
            SectionHeader->Misc.VirtualSize = Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;\r
            AllignedRelocSize = (Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size + Optional64->FileAlignment - 1) & (~(Optional64->FileAlignment - 1));\r
            //\r
            // Check to see if there is zero padding at the end of the base relocations\r
            //\r
            if (AllignedRelocSize < SectionHeader->SizeOfRawData) {\r
              //\r
              // Check to see if the base relocations are at the end of the file\r
              //\r
              if (SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData == Optional64->SizeOfImage) {\r
                //\r
                // All the required conditions are met to strip the zero padding of the end of the base relocations section\r
                //\r
                Optional64->SizeOfImage -= (SectionHeader->SizeOfRawData - AllignedRelocSize);\r
                Optional64->SizeOfInitializedData -= (SectionHeader->SizeOfRawData - AllignedRelocSize);\r
                SectionHeader->SizeOfRawData = AllignedRelocSize;\r
                FileLength = Optional64->SizeOfImage;\r
                DebugMsg (NULL, 0, 9, "Remove the zero padding bytes at the end of the base relocations", "The size of padding bytes is %u", (unsigned) (SectionHeader->SizeOfRawData - AllignedRelocSize));\r
              }\r
            }\r
          }\r
        }\r
      }\r
    }\r
  } else {\r
    Error (NULL, 0, 3000, "Invalid", "Magic 0x%x of PeImage %s is unknown.", PeHdr->Pe32.OptionalHeader.Magic, mInImageName);\r
    goto Finish;\r
  }\r
  \r
  if (((PeHdr->Pe32.FileHeader.Characteristics & EFI_IMAGE_FILE_RELOCS_STRIPPED) == 0) && \\r
    (TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress == 0) && \\r
    (TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].Size == 0)) {\r
    //\r
    // PeImage can be loaded into memory, but it has no relocation section. \r
    // Fix TeImage Header to set VA of relocation data directory to not zero, the size is still zero.\r
    //\r
    if (Optional32 != NULL) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = Optional32->SizeOfImage - sizeof (EFI_IMAGE_BASE_RELOCATION);\r
    } else if (Optional64 != NULL) {\r
      TEImageHeader.DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = Optional64->SizeOfImage - sizeof (EFI_IMAGE_BASE_RELOCATION);\r
    }\r
  }\r
   \r
  //\r
  // Zero ExceptionTable Xdata\r
  //\r
  if (!KeepExceptionTableFlag) {\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) &(PeHdr->Pe32.OptionalHeader) + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader);\r
    ZeroXdataSection(mInImageName, FileBuffer, SectionHeader, PeHdr->Pe32.FileHeader.NumberOfSections);\r
  }\r
\r
  //\r
  // Zero Time/Data field\r
  //\r
  ZeroDebugData (FileBuffer, FALSE);\r
\r
  if (OutImageType == FW_TE_IMAGE) {\r
    if ((PeHdr->Pe32.FileHeader.NumberOfSections &~0xFF) || (Type &~0xFF)) {\r
      //\r
      // Pack the subsystem and NumberOfSections into 1 byte. Make sure they fit both.\r
      //\r
      Error (NULL, 0, 3000, "Invalid", "Image's subsystem or NumberOfSections of PeImage %s cannot be packed into 1 byte.", mInImageName);\r
      goto Finish;\r
    }\r
\r
    if ((PeHdr->Pe32.OptionalHeader.SectionAlignment != PeHdr->Pe32.OptionalHeader.FileAlignment)) {\r
      //\r
      // TeImage has the same section alignment and file alignment.\r
      //\r
      Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment of PeImage %s do not match, they must be equal for a TeImage.", mInImageName);\r
      goto Finish;\r
    }\r
\r
    DebugMsg (NULL, 0, 9, "TeImage Header Info", "Machine type is %X, Number of sections is %X, Stripped size is %X, EntryPoint is %X, BaseOfCode is %X, ImageBase is %llX",\r
              TEImageHeader.Machine, TEImageHeader.NumberOfSections, TEImageHeader.StrippedSize, (unsigned) TEImageHeader.AddressOfEntryPoint, (unsigned) TEImageHeader.BaseOfCode, (unsigned long long) TEImageHeader.ImageBase);\r
    //\r
    // Update Image to TeImage\r
    //\r
    if (fpOut != NULL) {\r
      fwrite (&TEImageHeader, 1, sizeof (EFI_TE_IMAGE_HEADER), fpOut);\r
      fwrite (FileBuffer + TEImageHeader.StrippedSize, 1, FileLength - TEImageHeader.StrippedSize, fpOut);\r
    }\r
    if (fpInOut != NULL) {\r
      fwrite (&TEImageHeader, 1, sizeof (EFI_TE_IMAGE_HEADER), fpInOut);\r
      fwrite (FileBuffer + TEImageHeader.StrippedSize, 1, FileLength - TEImageHeader.StrippedSize, fpInOut);\r
    }\r
    VerboseMsg ("the size of output file is %u bytes", (unsigned) (FileLength - TEImageHeader.StrippedSize));\r
    goto Finish;\r
  }\r
WriteFile:\r
  //\r
  // Update Image to EfiImage\r
  //\r
  if (fpOut != NULL) {\r
    fwrite (FileBuffer, 1, FileLength, fpOut);\r
  }\r
  if (fpInOut != NULL) {\r
    fwrite (FileBuffer, 1, FileLength, fpInOut);\r
  }\r
  VerboseMsg ("the size of output file is %u bytes", (unsigned) FileLength);\r
\r
Finish:\r
  if (fpInOut != NULL) {\r
    if (GetUtilityStatus () != STATUS_SUCCESS) {\r
      //\r
      // when file updates failed, original file is still recoveried.\r
      //\r
      fwrite (FileBuffer, 1, FileLength, fpInOut);\r
    }\r
    //\r
    // Write converted data into fpInOut file and close input file.\r
    //\r
    fclose (fpInOut);\r
  }\r
\r
  if (FileBuffer != NULL) {\r
    free (FileBuffer);\r
  }\r
\r
  if (InputFileName != NULL) {\r
    free (InputFileName);\r
  }\r
\r
  if (fpOut != NULL) {\r
    //\r
    // Write converted data into fpOut file and close output file.\r
    //\r
    fclose (fpOut);\r
    if (GetUtilityStatus () != STATUS_SUCCESS) {\r
      if (OutputFileBuffer == NULL) {\r
        remove (OutImageName);\r
      } else {\r
        fpOut = fopen (OutImageName, "wb");\r
        fwrite (OutputFileBuffer, 1, OutputFileLength, fpOut);\r
        fclose (fpOut);\r
        free (OutputFileBuffer);\r
      }\r
    }\r
  }\r
\r
  VerboseMsg ("%s tool done with return code is 0x%x.", UTILITY_NAME, GetUtilityStatus ());\r
\r
  return GetUtilityStatus ();\r
}\r
\r
STATIC\r
EFI_STATUS\r
ZeroDebugData (\r
  IN OUT UINT8   *FileBuffer,\r
  BOOLEAN        ZeroDebugFlag\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Zero debug information in PeImage.\r
\r
Arguments:\r
\r
  FileBuffer    - Pointer to PeImage.\r
  ZeroDebugFlag - TRUE to zero Debug information, FALSE to only zero time/stamp\r
\r
Returns:\r
\r
  EFI_ABORTED   - PeImage is invalid.\r
  EFI_SUCCESS   - Zero debug data successfully.\r
\r
--*/\r
{\r
  UINT32                           Index;\r
  UINT32                           DebugDirectoryEntryRva;\r
  UINT32                           DebugDirectoryEntryFileOffset;\r
  UINT32                           ExportDirectoryEntryRva;\r
  UINT32                           ExportDirectoryEntryFileOffset;\r
  UINT32                           ResourceDirectoryEntryRva;\r
  UINT32                           ResourceDirectoryEntryFileOffset;\r
  EFI_IMAGE_DOS_HEADER            *DosHdr;\r
  EFI_IMAGE_FILE_HEADER           *FileHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER32     *Optional32Hdr;\r
  EFI_IMAGE_OPTIONAL_HEADER64     *Optional64Hdr;\r
  EFI_IMAGE_SECTION_HEADER        *SectionHeader;\r
  EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry;\r
  UINT32                          *NewTimeStamp;  \r
\r
  //\r
  // Init variable.\r
  //\r
  DebugDirectoryEntryRva           = 0;\r
  ExportDirectoryEntryRva          = 0;\r
  ResourceDirectoryEntryRva        = 0;\r
  DebugDirectoryEntryFileOffset    = 0;\r
  ExportDirectoryEntryFileOffset   = 0;\r
  ResourceDirectoryEntryFileOffset = 0;\r
  DosHdr   = (EFI_IMAGE_DOS_HEADER *)  FileBuffer;\r
  FileHdr  = (EFI_IMAGE_FILE_HEADER *) (FileBuffer + DosHdr->e_lfanew + sizeof (UINT32));\r
\r
\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)FileBuffer;\r
  if (DosHdr->e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
    // NO DOS header, must start with PE/COFF header\r
    FileHdr  = (EFI_IMAGE_FILE_HEADER *)(FileBuffer + sizeof (UINT32));\r
  } else {\r
    FileHdr  = (EFI_IMAGE_FILE_HEADER *)(FileBuffer + DosHdr->e_lfanew + sizeof (UINT32));\r
  }\r
\r
  //\r
  // Get Debug, Export and Resource EntryTable RVA address.\r
  // Resource Directory entry need to review.\r
  //\r
  if (FileHdr->Machine == EFI_IMAGE_MACHINE_IA32) {\r
    Optional32Hdr = (EFI_IMAGE_OPTIONAL_HEADER32 *) ((UINT8*) FileHdr + sizeof (EFI_IMAGE_FILE_HEADER));\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) Optional32Hdr +  FileHdr->SizeOfOptionalHeader);\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXPORT && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].Size != 0) {\r
      ExportDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;\r
    }\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size != 0) {\r
      ResourceDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;\r
    }\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size != 0) {\r
      DebugDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
      if (ZeroDebugFlag) {\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size = 0;\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = 0;\r
      }\r
    }\r
  } else {\r
    Optional64Hdr = (EFI_IMAGE_OPTIONAL_HEADER64 *) ((UINT8*) FileHdr + sizeof (EFI_IMAGE_FILE_HEADER));\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) Optional64Hdr +  FileHdr->SizeOfOptionalHeader);\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXPORT && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].Size != 0) {\r
      ExportDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;\r
    }\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size != 0) {\r
      ResourceDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;\r
    }\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size != 0) {\r
      DebugDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
      if (ZeroDebugFlag) {\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size = 0;\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress = 0;\r
      }\r
    }\r
  }\r
\r
  //\r
  // Get DirectoryEntryTable file offset.\r
  //\r
  for (Index = 0; Index < FileHdr->NumberOfSections; Index ++, SectionHeader ++) {\r
    if (DebugDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        DebugDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        DebugDirectoryEntryFileOffset =\r
        DebugDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
    if (ExportDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        ExportDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        ExportDirectoryEntryFileOffset =\r
        ExportDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
    if (ResourceDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        ResourceDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        ResourceDirectoryEntryFileOffset =\r
        ResourceDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
  }\r
\r
  //\r
  //Zero Debug Data and TimeStamp\r
  //\r
  FileHdr->TimeDateStamp = 0;\r
\r
  if (ExportDirectoryEntryFileOffset != 0) {\r
    NewTimeStamp  = (UINT32 *) (FileBuffer + ExportDirectoryEntryFileOffset + sizeof (UINT32));\r
    *NewTimeStamp = 0;\r
  }\r
\r
  if (ResourceDirectoryEntryFileOffset != 0) {\r
    NewTimeStamp  = (UINT32 *) (FileBuffer + ResourceDirectoryEntryFileOffset + sizeof (UINT32));\r
    *NewTimeStamp = 0;\r
  }\r
\r
  if (DebugDirectoryEntryFileOffset != 0) {\r
    DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) (FileBuffer + DebugDirectoryEntryFileOffset);\r
    DebugEntry->TimeDateStamp = 0;\r
    if (ZeroDebugFlag) {\r
      memset (FileBuffer + DebugEntry->FileOffset, 0, DebugEntry->SizeOfData);\r
      memset (DebugEntry, 0, sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY));\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
EFI_STATUS\r
SetStamp (\r
  IN OUT UINT8  *FileBuffer,\r
  IN     CHAR8  *TimeStamp\r
  )\r
/*++\r
\r
Routine Description:\r
\r
  Set new time stamp into PeImage FileHdr and Directory table:\r
  Debug, Export and Resource.\r
\r
Arguments:\r
\r
  FileBuffer    - Pointer to PeImage.\r
  TimeStamp     - Time stamp string.\r
\r
Returns:\r
\r
  EFI_INVALID_PARAMETER   - TimeStamp format is not recognized.\r
  EFI_SUCCESS             - Set new time stamp in this image successfully.\r
\r
--*/\r
{\r
  struct tm                       stime;\r
  struct tm                       *ptime;\r
  time_t                          newtime;\r
  UINT32                          Index;\r
  UINT32                          DebugDirectoryEntryRva;\r
  UINT32                          DebugDirectoryEntryFileOffset;\r
  UINT32                          ExportDirectoryEntryRva;\r
  UINT32                          ExportDirectoryEntryFileOffset;\r
  UINT32                          ResourceDirectoryEntryRva;\r
  UINT32                          ResourceDirectoryEntryFileOffset;\r
  EFI_IMAGE_DOS_HEADER            *DosHdr;\r
  EFI_IMAGE_FILE_HEADER           *FileHdr;\r
  EFI_IMAGE_OPTIONAL_HEADER32     *Optional32Hdr;\r
  EFI_IMAGE_OPTIONAL_HEADER64     *Optional64Hdr;\r
  EFI_IMAGE_SECTION_HEADER        *SectionHeader;\r
  UINT32                          *NewTimeStamp;\r
  \r
  //\r
  // Init variable.\r
  //\r
  DebugDirectoryEntryRva           = 0;\r
  DebugDirectoryEntryFileOffset    = 0;\r
  ExportDirectoryEntryRva          = 0;\r
  ExportDirectoryEntryFileOffset   = 0;\r
  ResourceDirectoryEntryRva        = 0;\r
  ResourceDirectoryEntryFileOffset = 0;\r
  //\r
  // Get time and date that will be set.\r
  //\r
  if (TimeStamp == NULL) {\r
    Error (NULL, 0, 3000, "Invalid", "TimeStamp cannot be NULL.");\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  //\r
  // compare the value with "NOW", if yes, current system time is set.\r
  //\r
  if (stricmp (TimeStamp, "NOW") == 0) {\r
    //\r
    // get system current time and date\r
    //\r
    time (&newtime);\r
  } else {\r
    //\r
    // Check Time Format strictly yyyy-mm-dd 00:00:00\r
    //\r
    for (Index = 0; TimeStamp[Index] != '\0' && Index < 20; Index ++) {\r
      if (Index == 4 || Index == 7) {\r
        if (TimeStamp[Index] == '-') {\r
          continue;\r
        }\r
      } else if (Index == 13 || Index == 16) {\r
        if (TimeStamp[Index] == ':') {\r
          continue;\r
        }\r
      } else if (Index == 10 && TimeStamp[Index] == ' ') {\r
        continue;\r
      } else if ((TimeStamp[Index] < '0') || (TimeStamp[Index] > '9')) {\r
        break;\r
      }\r
    }\r
\r
    if (Index < 19 || TimeStamp[19] != '\0') {\r
      Error (NULL, 0, 1003, "Invalid option value", "Incorrect Time \"%s\"\n  Correct Format \"yyyy-mm-dd 00:00:00\"", TimeStamp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // get the date and time from TimeStamp\r
    //\r
    if (sscanf (TimeStamp, "%d-%d-%d %d:%d:%d",\r
            &stime.tm_year,\r
            &stime.tm_mon,\r
            &stime.tm_mday,\r
            &stime.tm_hour,\r
            &stime.tm_min,\r
            &stime.tm_sec\r
            ) != 6) {\r
      Error (NULL, 0, 1003, "Invalid option value", "Incorrect Tiem \"%s\"\n  Correct Format \"yyyy-mm-dd 00:00:00\"", TimeStamp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // in struct, Month (0 - 11; Jan = 0). So decrease 1 from it\r
    //\r
    if (stime.tm_mon <= 0 || stime.tm_mday <=0) {\r
      Error (NULL, 0, 3000, "Invalid", "%s Invalid date!", TimeStamp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    stime.tm_mon -= 1;\r
\r
    //\r
    // in struct, Year (current year minus 1900)\r
    // and only the dates can be handled from Jan 1, 1970 to Jan 18, 2038\r
    //\r
    //\r
    // convert 0 -> 100 (2000), 1 -> 101 (2001), ..., 38 -> 138 (2038)\r
    //\r
    if (stime.tm_year >= 1970 && stime.tm_year <= 2038) {\r
      //\r
      // convert 1970 -> 70, 2000 -> 100, ...\r
      //\r
      stime.tm_year -= 1900;\r
    } else {\r
      Error (NULL, 0, 3000, "Invalid", "%s Invalid or unsupported datetime!", TimeStamp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    //\r
    // convert the date and time to time_t format\r
    //\r
    newtime = mktime (&stime);\r
    if (newtime == (time_t) - 1) {\r
      Error (NULL, 0, 3000, "Invalid", "%s Invalid or unsupported datetime!", TimeStamp);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
  }\r
\r
  ptime = localtime (&newtime);\r
  DebugMsg (NULL, 0, 9, "New Image Time Stamp", "%04d-%02d-%02d %02d:%02d:%02d",\r
            ptime->tm_year + 1900, ptime->tm_mon + 1, ptime->tm_mday, ptime->tm_hour, ptime->tm_min, ptime->tm_sec);\r
  //\r
  // Set new time and data into PeImage.\r
  //\r
  DosHdr = (EFI_IMAGE_DOS_HEADER *)FileBuffer;\r
  if (DosHdr->e_magic != EFI_IMAGE_DOS_SIGNATURE) {\r
    // NO DOS header, must start with PE/COFF header\r
    FileHdr  = (EFI_IMAGE_FILE_HEADER *)(FileBuffer + sizeof (UINT32));\r
  } else {\r
    FileHdr  = (EFI_IMAGE_FILE_HEADER *)(FileBuffer + DosHdr->e_lfanew + sizeof (UINT32));\r
  }\r
\r
  //\r
  // Get Debug, Export and Resource EntryTable RVA address.\r
  // Resource Directory entry need to review.\r
  //\r
  if (FileHdr->Machine == EFI_IMAGE_MACHINE_IA32) {\r
    Optional32Hdr = (EFI_IMAGE_OPTIONAL_HEADER32 *) ((UINT8*) FileHdr + sizeof (EFI_IMAGE_FILE_HEADER));\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) Optional32Hdr +  FileHdr->SizeOfOptionalHeader);\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXPORT && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].Size != 0) {\r
      ExportDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;\r
    }\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size != 0) {\r
      ResourceDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;\r
    }\r
    if (Optional32Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG && \\r
        Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size != 0) {\r
      DebugDirectoryEntryRva = Optional32Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
    }\r
  } else {\r
    Optional64Hdr = (EFI_IMAGE_OPTIONAL_HEADER64 *) ((UINT8*) FileHdr + sizeof (EFI_IMAGE_FILE_HEADER));\r
    SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ((UINT8 *) Optional64Hdr +  FileHdr->SizeOfOptionalHeader);\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_EXPORT && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].Size != 0) {\r
      ExportDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;\r
    }\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size != 0) {\r
      ResourceDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress;\r
    }\r
    if (Optional64Hdr->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG && \\r
        Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].Size != 0) {\r
      DebugDirectoryEntryRva = Optional64Hdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress;\r
    }\r
  }\r
\r
  //\r
  // Get DirectoryEntryTable file offset.\r
  //\r
  for (Index = 0; Index < FileHdr->NumberOfSections; Index ++, SectionHeader ++) {\r
    if (DebugDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        DebugDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        DebugDirectoryEntryFileOffset =\r
        DebugDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
    if (ExportDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        ExportDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        ExportDirectoryEntryFileOffset =\r
        ExportDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
    if (ResourceDirectoryEntryRva >= SectionHeader->VirtualAddress &&\r
        ResourceDirectoryEntryRva < SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize) {\r
        ResourceDirectoryEntryFileOffset =\r
        ResourceDirectoryEntryRva - SectionHeader->VirtualAddress + SectionHeader->PointerToRawData;\r
    }\r
  }\r
\r
  //\r
  // Set new stamp\r
  //\r
  FileHdr->TimeDateStamp = (UINT32) newtime;\r
\r
  if (ExportDirectoryEntryRva != 0) {\r
    NewTimeStamp  = (UINT32 *) (FileBuffer + ExportDirectoryEntryFileOffset + sizeof (UINT32));\r
    *NewTimeStamp = (UINT32) newtime;\r
  }\r
\r
  if (ResourceDirectoryEntryRva != 0) {\r
    NewTimeStamp  = (UINT32 *) (FileBuffer + ResourceDirectoryEntryFileOffset + sizeof (UINT32));\r
    *NewTimeStamp = (UINT32) newtime;\r
  }\r
\r
  if (DebugDirectoryEntryRva != 0) {\r
    NewTimeStamp  = (UINT32 *) (FileBuffer + DebugDirectoryEntryFileOffset + sizeof (UINT32));\r
    *NewTimeStamp = (UINT32) newtime;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
STATIC\r
STATUS\r
MicrocodeReadData (\r
  FILE          *InFptr,\r
  UINT32        *Data\r
  )\r
/*++\r
\r
Routine Description:\r
  Read a 32-bit microcode data value from a text file and convert to raw binary form.\r
\r
Arguments:\r
  InFptr    - file pointer to input text file\r
  Data      - pointer to where to return the data parsed\r
\r
Returns:\r
  STATUS_SUCCESS    - no errors or warnings, Data contains valid information\r
  STATUS_ERROR      - errors were encountered\r
\r
--*/\r
{\r
  CHAR8  Line[MAX_LINE_LEN];\r
  CHAR8  *cptr;\r
  unsigned ScannedData = 0;\r
\r
  Line[MAX_LINE_LEN - 1]  = 0;\r
  while (1) {\r
    if (fgets (Line, MAX_LINE_LEN, InFptr) == NULL) {\r
      return STATUS_ERROR;\r
    }\r
    //\r
    // If it was a binary file, then it may have overwritten our null terminator\r
    //\r
    if (Line[MAX_LINE_LEN - 1] != 0) {\r
      return STATUS_ERROR;\r
    }\r
\r
    //\r
    // strip space\r
    //\r
    for (cptr = Line; *cptr && isspace(*cptr); cptr++) {\r
    }\r
\r
    // Skip Blank Lines and Comment Lines\r
    if ((strlen(cptr) != 0) && (*cptr != ';')) {\r
      break;\r
    }\r
  }\r
\r
  // Look for\r
  // dd 000000001h ; comment\r
  // dd XXXXXXXX\r
  // DD  XXXXXXXXX\r
  //  DD XXXXXXXXX\r
  //\r
  if ((tolower(cptr[0]) == 'd') && (tolower(cptr[1]) == 'd') && isspace (cptr[2])) {\r
    //\r
    // Skip blanks and look for a hex digit\r
    //\r
    cptr += 3;\r
    for (; *cptr && isspace(*cptr); cptr++) {\r
    }\r
    if (isxdigit (*cptr)) {\r
      if (sscanf (cptr, "%X", &ScannedData) != 1) {\r
        return STATUS_ERROR;\r
      }\r
    }\r
    *Data = (UINT32) ScannedData;\r
    return STATUS_SUCCESS;\r
  }\r
\r
  return STATUS_ERROR;\r
}\r