tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-09-23 17:57:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

ImageTool: Append .hii during PE generation

Browse Source
This commit is contained in:
Marvin Häuser 2023-04-22 01:21:42 +02:00 committed by Mikhail Krichanov
parent 4a02e8a807
commit 942e747a91
8 changed files with 176 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
BaseTools/Conf/build_rule.template
View File

@ -379,6 +379,45 @@
$(CP) ${dst} $(BIN_DIR)(+)$(MODULE_NAME_GUID).efi $(CP) ${dst} $(BIN_DIR)(+)$(MODULE_NAME_GUID).efi
-$(CP) $(DEBUG_DIR)(+)*.map $(OUTPUT_DIR) -$(CP) $(DEBUG_DIR)(+)*.map $(OUTPUT_DIR)
[Dynamic-Library-File.UEFI_HII]
<InputFile>
?.dll
<OutputFile>
$(OUTPUT_DIR)(+)$(MODULE_NAME).efi
$(DEBUG_DIR)(+)$(MODULE_NAME).efi
$(OUTPUT_DIR)(+)$(MODULE_NAME).map
<ExtraDependency>
$(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
<Command.MSFT, Command.INTEL, Command.CLANGPDB>
ImageTool PeXip ${src} ${dst} $(MODULE_TYPE) $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
$(CP) ${dst} $(DEBUG_DIR)
$(CP) ${dst} $(BIN_DIR)(+)$(MODULE_NAME_GUID).efi
-$(CP) $(DEBUG_DIR)(+)*.map $(OUTPUT_DIR)
-$(CP) $(DEBUG_DIR)(+)*.pdb $(OUTPUT_DIR)
<Command.GCC, Command.CLANGGCC>
$(CP) ${src} $(DEBUG_DIR)(+)$(MODULE_NAME).strip
$(OBJCOPY) $(OBJCOPY_STRIPFLAG) $(DEBUG_DIR)(+)$(MODULE_NAME).strip
ImageTool ElfToPe $(DEBUG_DIR)(+)$(MODULE_NAME).strip ${dst} $(MODULE_TYPE) $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
$(CP) ${dst} $(DEBUG_DIR)
$(CP) ${dst} $(BIN_DIR)(+)$(MODULE_NAME_GUID).efi
-$(CP) $(DEBUG_DIR)(+)*.map $(OUTPUT_DIR)
<Command.XCODE>
# tool to convert Mach-O to PE/COFF
"$(MTOC)" -subsystem $(MODULE_TYPE) $(MTOC_FLAGS) ${src} $(DEBUG_DIR)(+)$(MODULE_NAME).pecoff
# create symbol file for GDB debug
-$(DSYMUTIL) ${src}
ImageTool PeXip $(DEBUG_DIR)(+)$(MODULE_NAME).pecoff ${dst} $(MODULE_TYPE) $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
$(CP) ${dst} $(DEBUG_DIR)
$(CP) ${dst} $(BIN_DIR)(+)$(MODULE_NAME_GUID).efi
-$(CP) $(DEBUG_DIR)(+)*.map $(OUTPUT_DIR)
[Dependency-Expression-File] [Dependency-Expression-File]
<InputFile> <InputFile>
?.dxs, ?.Dxs, ?.DXS ?.dxs, ?.Dxs, ?.DXS
@ -603,23 +642,8 @@
<InputFile> <InputFile>
*.hpk *.hpk
<OutputFile.MSFT, OutputFile.INTEL, OutputFile.GCC, OutputFile.CLANGPDB, OutputFile.CLANGGCC> <OutputFile>
$(OUTPUT_DIR)(+)$(MODULE_NAME)hii.lib
<OutputFile.XCODE>
$(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
<Command.CLANGPDB> <Command>
ImageTool HiiBinPe $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(MODULE_GUID) $(HII_BINARY_PACKAGES) ImageTool HiiBin $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(MODULE_GUID) $(HII_BINARY_PACKAGES)
"$(RC)" /Fo${dst} -- $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
<Command.MSFT, Command.INTEL>
ImageTool HiiBinPe $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(MODULE_GUID) $(HII_BINARY_PACKAGES)
"$(RC)" /Fo${dst} $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc
<Command.GCC, Command.CLANGGCC>
ImageTool HiiBinElf $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(MODULE_GUID) $(HII_BINARY_PACKAGES)
"$(RC)" $(RC_FLAGS) $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc ${dst}
<Command.XCODE>
ImageTool HiiBinElf $(OUTPUT_DIR)(+)$(MODULE_NAME)hii.rc $(MODULE_GUID) $(HII_BINARY_PACKAGES)

16
BaseTools/Conf/tools_def.template
View File

@ -738,12 +738,6 @@ DEFINE GCC_ASLPP_FLAGS = -x c -E -include AutoGen.h
DEFINE GCC_ASLCC_FLAGS = -x c DEFINE GCC_ASLCC_FLAGS = -x c
DEFINE GCC_WINDRES_FLAGS = -J rc -O coff DEFINE GCC_WINDRES_FLAGS = -J rc -O coff
DEFINE GCC_DTCPP_FLAGS = -E -x assembler-with-cpp -imacros AutoGen.h -nostdinc -undef DEFINE GCC_DTCPP_FLAGS = -E -x assembler-with-cpp -imacros AutoGen.h -nostdinc -undef
DEFINE GCC_IA32_RC_FLAGS = -I binary -O elf32-i386 -B i386 --rename-section .data=.hii
DEFINE GCC_X64_RC_FLAGS = -I binary -O elf64-x86-64 -B i386 --rename-section .data=.hii
DEFINE GCC_ARM_RC_FLAGS = -I binary -O elf32-littlearm -B arm --rename-section .data=.hii
DEFINE GCC_AARCH64_RC_FLAGS = -I binary -O elf64-littleaarch64 -B aarch64 --rename-section .data=.hii
DEFINE GCC_RISCV64_RC_FLAGS = -I binary -O elf64-littleriscv -B riscv --rename-section .data=.hii
DEFINE GCC_LOONGARCH64_RC_FLAGS = -I binary -O elf64-loongarch -B loongarch64 --rename-section .data=.hii
# GCC Build Flag for included header file list generation # GCC Build Flag for included header file list generation
DEFINE GCC_DEPS_FLAGS = -MMD -MF $@.deps DEFINE GCC_DEPS_FLAGS = -MMD -MF $@.deps
@ -835,7 +829,6 @@ DEFINE GCC_PP_FLAGS = -E -x assembler-with-cpp -include A
*_GCC5_IA32_ASLDLINK_FLAGS = DEF(GCC5_IA32_X64_ASLDLINK_FLAGS) -Wl,-q,-m,elf_i386 -no-pie *_GCC5_IA32_ASLDLINK_FLAGS = DEF(GCC5_IA32_X64_ASLDLINK_FLAGS) -Wl,-q,-m,elf_i386 -no-pie
*_GCC5_IA32_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m32 -march=i386 *_GCC5_IA32_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m32 -march=i386
*_GCC5_IA32_DLINK2_FLAGS = DEF(GCC5_IA32_DLINK2_FLAGS) -no-pie *_GCC5_IA32_DLINK2_FLAGS = DEF(GCC5_IA32_DLINK2_FLAGS) -no-pie
*_GCC5_IA32_RC_FLAGS = DEF(GCC_IA32_RC_FLAGS)
*_GCC5_IA32_NASM_FLAGS = -f elf32 -DRODATA_SECTION_NAME=.rodata *_GCC5_IA32_NASM_FLAGS = -f elf32 -DRODATA_SECTION_NAME=.rodata
DEBUG_GCC5_IA32_CC_FLAGS = DEF(GCC5_IA32_CC_FLAGS) -flto -Os DEBUG_GCC5_IA32_CC_FLAGS = DEF(GCC5_IA32_CC_FLAGS) -flto -Os
@ -866,7 +859,6 @@ RELEASE_GCC5_IA32_DLINK_FLAGS = DEF(GCC5_IA32_X64_DLINK_FLAGS) -flto -Os -Wl,
*_GCC5_X64_ASLDLINK_FLAGS = DEF(GCC5_IA32_X64_ASLDLINK_FLAGS) -Wl,-m,elf_x86_64 *_GCC5_X64_ASLDLINK_FLAGS = DEF(GCC5_IA32_X64_ASLDLINK_FLAGS) -Wl,-m,elf_x86_64
*_GCC5_X64_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m64 *_GCC5_X64_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m64
*_GCC5_X64_DLINK2_FLAGS = DEF(GCC5_X64_DLINK2_FLAGS) *_GCC5_X64_DLINK2_FLAGS = DEF(GCC5_X64_DLINK2_FLAGS)
*_GCC5_X64_RC_FLAGS = DEF(GCC_X64_RC_FLAGS)
*_GCC5_X64_NASM_FLAGS = -f elf64 -DRODATA_SECTION_NAME=.rodata *_GCC5_X64_NASM_FLAGS = -f elf64 -DRODATA_SECTION_NAME=.rodata
DEBUG_GCC5_X64_CC_FLAGS = DEF(GCC5_X64_CC_FLAGS) -flto -DUSING_LTO -Os DEBUG_GCC5_X64_CC_FLAGS = DEF(GCC5_X64_CC_FLAGS) -flto -DUSING_LTO -Os
@ -899,7 +891,6 @@ RELEASE_GCC5_X64_DLINK_FLAGS = DEF(GCC5_X64_DLINK_FLAGS) -flto -Os
*_GCC5_ARM_DLINK2_FLAGS = DEF(GCC5_ARM_DLINK2_FLAGS) *_GCC5_ARM_DLINK2_FLAGS = DEF(GCC5_ARM_DLINK2_FLAGS)
*_GCC5_ARM_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS) *_GCC5_ARM_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS)
*_GCC5_ARM_PP_FLAGS = DEF(GCC_PP_FLAGS) -mthumb -march=armv7-a *_GCC5_ARM_PP_FLAGS = DEF(GCC_PP_FLAGS) -mthumb -march=armv7-a
*_GCC5_ARM_RC_FLAGS = DEF(GCC_ARM_RC_FLAGS)
*_GCC5_ARM_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) -mthumb -march=armv7-a *_GCC5_ARM_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) -mthumb -march=armv7-a
*_GCC5_ARM_CC_SECPEIFLAGS = DEF(GCC_ARM_CC_SECPEIFLAGS) *_GCC5_ARM_CC_SECPEIFLAGS = DEF(GCC_ARM_CC_SECPEIFLAGS)
@ -933,7 +924,6 @@ RELEASE_GCC5_ARM_DLINK_FLAGS = DEF(GCC5_ARM_DLINK_FLAGS) -flto -Os -L$(WORKS
*_GCC5_AARCH64_DLINK2_FLAGS = DEF(GCC5_AARCH64_DLINK2_FLAGS) *_GCC5_AARCH64_DLINK2_FLAGS = DEF(GCC5_AARCH64_DLINK2_FLAGS)
*_GCC5_AARCH64_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS) *_GCC5_AARCH64_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS)
*_GCC5_AARCH64_PP_FLAGS = DEF(GCC_PP_FLAGS) *_GCC5_AARCH64_PP_FLAGS = DEF(GCC_PP_FLAGS)
*_GCC5_AARCH64_RC_FLAGS = DEF(GCC_AARCH64_RC_FLAGS)
*_GCC5_AARCH64_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) *_GCC5_AARCH64_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS)
*_GCC5_AARCH64_CC_SECPEIFLAGS = DEF(GCC_AARCH64_CC_SECPEIFLAGS) *_GCC5_AARCH64_CC_SECPEIFLAGS = DEF(GCC_AARCH64_CC_SECPEIFLAGS)
@ -977,7 +967,6 @@ RELEASE_GCC5_AARCH64_DLINK_SECPEIFLAGS = DEF(GCC_ALIGN)
*_GCC5_RISCV64_CC_FLAGS = DEF(GCC5_RISCV64_CC_FLAGS) -save-temps *_GCC5_RISCV64_CC_FLAGS = DEF(GCC5_RISCV64_CC_FLAGS) -save-temps
*_GCC5_RISCV64_DLINK_FLAGS = DEF(GCC5_RISCV64_DLINK_FLAGS) *_GCC5_RISCV64_DLINK_FLAGS = DEF(GCC5_RISCV64_DLINK_FLAGS)
*_GCC5_RISCV64_DLINK2_FLAGS = DEF(GCC5_RISCV64_DLINK2_FLAGS) *_GCC5_RISCV64_DLINK2_FLAGS = DEF(GCC5_RISCV64_DLINK2_FLAGS)
*_GCC5_RISCV64_RC_FLAGS = DEF(GCC_RISCV64_RC_FLAGS)
*_GCC5_RISCV64_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS) *_GCC5_RISCV64_DTCPP_FLAGS = DEF(GCC_DTCPP_FLAGS)
################## ##################
@ -1000,7 +989,6 @@ RELEASE_GCC5_AARCH64_DLINK_SECPEIFLAGS = DEF(GCC_ALIGN)
*_GCC5_LOONGARCH64_ASM_FLAGS = DEF(GCC5_LOONGARCH64_ASM_FLAGS) *_GCC5_LOONGARCH64_ASM_FLAGS = DEF(GCC5_LOONGARCH64_ASM_FLAGS)
*_GCC5_LOONGARCH64_DLINK_FLAGS = DEF(GCC5_LOONGARCH64_DLINK_FLAGS) *_GCC5_LOONGARCH64_DLINK_FLAGS = DEF(GCC5_LOONGARCH64_DLINK_FLAGS)
*_GCC5_LOONGARCH64_DLINK2_FLAGS = DEF(GCC5_LOONGARCH64_DLINK2_FLAGS) *_GCC5_LOONGARCH64_DLINK2_FLAGS = DEF(GCC5_LOONGARCH64_DLINK2_FLAGS)
*_GCC5_LOONGARCH64_RC_FLAGS = DEF(GCC_LOONGARCH64_RC_FLAGS)
*_GCC5_LOONGARCH64_NASM_FLAGS = -f elf32 *_GCC5_LOONGARCH64_NASM_FLAGS = -f elf32
*_GCC5_LOONGARCH64_PP_FLAGS = DEF(GCC5_LOONGARCH64_PP_FLAGS) *_GCC5_LOONGARCH64_PP_FLAGS = DEF(GCC5_LOONGARCH64_PP_FLAGS)
@ -1158,7 +1146,6 @@ DEFINE CLANGDWARF_IA32_DLINK2_FLAGS = -no-pie
*_CLANGDWARF_IA32_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m32 -fno-lto DEF(CLANGDWARF_IA32_TARGET) *_CLANGDWARF_IA32_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m32 -fno-lto DEF(CLANGDWARF_IA32_TARGET)
*_CLANGDWARF_IA32_ASLDLINK_FLAGS = DEF(CLANGDWARF_IA32_X64_ASLDLINK_FLAGS) -Wl,-q,-m,elf_i386 -fuse-ld=lld -no-pie *_CLANGDWARF_IA32_ASLDLINK_FLAGS = DEF(CLANGDWARF_IA32_X64_ASLDLINK_FLAGS) -Wl,-q,-m,elf_i386 -fuse-ld=lld -no-pie
*_CLANGDWARF_IA32_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m32 -march=i386 DEF(CLANGDWARF_IA32_TARGET) *_CLANGDWARF_IA32_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m32 -march=i386 DEF(CLANGDWARF_IA32_TARGET)
*_CLANGDWARF_IA32_RC_FLAGS = DEF(GCC_IA32_RC_FLAGS)
*_CLANGDWARF_IA32_NASM_FLAGS = -f elf32 -DRODATA_SECTION_NAME=.rodata *_CLANGDWARF_IA32_NASM_FLAGS = -f elf32 -DRODATA_SECTION_NAME=.rodata
*_CLANGDWARF_IA32_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_IA32_TARGET) *_CLANGDWARF_IA32_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_IA32_TARGET)
*_CLANGDWARF_IA32_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_IA32_TARGET) *_CLANGDWARF_IA32_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_IA32_TARGET)
@ -1194,7 +1181,6 @@ NOOPT_CLANGDWARF_IA32_DLINK2_FLAGS = DEF(CLANGDWARF_IA32_DLINK2_FLAGS) -O0 -
*_CLANGDWARF_X64_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m64 -fno-lto DEF(CLANGDWARF_X64_TARGET) *_CLANGDWARF_X64_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m64 -fno-lto DEF(CLANGDWARF_X64_TARGET)
*_CLANGDWARF_X64_ASLDLINK_FLAGS = DEF(CLANGDWARF_IA32_X64_ASLDLINK_FLAGS) -Wl,-m,elf_x86_64 -fuse-ld=lld *_CLANGDWARF_X64_ASLDLINK_FLAGS = DEF(CLANGDWARF_IA32_X64_ASLDLINK_FLAGS) -Wl,-m,elf_x86_64 -fuse-ld=lld
*_CLANGDWARF_X64_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m64 DEF(CLANGDWARF_X64_TARGET) *_CLANGDWARF_X64_ASM_FLAGS = DEF(GCC5_ASM_FLAGS) -m64 DEF(CLANGDWARF_X64_TARGET)
*_CLANGDWARF_X64_RC_FLAGS = DEF(GCC_X64_RC_FLAGS)
*_CLANGDWARF_X64_NASM_FLAGS = -f elf64 -DRODATA_SECTION_NAME=.rodata *_CLANGDWARF_X64_NASM_FLAGS = -f elf64 -DRODATA_SECTION_NAME=.rodata
*_CLANGDWARF_X64_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_X64_TARGET) *_CLANGDWARF_X64_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_X64_TARGET)
*_CLANGDWARF_X64_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_X64_TARGET) *_CLANGDWARF_X64_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_X64_TARGET)
@ -1242,7 +1228,6 @@ DEFINE CLANGDWARF_ARM_DLINK_FLAGS = DEF(CLANGDWARF_ARM_TARGET) DEF(GCC_ARM_DLI
*_CLANGDWARF_ARM_ASM_FLAGS = DEF(GCC_ASM_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a -Qunused-arguments *_CLANGDWARF_ARM_ASM_FLAGS = DEF(GCC_ASM_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a -Qunused-arguments
*_CLANGDWARF_ARM_DLINK2_FLAGS = DEF(GCC_DLINK2_FLAGS_COMMON) *_CLANGDWARF_ARM_DLINK2_FLAGS = DEF(GCC_DLINK2_FLAGS_COMMON)
*_CLANGDWARF_ARM_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a *_CLANGDWARF_ARM_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a
*_CLANGDWARF_ARM_RC_FLAGS = DEF(GCC_ARM_RC_FLAGS)
*_CLANGDWARF_ARM_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a *_CLANGDWARF_ARM_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) DEF(CLANGDWARF_ARM_TARGET) -march=armv7-a
*_CLANGDWARF_ARM_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_ARM_TARGET) *_CLANGDWARF_ARM_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_ARM_TARGET)
*_CLANGDWARF_ARM_CC_SECPEIFLAGS = DEF(GCC_ARM_CC_SECPEIFLAGS) *_CLANGDWARF_ARM_CC_SECPEIFLAGS = DEF(GCC_ARM_CC_SECPEIFLAGS)
@ -1286,7 +1271,6 @@ DEFINE CLANGDWARF_AARCH64_DLINK_FLAGS = DEF(CLANGDWARF_AARCH64_TARGET) DEF(GCC_
*_CLANGDWARF_AARCH64_DLINK_SECPEIFLAGS = DEF(GCC_ALIGN) *_CLANGDWARF_AARCH64_DLINK_SECPEIFLAGS = DEF(GCC_ALIGN)
*_CLANGDWARF_AARCH64_DLINK2_FLAGS = DEF(GCC_DLINK2_FLAGS_COMMON) *_CLANGDWARF_AARCH64_DLINK2_FLAGS = DEF(GCC_DLINK2_FLAGS_COMMON)
*_CLANGDWARF_AARCH64_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET) *_CLANGDWARF_AARCH64_PP_FLAGS = DEF(GCC_PP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET)
*_CLANGDWARF_AARCH64_RC_FLAGS = DEF(GCC_AARCH64_RC_FLAGS)
*_CLANGDWARF_AARCH64_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET) *_CLANGDWARF_AARCH64_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET)
*_CLANGDWARF_AARCH64_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET) *_CLANGDWARF_AARCH64_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS) DEF(CLANGDWARF_AARCH64_TARGET)
*_CLANGDWARF_AARCH64_CC_SECPEIFLAGS = DEF(GCC_AARCH64_CC_SECPEIFLAGS) *_CLANGDWARF_AARCH64_CC_SECPEIFLAGS = DEF(GCC_AARCH64_CC_SECPEIFLAGS)

