</xs:restriction>
</xs:simpleType>
</xs:element>
- <xs:element minOccurs="1" maxOccurs="1" name="DatumType"
+ <xs:element minOccurs="1" maxOccurs="1" name="DatumType"
type="PcdDatumTypes"/>
<xs:element minOccurs="0" maxOccurs="1" name="MaxDatumSize">
<xs:annotation>
</xs:annotation>
<xs:complexType>
<xs:sequence>
+ <xs:choice>
+ <xs:element minOccurs="0" maxOccurs="1" name="ValidValueList">
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="xs:normalizedString">
+ <xs:attribute name="Lang" type="xs:language" default="en-us" use="optional"/>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+ <xs:element minOccurs="0" maxOccurs="1" name="ValidValueRange" type="xs:normalizedString"/>
+ <xs:element minOccurs="0" maxOccurs="1" name="Expression" type="xs:normalizedString"/>
+ </xs:choice>
<xs:element minOccurs="1" maxOccurs="1" name="ErrorNumber">
<xs:annotation>
<xs:documentation xml:lang="en-us"> The minLength of 3 is
</xs:annotation>
<xs:complexType>
<xs:sequence>
+ <xs:choice>
+ <xs:element minOccurs="0" maxOccurs="1" name="ValidValueList">
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="xs:normalizedString">
+ <xs:attribute name="Lang" type="xs:language" default="en-us" use="optional"/>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+ </xs:element>
+ <xs:element minOccurs="0" maxOccurs="1" name="ValidValueRange" type="xs:normalizedString"/>
+ <xs:element minOccurs="0" maxOccurs="1" name="Expression" type="xs:normalizedString"/>
+ </xs:choice>
<xs:element minOccurs="1" maxOccurs="1" name="ErrorNumber">
<xs:annotation>
<xs:documentation xml:lang="en-us"> The minLength of 3 is
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="1" maxOccurs="1" name="CName" type="xs:NCName"/>
+ <xs:element minOccurs="0" maxOccurs="1" name="GUID" type="RegistryFormatGuid"/>
<xs:element minOccurs="0" maxOccurs="1" name="VariableName"
type="xs:normalizedString">
<xs:annotation>
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="1" maxOccurs="1" name="CName" type="xs:NCName"/>
+ <xs:element minOccurs="0" maxOccurs="1" name="GUID" type="RegistryFormatGuid"/>
<xs:element ref="HelpText" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="Usage" use="required">
<xs:complexType>
<xs:sequence>
<xs:element minOccurs="1" maxOccurs="1" name="CName" type="xs:NCName"/>
+ <xs:element minOccurs="0" maxOccurs="1" name="GUID" type="RegistryFormatGuid"/>
<xs:element ref="HelpText" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
<xs:attribute name="Usage" use="required">
different from the Distribution Package license. </xs:documentation>
</xs:annotation>
</xs:element>
- <xs:element minOccurs="0" maxOccurs="1" name="Abstract" type="xs:normalizedString">
+ <xs:element minOccurs="0" maxOccurs="1" name="Abstract">
<xs:annotation>
<xs:documentation xml:lang="en-us"> This is only required if the Abstract is
different from the Distribution Package Abstract. </xs:documentation>
</xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="xs:normalizedString">
+ <xs:attribute name="Lang" type="xs:language" default="en-us" use="optional"/>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
</xs:element>
- <xs:element minOccurs="0" maxOccurs="1" name="Description" type="xs:string">
+ <xs:element minOccurs="0" maxOccurs="1" name="Description">
<xs:annotation>
<xs:documentation xml:lang="en-us"> This is only required if the Description is
different from the Distribution Package Description. </xs:documentation>
</xs:annotation>
+ <xs:complexType>
+ <xs:simpleContent>
+ <xs:extension base="xs:string">
+ <xs:attribute name="Lang" type="xs:language" default="en-us" use="optional"/>
+ </xs:extension>
+ </xs:simpleContent>
+ </xs:complexType>
+
</xs:element>
</xs:sequence>
</xs:complexType>
<xs:enumeration value="File"/>
<xs:enumeration value="FV"/>
<xs:enumeration value="GUID"/>
+ <xs:enumeration value="HII"/>
<xs:enumeration value="Hii"/>
<xs:enumeration value="HOB"/>
<xs:enumeration value="SystemTable"/>
</xs:documentation>
</xs:annotation>
</xs:enumeration>
+ <xs:enumeration value="RedHat32"/>
+ <xs:enumeration value="RedHat64"/>
+ <xs:enumeration value="SuSE32"/>
+ <xs:enumeration value="SuSE64"/>
<xs:enumeration value="Linux32"/>
<xs:enumeration value="Linux64"/>
<xs:enumeration value="OS/X32"/>
<xs:enumeration value="OS/X64"/>
+ <xs:enumeration value="Generic"/>
<xs:enumeration value="GenericWin">
<xs:annotation>
<xs:documentation xml:lang="en-us"> Typically, this is used for Windows Batch files.
\r
<Command.GCC, Command.RVCT>\r
"$(PP)" $(PP_FLAGS) $(INC) ${src} > ${d_path}(+)${s_base}.i\r
- Trim --source-code -o ${d_path}(+)${s_base}.iii ${d_path}(+)${s_base}.i\r
+ Trim --trim-long --source-code -o ${d_path}(+)${s_base}.iii ${d_path}(+)${s_base}.i\r
# For RVCTCYGWIN ASM_FLAGS must be first to work around pathing issues\r
"$(ASM)" $(ASM_FLAGS) -o ${dst} $(INC) ${d_path}(+)${s_base}.iii\r
\r
DEFINE GCC47_IA32_PREFIX = /usr/bin/\r
DEFINE GCC47_X64_PREFIX = /usr/bin/\r
\r
+DEFINE GCC48_IA32_PREFIX = /usr/bin/\r
+DEFINE GCC48_X64_PREFIX = /usr/bin/\r
+\r
DEFINE UNIX_IASL_BIN = /usr/bin/iasl\r
#DEFINE UNIX_IASL_BIN = $(HOME)/programs/iasl\r
DEFINE WIN_ASL_BIN_DIR = C:\ASL\r
# Required to build platforms or ACPI tables:\r
# Intel(r) ACPI Compiler v20101013 from\r
# http://www.acpica.org/downloads/previous_releases.php\r
+# GCC48 -Linux- Requires:\r
+# GCC 4.8\r
+# Optional:\r
+# Required to build platforms or ACPI tables:\r
+# Intel(r) ACPI Compiler v20101013 from\r
+# http://www.acpica.org/downloads/previous_releases.php\r
# ELFGCC -Linux- Requires:\r
# GCC(this tool chain uses whatever version of gcc and binutils that is installed in /usr/bin)\r
# Optional:\r
DEFINE GCC_IA32_X64_DLINK_COMMON = DEF(GCC_DLINK_FLAGS_COMMON) --gc-sections\r
DEFINE GCC_ARM_AARCH64_DLINK_COMMON= -Ttext=0x0 --emit-relocs -nostdlib -u $(IMAGE_ENTRY_POINT) -e $(IMAGE_ENTRY_POINT) -Map $(DEST_DIR_DEBUG)/$(BASE_NAME).map\r
DEFINE GCC_IA32_X64_ASLDLINK_FLAGS = DEF(GCC_IA32_X64_DLINK_COMMON) --entry _ReferenceAcpiTable -u $(IMAGE_ENTRY_POINT)\r
+DEFINE GCC_ARM_AARCH64_ASLDLINK_FLAGS = DEF(GCC_ARM_AARCH64_DLINK_COMMON) --entry ReferenceAcpiTable -u $(IMAGE_ENTRY_POINT)\r
DEFINE GCC_IA32_X64_DLINK_FLAGS = DEF(GCC_IA32_X64_DLINK_COMMON) --entry _$(IMAGE_ENTRY_POINT) --file-alignment 0x20 --section-alignment 0x20 -Map $(DEST_DIR_DEBUG)/$(BASE_NAME).map\r
DEFINE GCC_IPF_DLINK_FLAGS = -nostdlib -O2 --gc-sections --dll -static --entry $(IMAGE_ENTRY_POINT) --undefined $(IMAGE_ENTRY_POINT) -Map $(DEST_DIR_DEBUG)/$(BASE_NAME).map\r
DEFINE GCC_IPF_OBJCOPY_FLAGS = -I elf64-ia64-little -O efi-bsdrv-ia64\r
DEFINE GCC46_ARM_ASM_FLAGS = $(ARCHASM_FLAGS) $(PLATFORM_FLAGS) DEF(GCC_ASM_FLAGS) -mlittle-endian\r
DEFINE GCC46_ARM_CC_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC44_ALL_CC_FLAGS) -mword-relocations -mlittle-endian -mabi=aapcs -mapcs -fno-short-enums -save-temps -fsigned-char -mno-unaligned-access -Wno-address -fomit-frame-pointer\r
DEFINE GCC46_ARM_DLINK_FLAGS = DEF(GCC_ARM_AARCH64_DLINK_COMMON) --oformat=elf32-littlearm\r
+DEFINE GCC46_ARM_ASLDLINK_FLAGS = DEF(GCC_ARM_AARCH64_ASLDLINK_FLAGS) --oformat=elf32-littlearm\r
\r
DEFINE GCC47_IA32_CC_FLAGS = DEF(GCC46_IA32_CC_FLAGS)\r
DEFINE GCC47_X64_CC_FLAGS = DEF(GCC46_X64_CC_FLAGS)\r
DEFINE GCC47_AARCH64_CC_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC44_ALL_CC_FLAGS) -mcmodel=large -mlittle-endian -fno-short-enums -save-temps -fverbose-asm -fsigned-char -ffunction-sections -fdata-sections -fomit-frame-pointer -fno-builtin -Wno-address\r
DEFINE GCC47_ARM_DLINK_FLAGS = DEF(GCC46_ARM_DLINK_FLAGS)\r
DEFINE GCC47_AARCH64_DLINK_FLAGS = DEF(GCC_ARM_AARCH64_DLINK_COMMON)\r
+DEFINE GCC47_ARM_ASLDLINK_FLAGS = DEF(GCC46_ARM_ASLDLINK_FLAGS)\r
+DEFINE GCC47_AARCH64_ASLDLINK_FLAGS = DEF(GCC_ARM_AARCH64_ASLDLINK_FLAGS)\r
+\r
+DEFINE GCC48_IA32_CC_FLAGS = DEF(GCC47_IA32_CC_FLAGS)\r
+DEFINE GCC48_X64_CC_FLAGS = DEF(GCC47_X64_CC_FLAGS)\r
+DEFINE GCC48_IA32_X64_DLINK_COMMON = DEF(GCC47_IA32_X64_DLINK_COMMON)\r
+DEFINE GCC48_IA32_X64_ASLDLINK_FLAGS = DEF(GCC47_IA32_X64_ASLDLINK_FLAGS)\r
+DEFINE GCC48_IA32_X64_DLINK_FLAGS = DEF(GCC47_IA32_X64_DLINK_FLAGS)\r
+DEFINE GCC48_X64_DLINK_FLAGS = DEF(GCC47_X64_DLINK_FLAGS)\r
+DEFINE GCC48_ASM_FLAGS = DEF(GCC47_ASM_FLAGS)\r
+DEFINE GCC48_ARM_ASM_FLAGS = DEF(GCC47_ARM_ASM_FLAGS)\r
+DEFINE GCC48_AARCH64_ASM_FLAGS = DEF(GCC47_AARCH64_ASM_FLAGS)\r
+DEFINE GCC48_ARM_CC_FLAGS = DEF(GCC47_ARM_CC_FLAGS)\r
+DEFINE GCC48_AARCH64_CC_FLAGS = DEF(GCC47_AARCH64_CC_FLAGS)\r
+DEFINE GCC48_ARM_DLINK_FLAGS = DEF(GCC47_ARM_DLINK_FLAGS)\r
+DEFINE GCC48_AARCH64_DLINK_FLAGS = DEF(GCC_ARM_AARCH64_DLINK_COMMON)\r
+DEFINE GCC48_ARM_ASLDLINK_FLAGS = DEF(GCC47_ARM_ASLDLINK_FLAGS)\r
+DEFINE GCC48_AARCH64_ASLDLINK_FLAGS = DEF(GCC_ARM_AARCH64_ASLDLINK_FLAGS)\r
\r
####################################################################################\r
#\r
*_GCC44_*_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS)\r
*_GCC44_*_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
*_GCC44_*_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS)\r
-*_GCC44_*_APP_FLAGS =\r
+*_GCC44_*_APP_FLAGS = DEF(GCC_PP_FLAGS)\r
*_GCC44_*_ASL_FLAGS = DEF(IASL_FLAGS)\r
*_GCC44_*_ASL_OUTFLAGS = DEF(IASL_OUTFLAGS)\r
\r
*_GCC46_ARM_ARCHCC_FLAGS = -mthumb\r
*_GCC46_ARM_PLATFORM_FLAGS = -march=armv7-a\r
\r
+*_GCC46_ARM_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC46_ARM_ASLDLINK_FLAGS = DEF(GCC46_ARM_ASLDLINK_FLAGS)\r
*_GCC46_ARM_ASM_FLAGS = DEF(GCC46_ARM_ASM_FLAGS)\r
*_GCC46_ARM_DLINK_FLAGS = DEF(GCC46_ARM_DLINK_FLAGS)\r
*_GCC46_ARM_PLATFORM_FLAGS = -march=armv7-a\r
*_GCC47_ARM_ASLPP_PATH = ENV(GCC47_ARM_PREFIX)gcc\r
*_GCC47_ARM_RC_PATH = ENV(GCC47_ARM_PREFIX)objcopy\r
\r
-*_GCC46_ARM_ARCHCC_FLAGS = -mthumb\r
-*_GCC46_ARM_PLATFORM_FLAGS = -march=armv7-a\r
+*_GCC47_ARM_ARCHCC_FLAGS = -mthumb\r
+*_GCC47_ARM_PLATFORM_FLAGS = -march=armv7-a\r
\r
+*_GCC47_ARM_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC47_ARM_ASLDLINK_FLAGS = DEF(GCC47_ARM_ASLDLINK_FLAGS)\r
*_GCC47_ARM_ASM_FLAGS = DEF(GCC47_ARM_ASM_FLAGS)\r
*_GCC47_ARM_DLINK_FLAGS = DEF(GCC47_ARM_DLINK_FLAGS)\r
*_GCC47_ARM_PLATFORM_FLAGS = -march=armv7-a\r
*_GCC47_AARCH64_ASLPP_PATH = ENV(GCC47_AARCH64_PREFIX)gcc\r
*_GCC47_AARCH64_RC_PATH = ENV(GCC47_AARCH64_PREFIX)objcopy\r
\r
+*_GCC47_AARCH64_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC47_AARCH64_ASLDLINK_FLAGS = DEF(GCC47_AARCH64_ASLDLINK_FLAGS)\r
*_GCC47_AARCH64_ASM_FLAGS = DEF(GCC47_AARCH64_ASM_FLAGS)\r
*_GCC47_AARCH64_DLINK_FLAGS = DEF(GCC47_AARCH64_DLINK_FLAGS)\r
*_GCC47_AARCH64_PLATFORM_FLAGS =\r
DEBUG_GCC47_AARCH64_CC_FLAGS = DEF(GCC47_AARCH64_CC_FLAGS) -O0\r
RELEASE_GCC47_AARCH64_CC_FLAGS = DEF(GCC47_AARCH64_CC_FLAGS) -Wno-unused-but-set-variable\r
\r
+####################################################################################\r
+#\r
+# GCC 4.8 - This configuration is used to compile under Linux to produce\r
+# PE/COFF binaries using GCC 4.8.\r
+#\r
+####################################################################################\r
+*_GCC48_*_*_FAMILY = GCC\r
+\r
+*_GCC48_*_MAKE_PATH = make\r
+*_GCC48_*_ASL_PATH = DEF(UNIX_IASL_BIN)\r
+\r
+*_GCC48_*_PP_FLAGS = DEF(GCC_PP_FLAGS)\r
+*_GCC48_*_ASLPP_FLAGS = DEF(GCC_ASLPP_FLAGS)\r
+*_GCC48_*_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC48_*_VFRPP_FLAGS = DEF(GCC_VFRPP_FLAGS)\r
+*_GCC48_*_APP_FLAGS =\r
+*_GCC48_*_ASL_FLAGS = DEF(IASL_FLAGS)\r
+*_GCC48_*_ASL_OUTFLAGS = DEF(IASL_OUTFLAGS)\r
+\r
+##################\r
+# GCC48 IA32 definitions\r
+##################\r
+*_GCC48_IA32_OBJCOPY_PATH = DEF(GCC48_IA32_PREFIX)objcopy\r
+*_GCC48_IA32_CC_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_SLINK_PATH = DEF(GCC48_IA32_PREFIX)ar\r
+*_GCC48_IA32_DLINK_PATH = DEF(GCC48_IA32_PREFIX)ld\r
+*_GCC48_IA32_ASLDLINK_PATH = DEF(GCC48_IA32_PREFIX)ld\r
+*_GCC48_IA32_ASM_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_PP_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_VFRPP_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_ASLCC_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_ASLPP_PATH = DEF(GCC48_IA32_PREFIX)gcc\r
+*_GCC48_IA32_RC_PATH = DEF(GCC48_IA32_PREFIX)objcopy\r
+\r
+*_GCC48_IA32_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m32\r
+*_GCC48_IA32_ASLDLINK_FLAGS = DEF(GCC48_IA32_X64_ASLDLINK_FLAGS) -m elf_i386\r
+*_GCC48_IA32_ASM_FLAGS = DEF(GCC48_ASM_FLAGS) -m32 -march=i386\r
+*_GCC48_IA32_CC_FLAGS = DEF(GCC48_IA32_CC_FLAGS) -Os\r
+*_GCC48_IA32_DLINK_FLAGS = DEF(GCC48_IA32_X64_DLINK_FLAGS) -m elf_i386 --oformat=elf32-i386\r
+*_GCC48_IA32_RC_FLAGS = DEF(GCC_IA32_RC_FLAGS)\r
+*_GCC48_IA32_OBJCOPY_FLAGS = \r
+\r
+##################\r
+# GCC48 X64 definitions\r
+##################\r
+*_GCC48_X64_OBJCOPY_PATH = DEF(GCC48_X64_PREFIX)objcopy\r
+*_GCC48_X64_CC_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_SLINK_PATH = DEF(GCC48_X64_PREFIX)ar\r
+*_GCC48_X64_DLINK_PATH = DEF(GCC48_X64_PREFIX)ld\r
+*_GCC48_X64_ASLDLINK_PATH = DEF(GCC48_X64_PREFIX)ld\r
+*_GCC48_X64_ASM_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_PP_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_VFRPP_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_ASLCC_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_ASLPP_PATH = DEF(GCC48_X64_PREFIX)gcc\r
+*_GCC48_X64_RC_PATH = DEF(GCC48_X64_PREFIX)objcopy\r
+\r
+*_GCC48_X64_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS) -m64\r
+*_GCC48_X64_ASLDLINK_FLAGS = DEF(GCC48_IA32_X64_ASLDLINK_FLAGS) -m elf_x86_64\r
+*_GCC48_X64_ASM_FLAGS = DEF(GCC48_ASM_FLAGS) -m64\r
+*_GCC48_X64_CC_FLAGS = DEF(GCC48_X64_CC_FLAGS)\r
+*_GCC48_X64_DLINK_FLAGS = DEF(GCC48_X64_DLINK_FLAGS)\r
+*_GCC48_X64_RC_FLAGS = DEF(GCC_X64_RC_FLAGS)\r
+*_GCC48_X64_OBJCOPY_FLAGS = \r
+\r
+##################\r
+# GCC48 ARM definitions\r
+##################\r
+*_GCC48_ARM_CC_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_SLINK_PATH = ENV(GCC48_ARM_PREFIX)ar\r
+*_GCC48_ARM_DLINK_PATH = ENV(GCC48_ARM_PREFIX)ld\r
+*_GCC48_ARM_ASLDLINK_PATH = ENV(GCC48_ARM_PREFIX)ld\r
+*_GCC48_ARM_ASM_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_PP_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_VFRPP_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_ASLCC_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_ASLPP_PATH = ENV(GCC48_ARM_PREFIX)gcc\r
+*_GCC48_ARM_RC_PATH = ENV(GCC48_ARM_PREFIX)objcopy\r
+\r
+*_GCC48_ARM_ARCHCC_FLAGS = -mthumb\r
+*_GCC48_ARM_PLATFORM_FLAGS = -march=armv7-a\r
+\r
+*_GCC48_ARM_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC48_ARM_ASLDLINK_FLAGS = DEF(GCC48_ARM_ASLDLINK_FLAGS)\r
+*_GCC48_ARM_ASM_FLAGS = DEF(GCC48_ARM_ASM_FLAGS)\r
+*_GCC48_ARM_DLINK_FLAGS = DEF(GCC48_ARM_DLINK_FLAGS)\r
+*_GCC48_ARM_PLATFORM_FLAGS = -march=armv7-a\r
+*_GCC48_ARM_PP_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC_PP_FLAGS)\r
+*_GCC48_ARM_RC_FLAGS = DEF(GCC_ARM_RC_FLAGS)\r
+*_GCC48_ARM_VFRPP_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC_VFRPP_FLAGS)\r
+\r
+ DEBUG_GCC48_ARM_CC_FLAGS = DEF(GCC48_ARM_CC_FLAGS) -O0\r
+RELEASE_GCC48_ARM_CC_FLAGS = DEF(GCC48_ARM_CC_FLAGS) -Wno-unused-but-set-variable\r
+\r
+##################\r
+# GCC48 AARCH64 definitions\r
+##################\r
+*_GCC48_AARCH64_CC_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_SLINK_PATH = ENV(GCC48_AARCH64_PREFIX)ar\r
+*_GCC48_AARCH64_DLINK_PATH = ENV(GCC48_AARCH64_PREFIX)ld\r
+*_GCC48_AARCH64_ASLDLINK_PATH = ENV(GCC48_AARCH64_PREFIX)ld\r
+*_GCC48_AARCH64_ASM_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_PP_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_VFRPP_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_ASLCC_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_ASLPP_PATH = ENV(GCC48_AARCH64_PREFIX)gcc\r
+*_GCC48_AARCH64_RC_PATH = ENV(GCC48_AARCH64_PREFIX)objcopy\r
+\r
+*_GCC48_AARCH64_ASLCC_FLAGS = DEF(GCC_ASLCC_FLAGS)\r
+*_GCC48_AARCH64_ASLDLINK_FLAGS = DEF(GCC48_AARCH64_ASLDLINK_FLAGS)\r
+*_GCC48_AARCH64_ASM_FLAGS = DEF(GCC48_AARCH64_ASM_FLAGS)\r
+*_GCC48_AARCH64_DLINK_FLAGS = DEF(GCC48_AARCH64_DLINK_FLAGS)\r
+*_GCC48_AARCH64_PLATFORM_FLAGS =\r
+*_GCC48_AARCH64_PP_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC_PP_FLAGS)\r
+*_GCC48_AARCH64_RC_FLAGS = DEF(GCC_AARCH64_RC_FLAGS)\r
+*_GCC48_AARCH64_VFRPP_FLAGS = $(ARCHCC_FLAGS) $(PLATFORM_FLAGS) DEF(GCC_VFRPP_FLAGS)\r
+\r
+ DEBUG_GCC48_AARCH64_CC_FLAGS = DEF(GCC48_AARCH64_CC_FLAGS) -O0\r
+RELEASE_GCC48_AARCH64_CC_FLAGS = DEF(GCC48_AARCH64_CC_FLAGS) -Wno-unused-but-set-variable\r
+\r
####################################################################################\r
#\r
# Cygwin GCC And Intel ACPI Compiler\r
*_ARMGCC_*_ASL_OUTFLAGS = DEF(IASL_OUTFLAGS)\r
*_ARMGCC_*_ASLPP_FLAGS = -x c -E -P\r
*_ARMGCC_*_ASLCC_FLAGS = -x c\r
-*_ARMGCC_*_ASLDLINK_FLAGS = DEF(GCC_DLINK_FLAGS_COMMON) --entry _ReferenceAcpiTable\r
+*_ARMGCC_*_ASLDLINK_FLAGS = DEF(GCC_DLINK_FLAGS_COMMON) --entry ReferenceAcpiTable\r
\r
##################\r
# ARM definitions\r
*_ARMLINUXGCC_*_ASL_OUTFLAGS = DEF(IASL_OUTFLAGS)\r
*_ARMLINUXGCC_*_ASLPP_FLAGS = -x c -E -P\r
*_ARMLINUXGCC_*_ASLCC_FLAGS = -x c\r
-*_ARMLINUXGCC_*_ASLDLINK_FLAGS = DEF(GCC_DLINK_FLAGS_COMMON) --entry _ReferenceAcpiTable\r
+*_ARMLINUXGCC_*_ASLDLINK_FLAGS = DEF(GCC_DLINK_FLAGS_COMMON) --entry ReferenceAcpiTable\r
\r
##################\r
# ARM definitions\r
/** @file\r
\r
-Copyright (c) 1999 - 2011, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 1999 - 2013, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials are licensed and made available \r
under the terms and conditions of the BSD License which accompanies this \r
distribution. The full text of the license may be found at\r
PCI_3_0_DATA_STRUCTURE *PciDs30;\r
UINT32 Index;\r
UINT8 ByteCheckSum;\r
+ UINT16 CodeType;\r
\r
PciDs23 = NULL;\r
PciDs30 = NULL;\r
//\r
if (mOptions.Pci23 == 1) {\r
PciDs23->ImageLength = (UINT16) (TotalSize / 512);\r
+ CodeType = PciDs23->CodeType;\r
} else {\r
PciDs30->ImageLength = (UINT16) (TotalSize / 512);\r
+ CodeType = PciDs30->CodeType;\r
}\r
\r
//\r
}\r
}\r
\r
- ByteCheckSum = 0;\r
- for (Index = 0; Index < FileSize - 1; Index++) {\r
- ByteCheckSum = (UINT8) (ByteCheckSum + Buffer[Index]);\r
- }\r
+ if (CodeType != PCI_CODE_TYPE_EFI_IMAGE) {\r
+ ByteCheckSum = 0;\r
+ for (Index = 0; Index < FileSize - 1; Index++) {\r
+ ByteCheckSum = (UINT8) (ByteCheckSum + Buffer[Index]);\r
+ }\r
\r
- Buffer[FileSize - 1] = (UINT8) ((~ByteCheckSum) + 1);\r
- if (mOptions.Verbose) {\r
- VerboseMsg(" Checksum = %02x\n\n", Buffer[FileSize - 1]);\r
+ Buffer[FileSize - 1] = (UINT8) ((~ByteCheckSum) + 1);\r
+ if (mOptions.Verbose) {\r
+ VerboseMsg(" Checksum = %02x\n\n", Buffer[FileSize - 1]);\r
+ }\r
}\r
\r
//\r
UINT16 MachineType;\r
UINT16 SubSystem;\r
UINT32 HeaderPadBytes;\r
+ UINT32 PadBytesBeforeImage;\r
+ UINT32 PadBytesAfterImage;\r
\r
//\r
// Try to open the input file\r
TotalSize = (TotalSize + 0x200) &~0x1ff;\r
}\r
//\r
+ // Workaround:\r
+ // If compressed, put the pad bytes after the image,\r
+ // else put the pad bytes before the image.\r
+ //\r
+ if ((InFile->FileFlags & FILE_FLAG_COMPRESS) != 0) {\r
+ PadBytesBeforeImage = 0;\r
+ PadBytesAfterImage = TotalSize - (FileSize + HeaderSize);\r
+ } else {\r
+ PadBytesBeforeImage = TotalSize - (FileSize + HeaderSize);\r
+ PadBytesAfterImage = 0;\r
+ }\r
+ //\r
// Check size\r
//\r
if (TotalSize > MAX_OPTION_ROM_SIZE) {\r
RomHdr.EfiSignature = EFI_PCI_EXPANSION_ROM_HEADER_EFISIGNATURE;\r
RomHdr.EfiSubsystem = SubSystem;\r
RomHdr.EfiMachineType = MachineType;\r
- RomHdr.EfiImageHeaderOffset = (UINT16) HeaderSize;\r
+ RomHdr.EfiImageHeaderOffset = (UINT16) (HeaderSize + PadBytesBeforeImage);\r
RomHdr.PcirOffset = (UINT16) (sizeof (RomHdr) + HeaderPadBytes);\r
//\r
// Set image as compressed or not\r
goto BailOut;\r
} \r
}\r
+\r
//\r
- // Keep track of how many bytes left to write\r
+ // Pad head to make it a multiple of 512 bytes\r
//\r
- TotalSize -= HeaderSize;\r
-\r
+ while (PadBytesBeforeImage > 0) {\r
+ if (putc (~0, OutFptr) == EOF) {\r
+ Error (NULL, 0, 2000, "Failed to write trailing pad bytes output file!", NULL);\r
+ Status = STATUS_ERROR;\r
+ goto BailOut;\r
+ }\r
+ PadBytesBeforeImage--;\r
+ }\r
//\r
// Now dump the input file's contents to the output file\r
//\r
goto BailOut;\r
}\r
\r
- TotalSize -= FileSize;\r
//\r
// Pad the rest of the image to make it a multiple of 512 bytes\r
//\r
- while (TotalSize > 0) {\r
+ while (PadBytesAfterImage > 0) {\r
if (putc (~0, OutFptr) == EOF) {\r
Error (NULL, 0, 2000, "Failed to write trailing pad bytes output file!", NULL);\r
Status = STATUS_ERROR;\r
goto BailOut;\r
}\r
\r
- TotalSize--;\r
+ PadBytesAfterImage--;\r
}\r
\r
BailOut:\r
//\r
// Copyright declaration\r
// \r
- fprintf (stdout, "Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.\n\n");\r
+ fprintf (stdout, "Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.\n\n");\r
\r
//\r
// Details Option\r
\r
case 0:\r
//\r
- // 8 byte alignment, mini alignment requirement for FFS file. \r
+ // 1 byte alignment\r
//\r
- *Alignment = 3;\r
+ *Alignment = 0;\r
break;\r
\r
case 1:\r
mFvDataInfo.FvNameGuid.Data4[7]);\r
}\r
\r
- if (CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {\r
+ if (CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0 ||\r
+ CompareGuid (&mFvDataInfo.FvFileSystemGuid, &mEfiFirmwareFileSystem3Guid) == 0) {\r
mFvDataInfo.IsPiFvImage = TRUE;\r
}\r
\r
// VTF (Firmware Volume Top File) signatures\r
//\r
#define IA32_X64_VTF_SIGNATURE_OFFSET 0x14\r
-#define IA32_X64_VTF0_SIGNATURE EFI_SIGNATURE_32('V','T','F',0)\r
+#define IA32_X64_VTF0_SIGNATURE SIGNATURE_32('V','T','F',0)\r
\r
//\r
// Defines to calculate the offset for PEI CORE entry points\r
\r
**/\r
\r
-#define __BUILD_VERSION "Build 2610"\r
+#define __BUILD_VERSION "Build 2640"\r
EFI_FV_BLOCK_MAP_ENTRY BlockMap[1];\r
} EFI_FIRMWARE_VOLUME_HEADER;\r
\r
-#define EFI_FVH_SIGNATURE EFI_SIGNATURE_32 ('_', 'F', 'V', 'H')\r
+#define EFI_FVH_SIGNATURE SIGNATURE_32 ('_', 'F', 'V', 'H')\r
\r
///\r
/// Firmware Volume Header Revision definition\r
/** @file\r
Defines data types and constants introduced in UEFI.\r
\r
- Copyright (c) 2006 - 2007, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials are licensed and made available\r
under the terms and conditions of the BSD License which accompanies this\r
//\r
// Define macros to build data structure signatures from characters.\r
//\r
-#define EFI_SIGNATURE_16(A, B) ((A) | (B << 8))\r
-#define EFI_SIGNATURE_32(A, B, C, D) (EFI_SIGNATURE_16 (A, B) | (EFI_SIGNATURE_16 (C, D) << 16))\r
-#define EFI_SIGNATURE_64(A, B, C, D, E, F, G, H) \\r
- (EFI_SIGNATURE_32 (A, B, C, D) | ((UINT64) (EFI_SIGNATURE_32 (E, F, G, H)) << 32))\r
+#define SIGNATURE_16(A, B) ((A) | (B << 8))\r
+#define SIGNATURE_32(A, B, C, D) (SIGNATURE_16 (A, B) | (SIGNATURE_16 (C, D) << 16))\r
+#define SIGNATURE_64(A, B, C, D, E, F, G, H) \\r
+ (SIGNATURE_32 (A, B, C, D) | ((UINT64) (SIGNATURE_32 (E, F, G, H)) << 32))\r
\r
\r
//\r
\r
@bug Fix text - doc as defined in MSFT EFI specification.\r
\r
- Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
Portions copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>\r
\r
This program and the accompanying materials are licensed and made available\r
///\r
/// Debug Data Structure defined by Apple Mach-O to Coff utility\r
///\r
-#define CODEVIEW_SIGNATURE_MTOC EFI_SIGNATURE_32('M', 'T', 'O', 'C')\r
+#define CODEVIEW_SIGNATURE_MTOC SIGNATURE_32('M', 'T', 'O', 'C')\r
typedef struct {\r
UINT32 Signature; ///< "MTOC"\r
EFI_GUID MachOUuid;\r
/** @file\r
Support for PCI 2.2 standard.\r
\r
- Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>\r
+ Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>\r
\r
This program and the accompanying materials are licensed and made available\r
under the terms and conditions of the BSD License which accompanies this\r
#pragma pack()\r
\r
#define PCI_EXPANSION_ROM_HEADER_SIGNATURE 0xaa55\r
-#define PCI_DATA_STRUCTURE_SIGNATURE EFI_SIGNATURE_32 ('P', 'C', 'I', 'R')\r
+#define PCI_DATA_STRUCTURE_SIGNATURE SIGNATURE_32 ('P', 'C', 'I', 'R')\r
#define PCI_CODE_TYPE_PCAT_IMAGE 0x00\r
#define PCI_CODE_TYPE_EFI_IMAGE 0x03\r
#define EFI_PCI_EXPANSION_ROM_HEADER_COMPRESSED 0x0001\r
\r
VfrCompiler main class and main function.\r
\r
-Copyright (c) 2004 - 2012, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>\r
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
UINT32 Index;\r
CONST CHAR8 *Help[] = {\r
" ", \r
- "VfrCompile version " VFR_COMPILER_VERSION __BUILD_VERSION VFR_COMPILER_UPDATE_TIME,\r
- "Copyright (c) 2004-2011 Intel Corporation. All rights reserved.",\r
+ "VfrCompile version " VFR_COMPILER_VERSION __BUILD_VERSION,\r
+ "Copyright (c) 2004-2013 Intel Corporation. All rights reserved.",\r
" ",\r
"Usage: VfrCompile [options] VfrFile",\r
" ",\r
#include "ParseInf.h"\r
\r
#define PROGRAM_NAME "VfrCompile"\r
-#define VFR_COMPILER_VERSION " 2.00 (UEFI 2.3.1)"\r
-#define VFR_COMPILER_UPDATE_TIME " updated on 2011/07/15"\r
+#define VFR_COMPILER_VERSION " 2.00 (UEFI 2.4) "\r
//\r
// This is how we invoke the C preprocessor on the VFR source file\r
// to resolve #defines, #includes, etc. To make C source files\r
// Get VarStoreType\r
//\r
ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId);\r
- if (ReturnCode == VFR_RETURN_UNDEFINED) {\r
- lCVfrDataStorage.DeclareBufferVarStore (\r
- FName, \r
- LocalFormSetGuid, \r
- &lCVfrVarDataTypeDB, \r
- FName,\r
- EFI_VARSTORE_ID_INVALID,\r
- FALSE\r
- );\r
- ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId, LocalFormSetGuid); \r
- }\r
if (ReturnCode != VFR_RETURN_SUCCESS) {\r
gCVfrErrorHandle.PrintMsg (pNode->mLineNo, FName, "Error", "Var Store Type is not defined");\r
return ReturnCode;\r
## @file\r
# Generate AutoGen.h, AutoGen.c and *.depex files\r
#\r
-# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
# 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
# Explicitly collect platform's dynamic PCDs\r
#\r
Pa.CollectPlatformDynamicPcds()\r
+ Pa.CollectFixedAtBuildPcds()\r
self.AutoGenObjectList.append(Pa)\r
\r
#\r
self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
+ self._NonDynamicPcdDict = {}\r
\r
self._ToolDefinitions = None\r
self._ToolDefFile = None # toolcode : tool path\r
(self.MetaFile, self.Arch))\r
self.IsMakeFileCreated = True\r
\r
+ ## Deal with Shared FixedAtBuild Pcds\r
+ #\r
+ def CollectFixedAtBuildPcds(self):\r
+ for LibAuto in self.LibraryAutoGenList:\r
+ FixedAtBuildPcds = {} \r
+ ShareFixedAtBuildPcdsSameValue = {} \r
+ for Module in LibAuto._ReferenceModules: \r
+ for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:\r
+ key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName)) \r
+ if key not in FixedAtBuildPcds:\r
+ ShareFixedAtBuildPcdsSameValue[key] = True\r
+ FixedAtBuildPcds[key] = Pcd.DefaultValue\r
+ else:\r
+ if FixedAtBuildPcds[key] != Pcd.DefaultValue:\r
+ ShareFixedAtBuildPcdsSameValue[key] = False \r
+ for Pcd in LibAuto.FixedAtBuildPcds:\r
+ key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
+ if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
+ continue\r
+ else:\r
+ DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
+ if DscPcd.Type != "FixedAtBuild":\r
+ continue\r
+ if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
+ LibAuto.ConstPcd[key] = Pcd.DefaultValue\r
+\r
## Collect dynamic PCDs\r
#\r
# Gather dynamic PCDs list from each module and their settings from platform\r
self._PackageList = list(self._PackageList)\r
return self._PackageList\r
\r
+ def _GetNonDynamicPcdDict(self):\r
+ if self._NonDynamicPcdDict:\r
+ return self._NonDynamicPcdDict\r
+ for Pcd in self.NonDynamicPcdList:\r
+ self._NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)] = Pcd\r
+ return self._NonDynamicPcdDict\r
+\r
## Get list of non-dynamic PCDs\r
def _GetNonDynamicPcdList(self):\r
if self._NonDynamicPcdList == None:\r
for La in Ma.LibraryAutoGenList:\r
if La not in self._LibraryAutoGenList:\r
self._LibraryAutoGenList.append(La)\r
+ if Ma not in La._ReferenceModules:\r
+ La._ReferenceModules.append(Ma)\r
\r
## Summarize ModuleAutoGen objects of all modules to be built for this platform\r
def _GetModuleAutoGenList(self):\r
PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
+ NonDynamicPcdDict = property(_GetNonDynamicPcdDict)\r
PackageList = property(_GetPackageList)\r
\r
ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
self._FinalBuildTargetList = None\r
self._FileTypes = None\r
self._BuildRules = None\r
-\r
+ \r
+ ## The Modules referenced to this Library\r
+ # Only Library has this attribute\r
+ self._ReferenceModules = [] \r
+ \r
+ ## Store the FixedAtBuild Pcds\r
+ # \r
+ self._FixedAtBuildPcds = []\r
+ self.ConstPcd = {}\r
return True\r
\r
def __repr__(self):\r
return "%s [%s]" % (self.MetaFile, self.Arch)\r
\r
+ # Get FixedAtBuild Pcds of this Module\r
+ def _GetFixedAtBuildPcds(self):\r
+ if self._FixedAtBuildPcds:\r
+ return self._FixedAtBuildPcds\r
+ for Pcd in self.ModulePcdList:\r
+ if self.IsLibrary:\r
+ if not (Pcd.Pending == False and Pcd.Type == "FixedAtBuild"):\r
+ continue\r
+ elif Pcd.Type != "FixedAtBuild":\r
+ continue\r
+ if Pcd not in self._FixedAtBuildPcds:\r
+ self._FixedAtBuildPcds.append(Pcd)\r
+ \r
+ return self._FixedAtBuildPcds \r
+\r
# Macros could be used in build_rule.txt (also Makefile)\r
def _GetMacros(self):\r
if self._Macro == None:\r
BuildOption = property(_GetModuleBuildOption)\r
BuildOptionIncPathList = property(_GetBuildOptionIncPathList)\r
BuildCommand = property(_GetBuildCommand)\r
+ \r
+ FixedAtBuildPcds = property(_GetFixedAtBuildPcds)\r
\r
# This acts like the main() function for the script, unless it is 'import'ed into another script.\r
if __name__ == '__main__':\r
AutoGenH.Append('#define %s %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
AutoGenH.Append('#define %s(Value) (%s = (Value))\n' % (SetModeName, PcdVariableName))
if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
+ key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))
+
AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
AutoGenH.Append('#define %s %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
AutoGenH.Append('//#define %s ASSERT(FALSE) // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
-
+
+ if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and key in Info.ConstPcd:
+ AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
+
## Create code for library constructor
if RawDataList is None:\r
RawDataList = [] \r
DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+ def GetListSize(self):\r
+ length = 0\r
+ for Data in self.RawDataList:\r
+ length += (1 + len(Data[1]))\r
+ return length * self.ItemSize\r
def PackData(self):\r
- PackStr = "=HH"\r
+ PackStr = "=H"\r
Buffer = ''\r
for Data in self.RawDataList:\r
Buffer += pack(PackStr, \r
- GetIntegerValue(Data[0]),\r
- GetIntegerValue(Data[1]))\r
+ GetIntegerValue(Data[0]))\r
+ for subData in Data[1]:\r
+ Buffer += pack(PackStr, \r
+ GetIntegerValue(subData))\r
return Buffer\r
\r
## DbStringItemList\r
DbPcdNameOffsetTable = DbItemList(4,RawDataList = PcdNameOffsetTable)\r
\r
SizeTableValue = zip(Dict['SIZE_TABLE_MAXIMUM_LENGTH'], Dict['SIZE_TABLE_CURRENT_LENGTH'])\r
- DbSizeTableValue = DbSizeTableItemList(4, RawDataList = SizeTableValue)\r
+ DbSizeTableValue = DbSizeTableItemList(2, RawDataList = SizeTableValue)\r
InitValueUint16 = Dict['INIT_DB_VALUE_UINT16']\r
DbInitValueUint16 = DbComItemList(2, RawDataList = InitValueUint16)\r
VardefValueUint16 = Dict['VARDEF_DB_VALUE_UINT16']\r
SkuIndexIndexTable = [(0) for i in xrange(len(Dict['SKU_INDEX_VALUE']))]\r
SkuIndexIndexTable[0] = 0 #Dict['SKU_INDEX_VALUE'][0][0]\r
for i in range(1,len(Dict['SKU_INDEX_VALUE'])):\r
- SkuIndexIndexTable[i] = SkuIndexIndexTable[i-1]+Dict['SKU_INDEX_VALUE'][i-1][0]\r
+ SkuIndexIndexTable[i] = SkuIndexIndexTable[i-1]+Dict['SKU_INDEX_VALUE'][i-1][0] + 1\r
for (LocalTokenNumberTableIndex, (Offset, Table)) in enumerate(LocalTokenNumberTable):\r
DbIndex = 0\r
DbOffset = FixedHeaderLen\r
LocalTokenNumberTable[LocalTokenNumberTableIndex] = DbOffset|int(TokenTypeValue)\r
# if PCD_TYPE_SKU_ENABLED, then we need to fix up the SkuTable\r
\r
- SkuIndexTabalOffset = SkuIdTableOffset + Dict['SKUID_VALUE'][0]\r
+ SkuIndexTabalOffset = SkuIdTableOffset + Dict['SKUID_VALUE'][0] + 1\r
if (TokenTypeValue & (0x2 << 28)):\r
SkuTable[SkuHeaderIndex] = (DbOffset|int(TokenTypeValue & ~(0x2<<28)), SkuIndexTabalOffset + SkuIndexIndexTable[SkuHeaderIndex])\r
LocalTokenNumberTable[LocalTokenNumberTableIndex] = (SkuTableOffset + SkuHeaderIndex * 8) | int(TokenTypeValue)\r
\r
# resolve variable table offset \r
for VariableEntries in VariableTable:\r
+ skuindex = 0\r
for VariableEntryPerSku in VariableEntries:\r
(VariableHeadGuidIndex, VariableHeadStringIndex, SKUVariableOffset, VariableOffset, VariableRefTable) = VariableEntryPerSku[:]\r
DbIndex = 0\r
DbOffset += DbItemTotal[DbIndex].GetListSize()\r
else:\r
assert(False)\r
- \r
+ if isinstance(VariableRefTable[0],list):\r
+ DbOffset += skuindex * 4 \r
+ skuindex += 1\r
if DbIndex >= InitTableNum:\r
assert(False)\r
\r
DbFile.write(PcdDbBuffer)\r
Changed = SaveFileOnChange(DbFileName, DbFile.getvalue(), True)\r
\r
-\r
-def CArrayToArray(carray):\r
- return "{%s, 0x00}" % ", ".join(["0x%02x" % ord(C) for C in carray])\r
-\r
## Create PCD database in DXE or PEI phase\r
#\r
# @param Platform The platform object\r
Dict['PCD_TOKENSPACE_MAP'] = []\r
Dict['PCD_NAME_OFFSET'] = []\r
\r
+ PCD_STRING_INDEX_MAP = {}\r
+ \r
StringTableIndex = 0\r
StringTableSize = 0\r
NumberOfLocalTokens = 0\r
GuidList = []\r
i = 0\r
for Pcd in Platform.DynamicPcdList:\r
+ VoidStarTypeCurrSize = []\r
i += 1\r
CName = Pcd.TokenCName\r
TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
SkuIndexTableTmp = []\r
SkuIndexTableTmp.append(0) \r
SkuIdIndex = 1 \r
+ VariableHeadList = []\r
for SkuName in Pcd.SkuInfoList:\r
Sku = Pcd.SkuInfoList[SkuName]\r
SkuId = Sku.SkuId\r
if len(Sku.VariableName) > 0:\r
Pcd.TokenTypeList += ['PCD_TYPE_HII']\r
Pcd.InitString = 'INIT'\r
- # store VariableName to stringTable and calculate the VariableHeadStringIndex\r
- if Sku.VariableName.startswith('{'):\r
- VariableNameStructure = CArrayToArray(Sku.VariableName)\r
- else:\r
- VariableNameStructure = StringToArray(Sku.VariableName)\r
- if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
- Dict['STRING_TABLE_CNAME'].append(CName)\r
- Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
- if StringTableIndex == 0:\r
- Dict['STRING_TABLE_INDEX'].append('')\r
- else:\r
- Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
-\r
- Dict['STRING_TABLE_LENGTH'].append((len(Sku.VariableName) - 3 + 1) * 2 )\r
- Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
- StringTableIndex += 1\r
- StringTableSize += (len(Sku.VariableName) - 3 + 1) * 2\r
- VariableHeadStringIndex = 0\r
- for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
- VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
-\r
+ # Store all variable names of one HII PCD under different SKU to stringTable\r
+ # and calculate the VariableHeadStringIndex\r
+ if SkuIdIndex - 2 == 0:\r
+ for SkuName in Pcd.SkuInfoList:\r
+ SkuInfo = Pcd.SkuInfoList[SkuName]\r
+ if SkuInfo.SkuId == None or SkuInfo.SkuId == '':\r
+ continue\r
+ VariableNameStructure = StringToArray(SkuInfo.VariableName)\r
+ if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
+ Dict['STRING_TABLE_CNAME'].append(CName)\r
+ Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
+ if StringTableIndex == 0:\r
+ Dict['STRING_TABLE_INDEX'].append('')\r
+ else:\r
+ Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
+ VarNameSize = len(VariableNameStructure.replace(',',' ').split())\r
+ Dict['STRING_TABLE_LENGTH'].append(VarNameSize )\r
+ Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
+ StringHeadOffsetList.append(str(StringTableSize) + 'U')\r
+ VarStringDbOffsetList = []\r
+ VarStringDbOffsetList.append(StringTableSize)\r
+ Dict['STRING_DB_VALUE'].append(VarStringDbOffsetList) \r
+ StringTableIndex += 1\r
+ StringTableSize += len(VariableNameStructure.replace(',',' ').split())\r
+ VariableHeadStringIndex = 0\r
+ for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
+ VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
+ VariableHeadList.append(VariableHeadStringIndex)\r
+ \r
+ VariableHeadStringIndex = VariableHeadList[SkuIdIndex - 2]\r
# store VariableGuid to GuidTable and get the VariableHeadGuidIndex\r
VariableGuidStructure = Sku.VariableGuidValue\r
VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
# the Pcd default value was filled before\r
VariableOffset = len(Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]) - 1\r
VariableRefTable = Dict['VARDEF_DB_VALUE_' + Pcd.DatumType]\r
- VariableDbValueList.append([VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, VariableOffset, VariableRefTable])\r
+ VariableDbValueList.append([VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, VariableOffset, VariableRefTable])\r
\r
elif Sku.VpdOffset != '':\r
Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
# Also add the VOID* string of VPD PCD to SizeTable \r
if Pcd.DatumType == 'VOID*':\r
NumberOfSizeItems += 1\r
- Dict['SIZE_TABLE_CNAME'].append(CName)\r
- Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
# For VPD type of PCD, its current size is equal to its MAX size.\r
- Dict['SIZE_TABLE_CURRENT_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')\r
- Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')\r
+ VoidStarTypeCurrSize = [str(Pcd.MaxDatumSize) + 'U'] \r
continue\r
\r
if Pcd.DatumType == 'VOID*':\r
else:\r
Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
if Sku.DefaultValue[0] == 'L':\r
- Size = (len(Sku.DefaultValue) - 3 + 1) * 2 \r
- Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))\r
+ DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
+ Size = len(DefaultValueBinStructure.replace(',',' ').split())\r
+ Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
elif Sku.DefaultValue[0] == '"':\r
- Size = len(Sku.DefaultValue) - 2 + 1\r
- Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))\r
+ DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
+ Size = len(Sku.DefaultValue) -2 + 1\r
+ Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
elif Sku.DefaultValue[0] == '{':\r
- Size = len(Sku.DefaultValue.replace(',',' ').split())\r
- Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
+ DefaultValueBinStructure = StringToArray(Sku.DefaultValue)\r
+ Size = len(Sku.DefaultValue.split(","))\r
+ Dict['STRING_TABLE_VALUE'].append(DefaultValueBinStructure)\r
\r
StringHeadOffsetList.append(str(StringTableSize) + 'U')\r
StringDbOffsetList.append(StringTableSize)\r
- Dict['SIZE_TABLE_CNAME'].append(CName)\r
- Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
- Dict['SIZE_TABLE_CURRENT_LENGTH'].append(str(Size) + 'U')\r
- Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')\r
if Pcd.MaxDatumSize != '':\r
MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
if MaxDatumSize < Size:\r
- MaxDatumSize = Size\r
- Size = MaxDatumSize\r
- Dict['STRING_TABLE_LENGTH'].append(Size)\r
+ EdkLogger.error("build", AUTOGEN_ERROR,\r
+ "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),\r
+ ExtraData="[%s]" % str(Platform))\r
+ else:\r
+ MaxDatumSize = Size\r
+ StringTabLen = MaxDatumSize\r
+ if StringTabLen % 2:\r
+ StringTabLen += 1\r
+ if Sku.VpdOffset == '':\r
+ VoidStarTypeCurrSize.append(str(Size) + 'U')\r
+ Dict['STRING_TABLE_LENGTH'].append(StringTabLen)\r
StringTableIndex += 1\r
- StringTableSize += (Size)\r
+ StringTableSize += (StringTabLen)\r
else:\r
if "PCD_TYPE_HII" not in Pcd.TokenTypeList:\r
Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
DbValueList.append(Sku.DefaultValue)\r
\r
Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
+ if Pcd.DatumType == 'VOID*': \r
+ Dict['SIZE_TABLE_CNAME'].append(CName)\r
+ Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
+ Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')\r
+ Dict['SIZE_TABLE_CURRENT_LENGTH'].append(VoidStarTypeCurrSize)\r
\r
- SkuIndexTableTmp[0] = len(SkuIndexTableTmp)\r
+ \r
+ SkuIndexTableTmp[0] = len(SkuIndexTableTmp) - 1\r
if len(Pcd.SkuInfoList) > 1:\r
Dict['SKU_INDEX_VALUE'].append(SkuIndexTableTmp) \r
\r
Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
Dict['STRING_DB_VALUE'].append(StringDbOffsetList)\r
+ PCD_STRING_INDEX_MAP[len(Dict['STRING_HEAD_CNAME_DECL']) -1 ] = len(Dict['STRING_DB_VALUE']) -1\r
if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
TokenSpaceGuidCNameArray = StringToArray('"' + TokenSpaceGuidCName + '"' )\r
if TokenSpaceGuidCNameArray not in Dict['PCD_TOKENSPACE']:\r
Dict['PCD_TOKENSPACE'].append(TokenSpaceGuidCNameArray)\r
- Dict['PCD_TOKENSPACE_LENGTH'].append( len(TokenSpaceGuidCName) + 1 )\r
+ Dict['PCD_TOKENSPACE_LENGTH'].append( len(TokenSpaceGuidCNameArray.split(",")) )\r
Dict['PCD_TOKENSPACE_MAP'][GeneratedTokenNumber] = Dict['PCD_TOKENSPACE'].index(TokenSpaceGuidCNameArray)\r
- Dict['PCD_CNAME'][GeneratedTokenNumber] = StringToArray('"' + CName + '"' )\r
+ CNameBinArray = StringToArray('"' + CName + '"' )\r
+ Dict['PCD_CNAME'][GeneratedTokenNumber] = CNameBinArray\r
\r
- Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CName) + 1\r
+ Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CNameBinArray.split(","))\r
\r
\r
Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
if 'PCD_TYPE_STRING' in Pcd.TokenTypeList and 'PCD_TYPE_HII' not in Pcd.TokenTypeList:\r
# Find index by CName, TokenSpaceGuid\r
Offset = GetMatchedIndex(CName, Dict['STRING_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['STRING_HEAD_GUID_DECL'])\r
+ Offset = PCD_STRING_INDEX_MAP[Offset]\r
assert(Offset != -1)\r
Table = Dict['STRING_DB_VALUE']\r
if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
Dict['PCD_TOKENSPACE_OFFSET'].append(TokenSpaceIndex) \r
for index in range(len(Dict['PCD_TOKENSPACE'])):\r
StringTableSize += Dict['PCD_TOKENSPACE_LENGTH'][index]\r
- \r
+ StringTableIndex += 1\r
for index in range(len(Dict['PCD_CNAME'])):\r
Dict['PCD_CNAME_OFFSET'].append(StringTableSize) \r
Dict['PCD_NAME_OFFSET'].append(Dict['PCD_TOKENSPACE_OFFSET'][index])\r
Dict['PCD_NAME_OFFSET'].append(StringTableSize)\r
StringTableSize += Dict['PCD_CNAME_LENGTH'][index]\r
- \r
+ StringTableIndex += 1\r
if GuidList != []:\r
Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
Dict['GUID_TABLE_SIZE'] = str(len(GuidList)) + 'U'\r
if Dict['SIZE_TABLE_CNAME'] == []:\r
Dict['SIZE_TABLE_CNAME'].append('')\r
Dict['SIZE_TABLE_GUID'].append('')\r
- Dict['SIZE_TABLE_CURRENT_LENGTH'].append('0U')\r
+ Dict['SIZE_TABLE_CURRENT_LENGTH'].append(['0U'])\r
Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append('0U')\r
\r
if NumberOfLocalTokens != 0:\r
if NumberOfSkuEnabledPcd != 0: \r
Dict['SKU_HEAD_SIZE'] = str(NumberOfSkuEnabledPcd) + 'U'\r
\r
- Dict['SKUID_VALUE'][0] = len(Dict['SKUID_VALUE'])\r
+ Dict['SKUID_VALUE'][0] = len(Dict['SKUID_VALUE']) - 1\r
\r
AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))\r
if NumberOfLocalTokens == 0:\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
-gBUILD_VERSION = "Build 2610"\r
+gBUILD_VERSION = "Build 2640"\r
PCDS_DYNAMICEX_VPD = "PcdsDynamicExVpd"\r
PCDS_DYNAMICEX_HII = "PcdsDynamicExHii"\r
\r
+SECTIONS_HAVE_ITEM_PCD = [PCDS_DYNAMIC_DEFAULT.upper(),PCDS_DYNAMIC_VPD.upper(),PCDS_DYNAMIC_HII.upper(), \\r
+ PCDS_DYNAMICEX_DEFAULT.upper(),PCDS_DYNAMICEX_VPD.upper(),PCDS_DYNAMICEX_HII.upper()]\r
# Section allowed to have items after arch\r
SECTIONS_HAVE_ITEM_AFTER_ARCH = [TAB_LIBRARY_CLASSES.upper(), TAB_DEPEX.upper(), TAB_USER_EXTENSIONS.upper(),\r
PCDS_DYNAMIC_DEFAULT.upper(),\r
Value = FieldList[0]
Size = ''
if len(FieldList) > 1:
- Size = FieldList[1]
+ Type = FieldList[1]
+ # Fix the PCD type when no DataType input
+ if Type == 'VOID*':
+ DataType = 'VOID*'
+ else:
+ Size = FieldList[1]
+ if len(FieldList) > 2:
+ Size = FieldList[2]
if DataType == 'VOID*':
- IsValid = (len(FieldList) <= 2)
+ IsValid = (len(FieldList) <= 3)
else:
IsValid = (len(FieldList) <= 1)
return [Value, '', Size], IsValid, 0
Size = FieldList[2]
else:
if Type == 'VOID*':
- Size = str(len(Value))
+ if Value.startswith("L"):
+ Size = str((len(Value)- 3 + 1) * 2)
+ elif Value.startswith("{"):
+ Size = str(len(Value.split(",")))
+ else:
+ Size = str(len(Value) -2 + 1 )
if DataType == 'VOID*':
IsValid = (len(FieldList) <= 3)
else:
Comment = Line[Index:].strip()\r
Line = Line[0:Index].strip()\r
break\r
- if Comment:\r
- # Remove prefixed and trailing comment characters\r
- Start = 0\r
- End = len(Comment)\r
- while Start < End and Comment.startswith(CommentCharacter, Start, End):\r
- Start += 1\r
- while End >= 0 and Comment.endswith(CommentCharacter, Start, End):\r
- End -= 1\r
- Comment = Comment[Start:End]\r
- Comment = Comment.strip()\r
\r
return Line, Comment\r
\r
return "{%s, 0x00, 0x00}" % ", ".join(["0x%02x, 0x00" % ord(C) for C in String[2:-1]])\r
elif String.startswith('"'):\r
if String == "\"\"":\r
- return "{0x00}";\r
+ return "{0x00,0x00}"\r
else:\r
- return "{%s, 0x00}" % ", ".join(["0x%02x" % ord(C) for C in String[1:-1]])\r
+ StringLen = len(String[1:-1])\r
+ if StringLen % 2:\r
+ return "{%s, 0x00}" % ", ".join(["0x%02x" % ord(C) for C in String[1:-1]])\r
+ else:\r
+ return "{%s, 0x00,0x00}" % ", ".join(["0x%02x" % ord(C) for C in String[1:-1]])\r
+ elif String.startswith('{'):\r
+ StringLen = len(String.split(","))\r
+ if StringLen % 2:\r
+ return "{%s, 0x00}" % ", ".join([ C for C in String[1:-1].split(',')])\r
+ else:\r
+ return "{%s}" % ", ".join([ C for C in String[1:-1].split(',')])\r
+ \r
else:\r
- return '{%s, 0}' % ', '.join(String.split())\r
+ if len(String.split()) % 2:\r
+ return '{%s, 0}' % ', '.join(String.split())\r
+ else:\r
+ return '{%s, 0,0}' % ', '.join(String.split())\r
\r
def StringArrayLength(String):\r
if isinstance(String, unicode):\r
MODEL_META_DATA_GLOBAL_DEFINE = 5017\r
MODEL_META_DATA_SECTION_HEADER = 5100\r
MODEL_META_DATA_SUBSECTION_HEADER = 5200\r
+MODEL_META_DATA_TAIL_COMMENT = 5300\r
\r
MODEL_EXTERNAL_DEPENDENCY = 10000\r
\r
## @file\r
# generate capsule\r
#\r
-# Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2007-2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# @param self The object pointer\r
# @retval string Generated file name\r
#\r
+ def GenCapsuleSubItem(self):\r
+ return self.FileName\r
+ \r
+## Afile class for capsule data\r
+#\r
+#\r
+class CapsuleAfile (CapsuleData):\r
+ ## The constructor\r
+ #\r
+ # @param self The object pointer\r
+ #\r
+ def __init__(self) :\r
+ self.Ffs = None\r
+ self.FileName = None\r
+\r
+ ## generate Afile capsule data\r
+ #\r
+ # @param self The object pointer\r
+ # @retval string Generated file name\r
+ #\r
def GenCapsuleSubItem(self):\r
return self.FileName
\ No newline at end of file
## @file\r
# parse FDF file\r
#\r
-# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
\r
RegionSizePattern = re.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")\r
RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*")\r
+RegionOffsetPcdPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*$")\r
ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")\r
\r
IncludeFileList = []\r
try:\r
return long(\r
ValueExpression(Expr,\r
- dict(['%s.%s' % (Pcd[1], Pcd[0]), Val] \r
- for Pcd, Val in self.Profile.PcdDict.iteritems())\r
+ self.__CollectMacroPcd()\r
)(True),0)\r
except Exception:\r
self.SetFileBufferPos(StartPos)\r
return True\r
\r
if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE"):\r
+ #\r
+ # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]]\r
+ # Or it might be next region's offset described by an expression which starts with a PCD.\r
+ # PcdOffset[|PcdSize] or OffsetPcdExpression|Size\r
+ #\r
self.__UndoToken()\r
- RegionObj.PcdOffset = self.__GetNextPcdName()\r
- self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0))\r
- FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
- self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple\r
- if self.__IsToken( "|"):\r
- RegionObj.PcdSize = self.__GetNextPcdName()\r
- self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size\r
+ IsRegionPcd = (RegionSizeGuidPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]) or\r
+ RegionOffsetPcdPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]))\r
+ if IsRegionPcd:\r
+ RegionObj.PcdOffset = self.__GetNextPcdName()\r
+ self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0))\r
+ self.__PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset\r
FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
- self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple\r
+ self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple\r
+ if self.__IsToken( "|"):\r
+ RegionObj.PcdSize = self.__GetNextPcdName()\r
+ self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size\r
+ self.__PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size\r
+ FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
+ self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple\r
\r
if not self.__GetNextWord():\r
return True\r
self.__UndoToken()\r
self.__GetRegionDataType( RegionObj)\r
else:\r
+ self.__UndoToken()\r
+ if self.__GetRegionLayout(Fd):\r
+ return True\r
raise Warning("A valid region type was not found. "\r
"Valid types are [SET, FV, CAPSULE, FILE, DATA]. This error occurred",\r
self.FileName, self.CurrentLineNumber)\r
# @retval None\r
#\r
def __GetFvAttributes(self, FvObj):\r
-\r
+ IsWordToken = False\r
while self.__GetNextWord():\r
+ IsWordToken = True\r
name = self.__Token\r
if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \\r
"STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \\r
\r
FvObj.FvAttributeDict[name] = self.__Token\r
\r
- return True\r
+ return IsWordToken\r
\r
## __GetFvNameGuid() method\r
#\r
FfsFileObj.CurrentLineNum = self.CurrentLineNumber\r
FfsFileObj.CurrentLineContent = self.__CurrentLine()\r
FfsFileObj.FileName = self.__Token\r
- if FfsFileObj.FileName.replace('$(WORKSPACE)', '').find('$') == -1:\r
- #\r
- # For file in OUTPUT_DIRECTORY will not check whether it exist or not at AutoGen phase.\r
- #\r
- if not GlobalData.gAutoGenPhase:\r
- #do case sensitive check for file path\r
- ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
- if ErrorCode != 0:\r
- EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
- else:\r
- if not self.__GetMacroValue("OUTPUT_DIRECTORY") in FfsFileObj.FileName:\r
- #do case sensitive check for file path\r
- ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
- if ErrorCode != 0:\r
- EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo) \r
-\r
+ self.__VerifyFile(FfsFileObj.FileName)\r
\r
if not self.__IsToken( "}"):\r
raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
if not self.__GetNextToken():\r
raise Warning("expected section file path", self.FileName, self.CurrentLineNumber)\r
DataSectionObj.SectFileName = self.__Token\r
- if DataSectionObj.SectFileName.replace('$(WORKSPACE)', '').find('$') == -1:\r
- #do case sensitive check for file path\r
- ErrorCode, ErrorInfo = PathClass(NormPath(DataSectionObj.SectFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
- if ErrorCode != 0:\r
- EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
+ self.__VerifyFile(DataSectionObj.SectFileName)\r
else:\r
if not self.__GetCglSection(DataSectionObj):\r
return False\r
\r
return True\r
\r
+ ## __VerifyFile\r
+ #\r
+ # Check if file exists or not:\r
+ # If current phase if GenFds, the file must exist;\r
+ # If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist\r
+ # @param FileName: File path to be verified.\r
+ #\r
+ def __VerifyFile(self, FileName):\r
+ if FileName.replace('$(WORKSPACE)', '').find('$') != -1:\r
+ return\r
+ if not GlobalData.gAutoGenPhase or not self.__GetMacroValue("OUTPUT_DIRECTORY") in FileName:\r
+ ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
+ if ErrorCode != 0:\r
+ EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
+\r
## __GetCglSection() method\r
#\r
# Get compressed or GUIDed section for Obj\r
Value += self.__Token.strip()\r
elif Name == 'OEM_CAPSULE_FLAGS':\r
Value = self.__Token.strip()\r
+ if not Value.upper().startswith('0X'):\r
+ raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
try:\r
Value = int(Value, 0)\r
except ValueError:\r
- raise Warning("expected integer value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+ raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
if not 0x0000 <= Value <= 0xFFFF:\r
- raise Warning("expected integer value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+ raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
Value = self.__Token.strip()\r
else:\r
Value = self.__Token.strip()\r
IsFv = self.__GetFvStatement(Obj)\r
IsFd = self.__GetFdStatement(Obj)\r
IsAnyFile = self.__GetAnyFileStatement(Obj)\r
- if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile):\r
+ IsAfile = self.__GetAfileStatement(Obj)\r
+ if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile):\r
break\r
\r
## __GetFvStatement() method\r
CapsuleAnyFile.FileName = AnyFileName\r
CapsuleObj.CapsuleDataList.append(CapsuleAnyFile)\r
return True\r
+ \r
+ ## __GetAfileStatement() method\r
+ #\r
+ # Get Afile for capsule\r
+ #\r
+ # @param self The object pointer\r
+ # @param CapsuleObj for whom Afile is got\r
+ # @retval True Successfully find a Afile statement\r
+ # @retval False Not able to find a Afile statement\r
+ #\r
+ def __GetAfileStatement(self, CapsuleObj):\r
+\r
+ if not self.__IsKeyword("APPEND"):\r
+ return False\r
+\r
+ if not self.__IsToken("="):\r
+ raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+\r
+ if not self.__GetNextToken():\r
+ raise Warning("expected Afile name", self.FileName, self.CurrentLineNumber)\r
+ \r
+ AfileName = self.__Token\r
+ AfileBaseName = os.path.basename(AfileName)\r
+ \r
+ if os.path.splitext(AfileBaseName)[1] not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]:\r
+ raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \\r
+ self.FileName, self.CurrentLineNumber)\r
+ \r
+ if not os.path.isabs(AfileName):\r
+ AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName)\r
+ self.__VerifyFile(AfileName)\r
+ else:\r
+ if not os.path.exists(AfileName):\r
+ raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber)\r
+ else:\r
+ pass\r
+\r
+ CapsuleAfile = CapsuleData.CapsuleAfile()\r
+ CapsuleAfile.FileName = AfileName\r
+ CapsuleObj.CapsuleDataList.append(CapsuleAfile)\r
+ return True\r
\r
## __GetRule() method\r
#\r
#\r
#\r
class FfsInfStatement(FfsInfStatementClassObject):\r
+ ## The mapping dictionary from datum type to its maximum number.\r
+ _MAX_SIZE_TYPE = {"BOOLEAN":0x01, "UINT8":0xFF, "UINT16":0xFFFF, "UINT32":0xFFFFFFFF, "UINT64":0xFFFFFFFFFFFFFFFF}\r
## The constructor\r
#\r
# @param self The object pointer\r
\r
if Inf._Defs != None and len(Inf._Defs) > 0:\r
self.OptRomDefs.update(Inf._Defs)\r
+\r
self.PatchPcds = []\r
InfPcds = Inf.Pcds\r
Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, self.CurrentArch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
FdfPcdDict = GenFdsGlobalVariable.FdfParser.Profile.PcdDict\r
+\r
+ # Workaround here: both build and GenFds tool convert the workspace path to lower case\r
+ # But INF file path in FDF and DSC file may have real case characters.\r
+ # Try to convert the path to lower case to see if PCDs value are override by DSC.\r
DscModules = {}\r
for DscModule in Platform.Modules:\r
DscModules[str(DscModule).lower()] = Platform.Modules[DscModule]\r
continue\r
if Pcd.Type != 'PatchableInModule':\r
continue\r
+ # Override Patchable PCD value by the value from DSC\r
PatchPcd = None\r
InfLowerPath = str(PathClassObj).lower()\r
if InfLowerPath in DscModules and PcdKey in DscModules[InfLowerPath].Pcds:\r
if PatchPcd and Pcd.Type == PatchPcd.Type:\r
DefaultValue = PatchPcd.DefaultValue\r
DscOverride = True\r
+\r
+ # Override Patchable PCD value by the value from FDF\r
FdfOverride = False\r
if PcdKey in FdfPcdDict:\r
DefaultValue = FdfPcdDict[PcdKey]\r
FdfOverride = True\r
+\r
if not DscOverride and not FdfOverride:\r
continue\r
+ # Check value, if value are equal, no need to patch\r
if Pcd.DatumType == "VOID*":\r
if Pcd.DefaultValue == DefaultValue or DefaultValue in [None, '']:\r
continue\r
+ # Get the string size from FDF or DSC\r
if DefaultValue[0] == 'L':\r
+ # Remove L"", but the '\0' must be appended\r
MaxDatumSize = str((len(DefaultValue) - 2) * 2)\r
elif DefaultValue[0] == '{':\r
MaxDatumSize = str(len(DefaultValue.split(',')))\r
MaxDatumSize = str(len(DefaultValue) - 1)\r
if DscOverride:\r
Pcd.MaxDatumSize = PatchPcd.MaxDatumSize\r
+ # If no defined the maximum size in DSC, try to get current size from INF\r
if Pcd.MaxDatumSize in ['', None]:\r
Pcd.MaxDatumSize = str(len(Pcd.DefaultValue.split(',')))\r
else:\r
continue\r
except:\r
continue\r
+ # Check the Pcd size and data type\r
if Pcd.DatumType == "VOID*":\r
if int(MaxDatumSize) > int(Pcd.MaxDatumSize):\r
EdkLogger.error("GenFds", GENFDS_ERROR, "The size of VOID* type PCD '%s.%s' exceeds its maximum size %d bytes." \\r
return EfiFile\r
Basename = os.path.basename(EfiFile)\r
Output = os.path.join(self.OutputPath, Basename)\r
- CopyLongFilePath(EfiFile, Output)\r
+ shutil.copy(EfiFile, Output)\r
for Pcd in self.PatchPcds:\r
RetVal, RetStr = PatchBinaryFile(Output, int(Pcd.Offset, 0), Pcd.DatumType, Pcd.DefaultValue, Pcd.MaxDatumSize)\r
if RetVal:\r
GenFdsGlobalVariable.ErrorLogger("Capsule %s in FD region can't contain a FV %s in FD region." % (self.CapsuleName, self.UiFvName.upper()))\r
\r
GenFdsGlobalVariable.InfLogger( "\nGenerating %s FV" %self.UiFvName)\r
+ GenFdsGlobalVariable.LargeFileInFvFlags.append(False)\r
+ FFSGuid = None\r
\r
if self.FvBaseAddress != None:\r
BaseAddress = self.FvBaseAddress\r
OrigFvInfo = None\r
if os.path.exists (FvInfoFileName):\r
OrigFvInfo = open(FvInfoFileName, 'r').read()\r
+ if GenFdsGlobalVariable.LargeFileInFvFlags[-1]:\r
+ FFSGuid = GenFdsGlobalVariable.EFI_FIRMWARE_FILE_SYSTEM3_GUID;\r
GenFdsGlobalVariable.GenerateFirmwareVolume(\r
FvOutputFile,\r
[self.InfFileName],\r
AddressFile=FvInfoFileName,\r
FfsList=FfsFileList,\r
- ForceRebase=self.FvForceRebase\r
+ ForceRebase=self.FvForceRebase,\r
+ FileSystemGuid=FFSGuid\r
)\r
\r
NewFvInfo = None\r
for FfsFile in self.FfsList :\r
FileName = FfsFile.GenFfs(MacroDict, FvChildAddr, BaseAddress)\r
\r
+ if GenFdsGlobalVariable.LargeFileInFvFlags[-1]:\r
+ FFSGuid = GenFdsGlobalVariable.EFI_FIRMWARE_FILE_SYSTEM3_GUID;\r
#Update GenFv again\r
GenFdsGlobalVariable.GenerateFirmwareVolume(\r
FvOutputFile,\r
[self.InfFileName],\r
AddressFile=FvInfoFileName,\r
FfsList=FfsFileList,\r
- ForceRebase=self.FvForceRebase\r
+ ForceRebase=self.FvForceRebase,\r
+ FileSystemGuid=FFSGuid\r
)\r
\r
#\r
self.FvAlignment = str (FvAlignmentValue)\r
FvFileObj.close()\r
GenFds.ImageBinDict[self.UiFvName.upper() + 'fv'] = FvOutputFile\r
+ GenFdsGlobalVariable.LargeFileInFvFlags.pop()\r
return FvOutputFile\r
\r
## __InitializeInf__()\r
## @file
# generate flash image
#
-# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
#
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
## Version and Copyright
versionNumber = "1.0" + ' ' + gBUILD_VERSION
__version__ = "%prog Version " + versionNumber
-__copyright__ = "Copyright (c) 2007 - 2010, Intel Corporation All rights reserved."
+__copyright__ = "Copyright (c) 2007 - 2013, Intel Corporation All rights reserved."
## Tool entrance method
#
BuildRuleFamily = "MSFT"
ToolChainFamily = "MSFT"
__BuildRuleDatabase = None
+
+ #
+ # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.
+ # At the beginning of each generation of FV, false flag is appended to the list,
+ # after the call to GenerateSection returns, check the size of the output file,
+ # if it is greater than 0xFFFFFF, the tail flag in list is set to true,
+ # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.
+ # At the end of generation of FV, pop the flag.
+ # List is used as a stack to handle nested FV generation.
+ #
+ LargeFileInFvFlags = []
+ EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'
+ LARGE_FILE_SIZE = 0x1000000
SectionHeader = struct.Struct("3B 1B")
Cmd += Input
SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
- if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
+ if GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
+ GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
+ GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
+ if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and
+ GenFdsGlobalVariable.LargeFileInFvFlags):
+ GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True
@staticmethod
def GetAlignment (AlignString):
@staticmethod
def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,
- AddressFile=None, MapFile=None, FfsList=[]):
+ AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):
if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):
return
GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
Cmd += ["-a", AddressFile]
if MapFile not in [None, '']:
Cmd += ["-m", MapFile]
+ if FileSystemGuid:
+ Cmd += ["-g", FileSystemGuid]
Cmd += ["-o", Output]
for I in Input:
Cmd += ["-i", I]
Build version information\r
'''\r
\r
-gBUILD_VERSION = "Build 2610"\r
+gBUILD_VERSION = "Build 2640"\r
## @file\r
# This file is used to define class for data type structure\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
TAB_BACK_SLASH = '/'\r
TAB_SPECIAL_COMMENT = '##'\r
TAB_HEADER_COMMENT = '@file'\r
+TAB_BINARY_HEADER_COMMENT = '@BinaryHeader'\r
TAB_STAR = "*"\r
\r
TAB_EDK_SOURCE = '$(EDK_SOURCE)'\r
TAB_INF_PCD = 'Pcd'\r
TAB_INF_PCD_EX = 'PcdEx'\r
TAB_INF_GUIDTYPE_VAR = 'Variable'\r
-\r
+TAB_INF_ABSTRACT = 'STR_MODULE_ABSTRACT'\r
+TAB_INF_DESCRIPTION = 'STR_MODULE_DESCRIPTION'\r
+TAB_INF_LICENSE = 'STR_MODULE_LICENSE'\r
+TAB_INF_BINARY_ABSTRACT = 'STR_MODULE_BINARY_ABSTRACT'\r
+TAB_INF_BINARY_DESCRIPTION = 'STR_MODULE_BINARY_DESCRIPTION'\r
+TAB_INF_BINARY_LICENSE = 'STR_MODULE_BINARY_LICENSE'\r
#\r
# Dec Definitions\r
#\r
TAB_DEC_DEFINES_PACKAGE_GUID = 'PACKAGE_GUID'\r
TAB_DEC_DEFINES_PACKAGE_VERSION = 'PACKAGE_VERSION'\r
TAB_DEC_DEFINES_PKG_UNI_FILE = 'PKG_UNI_FILE'\r
-\r
+TAB_DEC_PACKAGE_ABSTRACT = 'STR_PACKAGE_ABSTRACT'\r
+TAB_DEC_PACKAGE_DESCRIPTION = 'STR_PACKAGE_DESCRIPTION'\r
+TAB_DEC_PACKAGE_LICENSE = 'STR_PACKAGE_LICENSE'\r
+TAB_DEC_BINARY_ABSTRACT = 'STR_PACKAGE_BINARY_ABSTRACT'\r
+TAB_DEC_BINARY_DESCRIPTION = 'STR_PACKAGE_BINARY_DESCRIPTION'\r
+TAB_DEC_BINARY_LICENSE = 'STR_PACKAGE_ASBUILT_LICENSE'\r
#\r
# Dsc Definitions\r
#\r
TAB_HEADER_DESCRIPTION = 'Description' \r
TAB_HEADER_COPYRIGHT = 'Copyright'\r
TAB_HEADER_LICENSE = 'License'\r
+TAB_BINARY_HEADER_IDENTIFIER = 'BinaryHeader'\r
+TAB_BINARY_HEADER_USERID = 'TianoCore'\r
#\r
# Build database path\r
#\r
## @file\r
# This file is used to define strings used in the UPT tool\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
MSG_VERSION_NUMBER = _("1.0")\r
MSG_VERSION = _("Intel(r) UEFI Packaging Tool (Intel(r) UEFIPT) - Revision " + \\r
MSG_VERSION_NUMBER)\r
-MSG_COPYRIGHT = _("Copyright (c) 2011 Intel Corporation All Rights Reserved.")\r
+MSG_COPYRIGHT = _("Copyright (c) 2011 - 2013 Intel Corporation All Rights Reserved.")\r
MSG_VERSION_COPYRIGHT = _("\n %s\n %s" % (MSG_VERSION, MSG_COPYRIGHT))\r
MSG_USAGE = _("%s [options]\n%s" % ("upt.exe", MSG_VERSION_COPYRIGHT))\r
MSG_DESCRIPTION = _("The Intel(r) UEFIUPT is used to create, " + \\r
_("Header comment section must have copyright information")\r
ERR_LICENSE_MISSING = \\r
_("Header comment section must have license information")\r
+ERR_INVALID_BINARYHEADER_FORMAT = \\r
+_("Binary Header comment section must have abstract,description,copyright,license information")\r
+ERR_MULTIPLE_BINARYHEADER_EXIST = \\r
+_("the inf file at most support one BinaryHeader at the fileheader section.")\r
ERR_INVALID_COMMENT_FORMAT = _("Comment must start with #")\r
ERR_USER_ABORT = _("User has stopped the application")\r
ERR_DIST_EXT_ERROR = \\r
ERR_NOT_SUPPORTED_SA_MODULE = _("Stand-alone module distribution does not allow EDK 1 INF")\r
ERR_INSTALL_DIST_NOT_FOUND = \\r
_("Distribution file to be installed is not found in current working directory or workspace: %s")\r
+ERR_BINARY_HEADER_ORDER = _("Binary header must follow the file header.")\r
+ERR_NO_SOURCE_HEADER = _("File header statement \"## @file\" must exist at the first place.")\r
\r
#\r
# Expression error message\r
## @file\r
# This file is used to parse DEC file. It will consumed by DecParser\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
from Logger.ToolError import FILE_PARSE_FAILURE\r
from Logger.ToolError import FILE_OPEN_FAILURE\r
from Logger import StringTable as ST\r
+from Logger.ToolError import FORMAT_INVALID\r
\r
import Library.DataType as DT\r
from Library.ParserValidate import IsValidToken\r
_DecComments.__init__(self)\r
_DecBase.__init__(self, RawData)\r
\r
+ self.BinaryHeadComment = [] \r
self._Define = _DecDefine(RawData)\r
self._Include = _DecInclude(RawData)\r
self._Guid = _DecGuid(RawData)\r
# Parse DEC file\r
#\r
def ParseDecComment(self):\r
+ IsFileHeader = False\r
+ IsBinaryHeader = False\r
+ FileHeaderLineIndex = -1\r
+ BinaryHeaderLineIndex = -1\r
while not self._RawData.IsEndOfFile():\r
Line, Comment = CleanString(self._RawData.GetNextLine())\r
+\r
#\r
# Header must be pure comment\r
#\r
self._RawData.UndoNextLine()\r
break\r
\r
- if Comment:\r
+ if Comment and Comment.startswith(DT.TAB_SPECIAL_COMMENT) and Comment.find(DT.TAB_HEADER_COMMENT) > 0 \\r
+ and not Comment[2:Comment.find(DT.TAB_HEADER_COMMENT)].strip():\r
+ IsFileHeader = True\r
+ IsBinaryHeader = False\r
+ FileHeaderLineIndex = self._RawData.LineIndex\r
+ \r
+ #\r
+ # Get license information before '@file' \r
+ # \r
+ if not IsFileHeader and not IsBinaryHeader and Comment and Comment.startswith(DT.TAB_COMMENT_SPLIT) and \\r
+ DT.TAB_BINARY_HEADER_COMMENT not in Comment:\r
self._HeadComment.append((Comment, self._RawData.LineIndex))\r
+ \r
+ if Comment and IsFileHeader and \\r
+ not(Comment.startswith(DT.TAB_SPECIAL_COMMENT) \\r
+ and Comment.find(DT.TAB_BINARY_HEADER_COMMENT) > 0):\r
+ self._HeadComment.append((Comment, self._RawData.LineIndex))\r
+ #\r
+ # Double '#' indicates end of header comments\r
+ #\r
+ if (not Comment or Comment == DT.TAB_SPECIAL_COMMENT) and IsFileHeader:\r
+ IsFileHeader = False \r
+ continue\r
+ \r
+ if Comment and Comment.startswith(DT.TAB_SPECIAL_COMMENT) \\r
+ and Comment.find(DT.TAB_BINARY_HEADER_COMMENT) > 0:\r
+ IsBinaryHeader = True\r
+ IsFileHeader = False\r
+ BinaryHeaderLineIndex = self._RawData.LineIndex\r
+ \r
+ if Comment and IsBinaryHeader:\r
+ self.BinaryHeadComment.append((Comment, self._RawData.LineIndex))\r
#\r
# Double '#' indicates end of header comments\r
#\r
- if not Comment or Comment == DT.TAB_SPECIAL_COMMENT:\r
+ if (not Comment or Comment == DT.TAB_SPECIAL_COMMENT) and IsBinaryHeader:\r
+ IsBinaryHeader = False\r
break\r
- \r
+ \r
+ if FileHeaderLineIndex > -1 and not IsFileHeader and not IsBinaryHeader:\r
+ break\r
+\r
+ if FileHeaderLineIndex > BinaryHeaderLineIndex and FileHeaderLineIndex > -1 and BinaryHeaderLineIndex > -1:\r
+ self._LoggerError(ST.ERR_BINARY_HEADER_ORDER)\r
+ \r
+ if FileHeaderLineIndex == -1:\r
+ Logger.Error(TOOL_NAME, FORMAT_INVALID, \r
+ ST.ERR_NO_SOURCE_HEADER,\r
+ File=self._RawData.Filename) \r
return\r
\r
def _StopCurrentParsing(self, Line):\r
## @file\r
# This file contained the parser for INF file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
#\r
HeaderCommentStart = False \r
HeaderCommentEnd = False\r
+ HeaderStarLineNo = -1\r
+ BinaryHeaderCommentStart = False \r
+ BinaryHeaderCommentEnd = False\r
+ BinaryHeaderStarLineNo = -1\r
\r
#\r
# While Section ends. parse whole section contents.\r
#\r
if Line.startswith(DT.TAB_SPECIAL_COMMENT) and \\r
(Line.find(DT.TAB_HEADER_COMMENT) > -1) and \\r
- not HeaderCommentStart:\r
- if CurrentSection != DT.MODEL_UNKNOWN:\r
- Logger.Error("Parser", \r
- PARSER_ERROR, \r
- ST.ERR_INF_PARSER_HEADER_FILE, \r
- File=Filename, \r
- Line=LineNo, \r
- RaiseError = Logger.IS_RAISE_ERROR)\r
- else:\r
- CurrentSection = DT.MODEL_META_DATA_FILE_HEADER\r
- #\r
- # Append the first line to section lines.\r
- #\r
- SectionLines.append((Line, LineNo))\r
- HeaderCommentStart = True\r
- continue \r
+ not HeaderCommentStart and not HeaderCommentEnd:\r
+\r
+ CurrentSection = DT.MODEL_META_DATA_FILE_HEADER\r
+ #\r
+ # Append the first line to section lines.\r
+ #\r
+ HeaderStarLineNo = LineNo\r
+ SectionLines.append((Line, LineNo))\r
+ HeaderCommentStart = True\r
+ continue \r
\r
#\r
# Collect Header content.\r
#\r
if (Line.startswith(DT.TAB_SPECIAL_COMMENT) or not Line.strip().startswith("#")) and HeaderCommentStart \\r
and not HeaderCommentEnd:\r
- SectionLines.append((Line, LineNo))\r
+ HeaderCommentEnd = True\r
+ BinaryHeaderCommentStart = False \r
+ BinaryHeaderCommentEnd = False\r
HeaderCommentStart = False\r
+ if Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1:\r
+ self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName) \r
+ SectionLines = []\r
+ else:\r
+ SectionLines.append((Line, LineNo))\r
#\r
# Call Header comment parser.\r
#\r
self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName)\r
SectionLines = []\r
+ continue\r
+\r
+ #\r
+ # check whether binary header comment section started\r
+ #\r
+ if Line.startswith(DT.TAB_SPECIAL_COMMENT) and \\r
+ (Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1) and \\r
+ not BinaryHeaderCommentStart:\r
+ SectionLines = []\r
+ CurrentSection = DT.MODEL_META_DATA_FILE_HEADER\r
+ #\r
+ # Append the first line to section lines.\r
+ #\r
+ BinaryHeaderStarLineNo = LineNo\r
+ SectionLines.append((Line, LineNo))\r
+ BinaryHeaderCommentStart = True\r
HeaderCommentEnd = True \r
continue \r
\r
#\r
+ # check whether there are more than one binary header exist\r
+ #\r
+ if Line.startswith(DT.TAB_SPECIAL_COMMENT) and BinaryHeaderCommentStart and \\r
+ not BinaryHeaderCommentEnd and (Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1):\r
+ Logger.Error('Parser',\r
+ FORMAT_INVALID,\r
+ ST.ERR_MULTIPLE_BINARYHEADER_EXIST,\r
+ File=Filename)\r
+ \r
+ #\r
+ # Collect Binary Header content.\r
+ #\r
+ if (Line.startswith(DT.TAB_COMMENT_SPLIT) and CurrentSection == DT.MODEL_META_DATA_FILE_HEADER) and\\r
+ BinaryHeaderCommentStart and not Line.startswith(DT.TAB_SPECIAL_COMMENT) and not\\r
+ BinaryHeaderCommentEnd and NextLine != '':\r
+ SectionLines.append((Line, LineNo))\r
+ continue\r
+ #\r
+ # Binary Header content end\r
+ #\r
+ if (Line.startswith(DT.TAB_SPECIAL_COMMENT) or not Line.strip().startswith(DT.TAB_COMMENT_SPLIT)) and \\r
+ BinaryHeaderCommentStart and not BinaryHeaderCommentEnd:\r
+ SectionLines.append((Line, LineNo))\r
+ BinaryHeaderCommentStart = False\r
+ #\r
+ # Call Binary Header comment parser.\r
+ #\r
+ self.InfHeaderParser(SectionLines, self.InfBinaryHeader, self.FileName, True)\r
+ SectionLines = []\r
+ BinaryHeaderCommentEnd = True \r
+ continue \r
+ #\r
# Find a new section tab\r
# Or at the last line of INF file, \r
# need to process the last section.\r
#\r
if (Line.startswith(DT.TAB_SECTION_START) and \\r
Line.find(DT.TAB_SECTION_END) > -1) or LastSectionFalg: \r
+ \r
+ HeaderCommentEnd = True \r
+ BinaryHeaderCommentEnd = True \r
+ \r
if not LastSectionFalg:\r
#\r
# check to prevent '#' inside section header\r
# Clear section lines\r
#\r
SectionLines = [] \r
- #\r
- # End of for\r
- #\r
- #\r
- # Found the first section, No file header.\r
- #\r
- if DefineSectionParsedFlag and not HeaderCommentEnd:\r
+ \r
+ if HeaderStarLineNo == -1:\r
Logger.Error("InfParser", \r
FORMAT_INVALID, \r
- ST.ERR_INF_PARSER_HEADER_MISSGING, \r
+ ST.ERR_NO_SOURCE_HEADER, \r
File=self.FullPath)\r
- \r
+ if BinaryHeaderStarLineNo > -1 and HeaderStarLineNo > -1 and HeaderStarLineNo > BinaryHeaderStarLineNo:\r
+ Logger.Error("InfParser", \r
+ FORMAT_INVALID,\r
+ ST.ERR_BINARY_HEADER_ORDER,\r
+ File=self.FullPath) \r
#\r
# EDKII INF should not have EDKI style comment\r
#\r
SectionType = gINF_SECTION_DEF[SectionName.upper()] \r
\r
return SectionType \r
-
\ No newline at end of file
+ \r
## @file\r
# This file is used to parse a PCD file of .PKG file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available \r
# under the terms and conditions of the BSD License which accompanies this \r
Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')\r
if Executable.upper() == "TRUE":\r
Executable = True\r
- else:\r
+ elif Executable.upper() == "FALSE":\r
Executable = False\r
+ else:\r
+ Executable = ''\r
self.Files.append([Filename, Executable])\r
\r
MiscFile = MiscFileObject()\r
OsType = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'OS')\r
if Executable.upper() == "TRUE":\r
Executable = True\r
- else:\r
+ elif Executable.upper() == "FALSE":\r
Executable = False\r
+ else:\r
+ Executable = ''\r
self.Files.append([Filename, Executable, OsType])\r
\r
MiscFile = MiscFileObject()\r
for Item in GetSplitValueList(self._CurrentLine[1:-1], TAB_COMMA_SPLIT):
if Item == '':
continue
- ItemList = GetSplitValueList(Item, TAB_SPLIT)
+ ItemList = GetSplitValueList(Item, TAB_SPLIT,2)
# different section should not mix in one section
if self._SectionName != '' and self._SectionName != ItemList[0].upper():
EdkLogger.error('Parser', FORMAT_INVALID, "Different section names in the same section",
# S2 may be Platform or ModuleType
if len(ItemList) > 2:
- S2 = ItemList[2].upper()
+ if self._SectionName.upper() in SECTIONS_HAVE_ITEM_PCD:
+ S2 = ItemList[2]
+ else:
+ S2 = ItemList[2].upper()
else:
S2 = 'COMMON'
self._Scope.append([S1, S2])
# parse the file line by line
IsFindBlockComment = False
GetHeaderComment = False
+ TailComments = []
+ SectionComments = []
Comments = []
for Index in range(0, len(Content)):
if Line == '':
if Comment:
Comments.append((Comment, Index + 1))
+ elif GetHeaderComment:
+ SectionComments.extend(Comments)
+ Comments = []
continue
if Line.find(DataType.TAB_COMMENT_EDK_START) > -1:
IsFindBlockComment = True
self._Store(MODEL_META_DATA_HEADER_COMMENT, Cmt, '', '', 'COMMON',
'COMMON', self._Owner[-1], LNo, -1, LNo, -1, 0)
GetHeaderComment = True
+ else:
+ TailComments.extend(SectionComments + Comments)
Comments = []
self._SectionHeaderParser()
# Check invalid sections
self._Store(MODEL_META_DATA_COMMENT, Comment, '', '', Arch, Platform,
LastItem, LineNo, -1, LineNo, -1, 0)
Comments = []
+ SectionComments = []
+ TailComments.extend(SectionComments + Comments)
if IsFindBlockComment:
EdkLogger.error("Parser", FORMAT_INVALID, "Open block comments (starting with /*) are expected to end with */",
File=self.MetaFile)
+
+ # If there are tail comments in INF file, save to database whatever the comments are
+ for Comment in TailComments:
+ self._Store(MODEL_META_DATA_TAIL_COMMENT, Comment[0], '', '', 'COMMON',
+ 'COMMON', self._Owner[-1], -1, -1, -1, -1, 0)
self._Done()
## Data parser for the format in which there's path
## @file\r
# This file is used to create a database used by build tool\r
#\r
-# Copyright (c) 2008 - 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2008 - 2014, Intel Corporation. All rights reserved.<BR>\r
# 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
from BuildClassObject import *\r
from WorkspaceCommon import GetDeclaredPcd\r
from Common.Misc import AnalyzeDscPcd\r
+import re\r
\r
## Platform build information from DSC file\r
#\r
return False\r
\r
def _GetSkuIdentifier(self):\r
+ if self._SkuName:\r
+ return self._SkuName\r
if self._SkuIdentifier == None:\r
if self._Header == None:\r
self._GetHeaderInfo()\r
if self._SkuName == None:\r
if self._Header == None:\r
self._GetHeaderInfo()\r
- if self._SkuName == None or self._SkuName not in self.SkuIds:\r
+ if (self._SkuName == None or self._SkuName not in self.SkuIds):\r
self._SkuName = 'DEFAULT'\r
return self._SkuName\r
\r
## Override SKUID_IDENTIFIER\r
def _SetSkuName(self, Value):\r
- if Value in self.SkuIds:\r
- self._SkuName = Value\r
- # Needs to re-retrieve the PCD information\r
- self._Pcds = None\r
+ self._SkuName = Value\r
+ self._Pcds = None\r
\r
def _GetFdfFile(self):\r
if self._FlashDefinition == None:\r
if Record[1] in [None, '']:\r
EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r
File=self.MetaFile, Line=Record[-1])\r
- self._SkuIds[Record[1].upper()] = Record[0]\r
+ self._SkuIds[Record[1]] = Record[0]\r
if 'DEFAULT' not in self._SkuIds:\r
self._SkuIds['DEFAULT'] = '0'\r
if 'COMMON' not in self._SkuIds:\r
RecordList = self._RawData[Type, self._Arch]\r
PcdValueDict = sdict()\r
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- SkuName = SkuName.upper()\r
if SkuName in (SkuObj.SystemSkuId,'DEFAULT','COMMON'):\r
PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r
PcdDict[Arch, PcdCName, TokenSpaceGuid,SkuName] = Setting\r
\r
AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- SkuName = SkuName.upper()\r
if SkuName not in AvailableSkuIdSet:\r
continue\r
\r
if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r
pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
pcdObject.SkuInfoList[SkuName] = SkuInfo\r
+ if MaxDatumSize.strip():\r
+ CurrentMaxSize = int(MaxDatumSize.strip(),0)\r
+ else:\r
+ CurrentMaxSize = 0\r
+ if pcdObject.MaxDatumSize:\r
+ PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r
+ else:\r
+ PcdMaxSize = 0\r
+ if CurrentMaxSize > PcdMaxSize:\r
+ pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
else: \r
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
PcdCName,\r
)\r
\r
for pcd in Pcds.values():\r
- if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():\r
- pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
+ pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
+ if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys(): \r
valuefromDec = pcdDecObject.DefaultValue\r
SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)\r
pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r
pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
del(pcd.SkuInfoList['DEFAULT'])\r
- \r
- if SkuObj.SkuUsageType == SkuObj.MULTIPLE:\r
- if pcd.DatumType == "VOID*": \r
- MaxSize = int(pcd.MaxDatumSize,0)\r
- for (skuname,skuobj) in pcd.SkuInfoList.items():\r
- datalen = len(skuobj.DefaultValue)\r
- if datalen>MaxSize:\r
- MaxSize = datalen\r
- pcd.MaxDatumSize = str(MaxSize)\r
- \r
- \r
+ \r
return Pcds\r
\r
## Retrieve dynamic HII PCD settings\r
\r
AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- SkuName = SkuName.upper()\r
if SkuName not in AvailableSkuIdSet:\r
continue\r
PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r
if Setting == None:\r
continue\r
VariableName, VariableGuid, VariableOffset, DefaultValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
+ \r
+ ExceedMax = False\r
+ if VariableOffset.isdigit():\r
+ if int(VariableOffset,10) > 0xFFFF:\r
+ ExceedMax = True\r
+ elif re.match(r'[\t\s]*0[xX][a-fA-F0-9]+$',VariableOffset):\r
+ if int(VariableOffset,16) > 0xFFFF:\r
+ ExceedMax = True\r
+ else:\r
+ EdkLogger.error('Build', FORMAT_INVALID, "Invalid syntax or format of the variable offset value is incorrect for %s." % ".".join((TokenSpaceGuid,PcdCName)))\r
+ \r
+ if ExceedMax:\r
+ EdkLogger.error('Build', OPTION_VALUE_INVALID, "The variable offset value must not exceed the maximum value of 0xFFFF (UINT16) for %s." % ".".join((TokenSpaceGuid,PcdCName)))\r
+ \r
SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)\r
if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r
pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
\r
for pcd in Pcds.values():\r
SkuInfoObj = pcd.SkuInfoList.values()[0]\r
- if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():\r
- pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
+ pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
+ # Only fix the value while no value provided in DSC file.\r
+ for sku in pcd.SkuInfoList.values():\r
+ if (sku.HiiDefaultValue == "" or sku.HiiDefaultValue==None):\r
+ sku.HiiDefaultValue = pcdDecObject.DefaultValue\r
+ if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys(): \r
valuefromDec = pcdDecObject.DefaultValue\r
SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec)\r
pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
if 'DEFAULT' in pcd.SkuInfoList.keys() and SkuObj.SystemSkuId not in pcd.SkuInfoList.keys():\r
pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
del(pcd.SkuInfoList['DEFAULT'])\r
+ \r
+ \r
+ if pcd.MaxDatumSize.strip(): \r
+ MaxSize = int(pcd.MaxDatumSize,0)\r
+ else:\r
+ MaxSize = 0\r
+ if pcdDecObject.DatumType == 'VOID*':\r
+ for (skuname,skuobj) in pcd.SkuInfoList.items():\r
+ datalen = 0\r
+ if skuobj.HiiDefaultValue.startswith("L"):\r
+ datalen = (len(skuobj.HiiDefaultValue)- 3 + 1) * 2\r
+ elif skuobj.HiiDefaultValue.startswith("{"):\r
+ datalen = len(skuobj.HiiDefaultValue.split(","))\r
+ else:\r
+ datalen = len(skuobj.HiiDefaultValue) -2 + 1 \r
+ if datalen>MaxSize:\r
+ MaxSize = datalen\r
+ pcd.MaxDatumSize = str(MaxSize)\r
return Pcds\r
\r
## Retrieve dynamic VPD PCD settings\r
\r
AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
- SkuName = SkuName.upper()\r
if SkuName not in AvailableSkuIdSet:\r
continue\r
\r
if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r
pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
pcdObject.SkuInfoList[SkuName] = SkuInfo\r
+ if MaxDatumSize.strip():\r
+ CurrentMaxSize = int(MaxDatumSize.strip(),0)\r
+ else:\r
+ CurrentMaxSize = 0\r
+ if pcdObject.MaxDatumSize:\r
+ PcdMaxSize = int(pcdObject.MaxDatumSize,0)\r
+ else:\r
+ PcdMaxSize = 0\r
+ if CurrentMaxSize > PcdMaxSize:\r
+ pcdObject.MaxDatumSize = str(CurrentMaxSize)\r
else:\r
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
PcdCName,\r
)\r
for pcd in Pcds.values():\r
SkuInfoObj = pcd.SkuInfoList.values()[0]\r
+ pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
if 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' not in pcd.SkuInfoList.keys():\r
- pcdDecObject = self._DecPcds[pcd.TokenCName,pcd.TokenSpaceGuidCName]\r
valuefromDec = pcdDecObject.DefaultValue\r
SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '','',SkuInfoObj.VpdOffset, valuefromDec)\r
pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
pcd.SkuInfoList[SkuObj.SystemSkuId] = pcd.SkuInfoList['DEFAULT']\r
del(pcd.SkuInfoList['DEFAULT'])\r
\r
- if SkuObj.SkuUsageType == SkuObj.MULTIPLE:\r
- if pcd.MaxDatumSize.strip(): \r
- MaxSize = int(pcd.MaxDatumSize,0)\r
- for (skuname,skuobj) in pcd.SkuInfoList.items():\r
- datalen = len(skuobj.DefaultValue)\r
- if datalen>MaxSize:\r
- MaxSize = datalen\r
- pcd.MaxDatumSize = str(MaxSize)\r
return Pcds\r
\r
## Add external modules\r
## Set all internal used members of InfBuildData to None\r
def _Clear(self):\r
self._HeaderComments = None\r
+ self._TailComments = None\r
self._Header_ = None\r
self._AutoGenVersion = None\r
self._BaseName = None\r
for Record in RecordList:\r
self._HeaderComments.append(Record[0])\r
return self._HeaderComments\r
-\r
+ def _GetTailComments(self):\r
+ if not self._TailComments:\r
+ self._TailComments = []\r
+ RecordList = self._RawData[MODEL_META_DATA_TAIL_COMMENT]\r
+ for Record in RecordList:\r
+ self._TailComments.append(Record[0])\r
+ return self._TailComments\r
## Retrieve all information in [Defines] section\r
#\r
# (Retriving all [Defines] information in one-shot is just to save time.)\r
else:\r
Tool = ToolList[0]\r
ToolChain = "*_*_*_%s_FLAGS" % Tool\r
- ToolChainFamily = 'MSFT' # Edk.x only support MSFT tool chain\r
+ ToolChainFamily = '' \r
#ignore not replaced macros in value\r
ValueList = GetSplitList(' ' + Value, '/D')\r
Dummy = ValueList[0]\r
Platform = property(_GetPlatform, _SetPlatform)\r
\r
HeaderComments = property(_GetHeaderComments)\r
+ TailComments = property(_GetTailComments)\r
AutoGenVersion = property(_GetInfVersion)\r
BaseName = property(_GetBaseName)\r
ModuleType = property(_GetModuleType)\r
Statement = gOpCodeList[struct.unpack("B", OpCode)[0]]\r
if Statement in ["BEFORE", "AFTER", "PUSH"]:\r
GuidValue = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \\r
- struct.unpack("LHHBBBBBBBB", DepexFile.read(16))\r
+ struct.unpack("=LHHBBBBBBBB", DepexFile.read(16))\r
GuidString = self._GuidDb.get(GuidValue, GuidValue)\r
Statement = "%s %s" % (Statement, GuidString)\r
DepexStatement.append(Statement)\r
projects / mirror_edk2.git / commitdiff