141
BaseTools/ImageTool/BinEmit.c
View File

@ -58,33 +58,24 @@ CreateStringEntry (
*HiiSectionOffset += sizeof (*RDStr) + RDStr->Length * sizeof (RDStr->String[0]); *HiiSectionOffset += sizeof (*RDStr) + RDStr->Length * sizeof (RDStr->String[0]);
} }
static GLOBAL_REMOVE_IF_UNREFERENCED CONST UINT8 mHiiResourceSectionHeaderSize =
UINT8 * 3 * (sizeof (EFI_IMAGE_RESOURCE_DIRECTORY) + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY)
CreateHiiResouceSectionHeader ( + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_STRING) + 3 * sizeof (CHAR16)) + sizeof (EFI_IMAGE_RESOURCE_DATA_ENTRY);
OUT UINT32 *HiiHeaderSize,
VOID
InitializeHiiResouceSectionHeader (
OUT UINT8 *HiiSectionHeader,
IN UINT32 HiiDataAddress,
IN UINT32 HiiDataSize IN UINT32 HiiDataSize
) )
{ {
UINT32 HiiSectionHeaderSize;
UINT32 HiiSectionOffset; UINT32 HiiSectionOffset;
UINT8 *HiiSectionHeader;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *TypeRDirEntry; EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *TypeRDirEntry;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *NameRDirEntry; EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *NameRDirEntry;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *LangRDirEntry; EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *LangRDirEntry;
EFI_IMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry; EFI_IMAGE_RESOURCE_DATA_ENTRY *ResourceDataEntry;
assert (HiiHeaderSize != NULL); assert (HiiSectionHeader != NULL);
//
// Calculate the total size for the resource header (include Type, Name and Language)
// then allocate memory for whole Hii file.
//
HiiSectionHeaderSize = 3 * (sizeof (EFI_IMAGE_RESOURCE_DIRECTORY) + sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY)
+ sizeof (EFI_IMAGE_RESOURCE_DIRECTORY_STRING) + 3 * sizeof (CHAR16)) + sizeof (EFI_IMAGE_RESOURCE_DATA_ENTRY);
HiiSectionHeader = calloc (1, HiiSectionHeaderSize + HiiDataSize);
if (HiiSectionHeader == NULL) {
fprintf (stderr, "ImageTool: Could not allocate memory for Hii\n");
return NULL;
}
HiiSectionOffset = 0; HiiSectionOffset = 0;
// //
@ -105,12 +96,8 @@ CreateHiiResouceSectionHeader (
LangRDirEntry->u2.OffsetToData = HiiSectionOffset; LangRDirEntry->u2.OffsetToData = HiiSectionOffset;
ResourceDataEntry = (EFI_IMAGE_RESOURCE_DATA_ENTRY *)(HiiSectionHeader + HiiSectionOffset); ResourceDataEntry = (EFI_IMAGE_RESOURCE_DATA_ENTRY *)(HiiSectionHeader + HiiSectionOffset);
HiiSectionOffset += sizeof (EFI_IMAGE_RESOURCE_DATA_ENTRY); HiiSectionOffset += sizeof (EFI_IMAGE_RESOURCE_DATA_ENTRY);
ResourceDataEntry->OffsetToData = HiiSectionOffset; ResourceDataEntry->OffsetToData = HiiDataAddress + HiiSectionOffset;
ResourceDataEntry->Size = HiiDataSize; ResourceDataEntry->Size = HiiDataSize;
*HiiHeaderSize = HiiSectionHeaderSize;
return HiiSectionHeader;
} }
RETURN_STATUS RETURN_STATUS
@ -119,27 +106,19 @@ ConstructHii (
IN UINT32 NumOfFiles, IN UINT32 NumOfFiles,
IN GUID *HiiGuid, IN GUID *HiiGuid,
OUT void **Hii, OUT void **Hii,
OUT UINT32 *HiiSize, OUT UINT32 *HiiSize
IN BOOLEAN IsElf
) )
{ {
UINT8 *HiiPackageData;
UINT8 *HiiPackageDataPointer; UINT8 *HiiPackageDataPointer;
EFI_HII_PACKAGE_LIST_HEADER HiiPackageListHeader; EFI_HII_PACKAGE_LIST_HEADER HiiPackageListHeader;
EFI_HII_PACKAGE_HEADER *HiiPackageHeader; EFI_HII_PACKAGE_HEADER *HiiPackageHeader;
EFI_IFR_FORM_SET *IfrFormSet; EFI_IFR_FORM_SET *IfrFormSet;
EFI_HII_PACKAGE_HEADER EndPackage; EFI_HII_PACKAGE_HEADER EndPackage;
UINT32 HiiSectionHeaderSize;
UINT8 *HiiSectionHeader;
const char *HiiPackageRCFileHeader;
UINT32 Index; UINT32 Index;
UINT32 Total;
UINT8 *Buffer;
UINT8 *BufferStart;
UINT32 Step;
void *File; void *File;
UINT32 FileSize; UINT32 FileSize;
UINT8 NumberOfFormPackages; UINT8 NumberOfFormPackages;
UINT32 TempSize;
assert (Hii != NULL); assert (Hii != NULL);
assert (HiiGuid != NULL); assert (HiiGuid != NULL);
@ -191,111 +170,31 @@ ConstructHii (
CopyGuid (&HiiPackageListHeader.PackageListGuid, HiiGuid); CopyGuid (&HiiPackageListHeader.PackageListGuid, HiiGuid);
if (IsElf) { HiiPackageData = calloc (1, HiiPackageListHeader.PackageLength);
HiiSectionHeader = CreateHiiResouceSectionHeader (&HiiSectionHeaderSize, HiiPackageListHeader.PackageLength); if (HiiPackageData == NULL) {
if (HiiSectionHeader == NULL) {
return RETURN_OUT_OF_RESOURCES; return RETURN_OUT_OF_RESOURCES;
} }
HiiPackageDataPointer = HiiSectionHeader + HiiSectionHeaderSize; memmove (HiiPackageData, &HiiPackageListHeader, sizeof (HiiPackageListHeader));
memcpy (HiiPackageDataPointer, &HiiPackageListHeader, sizeof (HiiPackageListHeader));
HiiPackageDataPointer += sizeof (HiiPackageListHeader);
HiiPackageDataPointer = HiiPackageData + sizeof (HiiPackageListHeader);
for (Index = 0; Index < NumOfFiles; ++Index) { for (Index = 0; Index < NumOfFiles; ++Index) {
File = UserReadFile (FileNames[Index], &FileSize); File = UserReadFile (FileNames[Index], &FileSize);
if (File == NULL) { if (File == NULL) {
fprintf (stderr, "ImageTool: Could not open %s: %s\n", FileNames[Index], strerror (errno)); fprintf (stderr, "ImageTool: Could not open %s: %s\n", FileNames[Index], strerror (errno));
free (HiiSectionHeader);
return RETURN_ABORTED; return RETURN_ABORTED;
} }
memcpy (HiiPackageDataPointer, File, FileSize); memmove (HiiPackageDataPointer, File, FileSize);
HiiPackageDataPointer += FileSize; HiiPackageDataPointer += FileSize;
free (File); free (File);
} }
memcpy (HiiPackageDataPointer, &EndPackage, sizeof (EndPackage)); memmove (HiiPackageDataPointer, &EndPackage, sizeof (EndPackage));
*Hii = HiiSectionHeader; *Hii = HiiPackageData;
*HiiSize = HiiSectionHeaderSize + HiiPackageListHeader.PackageLength; *HiiSize = HiiPackageListHeader.PackageLength;
return RETURN_SUCCESS;
}
HiiPackageRCFileHeader = "//\n// DO NOT EDIT -- auto-generated file\n//\n\n1 HII\n{";
HiiSectionHeaderSize = (UINT32)AsciiStrLen (HiiPackageRCFileHeader);
TempSize = HiiSectionHeaderSize + 5 * HiiPackageListHeader.PackageLength;
HiiSectionHeader = calloc (1, TempSize);
if (HiiSectionHeader == NULL) {
fprintf (stderr, "ImageTool: Could not allocate memory for HiiRC\n");
return RETURN_OUT_OF_RESOURCES;
}
Buffer = calloc (1, HiiPackageListHeader.PackageLength);
if (Buffer == NULL) {
fprintf (stderr, "ImageTool: Could not allocate memory for Buffer\n");
free (HiiSectionHeader);
return RETURN_OUT_OF_RESOURCES;
}
BufferStart = Buffer;
memcpy (Buffer, &HiiPackageListHeader, sizeof (HiiPackageListHeader));
Buffer += sizeof (HiiPackageListHeader);
for (Index = 0; Index < NumOfFiles; ++Index) {
File = UserReadFile (FileNames[Index], &FileSize);
if (File == NULL) {
fprintf (stderr, "ImageTool: Could not open %s: %s\n", FileNames[Index], strerror (errno));
free (HiiSectionHeader);
free (BufferStart);
return RETURN_ABORTED;
}
memcpy (Buffer, File, FileSize);
Buffer += FileSize;
free (File);
}
memcpy (Buffer, &EndPackage, sizeof (EndPackage));
memcpy (HiiSectionHeader, HiiPackageRCFileHeader, HiiSectionHeaderSize);
HiiPackageDataPointer = HiiSectionHeader + HiiSectionHeaderSize;
Total = HiiSectionHeaderSize;
Buffer = BufferStart;
for (Index = 0; Index + 2 < HiiPackageListHeader.PackageLength; Index += 2) {
if (Index % 16 == 0) {
Step = snprintf ((char *)HiiPackageDataPointer, TempSize - Total, "\n ");
HiiPackageDataPointer += Step;
Total += Step;
}
Step = snprintf ((char *)HiiPackageDataPointer, TempSize - Total, " 0x%04X,", *(UINT16 *)Buffer);
HiiPackageDataPointer += Step;
Total += Step;
Buffer += 2;
}
if (Index % 16 == 0) {
Step = snprintf ((char *)HiiPackageDataPointer, TempSize - Total, "\n ");
HiiPackageDataPointer += Step;
Total += Step;
}
if ((Index + 2) == HiiPackageListHeader.PackageLength) {
Total += snprintf ((char *)HiiPackageDataPointer, TempSize - Total, " 0x%04X\n}\n", *(UINT16 *)Buffer);
} else if ((Index + 1) == HiiPackageListHeader.PackageLength) {
Total += snprintf ((char *)HiiPackageDataPointer, TempSize - Total, " 0x%04X\n}\n", *(UINT8 *)Buffer);
}
*Hii = HiiSectionHeader;
*HiiSize = Total;
free (BufferStart);
return RETURN_SUCCESS; return RETURN_SUCCESS;
} }

99
BaseTools/ImageTool/ElfScan.c
View File

@ -45,8 +45,6 @@
#define ELF_SUFFIX_(Name, Arch) ELF_SUFFIX__ (Name, Arch) #define ELF_SUFFIX_(Name, Arch) ELF_SUFFIX__ (Name, Arch)
#define ELF_SUFFIX(Name) ELF_SUFFIX_ (Name, ELF_ARCH) #define ELF_SUFFIX(Name) ELF_SUFFIX_ (Name, ELF_ARCH)
#define ELF_HII_SECTION_NAME ".hii"
typedef struct { typedef struct {
const Elf_Ehdr *Ehdr; const Elf_Ehdr *Ehdr;
uint32_t Alignment; uint32_t Alignment;
@ -104,21 +102,6 @@ GetString (
return (const char *)Ehdr + Shdr->sh_offset + Offset; return (const char *)Ehdr + Shdr->sh_offset + Offset;
} }
#define GetSIsHiiRsrcShdrtring ELF_SUFFIX(IsHiiRsrcShdr)
static
BOOLEAN
IsHiiRsrcShdr (
IN const Elf_Ehdr *Ehdr,
IN const Elf_Shdr *Shdr
)
{
assert (Shdr != NULL);
Elf_Shdr *Namedr = GetShdrByIndex (Ehdr, Ehdr->e_shstrndx);
return strcmp ((const char *)Ehdr + Namedr->sh_offset + Shdr->sh_name, ELF_HII_SECTION_NAME) == 0;
}
#define IsShdrLoadable ELF_SUFFIX(IsShdrLoadable) #define IsShdrLoadable ELF_SUFFIX(IsShdrLoadable)
static static
BOOLEAN BOOLEAN
@ -129,71 +112,7 @@ IsShdrLoadable (
{ {
assert (Shdr != NULL); assert (Shdr != NULL);
return (Shdr->sh_flags & SHF_ALLOC) != 0 && !IsHiiRsrcShdr (Ehdr, Shdr); return (Shdr->sh_flags & SHF_ALLOC) != 0;
}
#define SetHiiResourceHeader ELF_SUFFIX(SetHiiResourceHeader)
static
VOID
SetHiiResourceHeader (
IN OUT UINT8 *Hii,
IN UINT32 Offset
)
{
UINT32 Index;
EFI_IMAGE_RESOURCE_DIRECTORY *RDir;
EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *RDirEntry;
EFI_IMAGE_RESOURCE_DIRECTORY_STRING *RDirString;
EFI_IMAGE_RESOURCE_DATA_ENTRY *RDataEntry;
assert (Hii != NULL);
//
// Fill Resource section entry
//
RDir = (EFI_IMAGE_RESOURCE_DIRECTORY *)Hii;
RDirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *)(RDir + 1);
for (Index = 0; Index < RDir->NumberOfNamedEntries; ++Index) {
if (RDirEntry->u1.s.NameIsString) {
RDirString = (EFI_IMAGE_RESOURCE_DIRECTORY_STRING *)(Hii + RDirEntry->u1.s.NameOffset);
if ((RDirString->Length == 3)
&& (RDirString->String[0] == L'H')
&& (RDirString->String[1] == L'I')
&& (RDirString->String[2] == L'I')) {
//
// Resource Type "HII" found
//
if (RDirEntry->u2.s.DataIsDirectory) {
//
// Move to next level - resource Name
//
RDir = (EFI_IMAGE_RESOURCE_DIRECTORY *)(Hii + RDirEntry->u2.s.OffsetToDirectory);
RDirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *)(RDir + 1);
if (RDirEntry->u2.s.DataIsDirectory) {
//
// Move to next level - resource Language
//
RDir = (EFI_IMAGE_RESOURCE_DIRECTORY *)(Hii + RDirEntry->u2.s.OffsetToDirectory);
RDirEntry = (EFI_IMAGE_RESOURCE_DIRECTORY_ENTRY *)(RDir + 1);
}
}
//
// Now it ought to be resource Data. Update its OffsetToData value
//
if (!RDirEntry->u2.s.DataIsDirectory) {
RDataEntry = (EFI_IMAGE_RESOURCE_DATA_ENTRY *)(Hii + RDirEntry->u2.OffsetToData);
RDataEntry->OffsetToData = RDataEntry->OffsetToData + Offset;
break;
}
}
}
RDirEntry++;
}
return;
} }
#define ParseElfFile ELF_SUFFIX(ParseElfFile) #define ParseElfFile ELF_SUFFIX(ParseElfFile)
@ -689,21 +608,6 @@ CreateIntermediate (
return RETURN_VOLUME_CORRUPTED; return RETURN_VOLUME_CORRUPTED;
} }
if (IsHiiRsrcShdr (Ehdr, Shdr)) {
ImageInfo->HiiInfo.DataSize = (uint32_t)Shdr->sh_size;
ImageInfo->HiiInfo.Data = calloc (1, ImageInfo->HiiInfo.DataSize);
if (ImageInfo->HiiInfo.Data == NULL) {
fprintf (stderr, "ImageTool: Could not allocate memory for Hii Data\n");
return RETURN_OUT_OF_RESOURCES;
};
if (Shdr->sh_type == SHT_PROGBITS) {
memcpy (ImageInfo->HiiInfo.Data, (const char *)Ehdr + Shdr->sh_offset, ImageInfo->HiiInfo.DataSize);
}
SetHiiResourceHeader (ImageInfo->HiiInfo.Data, (UINT32)(Shdr->sh_addr - BaseAddress));
} else {
Name = GetString (Ehdr, Shdr->sh_name, 0); Name = GetString (Ehdr, Shdr->sh_name, 0);
if (Name == NULL) { if (Name == NULL) {
return RETURN_VOLUME_CORRUPTED; return RETURN_VOLUME_CORRUPTED;
@ -736,7 +640,6 @@ CreateIntermediate (
++SIndex; ++SIndex;
} }
}
assert (SIndex == ImageInfo->SegmentInfo.NumSegments); assert (SIndex == ImageInfo->SegmentInfo.NumSegments);

48
BaseTools/ImageTool/ImageTool.c
View File

@ -18,8 +18,7 @@ HiiBin (
IN const char *HiiName, IN const char *HiiName,
IN const char *Guid, IN const char *Guid,
IN const char *FileNames[], IN const char *FileNames[],
IN UINT32 NumOfFiles, IN UINT32 NumOfFiles
IN BOOLEAN IsElf
) )
{ {
RETURN_STATUS Status; RETURN_STATUS Status;
@ -37,7 +36,7 @@ HiiBin (
return Status; return Status;
} }
Status = ConstructHii (FileNames, NumOfFiles, &HiiGuid, &Hii, &HiiSize, IsElf); Status = ConstructHii (FileNames, NumOfFiles, &HiiGuid, &Hii, &HiiSize);
if (RETURN_ERROR (Status)) { if (RETURN_ERROR (Status)) {
fprintf (stderr, "ImageTool: Could not construct HiiBin\n"); fprintf (stderr, "ImageTool: Could not construct HiiBin\n");
return Status; return Status;
@ -278,11 +277,14 @@ GenExecutable (
IN const char *InputFileName, IN const char *InputFileName,
IN const char *FormatName, IN const char *FormatName,
IN const char *TypeName, IN const char *TypeName,
IN const char *HiiFileName,
IN const char *BaseAddress IN const char *BaseAddress
) )
{ {
UINT32 InputFileSize; UINT32 InputFileSize;
VOID *InputFile; VOID *InputFile;
UINT32 HiiFileSize;
VOID *HiiFile;
RETURN_STATUS Status; RETURN_STATUS Status;
bool Result; bool Result;
image_tool_image_info_t ImageInfo; image_tool_image_info_t ImageInfo;
@ -316,6 +318,19 @@ GenExecutable (
} }
} }
if (HiiFileName != NULL) {
HiiFile = UserReadFile (HiiFileName, &HiiFileSize);
if (HiiFile == NULL) {
fprintf (stderr, "ImageTool: Could not open %s: %s\n", HiiFileName, strerror (errno));
return RETURN_ABORTED;
}
free (ImageInfo.HiiInfo.Data);
ImageInfo.HiiInfo.Data = HiiFile;
ImageInfo.HiiInfo.DataSize = HiiFileSize;
}
Result = CheckToolImage (&ImageInfo); Result = CheckToolImage (&ImageInfo);
if (!Result) { if (!Result) {
ToolImageDestruct (&ImageInfo); ToolImageDestruct (&ImageInfo);
@ -371,42 +386,27 @@ int main (int argc, const char *argv[])
if (strcmp (argv[1], "ElfToPe") == 0 || strcmp (argv[1], "PeXip") == 0) { if (strcmp (argv[1], "ElfToPe") == 0 || strcmp (argv[1], "PeXip") == 0) {
if (argc < 5) { if (argc < 5) {
fprintf (stderr, "ImageTool: Command arguments are missing\n"); fprintf (stderr, "ImageTool: Command arguments are missing\n");
fprintf (stderr, " Usage: ImageTool %s InputFile OutputFile ModuleType\n", argv[1]); fprintf (stderr, " Usage: ImageTool %s InputFile OutputFile ModuleType [HiiRc]\n", argv[1]);
raise (); raise ();
return -1; return -1;
} }
Status = GenExecutable (argv[3], argv[2], "PE", argv[4], NULL); Status = GenExecutable (argv[3], argv[2], "PE", argv[4], argc >= 6 ? argv[5] : NULL, NULL);
if (RETURN_ERROR (Status)) { if (RETURN_ERROR (Status)) {
raise (); raise ();
return -1; return -1;
} }
} else if (strcmp (argv[1], "HiiBinElf") == 0) { } else if (strcmp (argv[1], "HiiBin") == 0) {
if (argc < 5) { if (argc < 5) {
fprintf (stderr, "ImageTool: Command arguments are missing\n"); fprintf (stderr, "ImageTool: Command arguments are missing\n");
fprintf (stderr, " Usage: ImageTool HiiBinElf OutputFile GUID InputFile1 InputFile2 ...\n"); fprintf (stderr, " Usage: ImageTool HiiBin OutputFile GUID InputFile1 InputFile2 ...\n");
raise (); raise ();
return -1; return -1;
} }
NumOfFiles = (UINT32)argc - 4U; NumOfFiles = (UINT32)argc - 4U;
Status = HiiBin (argv[2], argv[3], &argv[4], NumOfFiles, TRUE); Status = HiiBin (argv[2], argv[3], &argv[4], NumOfFiles);
if (RETURN_ERROR (Status)) {
raise ();
return -1;
}
} else if (strcmp (argv[1], "HiiBinPe") == 0) {
if (argc < 5) {
fprintf (stderr, "ImageTool: Command arguments are missing\n");
fprintf (stderr, " Usage: ImageTool HiiBinPe OutputFile GUID InputFile1 InputFile2 ...\n");
raise ();
return -1;
}
NumOfFiles = (UINT32)argc - 4U;
Status = HiiBin (argv[2], argv[3], &argv[4], NumOfFiles, FALSE);
if (RETURN_ERROR (Status)) { if (RETURN_ERROR (Status)) {
raise (); raise ();
return -1; return -1;
@ -419,7 +419,7 @@ int main (int argc, const char *argv[])
return -1; return -1;
} }
Status = GenExecutable (argv[4], argv[3], "PE", NULL, argv[2]); Status = GenExecutable (argv[4], argv[3], "PE", NULL, NULL, argv[2]);
if (RETURN_ERROR (Status)) { if (RETURN_ERROR (Status)) {
raise (); raise ();
return -1; return -1;

12
BaseTools/ImageTool/ImageTool.h
View File

@ -140,14 +140,22 @@ ScanElf (
IN const char *SymbolsPath IN const char *SymbolsPath
); );
extern CONST UINT8 mHiiResourceSectionHeaderSize;
VOID
InitializeHiiResouceSectionHeader (
OUT UINT8 *HiiSectionHeader,
IN UINT32 HiiDataAddress,
IN UINT32 HiiDataSize
);
RETURN_STATUS RETURN_STATUS
ConstructHii ( ConstructHii (
IN const char *FileNames[], IN const char *FileNames[],
IN UINT32 NumOfFiles, IN UINT32 NumOfFiles,
IN GUID *HiiGuid, IN GUID *HiiGuid,
OUT void **Hii, OUT void **Hii,
OUT UINT32 *HiiSize, OUT UINT32 *HiiSize
IN BOOLEAN IsElf
); );
#endif // IMAGE_TOOL_H #endif // IMAGE_TOOL_H

38
BaseTools/ImageTool/PeEmit.c
View File

@ -36,6 +36,7 @@ typedef struct {
EFI_IMAGE_NT_HEADERS *PeHdr; EFI_IMAGE_NT_HEADERS *PeHdr;
image_tool_emit_pe_hdr_info_t HdrInfo; image_tool_emit_pe_hdr_info_t HdrInfo;
uint32_t SectionsSize; uint32_t SectionsSize;
uint32_t HiiSectionAddress;
uint32_t ExtraSectionsSize; uint32_t ExtraSectionsSize;
uint32_t UnsignedFileSize; uint32_t UnsignedFileSize;
uint32_t RelocTableSize; uint32_t RelocTableSize;
@ -236,8 +237,16 @@ EmitPeGetExtraSectionsSize (
return false; return false;
} }
Overflow = BaseOverflowAlignUpU32 ( AlignedHiiTableSize = 0;
if (Context->Image->HiiInfo.DataSize > 0) {
Overflow = BaseOverflowAddU32 (
mHiiResourceSectionHeaderSize,
Context->Image->HiiInfo.DataSize, Context->Image->HiiInfo.DataSize,
&AlignedHiiTableSize
);
Overflow |= BaseOverflowAlignUpU32 (
AlignedHiiTableSize,
Context->FileAlignment, Context->FileAlignment,
&AlignedHiiTableSize &AlignedHiiTableSize
); );
@ -245,6 +254,7 @@ EmitPeGetExtraSectionsSize (
raise (); raise ();
return false; return false;
} }
}
Overflow = BaseOverflowAddU32 ( Overflow = BaseOverflowAddU32 (
AlignedRelocTableSize, AlignedRelocTableSize,
@ -348,6 +358,7 @@ ToolImageEmitPeExtraSectionHeaders (
uint32_t SectionHeadersSize; uint32_t SectionHeadersSize;
EFI_IMAGE_SECTION_HEADER *Section; EFI_IMAGE_SECTION_HEADER *Section;
uint32_t SectionOffset; uint32_t SectionOffset;
uint32_t HiiSectionSize;
assert (Context != NULL); assert (Context != NULL);
assert (Buffer != NULL); assert (Buffer != NULL);
@ -361,18 +372,22 @@ ToolImageEmitPeExtraSectionHeaders (
assert (sizeof (EFI_IMAGE_SECTION_HEADER) <= *BufferSize); assert (sizeof (EFI_IMAGE_SECTION_HEADER) <= *BufferSize);
HiiSectionSize = mHiiResourceSectionHeaderSize + Context->Image->HiiInfo.DataSize;
Section = (void *) *Buffer; Section = (void *) *Buffer;
strncpy ((char *)Section->Name, ".rsrc", sizeof (Section->Name)); strncpy ((char *)Section->Name, ".rsrc", sizeof (Section->Name));
Section->SizeOfRawData = ALIGN_VALUE (Context->Image->HiiInfo.DataSize, Context->FileAlignment); Section->SizeOfRawData = ALIGN_VALUE (HiiSectionSize, Context->FileAlignment);
Section->VirtualSize = Section->SizeOfRawData; Section->VirtualSize = ALIGN_VALUE (HiiSectionSize, Context->Image->SegmentInfo.SegmentAlignment);
Section->Characteristics = EFI_IMAGE_SCN_CNT_INITIALIZED_DATA | EFI_IMAGE_SCN_MEM_READ; Section->Characteristics = EFI_IMAGE_SCN_CNT_INITIALIZED_DATA | EFI_IMAGE_SCN_MEM_READ;
Section->PointerToRawData = SectionOffset; Section->PointerToRawData = SectionOffset;
Section->VirtualAddress = Section->PointerToRawData; Section->VirtualAddress = Section->PointerToRawData;
Context->HiiSectionAddress = SectionOffset;
SectionOffset += Section->SizeOfRawData; SectionOffset += Section->SizeOfRawData;
Context->PeHdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = Context->Image->HiiInfo.DataSize; Context->PeHdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].Size = HiiSectionSize;
Context->PeHdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = Section->PointerToRawData; Context->PeHdr->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_RESOURCE].VirtualAddress = Section->PointerToRawData;
*BufferSize -= sizeof (EFI_IMAGE_SECTION_HEADER); *BufferSize -= sizeof (EFI_IMAGE_SECTION_HEADER);
@ -796,7 +811,18 @@ ToolImageEmitPeHiiTable (
return true; return true;
} }
Context->PeHdr->SizeOfImage += ALIGN_VALUE (Image->HiiInfo.DataSize, Image->SegmentInfo.SegmentAlignment); Context->PeHdr->SizeOfImage += ALIGN_VALUE (mHiiResourceSectionHeaderSize + Image->HiiInfo.DataSize, Image->SegmentInfo.SegmentAlignment);
assert (mHiiResourceSectionHeaderSize <= *BufferSize);
InitializeHiiResouceSectionHeader (
*Buffer,
Context->HiiSectionAddress,
Context->Image->HiiInfo.DataSize
);
*BufferSize -= mHiiResourceSectionHeaderSize;
*Buffer += mHiiResourceSectionHeaderSize;
assert (Image->HiiInfo.DataSize <= *BufferSize); assert (Image->HiiInfo.DataSize <= *BufferSize);
@ -806,7 +832,7 @@ ToolImageEmitPeHiiTable (
*Buffer += Image->HiiInfo.DataSize; *Buffer += Image->HiiInfo.DataSize;
HiiTablePadding = ALIGN_VALUE_ADDEND( HiiTablePadding = ALIGN_VALUE_ADDEND(
Image->HiiInfo.DataSize, mHiiResourceSectionHeaderSize + Image->HiiInfo.DataSize,
Context->FileAlignment Context->FileAlignment
); );

27
BaseTools/ImageTool/PeScan.c
View File

@ -173,7 +173,6 @@ static
bool bool
ScanPeGetSegmentInfo ( ScanPeGetSegmentInfo (
OUT image_tool_segment_info_t *SegmentInfo, OUT image_tool_segment_info_t *SegmentInfo,
OUT image_tool_hii_info_t *HiiInfo,
IN PE_COFF_LOADER_IMAGE_CONTEXT *Context IN PE_COFF_LOADER_IMAGE_CONTEXT *Context
) )
{ {
@ -184,7 +183,6 @@ ScanPeGetSegmentInfo (
uint32_t Index; uint32_t Index;
assert (SegmentInfo != NULL); assert (SegmentInfo != NULL);
assert (HiiInfo != NULL);
assert (Context != NULL); assert (Context != NULL);
SegmentInfo->SegmentAlignment = PeCoffGetSectionAlignment (Context); SegmentInfo->SegmentAlignment = PeCoffGetSectionAlignment (Context);
@ -242,21 +240,6 @@ ScanPeGetSegmentInfo (
++SegmentInfo->NumSegments; ++SegmentInfo->NumSegments;
++ImageSegment; ++ImageSegment;
} else if (memcmp (Section->Name, PE_COFF_SECT_NAME_RESRC, sizeof (Section->Name)) == 0) {
// FIXME: Store only the HII data and construct the RESRC dir in PeEmit.c
HiiInfo->DataSize = MIN (Section->SizeOfRawData, Section->VirtualSize);
HiiInfo->Data = malloc (HiiInfo->DataSize);
if (HiiInfo->Data == NULL) {
fprintf (stderr, "ImageTool: Could not allocate memory for Hii Data\n");
return false;
}
memmove (
HiiInfo->Data,
ImageBuffer + Section->VirtualAddress,
HiiInfo->DataSize
);
} }
} }
@ -406,7 +389,7 @@ ToolContextConstructPe (
return RETURN_VOLUME_CORRUPTED; return RETURN_VOLUME_CORRUPTED;
} }
Result = ScanPeGetSegmentInfo (&Image->SegmentInfo, &Image->HiiInfo, &Context); Result = ScanPeGetSegmentInfo (&Image->SegmentInfo, &Context);
if (!Result) { if (!Result) {
fprintf (stderr, "ImageTool: Could not retrieve segment info\n"); fprintf (stderr, "ImageTool: Could not retrieve segment info\n");
ToolImageDestruct (Image); ToolImageDestruct (Image);
@ -422,6 +405,14 @@ ToolContextConstructPe (
return RETURN_VOLUME_CORRUPTED; return RETURN_VOLUME_CORRUPTED;
} }
Result = ScanPeGetHiiInfo (&Image->HiiInfo, &Context);
if (!Result) {
fprintf (stderr, "ImageTool: Could not retrieve HII info\n");
ToolImageDestruct (Image);
FreeAlignedPages (Destination, DestinationPages);
return RETURN_VOLUME_CORRUPTED;
}
FreeAlignedPages (Destination, DestinationPages); FreeAlignedPages (Destination, DestinationPages);
return RETURN_SUCCESS; return RETURN_SUCCESS;