Sync BaseTool trunk (version r2610) into EDKII BaseTools.

Signed-off-by: Liming Gao <liming.gao@intel.com>
git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@14856 6f19259b-4bc3-4df7-8a09-765794883524

diff --git a/BaseTools/Bin/Win32/BPDG.exe b/BaseTools/Bin/Win32/BPDG.exe
index 1a684bb8739689fc7eb5f3ad685eb7ba7e6f201b..d81803a80c8d6e1f9ce733d7298f143134c03398 100644 (file)
Binary files a/BaseTools/Bin/Win32/BPDG.exe and b/BaseTools/Bin/Win32/BPDG.exe differ

diff --git a/BaseTools/Bin/Win32/BootSectImage.exe b/BaseTools/Bin/Win32/BootSectImage.exe
index 59b0b845850033cb9443bab8b076abc31018c344..4ba8c50e876bfe74d916bc17366d24c668ab8b61 100755 (executable)
Binary files a/BaseTools/Bin/Win32/BootSectImage.exe and b/BaseTools/Bin/Win32/BootSectImage.exe differ

diff --git a/BaseTools/Bin/Win32/EfiLdrImage.exe b/BaseTools/Bin/Win32/EfiLdrImage.exe
index c732a73306f16ff8964f28efb185d40c6a76b514..a06534db8dbc1e978863bb1182a934c7815c1eb4 100755 (executable)
Binary files a/BaseTools/Bin/Win32/EfiLdrImage.exe and b/BaseTools/Bin/Win32/EfiLdrImage.exe differ

diff --git a/BaseTools/Bin/Win32/EfiRom.exe b/BaseTools/Bin/Win32/EfiRom.exe
index 2e761cc08de9b7be0cb4c1c82bf4f55df754419c..1baf7a99dbf61d669e7a7fe703df7fc1705ada01 100755 (executable)
Binary files a/BaseTools/Bin/Win32/EfiRom.exe and b/BaseTools/Bin/Win32/EfiRom.exe differ

diff --git a/BaseTools/Bin/Win32/GenBootSector.exe b/BaseTools/Bin/Win32/GenBootSector.exe
index 84d67f9b83e1ac96aaf8ac6690f9eae99135b433..df8f019d2f3a0d4872a4be69ac8daaa1c6c12e9b 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenBootSector.exe and b/BaseTools/Bin/Win32/GenBootSector.exe differ

diff --git a/BaseTools/Bin/Win32/GenCrc32.exe b/BaseTools/Bin/Win32/GenCrc32.exe
index cdefa75895e3a95c7216d70c12d458116098b5ab..4a440145ecdbd476705013bfe683c1d848bb981d 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenCrc32.exe and b/BaseTools/Bin/Win32/GenCrc32.exe differ

diff --git a/BaseTools/Bin/Win32/GenDepex.exe b/BaseTools/Bin/Win32/GenDepex.exe
index 2d7e20f60f8fc3b9c908ad03af1e0c9771c31b40..ca008dbc36fa73471c489d7b9e30f1a3522749d4 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenDepex.exe and b/BaseTools/Bin/Win32/GenDepex.exe differ

diff --git a/BaseTools/Bin/Win32/GenFds.exe b/BaseTools/Bin/Win32/GenFds.exe
index 6d2a1aa55d966eef22babe1e13bd6942020effb7..529d29152dd8662a79eea14a864d59bec186c34f 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenFds.exe and b/BaseTools/Bin/Win32/GenFds.exe differ

diff --git a/BaseTools/Bin/Win32/GenFfs.exe b/BaseTools/Bin/Win32/GenFfs.exe
index b419b0d172fcfffaeb79414cd694c7e66f5ab8c7..3a57ec90f69e15c208c0dc84be067f86f2ca662a 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenFfs.exe and b/BaseTools/Bin/Win32/GenFfs.exe differ

diff --git a/BaseTools/Bin/Win32/GenFv.exe b/BaseTools/Bin/Win32/GenFv.exe
index c6e3ad656cd7fb11a3b4d35c1311206db8d5c196..31b49654b27771b1a0fcc6d5f927d81d2338191f 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenFv.exe and b/BaseTools/Bin/Win32/GenFv.exe differ

diff --git a/BaseTools/Bin/Win32/GenFw.exe b/BaseTools/Bin/Win32/GenFw.exe
index 8e19c1724fe5a3f7a1cec8947f709bd6f95747ad..7d53501b8004a07c2946d9bafb266a4e445276f7 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenFw.exe and b/BaseTools/Bin/Win32/GenFw.exe differ

diff --git a/BaseTools/Bin/Win32/GenPage.exe b/BaseTools/Bin/Win32/GenPage.exe
index a2a95bd30fc87660c1e0883a125a60875fce5510..3ccbb5b334b97cd89e5c255c0f97ddbd8fc45687 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenPage.exe and b/BaseTools/Bin/Win32/GenPage.exe differ

diff --git a/BaseTools/Bin/Win32/GenPatchPcdTable.exe b/BaseTools/Bin/Win32/GenPatchPcdTable.exe
index 7f7aa5ab6fb38022f137fd8a66e698bcb5aa584c..a978e64b9e9b936b91815e9eb037cdebd6ec16a3 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenPatchPcdTable.exe and b/BaseTools/Bin/Win32/GenPatchPcdTable.exe differ

diff --git a/BaseTools/Bin/Win32/GenSec.exe b/BaseTools/Bin/Win32/GenSec.exe
index 2cb0c3b81390e24e3689256285a22cd214eba7cf..277d623384f1168b09ffa30ac9a8f3cfc18d57b8 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenSec.exe and b/BaseTools/Bin/Win32/GenSec.exe differ

diff --git a/BaseTools/Bin/Win32/GenVtf.exe b/BaseTools/Bin/Win32/GenVtf.exe
index 7e38d68bac5e05934c8cc828a4fdc3a829a51204..fd936b071e127093049361f484f30158830cb040 100755 (executable)
Binary files a/BaseTools/Bin/Win32/GenVtf.exe and b/BaseTools/Bin/Win32/GenVtf.exe differ

diff --git a/BaseTools/Bin/Win32/LzmaCompress.exe b/BaseTools/Bin/Win32/LzmaCompress.exe
index 9838c0e9b118d98cd067e3cfccf44559bbd44199..1984cc73eed798c7f0f3d41e3d2f40594c37e92d 100755 (executable)
Binary files a/BaseTools/Bin/Win32/LzmaCompress.exe and b/BaseTools/Bin/Win32/LzmaCompress.exe differ

diff --git a/BaseTools/Bin/Win32/PatchPcdValue.exe b/BaseTools/Bin/Win32/PatchPcdValue.exe
index 142d59a16cf20d774ac566b3f4750fbaa3460896..aa0e088f7a42a454b84a98aa968e4a9866dba7f9 100755 (executable)
Binary files a/BaseTools/Bin/Win32/PatchPcdValue.exe and b/BaseTools/Bin/Win32/PatchPcdValue.exe differ

diff --git a/BaseTools/Bin/Win32/Split.exe b/BaseTools/Bin/Win32/Split.exe
index 254590bbe305871f4f7c939ea9f1ef665b995899..30451d4bcea5f8429acc2f074224d61fae9ee0fd 100755 (executable)
Binary files a/BaseTools/Bin/Win32/Split.exe and b/BaseTools/Bin/Win32/Split.exe differ

diff --git a/BaseTools/Bin/Win32/TargetTool.exe b/BaseTools/Bin/Win32/TargetTool.exe
index c8c23d5a37047ac87d9a4a67f74c91f791fa0180..c8b1006edea3c29d14472803f25737596518e748 100755 (executable)
Binary files a/BaseTools/Bin/Win32/TargetTool.exe and b/BaseTools/Bin/Win32/TargetTool.exe differ

diff --git a/BaseTools/Bin/Win32/TianoCompress.exe b/BaseTools/Bin/Win32/TianoCompress.exe
index cdbe97f85e84cebbe701af8e8f867f6762d1854c..a574d075d786d84f8ca73a88f0610cacc4da1839 100755 (executable)
Binary files a/BaseTools/Bin/Win32/TianoCompress.exe and b/BaseTools/Bin/Win32/TianoCompress.exe differ

diff --git a/BaseTools/Bin/Win32/Trim.exe b/BaseTools/Bin/Win32/Trim.exe
index 056581b00bb8a4a66cd5024b6d1eec1811c33744..8a83841599d903f080744ea257158cd4fc222ee0 100755 (executable)
Binary files a/BaseTools/Bin/Win32/Trim.exe and b/BaseTools/Bin/Win32/Trim.exe differ

diff --git a/BaseTools/Bin/Win32/UPT.exe b/BaseTools/Bin/Win32/UPT.exe
index 3101afd618df528582f4f6a99d2566fad86b67ec..5bb1d9e2cba33e66d546d225f750f4e84a712eec 100644 (file)
Binary files a/BaseTools/Bin/Win32/UPT.exe and b/BaseTools/Bin/Win32/UPT.exe differ

diff --git a/BaseTools/Bin/Win32/VfrCompile.exe b/BaseTools/Bin/Win32/VfrCompile.exe
index 1c1ca78f7ca1f993f631373944d9c47c298322f1..34df8a2dc2229411d1811e6d097f0f8fb20c90a7 100755 (executable)
Binary files a/BaseTools/Bin/Win32/VfrCompile.exe and b/BaseTools/Bin/Win32/VfrCompile.exe differ

diff --git a/BaseTools/Bin/Win32/VolInfo.exe b/BaseTools/Bin/Win32/VolInfo.exe
index c042d9222b59212214be8a2114bd1fe4df4a5e94..f7a7591cf59b53696601d53851b24ff7afbf5193 100755 (executable)
Binary files a/BaseTools/Bin/Win32/VolInfo.exe and b/BaseTools/Bin/Win32/VolInfo.exe differ

diff --git a/BaseTools/Bin/Win32/build.exe b/BaseTools/Bin/Win32/build.exe
index 3c03283bdd79852ff1ff50c75dfb7ab9eef233b4..ee3f7eb9d87c3937839585156b220759ae8497c9 100755 (executable)
Binary files a/BaseTools/Bin/Win32/build.exe and b/BaseTools/Bin/Win32/build.exe differ

diff --git a/BaseTools/Source/C/Common/FvLib.c b/BaseTools/Source/C/Common/FvLib.c
index 1b289d83cd62a921497968abd10f713201399689..4758749dc363d9885613120f2f4fc4c2b31d4bcb 100644 (file)
--- a/BaseTools/Source/C/Common/FvLib.c
+++ b/BaseTools/Source/C/Common/FvLib.c
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2004 - 2008, 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
 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


@@ -181,7 +181,7 @@ Returns:
       //\r
       // Verify file is in this FV.\r
       //\r
       //\r
       // Verify file is in this FV.\r
       //\r

-      if ((UINTN) CurrentFile + GetLength (CurrentFile->Size) > (UINTN) mFvHeader + mFvLength) {\r
+      if ((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength) {\r

         *NextFile = NULL;\r
         return EFI_SUCCESS;\r
       }\r
         *NextFile = NULL;\r
         return EFI_SUCCESS;\r
       }\r


@@ -194,20 +194,20 @@ Returns:
   // Verify current file is in range\r
   //\r
   if (((UINTN) CurrentFile < (UINTN) mFvHeader + mFvHeader->HeaderLength) ||\r
   // Verify current file is in range\r
   //\r
   if (((UINTN) CurrentFile < (UINTN) mFvHeader + mFvHeader->HeaderLength) ||\r

-      ((UINTN) CurrentFile + GetLength (CurrentFile->Size) > (UINTN) mFvHeader + mFvLength)\r
+      ((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength)\r

      ) {\r
     return EFI_INVALID_PARAMETER;\r
   }\r
   //\r
   // Get next file, compensate for 8 byte alignment if necessary.\r
   //\r
      ) {\r
     return EFI_INVALID_PARAMETER;\r
   }\r
   //\r
   // Get next file, compensate for 8 byte alignment if necessary.\r
   //\r

-  *NextFile = (EFI_FFS_FILE_HEADER *) ((((UINTN) CurrentFile - (UINTN) mFvHeader + GetLength (CurrentFile->Size) + 0x07) & (-1 << 3)) + (UINT8 *) mFvHeader);\r
+  *NextFile = (EFI_FFS_FILE_HEADER *) ((((UINTN) CurrentFile - (UINTN) mFvHeader + GetFfsFileLength(CurrentFile) + 0x07) & (-1 << 3)) + (UINT8 *) mFvHeader);\r

 \r
   //\r
   // Verify file is in this FV.\r
   //\r
 \r
   //\r
   // Verify file is in this FV.\r
   //\r

-  if (((UINTN) *NextFile + sizeof (EFI_FFS_FILE_HEADER) >= (UINTN) mFvHeader + mFvLength) ||\r
-      ((UINTN) *NextFile + GetLength ((*NextFile)->Size) > (UINTN) mFvHeader + mFvLength)\r
+  if (((UINTN) *NextFile + GetFfsHeaderLength(*NextFile) >= (UINTN) mFvHeader + mFvLength) ||\r
+      ((UINTN) *NextFile + GetFfsFileLength (*NextFile) > (UINTN) mFvHeader + mFvLength)\r

      ) {\r
     *NextFile = NULL;\r
     return EFI_SUCCESS;\r
      ) {\r
     *NextFile = NULL;\r
     return EFI_SUCCESS;\r


@@ -434,7 +434,11 @@ Returns:
   EFI_FILE_SECTION_POINTER  InnerSection;\r
   EFI_STATUS                Status;\r
   UINTN                     SectionSize;\r
   EFI_FILE_SECTION_POINTER  InnerSection;\r
   EFI_STATUS                Status;\r
   UINTN                     SectionSize;\r

+  UINT16                    GuidSecAttr;\r
+  UINT16                    GuidDataOffset;\r

 \r
 \r

+  GuidSecAttr = 0;\r
+  GuidDataOffset = 0;\r

   CurrentSection = FirstSection;\r
 \r
   while ((UINTN) CurrentSection.CommonHeader < (UINTN) SearchEnd) {\r
   CurrentSection = FirstSection;\r
 \r
   while ((UINTN) CurrentSection.CommonHeader < (UINTN) SearchEnd) {\r


@@ -452,14 +456,21 @@ Returns:
     // special processing, go ahead to search the requesting\r
     // section inside the GUID-defined section.\r
     //\r
     // special processing, go ahead to search the requesting\r
     // section inside the GUID-defined section.\r
     //\r

+    if (CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED) {\r
+      if (GetLength(CurrentSection.CommonHeader->Size) == 0xffffff) {\r
+        GuidSecAttr = CurrentSection.GuidDefinedSection2->Attributes;\r
+        GuidDataOffset = CurrentSection.GuidDefinedSection2->DataOffset;\r
+      } else {\r
+        GuidSecAttr = CurrentSection.GuidDefinedSection->Attributes;\r
+        GuidDataOffset = CurrentSection.GuidDefinedSection->DataOffset;\r
+      }\r
+    }\r

     if (SectionType != EFI_SECTION_GUID_DEFINED &&\r
         CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED &&\r
     if (SectionType != EFI_SECTION_GUID_DEFINED &&\r
         CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED &&\r

-        !(CurrentSection.GuidDefinedSection->Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) {\r
+        !(GuidSecAttr & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) {\r

       InnerSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *)\r
       InnerSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *)\r

-        ((UINTN) CurrentSection.CommonHeader + CurrentSection.GuidDefinedSection->DataOffset);\r
-      SectionSize = CurrentSection.CommonHeader->Size[0] +\r
-        (CurrentSection.CommonHeader->Size[1] << 8) + \r
-        (CurrentSection.CommonHeader->Size[2] << 16);\r
+        ((UINTN) CurrentSection.CommonHeader + GuidDataOffset);\r
+      SectionSize = GetSectionFileLength(CurrentSection.CommonHeader);\r

       Status = SearchSectionByType (\r
                  InnerSection,\r
                  (UINT8 *) ((UINTN) CurrentSection.CommonHeader + SectionSize),\r
       Status = SearchSectionByType (\r
                  InnerSection,\r
                  (UINT8 *) ((UINTN) CurrentSection.CommonHeader + SectionSize),\r


@@ -475,7 +486,7 @@ Returns:
     //\r
     // Find next section (including compensating for alignment issues.\r
     //\r
     //\r
     // Find next section (including compensating for alignment issues.\r
     //\r

-    CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetLength (CurrentSection.CommonHeader->Size) + 0x03) & (-1 << 2));\r
+    CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetSectionFileLength(CurrentSection.CommonHeader) + 0x03) & (-1 << 2));\r

   }\r
 \r
   return EFI_NOT_FOUND;\r
   }\r
 \r
   return EFI_NOT_FOUND;\r


@@ -538,14 +549,14 @@ Returns:
   //\r
   // Get the first section\r
   //\r
   //\r
   // Get the first section\r
   //\r

-  CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + sizeof (EFI_FFS_FILE_HEADER));\r
+  CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + GetFfsHeaderLength(File));\r

   \r
   //\r
   // Depth-first manner to find section file.\r
   //\r
   Status = SearchSectionByType (\r
              CurrentSection,\r
   \r
   //\r
   // Depth-first manner to find section file.\r
   //\r
   Status = SearchSectionByType (\r
              CurrentSection,\r

-             (UINT8 *) ((UINTN) File + GetLength (File->Size)),\r
+             (UINT8 *) ((UINTN) File + GetFfsFileLength (File)),\r

              SectionType,\r
              &SectionCount,\r
              Instance,\r
              SectionType,\r
              &SectionCount,\r
              Instance,\r


@@ -639,12 +650,14 @@ Returns:
 {\r
   BOOLEAN             ErasePolarity;\r
   EFI_STATUS          Status;\r
 {\r
   BOOLEAN             ErasePolarity;\r
   EFI_STATUS          Status;\r

-  EFI_FFS_FILE_HEADER BlankHeader;\r
+  EFI_FFS_FILE_HEADER2 BlankHeader;\r

   UINT8               Checksum;\r
   UINT32              FileLength;\r
   UINT8               SavedChecksum;\r
   UINT8               SavedState;\r
   UINT8               FileGuidString[80];\r
   UINT8               Checksum;\r
   UINT32              FileLength;\r
   UINT8               SavedChecksum;\r
   UINT8               SavedState;\r
   UINT8               FileGuidString[80];\r

+  UINT32              FfsHeaderSize;\r
+\r

   //\r
   // Verify library has been initialized.\r
   //\r
   //\r
   // Verify library has been initialized.\r
   //\r


@@ -665,16 +678,18 @@ Returns:
   if (EFI_ERROR (Status)) {\r
     return EFI_ABORTED;\r
   }\r
   if (EFI_ERROR (Status)) {\r
     return EFI_ABORTED;\r
   }\r

+\r
+  FfsHeaderSize = GetFfsHeaderLength(FfsHeader);\r

   //\r
   // Check if we have free space\r
   //\r
   if (ErasePolarity) {\r
   //\r
   // Check if we have free space\r
   //\r
   if (ErasePolarity) {\r

-    memset (&BlankHeader, -1, sizeof (EFI_FFS_FILE_HEADER));\r
+    memset (&BlankHeader, -1, FfsHeaderSize);\r

   } else {\r
   } else {\r

-    memset (&BlankHeader, 0, sizeof (EFI_FFS_FILE_HEADER));\r
+    memset (&BlankHeader, 0, FfsHeaderSize);\r

   }\r
 \r
   }\r
 \r

-  if (memcmp (&BlankHeader, FfsHeader, sizeof (EFI_FFS_FILE_HEADER)) == 0) {\r
+  if (memcmp (&BlankHeader, FfsHeader, FfsHeaderSize) == 0) {\r

     return EFI_NOT_FOUND;\r
   }\r
   //\r
     return EFI_NOT_FOUND;\r
   }\r
   //\r


@@ -689,7 +704,7 @@ Returns:
   FfsHeader->State = 0;\r
   SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File;\r
   FfsHeader->IntegrityCheck.Checksum.File = 0;\r
   FfsHeader->State = 0;\r
   SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File;\r
   FfsHeader->IntegrityCheck.Checksum.File = 0;\r

-  Checksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));\r
+  Checksum = CalculateSum8 ((UINT8 *) FfsHeader, FfsHeaderSize);\r

   FfsHeader->State = SavedState;\r
   FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum;\r
   if (Checksum != 0) {\r
   FfsHeader->State = SavedState;\r
   FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum;\r
   if (Checksum != 0) {\r


@@ -703,8 +718,8 @@ Returns:
     //\r
     // Verify file data checksum\r
     //\r
     //\r
     // Verify file data checksum\r
     //\r

-    FileLength          = GetLength (FfsHeader->Size);\r
-    Checksum            = CalculateSum8 ((UINT8 *) (FfsHeader + 1), FileLength - sizeof (EFI_FFS_FILE_HEADER));\r
+    FileLength          = GetFfsFileLength (FfsHeader);\r
+    Checksum            = CalculateSum8 ((UINT8 *) ((UINT8 *)FfsHeader + FfsHeaderSize), FileLength - FfsHeaderSize);\r

     Checksum            = Checksum + FfsHeader->IntegrityCheck.Checksum.File;\r
     if (Checksum != 0) {\r
       Error (NULL, 0, 0006, "invalid FFS file checksum", "Ffs file with Guid %s", FileGuidString);\r
     Checksum            = Checksum + FfsHeader->IntegrityCheck.Checksum.File;\r
     if (Checksum != 0) {\r
       Error (NULL, 0, 0006, "invalid FFS file checksum", "Ffs file with Guid %s", FileGuidString);\r


@@ -724,6 +739,80 @@ Returns:
   return EFI_SUCCESS;\r
 }\r
 \r
   return EFI_SUCCESS;\r
 }\r
 \r

+UINT32\r
+GetFfsHeaderLength(\r
+   IN EFI_FFS_FILE_HEADER *FfsHeader\r
+   )\r
+{\r
+  if (FfsHeader == NULL) {\r
+    return 0;\r
+  }\r
+  if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) {\r
+    return sizeof(EFI_FFS_FILE_HEADER2);\r
+  }\r
+  return sizeof(EFI_FFS_FILE_HEADER);\r
+}\r
+\r
+UINT32\r
+GetSectionHeaderLength(\r
+   IN EFI_COMMON_SECTION_HEADER *SectionHeader\r
+   )\r
+{\r
+  if (SectionHeader == NULL) {\r
+    return 0;\r
+  }\r
+  if (GetLength(SectionHeader->Size) == 0xffffff) {\r
+    return sizeof(EFI_COMMON_SECTION_HEADER2);\r
+  }\r
+  return sizeof(EFI_COMMON_SECTION_HEADER);\r
+}\r
+\r
+UINT32\r
+GetFfsFileLength (\r
+  EFI_FFS_FILE_HEADER *FfsHeader\r
+  )\r
+/*++\r
+\r
+Routine Description:\r
+\r
+  Get FFS file length including FFS header.\r
+\r
+Arguments:\r
+\r
+  FfsHeader   Pointer to EFI_FFS_FILE_HEADER.\r
+\r
+Returns:\r
+\r
+  UINT32      Length of FFS file header.\r
+\r
+--*/\r
+{\r
+  if (FfsHeader == NULL) {\r
+    return 0;\r
+  }\r
+  if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) {\r
+    return ((EFI_FFS_FILE_HEADER2 *)FfsHeader)->ExtendedSize;\r
+  } else {\r
+    return GetLength(FfsHeader->Size);\r
+  }\r
+}\r
+\r
+UINT32\r
+GetSectionFileLength (\r
+  EFI_COMMON_SECTION_HEADER *SectionHeader\r
+  )\r
+{\r
+  UINT32 Length;\r
+  if (SectionHeader == NULL) {\r
+    return 0;\r
+  }\r
+  Length = GetLength(SectionHeader->Size);\r
+  if (Length == 0xffffff) {\r
+    Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;\r
+  }\r
+  return Length;\r
+}\r
+\r

 UINT32\r
 GetLength (\r
   UINT8     *ThreeByteLength\r
 UINT32\r
 GetLength (\r
   UINT8     *ThreeByteLength\r

diff --git a/BaseTools/Source/C/Common/FvLib.h b/BaseTools/Source/C/Common/FvLib.h
index 7815baae3ffa7513cffbfe0d5bbfefe404389762..567430a3780e0d9ee455270396fc282bd8ec0ce1 100644 (file)
--- a/BaseTools/Source/C/Common/FvLib.h
+++ b/BaseTools/Source/C/Common/FvLib.h
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2004 - 2008, 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
 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


@@ -90,6 +90,30 @@ VerifyFfsFile (
   )\r
 ;\r
 \r
   )\r
 ;\r
 \r

+UINT32\r
+GetFfsFileLength (\r
+  EFI_FFS_FILE_HEADER *FfsHeader\r
+  )\r
+;\r
+\r
+UINT32\r
+GetSectionFileLength (\r
+  EFI_COMMON_SECTION_HEADER *SectionHeader\r
+  )\r
+;\r
+\r
+UINT32\r
+GetFfsHeaderLength(\r
+   IN EFI_FFS_FILE_HEADER *FfsHeader\r
+   )\r
+;\r
+\r
+UINT32\r
+GetSectionHeaderLength(\r
+   IN EFI_COMMON_SECTION_HEADER *SectionHeader\r
+   )\r
+;\r
+\r

 /*++\r
 \r
 Routine Description:\r
 /*++\r
 \r
 Routine Description:\r

diff --git a/BaseTools/Source/C/GenFfs/GenFfs.c b/BaseTools/Source/C/GenFfs/GenFfs.c
index 24081ebfc44e8ac1765ac2062a25ca84fe5d4964..6f4804e90a0aa554e0d3f6011b728f42b8f6eabe 100644 (file)
--- a/BaseTools/Source/C/GenFfs/GenFfs.c
+++ b/BaseTools/Source/C/GenFfs/GenFfs.c
@@ -1,6 +1,6 @@
 /**\r
 \r
 /**\r
 \r

-Copyright (c) 2004 - 2010, 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
 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


@@ -119,7 +119,7 @@ Returns:
   //\r
   // Copyright declaration\r
   // \r
   //\r
   // Copyright declaration\r
   // \r

-  fprintf (stdout, "Copyright (c) 2007 - 2010, 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
   //\r
   // Details Option\r


@@ -284,10 +284,11 @@ Returns:
   UINT32                     Index;\r
   FILE                       *InFile;\r
   EFI_COMMON_SECTION_HEADER  *SectHeader;\r
   UINT32                     Index;\r
   FILE                       *InFile;\r
   EFI_COMMON_SECTION_HEADER  *SectHeader;\r

-  EFI_COMMON_SECTION_HEADER  TempSectHeader;\r
+  EFI_COMMON_SECTION_HEADER2 TempSectHeader;\r

   EFI_TE_IMAGE_HEADER        TeHeader;\r
   UINT32                     TeOffset;\r
   EFI_GUID_DEFINED_SECTION   GuidSectHeader;\r
   EFI_TE_IMAGE_HEADER        TeHeader;\r
   UINT32                     TeOffset;\r
   EFI_GUID_DEFINED_SECTION   GuidSectHeader;\r

+  EFI_GUID_DEFINED_SECTION2  GuidSectHeader2;\r

   UINT32                     HeaderSize;\r
 \r
   Size          = 0;\r
   UINT32                     HeaderSize;\r
 \r
   Size          = 0;\r


@@ -332,8 +333,12 @@ Returns:
     // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.\r
     //\r
     TeOffset = 0;\r
     // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.\r
     //\r
     TeOffset = 0;\r

-    HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);\r
-    fread (&TempSectHeader, 1, sizeof (TempSectHeader), InFile);\r
+    if (FileSize >= MAX_FFS_SIZE) {\r
+      HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);\r
+    } else {\r
+      HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);\r
+    }\r
+    fread (&TempSectHeader, 1, HeaderSize, InFile);\r

     if (TempSectHeader.Type == EFI_SECTION_TE) {\r
       (*PESectionNum) ++;\r
       fread (&TeHeader, 1, sizeof (TeHeader), InFile);\r
     if (TempSectHeader.Type == EFI_SECTION_TE) {\r
       (*PESectionNum) ++;\r
       fread (&TeHeader, 1, sizeof (TeHeader), InFile);\r


@@ -344,9 +349,16 @@ Returns:
       (*PESectionNum) ++;\r
     } else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {\r
       fseek (InFile, 0, SEEK_SET);\r
       (*PESectionNum) ++;\r
     } else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {\r
       fseek (InFile, 0, SEEK_SET);\r

-      fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);\r
-      if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
-        HeaderSize = GuidSectHeader.DataOffset;\r
+      if (FileSize >= MAX_SECTION_SIZE) {\r
+        fread (&GuidSectHeader2, 1, sizeof (GuidSectHeader2), InFile);\r
+        if ((GuidSectHeader2.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
+          HeaderSize = GuidSectHeader2.DataOffset;\r
+        }\r
+      } else {\r
+        fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);\r
+        if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
+          HeaderSize = GuidSectHeader.DataOffset;\r
+        }\r

       }\r
       (*PESectionNum) ++;\r
     } else if (TempSectHeader.Type == EFI_SECTION_COMPRESSION || \r
       }\r
       (*PESectionNum) ++;\r
     } else if (TempSectHeader.Type == EFI_SECTION_COMPRESSION || \r


@@ -378,6 +390,9 @@ Returns:
       Offset = Offset - Size - HeaderSize - TeOffset;\r
        \r
       if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {\r
       Offset = Offset - Size - HeaderSize - TeOffset;\r
        \r
       if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {\r

+        //\r
+        // The maximal alignment is 64K, the raw section size must be less than 0xffffff\r
+        //\r

         memset (FileBuffer + Size, 0, Offset);\r
         SectHeader          = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);\r
         SectHeader->Type    = EFI_SECTION_RAW;\r
         memset (FileBuffer + Size, 0, Offset);\r
         SectHeader          = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);\r
         SectHeader->Type    = EFI_SECTION_RAW;\r


@@ -453,11 +468,12 @@ Returns:
   UINT8                   *FileBuffer;\r
   UINT32                  FileSize;\r
   UINT32                  MaxAlignment;\r
   UINT8                   *FileBuffer;\r
   UINT32                  FileSize;\r
   UINT32                  MaxAlignment;\r

-  EFI_FFS_FILE_HEADER     FfsFileHeader;\r
+  EFI_FFS_FILE_HEADER2    FfsFileHeader;\r

   FILE                    *FfsFile;\r
   UINT32                  Index;\r
   UINT64                  LogLevel;\r
   UINT8                   PeSectionNum;\r
   FILE                    *FfsFile;\r
   UINT32                  Index;\r
   UINT64                  LogLevel;\r
   UINT8                   PeSectionNum;\r

+  UINT32                  HeaderSize;\r

   \r
   //\r
   // Init local variables\r
   \r
   //\r
   // Init local variables\r


@@ -816,7 +832,7 @@ Returns:
   //\r
   // Create Ffs file header.\r
   //\r
   //\r
   // Create Ffs file header.\r
   //\r

-  memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER));\r
+  memset (&FfsFileHeader, 0, sizeof (EFI_FFS_FILE_HEADER2));\r

   memcpy (&FfsFileHeader.Name, &FileGuid, sizeof (EFI_GUID));\r
   FfsFileHeader.Type       = FfsFiletype;\r
   //\r
   memcpy (&FfsFileHeader.Name, &FileGuid, sizeof (EFI_GUID));\r
   FfsFileHeader.Type       = FfsFiletype;\r
   //\r


@@ -832,16 +848,27 @@ Returns:
     FfsAlign = Index;\r
   }\r
   VerboseMsg ("the alignment of the generated FFS file is %u", (unsigned) mFfsValidAlign [FfsAlign + 1]);  \r
     FfsAlign = Index;\r
   }\r
   VerboseMsg ("the alignment of the generated FFS file is %u", (unsigned) mFfsValidAlign [FfsAlign + 1]);  \r

-  FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));\r

   \r
   //\r
   // Now FileSize includes the EFI_FFS_FILE_HEADER\r
   //\r
   \r
   //\r
   // Now FileSize includes the EFI_FFS_FILE_HEADER\r
   //\r

-  FileSize += sizeof (EFI_FFS_FILE_HEADER);\r
+  if (FileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {\r
+    HeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+    FileSize += sizeof (EFI_FFS_FILE_HEADER2);\r
+    FfsFileHeader.ExtendedSize = FileSize;\r
+    memset(FfsFileHeader.Size, 0, sizeof (UINT8) * 3);\r
+    FfsAttrib |= FFS_ATTRIB_LARGE_FILE;\r
+  } else {\r
+    HeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+    FileSize += sizeof (EFI_FFS_FILE_HEADER);\r
+    FfsFileHeader.Size[0]  = (UINT8) (FileSize & 0xFF);\r
+    FfsFileHeader.Size[1]  = (UINT8) ((FileSize & 0xFF00) >> 8);\r
+    FfsFileHeader.Size[2]  = (UINT8) ((FileSize & 0xFF0000) >> 16);\r
+  }\r

   VerboseMsg ("the size of the generated FFS file is %u bytes", (unsigned) FileSize);\r
   VerboseMsg ("the size of the generated FFS file is %u bytes", (unsigned) FileSize);\r

-  FfsFileHeader.Size[0]  = (UINT8) (FileSize & 0xFF);\r
-  FfsFileHeader.Size[1]  = (UINT8) ((FileSize & 0xFF00) >> 8);\r
-  FfsFileHeader.Size[2]  = (UINT8) ((FileSize & 0xFF0000) >> 16);\r
+\r
+  FfsFileHeader.Attributes = (EFI_FFS_FILE_ATTRIBUTES) (FfsAttrib | (FfsAlign << 3));\r
+\r

   //\r
   // Fill in checksums and state, these must be zero for checksumming\r
   //\r
   //\r
   // Fill in checksums and state, these must be zero for checksumming\r
   //\r


@@ -851,7 +878,7 @@ Returns:
   //\r
   FfsFileHeader.IntegrityCheck.Checksum.Header = CalculateChecksum8 (\r
                                                    (UINT8 *) &FfsFileHeader,\r
   //\r
   FfsFileHeader.IntegrityCheck.Checksum.Header = CalculateChecksum8 (\r
                                                    (UINT8 *) &FfsFileHeader,\r

-                                                   sizeof (EFI_FFS_FILE_HEADER)\r
+                                                   HeaderSize\r

                                                    );\r
 \r
   if (FfsFileHeader.Attributes & FFS_ATTRIB_CHECKSUM) {\r
                                                    );\r
 \r
   if (FfsFileHeader.Attributes & FFS_ATTRIB_CHECKSUM) {\r


@@ -860,7 +887,7 @@ Returns:
     //\r
     FfsFileHeader.IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
                                                    FileBuffer, \r
     //\r
     FfsFileHeader.IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
                                                    FileBuffer, \r

-                                                   FileSize - sizeof (EFI_FFS_FILE_HEADER)\r
+                                                   FileSize - HeaderSize\r

                                                    );    \r
   } else {\r
     FfsFileHeader.IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
                                                    );    \r
   } else {\r
     FfsFileHeader.IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r


@@ -880,11 +907,11 @@ Returns:
   //\r
   // write header\r
   //\r
   //\r
   // write header\r
   //\r

-  fwrite (&FfsFileHeader, 1, sizeof (FfsFileHeader), FfsFile);\r
+  fwrite (&FfsFileHeader, 1, HeaderSize, FfsFile);\r

   //\r
   // write data\r
   //\r
   //\r
   // write data\r
   //\r

-  fwrite (FileBuffer, 1, FileSize - sizeof (EFI_FFS_FILE_HEADER), FfsFile);\r
+  fwrite (FileBuffer, 1, FileSize - HeaderSize, FfsFile);\r

 \r
   fclose (FfsFile);\r
 \r
 \r
   fclose (FfsFile);\r
 \r

diff --git a/BaseTools/Source/C/GenFv/GenFv.c b/BaseTools/Source/C/GenFv/GenFv.c
index fa86d009da28a831eb52d1b6a1ad8d8973aae617..8f837d2695f593ebaebd0dcc7184ee6e81704a74 100644 (file)
--- a/BaseTools/Source/C/GenFv/GenFv.c
+++ b/BaseTools/Source/C/GenFv/GenFv.c
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2007 - 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
 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


@@ -42,6 +42,7 @@ Abstract:
 #define UTILITY_MINOR_VERSION 1\r
 \r
 EFI_GUID  mEfiFirmwareFileSystem2Guid = EFI_FIRMWARE_FILE_SYSTEM2_GUID;\r
 #define UTILITY_MINOR_VERSION 1\r
 \r
 EFI_GUID  mEfiFirmwareFileSystem2Guid = EFI_FIRMWARE_FILE_SYSTEM2_GUID;\r

+EFI_GUID  mEfiFirmwareFileSystem3Guid = EFI_FIRMWARE_FILE_SYSTEM3_GUID;\r

 \r
 STATIC\r
 VOID \r
 \r
 STATIC\r
 VOID \r


@@ -96,7 +97,7 @@ Returns:
   //\r
   // Copyright declaration\r
   // \r
   //\r
   // Copyright declaration\r
   // \r

-  fprintf (stdout, "Copyright (c) 2007 - 2010, 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
   //\r
   // Details Option\r


@@ -143,6 +144,8 @@ Returns:
                         Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");\r
   fprintf (stdout, "  --capflag CapFlag     Capsule Reset Flag can be PersistAcrossReset,\n\\r
                         or PopulateSystemTable or InitiateReset or not set\n");\r
                         Its format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n");\r
   fprintf (stdout, "  --capflag CapFlag     Capsule Reset Flag can be PersistAcrossReset,\n\\r
                         or PopulateSystemTable or InitiateReset or not set\n");\r

+  fprintf (stdout, "  --capoemflag CapOEMFlag\n\\r
+                        Capsule OEM Flag is an integer between 0x0000 and 0xffff\n");\r

   fprintf (stdout, "  --capheadsize HeadSize\n\\r
                         HeadSize is one HEX or DEC format value\n\\r
                         HeadSize is required by Capsule Image.\n");                        \r
   fprintf (stdout, "  --capheadsize HeadSize\n\\r
                         HeadSize is one HEX or DEC format value\n\\r
                         HeadSize is required by Capsule Image.\n");                        \r


@@ -439,6 +442,22 @@ Returns:
       continue; \r
     }\r
 \r
       continue; \r
     }\r
 \r

+    if (stricmp (argv[0], "--capoemflag") == 0) {\r
+      if (argv[1] == NULL) {\r
+        Error (NULL, 0, 1003, "Invalid option value", "Capsule OEM flag can't be null");\r
+      }\r
+      Status = AsciiStringToUint64(argv[1], FALSE, &TempNumber);\r
+      if (EFI_ERROR (Status) || TempNumber > 0xffff) {\r
+        Error (NULL, 0, 1003, "Invalid option value", "Capsule OEM flag value must be integer value between 0x0000 and 0xffff");\r
+        return STATUS_ERROR;\r
+      }\r
+      mCapDataInfo.Flags |= TempNumber;\r
+      DebugMsg( NULL, 0, 9, "Capsule OEM Flags", argv[1]);\r
+      argc -= 2;\r
+      argv += 2;\r
+      continue;\r
+    }\r
+\r

     if (stricmp (argv[0], "--capguid") == 0) {\r
       //\r
       // Get the Capsule Guid\r
     if (stricmp (argv[0], "--capguid") == 0) {\r
       //\r
       // Get the Capsule Guid\r

diff --git a/BaseTools/Source/C/GenFv/GenFvInternalLib.c b/BaseTools/Source/C/GenFv/GenFvInternalLib.c
index dd0e9ec3be6ae53dedc4ac863da387d686898a31..d0df4ac13daa80c2e13c3e8d541cec4c969ad5fd 100644 (file)
--- a/BaseTools/Source/C/GenFv/GenFvInternalLib.c
+++ b/BaseTools/Source/C/GenFv/GenFvInternalLib.c
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2004 - 2011, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2004 - 2013, Intel Corporation. All rights reserved.<BR>\r

 Portions Copyright (c) 2011 - 2013, ARM Ltd. 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
 Portions Copyright (c) 2011 - 2013, ARM Ltd. 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


@@ -159,6 +159,7 @@ UINT8                                   m64kRecoveryStartupApDataArray[SIZEOF_ST
 \r
 FV_INFO                     mFvDataInfo;\r
 CAP_INFO                    mCapDataInfo;\r
 \r
 FV_INFO                     mFvDataInfo;\r
 CAP_INFO                    mCapDataInfo;\r

+BOOLEAN                     mIsLargeFfs = FALSE;\r

 \r
 EFI_PHYSICAL_ADDRESS mFvBaseAddress[0x10];\r
 UINT32               mFvBaseAddressNumber = 0;\r
 \r
 EFI_PHYSICAL_ADDRESS mFvBaseAddress[0x10];\r
 UINT32               mFvBaseAddressNumber = 0;\r


@@ -280,6 +281,19 @@ Returns:
     }\r
   }\r
 \r
     }\r
   }\r
 \r

+  //\r
+  // Read weak alignment flag\r
+  //\r
+  Status = FindToken (InfFile, ATTRIBUTES_SECTION_STRING, EFI_FV_WEAK_ALIGNMENT_STRING, 0, Value);\r
+  if (Status == EFI_SUCCESS) {\r
+    if ((strcmp (Value, TRUE_STRING) == 0) || (strcmp (Value, ONE_STRING) == 0)) {\r
+      FvInfo->FvAttributes |= EFI_FVB2_WEAK_ALIGNMENT;\r
+    } else if ((strcmp (Value, FALSE_STRING) != 0) && (strcmp (Value, ZERO_STRING) != 0)) {\r
+      Error (NULL, 0, 2000, "Invalid parameter", "Weak alignment value expected one of TRUE, FALSE, 1 or 0.");\r
+      return EFI_ABORTED;\r
+    }\r
+  }\r
+\r

   //\r
   // Read block maps\r
   //\r
   //\r
   // Read block maps\r
   //\r


@@ -510,7 +524,8 @@ AddPadFile (
   IN OUT MEMORY_FILE  *FvImage,\r
   IN UINT32           DataAlignment,\r
   IN VOID             *FvEnd,\r
   IN OUT MEMORY_FILE  *FvImage,\r
   IN UINT32           DataAlignment,\r
   IN VOID             *FvEnd,\r

-  IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader\r
+  IN EFI_FIRMWARE_VOLUME_EXT_HEADER *ExtHeader,\r
+  IN UINT32           NextFfsSize\r

   )\r
 /*++\r
 \r
   )\r
 /*++\r
 \r


@@ -538,7 +553,10 @@ Returns:
 {\r
   EFI_FFS_FILE_HEADER *PadFile;\r
   UINTN               PadFileSize;\r
 {\r
   EFI_FFS_FILE_HEADER *PadFile;\r
   UINTN               PadFileSize;\r

+  UINT32              NextFfsHeaderSize;\r
+  UINT32              CurFfsHeaderSize;\r

 \r
 \r

+  CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r

   //\r
   // Verify input parameters.\r
   //\r
   //\r
   // Verify input parameters.\r
   //\r


@@ -546,43 +564,45 @@ Returns:
     return EFI_INVALID_PARAMETER;\r
   }\r
 \r
     return EFI_INVALID_PARAMETER;\r
   }\r
 \r

-  //\r
-  // Check if a pad file is necessary\r
-  //\r
-  if ((ExtHeader == NULL) && (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER)) % DataAlignment == 0)) {\r
-    return EFI_SUCCESS;\r
-  }\r
-\r

   //\r
   // Calculate the pad file size\r
   //\r
   //\r
   // Calculate the pad file size\r
   //\r

-  //\r
-  // This is the earliest possible valid offset (current plus pad file header\r
-  // plus the next file header)\r
-  //\r
-  PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + (sizeof (EFI_FFS_FILE_HEADER) * 2);\r

 \r
 \r

-  //\r
-  // Add whatever it takes to get to the next aligned address\r
-  //\r
-  while ((PadFileSize % DataAlignment) != 0) {\r
-    PadFileSize++;\r
-  }\r
-  //\r
-  // Subtract the next file header size\r
-  //\r
-  PadFileSize -= sizeof (EFI_FFS_FILE_HEADER);\r
-\r
-  //\r
-  // Subtract the starting offset to get size\r
-  //\r
-  PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;\r
-  \r

   //\r
   // Append extension header size\r
   //\r
   if (ExtHeader != NULL) {\r
   //\r
   // Append extension header size\r
   //\r
   if (ExtHeader != NULL) {\r

-    PadFileSize = PadFileSize + ExtHeader->ExtHeaderSize;\r
+    PadFileSize = ExtHeader->ExtHeaderSize;\r
+    if (PadFileSize + sizeof (EFI_FFS_FILE_HEADER) >= MAX_FFS_SIZE) {\r
+      CurFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+    }\r
+    PadFileSize += CurFfsHeaderSize;\r
+  } else {\r
+    NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER);\r
+    if (NextFfsSize >= MAX_FFS_SIZE) {\r
+      NextFfsHeaderSize = sizeof (EFI_FFS_FILE_HEADER2);\r
+    }\r
+    //\r
+    // Check if a pad file is necessary\r
+    //\r
+    if (((UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + NextFfsHeaderSize) % DataAlignment == 0) {\r
+      return EFI_SUCCESS;\r
+    }\r
+    PadFileSize = (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage + sizeof (EFI_FFS_FILE_HEADER) + NextFfsHeaderSize;\r
+    //\r
+    // Add whatever it takes to get to the next aligned address\r
+    //\r
+    while ((PadFileSize % DataAlignment) != 0) {\r
+      PadFileSize++;\r
+    }\r
+    //\r
+    // Subtract the next file header size\r
+    //\r
+    PadFileSize -= NextFfsHeaderSize;\r
+    //\r
+    // Subtract the starting offset to get size\r
+    //\r
+    PadFileSize -= (UINTN) FvImage->CurrentFilePointer - (UINTN) FvImage->FileImage;\r

   }\r
 \r
   //\r
   }\r
 \r
   //\r


@@ -606,9 +626,15 @@ Returns:
   //\r
   // Write pad file size (calculated size minus next file header size)\r
   //\r
   //\r
   // Write pad file size (calculated size minus next file header size)\r
   //\r

-  PadFile->Size[0]  = (UINT8) (PadFileSize & 0xFF);\r
-  PadFile->Size[1]  = (UINT8) ((PadFileSize >> 8) & 0xFF);\r
-  PadFile->Size[2]  = (UINT8) ((PadFileSize >> 16) & 0xFF);\r
+  if (PadFileSize >= MAX_FFS_SIZE) {\r
+    memset(PadFile->Size, 0, sizeof(UINT8) * 3);\r
+    ((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = PadFileSize;\r
+    PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+  } else {\r
+    PadFile->Size[0]  = (UINT8) (PadFileSize & 0xFF);\r
+    PadFile->Size[1]  = (UINT8) ((PadFileSize >> 8) & 0xFF);\r
+    PadFile->Size[2]  = (UINT8) ((PadFileSize >> 16) & 0xFF);\r
+  }\r

 \r
   //\r
   // Fill in checksums and state, they must be 0 for checksumming.\r
 \r
   //\r
   // Fill in checksums and state, they must be 0 for checksumming.\r


@@ -616,7 +642,7 @@ Returns:
   PadFile->IntegrityCheck.Checksum.Header = 0;\r
   PadFile->IntegrityCheck.Checksum.File   = 0;\r
   PadFile->State                          = 0;\r
   PadFile->IntegrityCheck.Checksum.Header = 0;\r
   PadFile->IntegrityCheck.Checksum.File   = 0;\r
   PadFile->State                          = 0;\r

-  PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));\r
+  PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, CurFfsHeaderSize);\r

   PadFile->IntegrityCheck.Checksum.File   = FFS_FIXED_CHECKSUM;\r
 \r
   PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
   PadFile->IntegrityCheck.Checksum.File   = FFS_FIXED_CHECKSUM;\r
 \r
   PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r


@@ -634,8 +660,8 @@ Returns:
     //\r
     // Copy Fv Extension Header and Set Fv Extension header offset\r
     //\r
     //\r
     // Copy Fv Extension Header and Set Fv Extension header offset\r
     //\r

-    memcpy (PadFile + 1, ExtHeader, ExtHeader->ExtHeaderSize);\r
-    ((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) (PadFile + 1) - (UINTN) FvImage->FileImage);\r
+    memcpy ((UINT8 *)PadFile + CurFfsHeaderSize, ExtHeader, ExtHeader->ExtHeaderSize);\r
+    ((EFI_FIRMWARE_VOLUME_HEADER *) FvImage->FileImage)->ExtHeaderOffset = (UINT16) ((UINTN) ((UINT8 *)PadFile + CurFfsHeaderSize) - (UINTN) FvImage->FileImage);\r

          //\r
          // Make next file start at QWord Boundry\r
          //\r
          //\r
          // Make next file start at QWord Boundry\r
          //\r


@@ -1078,7 +1104,7 @@ Returns:
       //\r
       // Sanity check. The file MUST align appropriately\r
       //\r
       //\r
       // Sanity check. The file MUST align appropriately\r
       //\r

-      if (((UINTN) *VtfFileImage + sizeof (EFI_FFS_FILE_HEADER) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {\r
+      if (((UINTN) *VtfFileImage + GetFfsHeaderLength((EFI_FFS_FILE_HEADER *)FileBuffer) - (UINTN) FvImage->FileImage) % (1 << CurrentFileAlignment)) {\r

         Error (NULL, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment));\r
         free (FileBuffer);\r
         return EFI_ABORTED;\r
         Error (NULL, 0, 3000, "Invalid", "VTF file cannot be aligned on a %u-byte boundary.", (unsigned) (1 << CurrentFileAlignment));\r
         free (FileBuffer);\r
         return EFI_ABORTED;\r


@@ -1116,7 +1142,7 @@ Returns:
   //\r
   // Add pad file if necessary\r
   //\r
   //\r
   // Add pad file if necessary\r
   //\r

-  Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL);\r
+  Status = AddPadFile (FvImage, 1 << CurrentFileAlignment, *VtfFileImage, NULL, FileSize);\r

   if (EFI_ERROR (Status)) {\r
     Error (NULL, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");\r
     free (FileBuffer);\r
   if (EFI_ERROR (Status)) {\r
     Error (NULL, 0, 4002, "Resource", "FV space is full, could not add pad file for data alignment property.");\r
     free (FileBuffer);\r


@@ -1190,6 +1216,7 @@ Returns:
 {\r
   EFI_FFS_FILE_HEADER *PadFile;\r
   UINTN               FileSize;\r
 {\r
   EFI_FFS_FILE_HEADER *PadFile;\r
   UINTN               FileSize;\r

+  UINT32              FfsHeaderSize;\r

 \r
   //\r
   // If there is no VTF or the VTF naturally follows the previous file without a\r
 \r
   //\r
   // If there is no VTF or the VTF naturally follows the previous file without a\r


@@ -1219,9 +1246,18 @@ Returns:
   // FileSize includes the EFI_FFS_FILE_HEADER\r
   //\r
   FileSize          = (UINTN) VtfFileImage - (UINTN) FvImage->CurrentFilePointer;\r
   // FileSize includes the EFI_FFS_FILE_HEADER\r
   //\r
   FileSize          = (UINTN) VtfFileImage - (UINTN) FvImage->CurrentFilePointer;\r

-  PadFile->Size[0]  = (UINT8) (FileSize & 0x000000FF);\r
-  PadFile->Size[1]  = (UINT8) ((FileSize & 0x0000FF00) >> 8);\r
-  PadFile->Size[2]  = (UINT8) ((FileSize & 0x00FF0000) >> 16);\r
+  if (FileSize >= MAX_FFS_SIZE) {\r
+    PadFile->Attributes |= FFS_ATTRIB_LARGE_FILE;\r
+    memset(PadFile->Size, 0, sizeof(UINT8) * 3);\r
+    ((EFI_FFS_FILE_HEADER2 *)PadFile)->ExtendedSize = FileSize;\r
+    FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);\r
+    mIsLargeFfs = TRUE;\r
+  } else {\r
+    PadFile->Size[0]  = (UINT8) (FileSize & 0x000000FF);\r
+    PadFile->Size[1]  = (UINT8) ((FileSize & 0x0000FF00) >> 8);\r
+    PadFile->Size[2]  = (UINT8) ((FileSize & 0x00FF0000) >> 16);\r
+    FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);\r
+  }\r

 \r
   //\r
   // Fill in checksums and state, must be zero during checksum calculation.\r
 \r
   //\r
   // Fill in checksums and state, must be zero during checksum calculation.\r


@@ -1229,7 +1265,7 @@ Returns:
   PadFile->IntegrityCheck.Checksum.Header = 0;\r
   PadFile->IntegrityCheck.Checksum.File   = 0;\r
   PadFile->State                          = 0;\r
   PadFile->IntegrityCheck.Checksum.Header = 0;\r
   PadFile->IntegrityCheck.Checksum.File   = 0;\r
   PadFile->State                          = 0;\r

-  PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, sizeof (EFI_FFS_FILE_HEADER));\r
+  PadFile->IntegrityCheck.Checksum.Header = CalculateChecksum8 ((UINT8 *) PadFile, FfsHeaderSize);\r

   PadFile->IntegrityCheck.Checksum.File   = FFS_FIXED_CHECKSUM;\r
 \r
   PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r
   PadFile->IntegrityCheck.Checksum.File   = FFS_FIXED_CHECKSUM;\r
 \r
   PadFile->State = EFI_FILE_HEADER_CONSTRUCTION | EFI_FILE_HEADER_VALID | EFI_FILE_DATA_VALID;\r


@@ -1297,6 +1333,8 @@ Returns:
   UINT64                    FitAddress;\r
   FIT_TABLE                 *FitTablePtr;\r
   BOOLEAN                   Vtf0Detected;\r
   UINT64                    FitAddress;\r
   FIT_TABLE                 *FitTablePtr;\r
   BOOLEAN                   Vtf0Detected;\r

+  UINT32                    FfsHeaderSize;\r
+  UINT32                    SecHeaderSize;\r

 \r
   //\r
   // Verify input parameters\r
 \r
   //\r
   // Verify input parameters\r


@@ -1359,8 +1397,9 @@ Returns:
     return EFI_ABORTED;\r
   }\r
 \r
     return EFI_ABORTED;\r
   }\r
 \r

+  SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);\r

   Status = GetPe32Info (\r
   Status = GetPe32Info (\r

-            (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+            (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),\r

             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r
             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r


@@ -1388,7 +1427,7 @@ Returns:
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   SecCorePhysicalAddress = FvInfo->BaseAddress;\r
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   SecCorePhysicalAddress = FvInfo->BaseAddress;\r

-  SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+  SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;\r

   SecCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
 \r
   SecCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
 \r


@@ -1413,8 +1452,9 @@ Returns:
     return EFI_ABORTED;\r
   }\r
 \r
     return EFI_ABORTED;\r
   }\r
 \r

+  SecHeaderSize = GetSectionHeaderLength(Pe32Section.CommonHeader);\r

   Status = GetPe32Info (\r
   Status = GetPe32Info (\r

-            (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+            (VOID *) ((UINTN) Pe32Section.Pe32Section + SecHeaderSize),\r

             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r
             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r


@@ -1428,7 +1468,7 @@ Returns:
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   PeiCorePhysicalAddress = FvInfo->BaseAddress;\r

-  PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+  PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + SecHeaderSize - (UINTN) FvImage->FileImage;\r

   PeiCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
 \r
   PeiCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
 \r


@@ -1598,9 +1638,10 @@ Returns:
   VtfFile->IntegrityCheck.Checksum.File = 0;\r
   VtfFile->State                        = 0;\r
   if (VtfFile->Attributes & FFS_ATTRIB_CHECKSUM) {\r
   VtfFile->IntegrityCheck.Checksum.File = 0;\r
   VtfFile->State                        = 0;\r
   if (VtfFile->Attributes & FFS_ATTRIB_CHECKSUM) {\r

+    FfsHeaderSize = GetFfsHeaderLength(VtfFile);\r

     VtfFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
     VtfFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r

-                                              (UINT8 *) (VtfFile + 1),\r
-                                              GetLength (VtfFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+                                              (UINT8 *) ((UINT8 *)VtfFile + FfsHeaderSize),\r
+                                              GetFfsFileLength (VtfFile) - FfsHeaderSize\r

                                               );\r
   } else {\r
     VtfFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r
                                               );\r
   } else {\r
     VtfFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM;\r


@@ -1720,7 +1761,7 @@ Returns:
       }\r
     \r
       Status = GetPe32Info (\r
       }\r
     \r
       Status = GetPe32Info (\r

-                (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+                (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r

                 &EntryPoint,\r
                 &BaseOfCode,\r
                 &MachineType\r
                 &EntryPoint,\r
                 &BaseOfCode,\r
                 &MachineType\r


@@ -1734,7 +1775,7 @@ Returns:
       // Physical address is FV base + offset of PE32 + offset of the entry point\r
       //\r
       PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
       // Physical address is FV base + offset of PE32 + offset of the entry point\r
       //\r
       PeiCorePhysicalAddress = FvInfo->BaseAddress;\r

-      PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+      PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r

       PeiCorePhysicalAddress += EntryPoint;\r
       DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
 \r
       PeiCorePhysicalAddress += EntryPoint;\r
       DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
 \r


@@ -1768,7 +1809,7 @@ Returns:
   }\r
 \r
   Status = GetPe32Info (\r
   }\r
 \r
   Status = GetPe32Info (\r

-            (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+            (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r

             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r
             &EntryPoint,\r
             &BaseOfCode,\r
             &MachineType\r


@@ -1789,7 +1830,7 @@ Returns:
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   SecCorePhysicalAddress = FvInfo->BaseAddress;\r
   // Physical address is FV base + offset of PE32 + offset of the entry point\r
   //\r
   SecCorePhysicalAddress = FvInfo->BaseAddress;\r

-  SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+  SecCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r

   SecCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
 \r
   SecCorePhysicalAddress += EntryPoint;\r
   DebugMsg (NULL, 0, 9, "SecCore physical entry point address", "Address = 0x%llX", (unsigned long long) SecCorePhysicalAddress); \r
 \r


@@ -1813,7 +1854,7 @@ Returns:
     }\r
   \r
     Status = GetPe32Info (\r
     }\r
   \r
     Status = GetPe32Info (\r

-              (VOID *) ((UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32)),\r
+              (VOID *) ((UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader)),\r

               &EntryPoint,\r
               &BaseOfCode,\r
               &MachineType\r
               &EntryPoint,\r
               &BaseOfCode,\r
               &MachineType\r


@@ -1827,7 +1868,7 @@ Returns:
     // Physical address is FV base + offset of PE32 + offset of the entry point\r
     //\r
     PeiCorePhysicalAddress = FvInfo->BaseAddress;\r
     // Physical address is FV base + offset of PE32 + offset of the entry point\r
     //\r
     PeiCorePhysicalAddress = FvInfo->BaseAddress;\r

-    PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + sizeof (EFI_SECTION_PE32) - (UINTN) FvImage->FileImage;\r
+    PeiCorePhysicalAddress += (UINTN) Pe32Section.Pe32Section + GetSectionHeaderLength(Pe32Section.CommonHeader) - (UINTN) FvImage->FileImage;\r

     PeiCorePhysicalAddress += EntryPoint;\r
     DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
   }\r
     PeiCorePhysicalAddress += EntryPoint;\r
     DebugMsg (NULL, 0, 9, "PeiCore physical entry point address", "Address = 0x%llX", (unsigned long long) PeiCorePhysicalAddress);\r
   }\r


@@ -2344,7 +2385,7 @@ Returns:
     //\r
     // Add FV Extended Header contents to the FV as a PAD file\r
     //\r
     //\r
     // Add FV Extended Header contents to the FV as a PAD file\r
     //\r

-    AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader);\r
+    AddPadFile (&FvImageMemoryFile, 4, VtfFileImage, FvExtHeader, 0);\r

 \r
     //\r
     // Fv Extension header change update Fv Header Check sum\r
 \r
     //\r
     // Fv Extension header change update Fv Header Check sum\r


@@ -2419,7 +2460,8 @@ Returns:
   //\r
   // Update FV Alignment attribute to the largest alignment of all the FFS files in the FV\r
   //\r
   //\r
   // Update FV Alignment attribute to the largest alignment of all the FFS files in the FV\r
   //\r

-  if ((((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {\r
+  if (((FvHeader->Attributes & EFI_FVB2_WEAK_ALIGNMENT) != EFI_FVB2_WEAK_ALIGNMENT) &&\r
+      (((FvHeader->Attributes & EFI_FVB2_ALIGNMENT) >> 16)) < MaxFfsAlignment) {\r

     FvHeader->Attributes = ((MaxFfsAlignment << 16) | (FvHeader->Attributes & 0xFFFF));\r
     //\r
     // Update Checksum for FvHeader\r
     FvHeader->Attributes = ((MaxFfsAlignment << 16) | (FvHeader->Attributes & 0xFFFF));\r
     //\r
     // Update Checksum for FvHeader\r


@@ -2428,6 +2470,15 @@ Returns:
     FvHeader->Checksum      = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));\r
   }\r
 \r
     FvHeader->Checksum      = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));\r
   }\r
 \r

+  //\r
+  // If there are large FFS in FV, the file system GUID should set to system 3 GUID.\r
+  //\r
+  if (mIsLargeFfs && CompareGuid (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem2Guid) == 0) {\r
+    memcpy (&FvHeader->FileSystemGuid, &mEfiFirmwareFileSystem3Guid, sizeof (EFI_GUID));\r
+    FvHeader->Checksum      = 0;\r
+    FvHeader->Checksum      = CalculateChecksum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));\r
+  }\r
+\r

 WriteFile: \r
   //\r
   // Write fv file\r
 WriteFile: \r
   //\r
   // Write fv file\r


@@ -2564,6 +2615,7 @@ Returns:
   UINTN               FfsFileSize;\r
   UINTN               FvExtendHeaderSize;\r
   UINT32              FfsAlignment;\r
   UINTN               FfsFileSize;\r
   UINTN               FvExtendHeaderSize;\r
   UINT32              FfsAlignment;\r

+  UINT32              FfsHeaderSize;\r

   EFI_FFS_FILE_HEADER FfsHeader;\r
   BOOLEAN             VtfFileFlag;\r
   UINTN               VtfFileSize;\r
   EFI_FFS_FILE_HEADER FfsHeader;\r
   BOOLEAN             VtfFileFlag;\r
   UINTN               VtfFileSize;\r


@@ -2605,7 +2657,12 @@ Returns:
     }\r
     FvExtendHeaderSize = _filelength (fileno (fpin));\r
     fclose (fpin);\r
     }\r
     FvExtendHeaderSize = _filelength (fileno (fpin));\r
     fclose (fpin);\r

-    CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;\r
+    if (sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize >= MAX_FFS_SIZE) {\r
+      CurrentOffset += sizeof (EFI_FFS_FILE_HEADER2) + FvExtendHeaderSize;\r
+      mIsLargeFfs = TRUE;\r
+    } else {\r
+      CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + FvExtendHeaderSize;\r
+    }\r

     CurrentOffset = (CurrentOffset + 7) & (~7);\r
   } else if (mFvDataInfo.FvNameGuidSet) {\r
     CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);\r
     CurrentOffset = (CurrentOffset + 7) & (~7);\r
   } else if (mFvDataInfo.FvNameGuidSet) {\r
     CurrentOffset += sizeof (EFI_FFS_FILE_HEADER) + sizeof (EFI_FIRMWARE_VOLUME_EXT_HEADER);\r


@@ -2629,6 +2686,12 @@ Returns:
     // Get the file size\r
     //\r
     FfsFileSize = _filelength (fileno (fpin));\r
     // Get the file size\r
     //\r
     FfsFileSize = _filelength (fileno (fpin));\r

+    if (FfsFileSize >= MAX_FFS_SIZE) {\r
+      FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER2);\r
+      mIsLargeFfs = TRUE;\r
+    } else {\r
+      FfsHeaderSize = sizeof(EFI_FFS_FILE_HEADER);\r
+    }\r

     //\r
     // Read Ffs File header\r
     //\r
     //\r
     // Read Ffs File header\r
     //\r


@@ -2662,9 +2725,12 @@ Returns:
       //\r
       // Add Pad file\r
       //\r
       //\r
       // Add Pad file\r
       //\r

-      if (((CurrentOffset + sizeof (EFI_FFS_FILE_HEADER)) % FfsAlignment) != 0) {\r
-        CurrentOffset = (CurrentOffset + sizeof (EFI_FFS_FILE_HEADER) * 2 + FfsAlignment - 1) & ~(FfsAlignment - 1);\r
-        CurrentOffset -= sizeof (EFI_FFS_FILE_HEADER);\r
+      if (((CurrentOffset + FfsHeaderSize) % FfsAlignment) != 0) {\r
+        //\r
+        // Only EFI_FFS_FILE_HEADER is needed for a pad section.\r
+        //\r
+        CurrentOffset = (CurrentOffset + FfsHeaderSize + sizeof(EFI_FFS_FILE_HEADER) + FfsAlignment - 1) & ~(FfsAlignment - 1);\r
+        CurrentOffset -= FfsHeaderSize;\r

       }\r
          }\r
 \r
       }\r
          }\r
 \r


@@ -2792,7 +2858,7 @@ Returns:
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r

-    SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + sizeof (EFI_FIRMWARE_VOLUME_IMAGE_SECTION));\r
+    SubFvImageHeader = (EFI_FIRMWARE_VOLUME_HEADER *) ((UINT8 *) SubFvSection.FVImageSection + GetSectionHeaderLength(SubFvSection.FVImageSection));\r

     //\r
     // Rebase on Flash\r
     //\r
     //\r
     // Rebase on Flash\r
     //\r


@@ -2854,6 +2920,8 @@ Returns:
   UINT8                                 *PeFileBuffer;\r
   UINT32                                PeFileSize;\r
   CHAR8                                 *PdbPointer;\r
   UINT8                                 *PeFileBuffer;\r
   UINT32                                PeFileSize;\r
   CHAR8                                 *PdbPointer;\r

+  UINT32                                FfsHeaderSize;\r
+  UINT32                                CurSecHdrSize;\r

 \r
   Index              = 0;  \r
   MemoryImagePointer = NULL;\r
 \r
   Index              = 0;  \r
   MemoryImagePointer = NULL;\r


@@ -2905,6 +2973,8 @@ Returns:
     default:\r
       return EFI_SUCCESS;\r
   }\r
     default:\r
       return EFI_SUCCESS;\r
   }\r

+\r
+  FfsHeaderSize = GetFfsHeaderLength(FfsFile);\r

   //\r
   // Rebase each PE32 section\r
   //\r
   //\r
   // Rebase each PE32 section\r
   //\r


@@ -2922,12 +2992,13 @@ Returns:
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r

+    CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);\r

 \r
     //\r
     // Initialize context\r
     //\r
     memset (&ImageContext, 0, sizeof (ImageContext));\r
 \r
     //\r
     // Initialize context\r
     //\r
     memset (&ImageContext, 0, sizeof (ImageContext));\r

-    ImageContext.Handle     = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION));\r
+    ImageContext.Handle     = (VOID *) ((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize);\r

     ImageContext.ImageRead  = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;\r
     Status                  = PeCoffLoaderGetImageInfo (&ImageContext);\r
     if (EFI_ERROR (Status)) {\r
     ImageContext.ImageRead  = (PE_COFF_LOADER_READ_FILE) FfsRebaseImageRead;\r
     Status                  = PeCoffLoaderGetImageInfo (&ImageContext);\r
     if (EFI_ERROR (Status)) {\r


@@ -2953,7 +3024,7 @@ Returns:
     //\r
     // Get PeHeader pointer\r
     //\r
     //\r
     // Get PeHeader pointer\r
     //\r

-    ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) + ImageContext.PeCoffHeaderOffset);\r
+    ImgHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize + ImageContext.PeCoffHeaderOffset);\r

 \r
     //\r
     // Calculate the PE32 base address, based on file type\r
 \r
     //\r
     // Calculate the PE32 base address, based on file type\r


@@ -3030,7 +3101,7 @@ Returns:
           ImageContext.RelocationsStripped = FALSE;\r
         }\r
 \r
           ImageContext.RelocationsStripped = FALSE;\r
         }\r
 \r

-        NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;\r
+        NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;\r

         break;\r
 \r
       case EFI_FV_FILETYPE_DRIVER:\r
         break;\r
 \r
       case EFI_FV_FILETYPE_DRIVER:\r


@@ -3045,7 +3116,7 @@ Returns:
           Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);\r
           return EFI_ABORTED;\r
         }\r
           Error (NULL, 0, 3000, "Invalid", "Section-Alignment and File-Alignment do not match : %s.", FileName);\r
           return EFI_ABORTED;\r
         }\r

-        NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + sizeof (EFI_PE32_SECTION) - (UINTN)FfsFile;\r
+        NewPe32BaseAddress = XipBase + (UINTN) CurrentPe32Section.Pe32Section + CurSecHdrSize - (UINTN)FfsFile;\r

         break;\r
 \r
       default:\r
         break;\r
 \r
       default:\r


@@ -3104,7 +3175,7 @@ Returns:
     \r
     for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {\r
       CopyMem (\r
     \r
     for (Index = 0; Index < ImgHdr->Pe32.FileHeader.NumberOfSections; Index ++, SectionHeader ++) {\r
       CopyMem (\r

-        (UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER) + SectionHeader->PointerToRawData, \r
+        (UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize + SectionHeader->PointerToRawData, \r

         (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress), \r
         SectionHeader->SizeOfRawData\r
         );\r
         (VOID*) (UINTN) (ImageContext.ImageAddress + SectionHeader->VirtualAddress), \r
         SectionHeader->SizeOfRawData\r
         );\r


@@ -3140,8 +3211,8 @@ Returns:
       FfsFile->IntegrityCheck.Checksum.File = 0;\r
       FfsFile->State                        = 0;\r
       FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
       FfsFile->IntegrityCheck.Checksum.File = 0;\r
       FfsFile->State                        = 0;\r
       FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r

-                                                (UINT8 *) (FfsFile + 1),\r
-                                                GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+                                                (UINT8 *) ((UINT8 *)FfsFile + FfsHeaderSize),\r
+                                                GetFfsFileLength (FfsFile) - FfsHeaderSize\r

                                                 );\r
       FfsFile->State = SavedState;\r
     }\r
                                                 );\r
       FfsFile->State = SavedState;\r
     }\r


@@ -3185,12 +3256,14 @@ Returns:
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r
     if (EFI_ERROR (Status)) {\r
       break;\r
     }\r

+\r
+    CurSecHdrSize = GetSectionHeaderLength(CurrentPe32Section.CommonHeader);\r

     \r
     //\r
     // Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off\r
     // by GenTEImage\r
     //\r
     \r
     //\r
     // Calculate the TE base address, the FFS file base plus the offset of the TE section less the size stripped off\r
     // by GenTEImage\r
     //\r

-    TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + sizeof (EFI_COMMON_SECTION_HEADER));\r
+    TEImageHeader = (EFI_TE_IMAGE_HEADER *) ((UINT8 *) CurrentPe32Section.Pe32Section + CurSecHdrSize);\r

 \r
     //\r
     // Initialize context, load image info.\r
 \r
     //\r
     // Initialize context, load image info.\r


@@ -3365,8 +3438,8 @@ Returns:
       FfsFile->IntegrityCheck.Checksum.File = 0;\r
       FfsFile->State                        = 0;\r
       FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r
       FfsFile->IntegrityCheck.Checksum.File = 0;\r
       FfsFile->State                        = 0;\r
       FfsFile->IntegrityCheck.Checksum.File = CalculateChecksum8 (\r

-                                                (UINT8 *)(FfsFile + 1),\r
-                                                GetLength (FfsFile->Size) - sizeof (EFI_FFS_FILE_HEADER)\r
+                                                (UINT8 *)((UINT8 *)FfsFile + FfsHeaderSize),\r
+                                                GetFfsFileLength (FfsFile) - FfsHeaderSize\r

                                                 );\r
       FfsFile->State = SavedState;\r
     }\r
                                                 );\r
       FfsFile->State = SavedState;\r
     }\r


@@ -3436,12 +3509,12 @@ Returns:
     //\r
     // Get Pad file size.\r
     //\r
     //\r
     // Get Pad file size.\r
     //\r

-    FileLength = (*(UINT32 *)(PadFile->Size)) & 0x00FFFFFF;\r
+    FileLength = GetFfsFileLength(PadFile);\r

     FileLength = (FileLength + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1); \r
     //\r
     // FixPoint must be align on 0x1000 relative to FvImage Header\r
     //\r
     FileLength = (FileLength + EFI_FFS_FILE_HEADER_ALIGNMENT - 1) & ~(EFI_FFS_FILE_HEADER_ALIGNMENT - 1); \r
     //\r
     // FixPoint must be align on 0x1000 relative to FvImage Header\r
     //\r

-    FixPoint = (UINT8*) PadFile + sizeof (EFI_FFS_FILE_HEADER);\r
+    FixPoint = (UINT8*) PadFile + GetFfsHeaderLength(PadFile);\r

     FixPoint = FixPoint + 0x1000 - (((UINTN) FixPoint - (UINTN) FvImage->FileImage) & 0xFFF);\r
     //\r
     // FixPoint be larger at the last place of one fv image.\r
     FixPoint = FixPoint + 0x1000 - (((UINTN) FixPoint - (UINTN) FvImage->FileImage) & 0xFFF);\r
     //\r
     // FixPoint be larger at the last place of one fv image.\r


@@ -3451,7 +3524,7 @@ Returns:
     }\r
     FixPoint -= 0x1000;\r
     \r
     }\r
     FixPoint -= 0x1000;\r
     \r

-    if ((UINTN) FixPoint < ((UINTN) PadFile + sizeof (EFI_FFS_FILE_HEADER))) {\r
+    if ((UINTN) FixPoint < ((UINTN) PadFile + GetFfsHeaderLength(PadFile))) {\r

       //\r
       // No alignment FixPoint in this Pad File.\r
       //\r
       //\r
       // No alignment FixPoint in this Pad File.\r
       //\r


@@ -3556,6 +3629,19 @@ Returns:
     DebugMsg (NULL, 0, 9, "Capsule Flag", Value);\r
   }\r
 \r
     DebugMsg (NULL, 0, 9, "Capsule Flag", Value);\r
   }\r
 \r

+  Status = FindToken (InfFile, OPTIONS_SECTION_STRING, EFI_OEM_CAPSULE_FLAGS_STRING, 0, Value);\r
+  if (Status == EFI_SUCCESS) {\r
+    Status = AsciiStringToUint64 (Value, FALSE, &Value64);\r
+    if (EFI_ERROR (Status) || Value64 > 0xffff) {\r
+      Error (NULL, 0, 2000, "Invalid parameter",\r
+        "invalid Flag setting for %s. Must be integer value between 0x0000 and 0xffff.",\r
+        EFI_OEM_CAPSULE_FLAGS_STRING);\r
+      return EFI_ABORTED;\r
+    }\r
+    CapInfo->Flags |= Value64;\r
+    DebugMsg (NULL, 0, 9, "Capsule Extend Flag", Value);\r
+  }\r
+\r

   //\r
   // Read Capsule File name\r
   //\r
   //\r
   // Read Capsule File name\r
   //\r

diff --git a/BaseTools/Source/C/GenFv/GenFvInternalLib.h b/BaseTools/Source/C/GenFv/GenFvInternalLib.h
index 40c23600ab8ea58c79bf384df6b8e49e1fc0ccde..21993b5e7be493d081eb8932d5b2c8e49ccc4905 100644 (file)
--- a/BaseTools/Source/C/GenFv/GenFvInternalLib.h
+++ b/BaseTools/Source/C/GenFv/GenFvInternalLib.h
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2004 - 2011, 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
 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


@@ -82,6 +82,7 @@ Abstract:
 #define EFI_CAPSULE_GUID_STRING           "EFI_CAPSULE_GUID"\r
 #define EFI_CAPSULE_HEADER_SIZE_STRING    "EFI_CAPSULE_HEADER_SIZE"\r
 #define EFI_CAPSULE_FLAGS_STRING          "EFI_CAPSULE_FLAGS"\r
 #define EFI_CAPSULE_GUID_STRING           "EFI_CAPSULE_GUID"\r
 #define EFI_CAPSULE_HEADER_SIZE_STRING    "EFI_CAPSULE_HEADER_SIZE"\r
 #define EFI_CAPSULE_FLAGS_STRING          "EFI_CAPSULE_FLAGS"\r

+#define EFI_OEM_CAPSULE_FLAGS_STRING      "EFI_OEM_CAPSULE_FLAGS"\r

 #define EFI_CAPSULE_VERSION_STRING        "EFI_CAPSULE_VERSION"\r
 \r
 #define EFI_FV_TOTAL_SIZE_STRING    "EFI_FV_TOTAL_SIZE"\r
 #define EFI_CAPSULE_VERSION_STRING        "EFI_CAPSULE_VERSION"\r
 \r
 #define EFI_FV_TOTAL_SIZE_STRING    "EFI_FV_TOTAL_SIZE"\r


@@ -144,6 +145,8 @@ Abstract:
 #define EFI_FVB2_ALIGNMENT_1G_STRING      "EFI_FVB2_ALIGNMENT_1G"  \r
 #define EFI_FVB2_ALIGNMENT_2G_STRING      "EFI_FVB2_ALIGNMENT_2G"  \r
 \r
 #define EFI_FVB2_ALIGNMENT_1G_STRING      "EFI_FVB2_ALIGNMENT_1G"  \r
 #define EFI_FVB2_ALIGNMENT_2G_STRING      "EFI_FVB2_ALIGNMENT_2G"  \r
 \r

+#define EFI_FV_WEAK_ALIGNMENT_STRING      "EFI_WEAK_ALIGNMENT"\r
+\r

 //\r
 // File sections\r
 //\r
 //\r
 // File sections\r
 //\r


@@ -259,6 +262,7 @@ typedef struct {
 extern FV_INFO    mFvDataInfo;\r
 extern CAP_INFO   mCapDataInfo;\r
 extern EFI_GUID   mEfiFirmwareFileSystem2Guid;\r
 extern FV_INFO    mFvDataInfo;\r
 extern CAP_INFO   mCapDataInfo;\r
 extern EFI_GUID   mEfiFirmwareFileSystem2Guid;\r

+extern EFI_GUID   mEfiFirmwareFileSystem3Guid;\r

 extern UINT32     mFvTotalSize;\r
 extern UINT32     mFvTakenSize;\r
 \r
 extern UINT32     mFvTotalSize;\r
 extern UINT32     mFvTakenSize;\r
 \r

diff --git a/BaseTools/Source/C/GenFw/Elf32Convert.c b/BaseTools/Source/C/GenFw/Elf32Convert.c
index ddb45acc8677c408e4aa770fb1b03283325586cc..58ac333888dcfdd65ba88c352698a4aa4fc35efa 100644 (file)
--- a/BaseTools/Source/C/GenFw/Elf32Convert.c
+++ b/BaseTools/Source/C/GenFw/Elf32Convert.c
@@ -1,6 +1,7 @@
 /** @file
 
 Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
 /** @file
 
 Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>

+Portions copyright (c) 2013, ARM Ltd. All rights reserved.<BR>

 
 This program and the accompanying materials are licensed and made available
 under the terms and conditions of the BSD License which accompanies this
 
 This program and the accompanying materials are licensed and made available
 under the terms and conditions of the BSD License which accompanies this


@@ -18,6 +19,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <windows.h>
 #include <io.h>
 #endif
 #include <windows.h>
 #include <io.h>
 #endif

+#include <assert.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>


@@ -264,9 +266,12 @@ ScanSections32 (
   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
   UINT32                          CoffEntry;
   UINT32                          SectionCount;
   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
   UINT32                          CoffEntry;
   UINT32                          SectionCount;

+  BOOLEAN                         FoundText;

 
   CoffEntry = 0;
   mCoffOffset = 0;
 
   CoffEntry = 0;
   mCoffOffset = 0;

+  mTextOffset = 0;
+  FoundText = FALSE;

 
   //
   // Coff file start with a DOS header.
 
   //
   // Coff file start with a DOS header.


@@ -291,7 +296,6 @@ ScanSections32 (
   // First text sections.
   //
   mCoffOffset = CoffAlign(mCoffOffset);
   // First text sections.
   //
   mCoffOffset = CoffAlign(mCoffOffset);

-  mTextOffset = mCoffOffset;

   SectionCount = 0;
   for (i = 0; i < mEhdr->e_shnum; i++) {
     Elf_Shdr *shdr = GetShdrByIndex(i);
   SectionCount = 0;
   for (i = 0; i < mEhdr->e_shnum; i++) {
     Elf_Shdr *shdr = GetShdrByIndex(i);


@@ -315,12 +319,26 @@ ScanSections32 (
           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
         CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
       }
           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
         CoffEntry = mCoffOffset + mEhdr->e_entry - shdr->sh_addr;
       }

+
+      //
+      // Set mTextOffset with the offset of the first '.text' section
+      //
+      if (!FoundText) {
+        mTextOffset = mCoffOffset;
+        FoundText = TRUE;
+      }
+

       mCoffSectionsOffset[i] = mCoffOffset;
       mCoffOffset += shdr->sh_size;
       SectionCount ++;
     }
   }
 
       mCoffSectionsOffset[i] = mCoffOffset;
       mCoffOffset += shdr->sh_size;
       SectionCount ++;
     }
   }
 

+  if (!FoundText) {
+    Error (NULL, 0, 3000, "Invalid", "Did not find any '.text' section.");
+    assert (FALSE);
+  }
+

   if (mEhdr->e_machine != EM_ARM) {
     mCoffOffset = CoffAlign(mCoffOffset);
   }
   if (mEhdr->e_machine != EM_ARM) {
     mCoffOffset = CoffAlign(mCoffOffset);
   }

diff --git a/BaseTools/Source/C/GenFw/Elf64Convert.c b/BaseTools/Source/C/GenFw/Elf64Convert.c
index 72d6cd16d786f7e8674888c9da648012cbf6f5a6..713f8f7e4722f2e2bc7f82296554370032eba5f0 100644 (file)
--- a/BaseTools/Source/C/GenFw/Elf64Convert.c
+++ b/BaseTools/Source/C/GenFw/Elf64Convert.c
@@ -19,6 +19,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 #include <windows.h>
 #include <io.h>
 #endif
 #include <windows.h>
 #include <io.h>
 #endif

+#include <assert.h>

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>


@@ -258,9 +259,12 @@ ScanSections64 (
   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
   UINT32                          CoffEntry;
   UINT32                          SectionCount;
   EFI_IMAGE_OPTIONAL_HEADER_UNION *NtHdr;
   UINT32                          CoffEntry;
   UINT32                          SectionCount;

+  BOOLEAN                         FoundText;

 
   CoffEntry = 0;
   mCoffOffset = 0;
 
   CoffEntry = 0;
   mCoffOffset = 0;

+  mTextOffset = 0;
+  FoundText = FALSE;

 
   //
   // Coff file start with a DOS header.
 
   //
   // Coff file start with a DOS header.


@@ -286,7 +290,6 @@ ScanSections64 (
   // First text sections.
   //
   mCoffOffset = CoffAlign(mCoffOffset);
   // First text sections.
   //
   mCoffOffset = CoffAlign(mCoffOffset);

-  mTextOffset = mCoffOffset;

   SectionCount = 0;
   for (i = 0; i < mEhdr->e_shnum; i++) {
     Elf_Shdr *shdr = GetShdrByIndex(i);
   SectionCount = 0;
   for (i = 0; i < mEhdr->e_shnum; i++) {
     Elf_Shdr *shdr = GetShdrByIndex(i);


@@ -310,12 +313,26 @@ ScanSections64 (
           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
         CoffEntry = (UINT32) (mCoffOffset + mEhdr->e_entry - shdr->sh_addr);
       }
           (mEhdr->e_entry < shdr->sh_addr + shdr->sh_size)) {
         CoffEntry = (UINT32) (mCoffOffset + mEhdr->e_entry - shdr->sh_addr);
       }

+
+      //
+      // Set mTextOffset with the offset of the first '.text' section
+      //
+      if (!FoundText) {
+        mTextOffset = mCoffOffset;
+        FoundText = TRUE;
+      }
+

       mCoffSectionsOffset[i] = mCoffOffset;
       mCoffOffset += (UINT32) shdr->sh_size;
       SectionCount ++;
     }
   }
 
       mCoffSectionsOffset[i] = mCoffOffset;
       mCoffOffset += (UINT32) shdr->sh_size;
       SectionCount ++;
     }
   }
 

+  if (!FoundText) {
+    Error (NULL, 0, 3000, "Invalid", "Did not find any '.text' section.");
+    assert (FALSE);
+  }
+

   if (mEhdr->e_machine != EM_ARM) {
     mCoffOffset = CoffAlign(mCoffOffset);
   }
   if (mEhdr->e_machine != EM_ARM) {
     mCoffOffset = CoffAlign(mCoffOffset);
   }

diff --git a/BaseTools/Source/C/GenSec/GenSec.c b/BaseTools/Source/C/GenSec/GenSec.c
index d6b22aee86b7ca9604232b83f985f1df3b8129bf..63e8e13e8fc53da1e2146ff842859e6cc2e6d226 100644 (file)
--- a/BaseTools/Source/C/GenSec/GenSec.c
+++ b/BaseTools/Source/C/GenSec/GenSec.c
@@ -1,6 +1,6 @@
 /** @file\r
 \r
 /** @file\r
 \r

-Copyright (c) 2004 - 2011, 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
 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


@@ -42,8 +42,6 @@ Abstract:
 #define UTILITY_MAJOR_VERSION   0\r
 #define UTILITY_MINOR_VERSION   1\r
 \r
 #define UTILITY_MAJOR_VERSION   0\r
 #define UTILITY_MINOR_VERSION   1\r
 \r

-#define MAX_SECTION_SIZE        0x1000000\r
-\r

 STATIC CHAR8      *mSectionTypeName[] = {\r
   NULL,                                 // 0x00 - reserved\r
   "EFI_SECTION_COMPRESSION",            // 0x01\r
 STATIC CHAR8      *mSectionTypeName[] = {\r
   NULL,                                 // 0x00 - reserved\r
   "EFI_SECTION_COMPRESSION",            // 0x01\r


@@ -94,6 +92,11 @@ typedef struct {
   UINT32                    CRC32Checksum;\r
 } CRC32_SECTION_HEADER;\r
 \r
   UINT32                    CRC32Checksum;\r
 } CRC32_SECTION_HEADER;\r
 \r

+typedef struct {\r
+  EFI_GUID_DEFINED_SECTION2 GuidSectionHeader;\r
+  UINT32                    CRC32Checksum;\r
+} CRC32_SECTION_HEADER2;\r
+\r

 STATIC EFI_GUID  mZeroGuid                 = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};\r
 STATIC EFI_GUID  mEfiCrc32SectionGuid      = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;\r
 \r
 STATIC EFI_GUID  mZeroGuid                 = {0x0, 0x0, 0x0, {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};\r
 STATIC EFI_GUID  mEfiCrc32SectionGuid      = EFI_CRC32_GUIDED_SECTION_EXTRACTION_PROTOCOL_GUID;\r
 \r


@@ -150,7 +153,7 @@ Returns:
   //\r
   // Copyright declaration\r
   // \r
   //\r
   // Copyright declaration\r
   // \r

-  fprintf (stdout, "Copyright (c) 2007 - 2010, 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
   //\r
   // Details Option\r


@@ -184,7 +187,7 @@ Returns:
   fprintf (stdout, "  -n String, --name String\n\\r
                         String is a NULL terminated string used in Ui section.\n");\r
   fprintf (stdout, "  -j Number, --buildnumber Number\n\\r
   fprintf (stdout, "  -n String, --name String\n\\r
                         String is a NULL terminated string used in Ui section.\n");\r
   fprintf (stdout, "  -j Number, --buildnumber Number\n\\r

-                        Number is an integer value between 0000 and 9999\n\\r
+                        Number is an integer value between 0 and 65535\n\\r

                         used in Ver section.\n");\r
   fprintf (stdout, "  --sectionalign SectionAlign\n\\r
                         SectionAlign points to section alignment, which support\n\\r
                         used in Ver section.\n");\r
   fprintf (stdout, "  --sectionalign SectionAlign\n\\r
                         SectionAlign points to section alignment, which support\n\\r


@@ -266,6 +269,7 @@ Returns:
   FILE                      *InFile;\r
   UINT8                     *Buffer;\r
   UINT32                    TotalLength;\r
   FILE                      *InFile;\r
   UINT8                     *Buffer;\r
   UINT32                    TotalLength;\r

+  UINT32                    HeaderLength;\r

   EFI_COMMON_SECTION_HEADER *CommonSect;\r
   STATUS                    Status;\r
 \r
   EFI_COMMON_SECTION_HEADER *CommonSect;\r
   STATUS                    Status;\r
 \r


@@ -298,9 +302,14 @@ Returns:
   //\r
   // Size must fit in 3 bytes\r
   //\r
   //\r
   // Size must fit in 3 bytes\r
   //\r

+  //if (TotalLength >= MAX_SECTION_SIZE) {\r
+  //  Error (NULL, 0, 2000, "Invalid paramter", "%s file size (0x%X) exceeds section size limit(%uM).", InputFileName[0], (unsigned) TotalLength, MAX_SECTION_SIZE>>20);\r
+  //  goto Done;\r
+  //}\r
+  HeaderLength = sizeof (EFI_COMMON_SECTION_HEADER);\r

   if (TotalLength >= MAX_SECTION_SIZE) {\r
   if (TotalLength >= MAX_SECTION_SIZE) {\r

-    Error (NULL, 0, 2000, "Invalid paramter", "%s file size (0x%X) exceeds section size limit(%uM).", InputFileName[0], (unsigned) TotalLength, MAX_SECTION_SIZE>>20);\r
-    goto Done;\r
+    TotalLength = sizeof (EFI_COMMON_SECTION_HEADER2) + InputFileLength;\r
+    HeaderLength = sizeof (EFI_COMMON_SECTION_HEADER2);\r

   }\r
   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
   //\r
   }\r
   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
   //\r


@@ -313,15 +322,20 @@ Returns:
   }\r
   CommonSect = (EFI_COMMON_SECTION_HEADER *) Buffer;\r
   CommonSect->Type     = SectionType;\r
   }\r
   CommonSect = (EFI_COMMON_SECTION_HEADER *) Buffer;\r
   CommonSect->Type     = SectionType;\r

-  CommonSect->Size[0]  = (UINT8) (TotalLength & 0xff);\r
-  CommonSect->Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
-  CommonSect->Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
+  if (TotalLength < MAX_SECTION_SIZE) {\r
+    CommonSect->Size[0]  = (UINT8) (TotalLength & 0xff);\r
+    CommonSect->Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
+    CommonSect->Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
+  } else {\r
+    memset(CommonSect->Size, 0xff, sizeof(UINT8) * 3);\r
+    ((EFI_COMMON_SECTION_HEADER2 *)CommonSect)->ExtendedSize = TotalLength;\r
+  }\r

   \r
   //\r
   // read data from the input file.\r
   //\r
   if (InputFileLength != 0) {\r
   \r
   //\r
   // read data from the input file.\r
   //\r
   if (InputFileLength != 0) {\r

-    if (fread (Buffer + sizeof (EFI_COMMON_SECTION_HEADER), (size_t) InputFileLength, 1, InFile) != 1) {\r
+    if (fread (Buffer + HeaderLength, (size_t) InputFileLength, 1, InFile) != 1) {\r

       Error (NULL, 0, 0004, "Error reading file", InputFileName[0]);\r
       goto Done;\r
     }\r
       Error (NULL, 0, 0004, "Error reading file", InputFileName[0]);\r
       goto Done;\r
     }\r


@@ -421,10 +435,11 @@ Returns:
   UINT32                     Index;\r
   FILE                       *InFile;\r
   EFI_COMMON_SECTION_HEADER  *SectHeader;\r
   UINT32                     Index;\r
   FILE                       *InFile;\r
   EFI_COMMON_SECTION_HEADER  *SectHeader;\r

-  EFI_COMMON_SECTION_HEADER  TempSectHeader;\r
+  EFI_COMMON_SECTION_HEADER2 TempSectHeader;\r

   EFI_TE_IMAGE_HEADER        TeHeader;\r
   UINT32                     TeOffset;\r
   EFI_GUID_DEFINED_SECTION   GuidSectHeader;\r
   EFI_TE_IMAGE_HEADER        TeHeader;\r
   UINT32                     TeOffset;\r
   EFI_GUID_DEFINED_SECTION   GuidSectHeader;\r

+  EFI_GUID_DEFINED_SECTION2  GuidSectHeader2;\r

   UINT32                     HeaderSize;\r
 \r
   if (InputFileNum < 1) {\r
   UINT32                     HeaderSize;\r
 \r
   if (InputFileNum < 1) {\r


@@ -476,8 +491,16 @@ Returns:
       // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.\r
       //\r
       TeOffset = 0;\r
       // Check this section is Te/Pe section, and Calculate the numbers of Te/Pe section.\r
       //\r
       TeOffset = 0;\r

-      HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);\r
-      fread (&TempSectHeader, 1, sizeof (TempSectHeader), InFile);\r
+      //\r
+      // The section might be EFI_COMMON_SECTION_HEADER2\r
+      // But only Type needs to be checked\r
+      //\r
+      if (FileSize >= MAX_SECTION_SIZE) {\r
+        HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER2);\r
+      } else {\r
+        HeaderSize = sizeof (EFI_COMMON_SECTION_HEADER);\r
+      }\r
+      fread (&TempSectHeader, 1, HeaderSize, InFile);\r

       if (TempSectHeader.Type == EFI_SECTION_TE) {\r
         fread (&TeHeader, 1, sizeof (TeHeader), InFile);\r
         if (TeHeader.Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r
       if (TempSectHeader.Type == EFI_SECTION_TE) {\r
         fread (&TeHeader, 1, sizeof (TeHeader), InFile);\r
         if (TeHeader.Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) {\r


@@ -485,9 +508,16 @@ Returns:
         }\r
       } else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {\r
         fseek (InFile, 0, SEEK_SET);\r
         }\r
       } else if (TempSectHeader.Type == EFI_SECTION_GUID_DEFINED) {\r
         fseek (InFile, 0, SEEK_SET);\r

-        fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);\r
-        if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
-          HeaderSize = GuidSectHeader.DataOffset;\r
+        if (FileSize >= MAX_SECTION_SIZE) {\r
+          fread (&GuidSectHeader2, 1, sizeof (GuidSectHeader2), InFile);\r
+          if ((GuidSectHeader2.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
+            HeaderSize = GuidSectHeader2.DataOffset;\r
+          }\r
+        } else {\r
+          fread (&GuidSectHeader, 1, sizeof (GuidSectHeader), InFile);\r
+          if ((GuidSectHeader.Attributes & EFI_GUIDED_SECTION_PROCESSING_REQUIRED) == 0) {\r
+            HeaderSize = GuidSectHeader.DataOffset;\r
+          }\r

         }\r
       } \r
 \r
         }\r
       } \r
 \r


@@ -510,6 +540,9 @@ Returns:
         Offset = Offset - Size - HeaderSize - TeOffset;\r
          \r
         if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {\r
         Offset = Offset - Size - HeaderSize - TeOffset;\r
          \r
         if (FileBuffer != NULL && ((Size + Offset) < *BufferLength)) {\r

+          //\r
+          // The maximal alignment is 64K, the raw section size must be less than 0xffffff\r
+          //\r

           memset (FileBuffer + Size, 0, Offset);\r
           SectHeader          = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);\r
           SectHeader->Type    = EFI_SECTION_RAW;\r
           memset (FileBuffer + Size, 0, Offset);\r
           SectHeader          = (EFI_COMMON_SECTION_HEADER *) (FileBuffer + Size);\r
           SectHeader->Type    = EFI_SECTION_RAW;\r


@@ -591,16 +624,19 @@ Returns:
   UINT32                  TotalLength;\r
   UINT32                  InputLength;\r
   UINT32                  CompressedLength;\r
   UINT32                  TotalLength;\r
   UINT32                  InputLength;\r
   UINT32                  CompressedLength;\r

+  UINT32                  HeaderLength;\r

   UINT8                   *FileBuffer;\r
   UINT8                   *OutputBuffer;\r
   EFI_STATUS              Status;\r
   EFI_COMPRESSION_SECTION *CompressionSect;\r
   UINT8                   *FileBuffer;\r
   UINT8                   *OutputBuffer;\r
   EFI_STATUS              Status;\r
   EFI_COMPRESSION_SECTION *CompressionSect;\r

+  EFI_COMPRESSION_SECTION2 *CompressionSect2;\r

   COMPRESS_FUNCTION       CompressFunction;\r
 \r
   InputLength       = 0;\r
   FileBuffer        = NULL;\r
   OutputBuffer      = NULL;\r
   CompressedLength  = 0;\r
   COMPRESS_FUNCTION       CompressFunction;\r
 \r
   InputLength       = 0;\r
   FileBuffer        = NULL;\r
   OutputBuffer      = NULL;\r
   CompressedLength  = 0;\r

+  TotalLength       = 0;\r

   //\r
   // read all input file contents into a buffer\r
   // first get the size of all file contents\r
   //\r
   // read all input file contents into a buffer\r
   // first get the size of all file contents\r


@@ -646,15 +682,21 @@ Returns:
   switch (SectCompSubType) {\r
   case EFI_NOT_COMPRESSED:\r
     CompressedLength = InputLength;\r
   switch (SectCompSubType) {\r
   case EFI_NOT_COMPRESSED:\r
     CompressedLength = InputLength;\r

+    HeaderLength = sizeof (EFI_COMPRESSION_SECTION);\r
+    if (CompressedLength + HeaderLength >= MAX_SECTION_SIZE) {\r
+      HeaderLength = sizeof (EFI_COMPRESSION_SECTION2);\r
+    }\r
+    TotalLength = CompressedLength + HeaderLength;\r

     //\r
     // Copy file buffer to the none compressed data.\r
     //\r
     //\r
     // Copy file buffer to the none compressed data.\r
     //\r

-    OutputBuffer = malloc (CompressedLength + sizeof (EFI_COMPRESSION_SECTION));\r
+    OutputBuffer = malloc (TotalLength);\r

     if (OutputBuffer == NULL) {\r
       free (FileBuffer);\r
       return EFI_OUT_OF_RESOURCES;\r
     }\r
     if (OutputBuffer == NULL) {\r
       free (FileBuffer);\r
       return EFI_OUT_OF_RESOURCES;\r
     }\r

-    memcpy (OutputBuffer + sizeof (EFI_COMPRESSION_SECTION), FileBuffer, CompressedLength);\r
+    memcpy (OutputBuffer + HeaderLength, FileBuffer, CompressedLength);\r
+    free (FileBuffer);\r

     FileBuffer = OutputBuffer;\r
     break;\r
 \r
     FileBuffer = OutputBuffer;\r
     break;\r
 \r


@@ -672,13 +714,18 @@ Returns:
 \r
     Status = CompressFunction (FileBuffer, InputLength, OutputBuffer, &CompressedLength);\r
     if (Status == EFI_BUFFER_TOO_SMALL) {\r
 \r
     Status = CompressFunction (FileBuffer, InputLength, OutputBuffer, &CompressedLength);\r
     if (Status == EFI_BUFFER_TOO_SMALL) {\r

-      OutputBuffer = malloc (CompressedLength + sizeof (EFI_COMPRESSION_SECTION));\r
+      HeaderLength = sizeof (EFI_COMPRESSION_SECTION);\r
+      if (CompressedLength + HeaderLength >= MAX_SECTION_SIZE) {\r
+        HeaderLength = sizeof (EFI_COMPRESSION_SECTION2);\r
+      }\r
+      TotalLength = CompressedLength + HeaderLength;\r
+      OutputBuffer = malloc (TotalLength);\r

       if (!OutputBuffer) {\r
         free (FileBuffer);\r
         return EFI_OUT_OF_RESOURCES;\r
       }\r
 \r
       if (!OutputBuffer) {\r
         free (FileBuffer);\r
         return EFI_OUT_OF_RESOURCES;\r
       }\r
 \r

-      Status = CompressFunction (FileBuffer, InputLength, OutputBuffer + sizeof (EFI_COMPRESSION_SECTION), &CompressedLength);\r
+      Status = CompressFunction (FileBuffer, InputLength, OutputBuffer + HeaderLength, &CompressedLength);\r

     }\r
 \r
     free (FileBuffer);\r
     }\r
 \r
     free (FileBuffer);\r


@@ -695,30 +742,40 @@ Returns:
 \r
   DebugMsg (NULL, 0, 9, "comprss file size", \r
             "the original section size is %d bytes and the compressed section size is %u bytes", (unsigned) InputLength, (unsigned) CompressedLength);\r
 \r
   DebugMsg (NULL, 0, 9, "comprss file size", \r
             "the original section size is %d bytes and the compressed section size is %u bytes", (unsigned) InputLength, (unsigned) CompressedLength);\r

-  TotalLength = CompressedLength + sizeof (EFI_COMPRESSION_SECTION);\r
-  if (TotalLength >= MAX_SECTION_SIZE) {\r
-    Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);\r
-    if (FileBuffer != NULL) {\r
-      free (FileBuffer);\r
-    }\r
-    if (OutputBuffer != NULL) {\r
-      free (OutputBuffer);\r
-    }\r
-    return STATUS_ERROR;\r
-  }\r
+\r
+  //if (TotalLength >= MAX_SECTION_SIZE) {\r
+  //  Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);\r
+  //  if (FileBuffer != NULL) {\r
+  //    free (FileBuffer);\r
+  //  }\r
+  //  if (OutputBuffer != NULL) {\r
+  //    free (OutputBuffer);\r
+  //  }\r
+  //  return STATUS_ERROR;\r
+  //}\r

   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
 \r
   //\r
   // Add the section header for the compressed data\r
   //\r
   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
 \r
   //\r
   // Add the section header for the compressed data\r
   //\r

-  CompressionSect = (EFI_COMPRESSION_SECTION *) FileBuffer;\r
-  \r
-  CompressionSect->CommonHeader.Type     = EFI_SECTION_COMPRESSION;\r
-  CompressionSect->CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
-  CompressionSect->CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
-  CompressionSect->CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
-  CompressionSect->CompressionType       = SectCompSubType;\r
-  CompressionSect->UncompressedLength    = InputLength;\r
+  if (TotalLength >= MAX_SECTION_SIZE) {\r
+    CompressionSect2 = (EFI_COMPRESSION_SECTION2 *)FileBuffer;\r
+\r
+    memset(CompressionSect2->CommonHeader.Size, 0xff, sizeof(UINT8) * 3);\r
+    CompressionSect2->CommonHeader.Type         = EFI_SECTION_COMPRESSION;\r
+    CompressionSect2->CommonHeader.ExtendedSize = TotalLength;\r
+    CompressionSect2->CompressionType           = SectCompSubType;\r
+    CompressionSect2->UncompressedLength        = InputLength;\r
+  } else {\r
+    CompressionSect = (EFI_COMPRESSION_SECTION *) FileBuffer;\r
+    \r
+    CompressionSect->CommonHeader.Type     = EFI_SECTION_COMPRESSION;\r
+    CompressionSect->CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
+    CompressionSect->CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
+    CompressionSect->CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
+    CompressionSect->CompressionType       = SectCompSubType;\r
+    CompressionSect->UncompressedLength    = InputLength;\r
+  }\r

 \r
   //\r
   // Set OutFileBuffer \r
 \r
   //\r
   // Set OutFileBuffer \r


@@ -779,17 +836,14 @@ Returns:
   UINT32                Crc32Checksum;\r
   EFI_STATUS            Status;\r
   CRC32_SECTION_HEADER  *Crc32GuidSect;\r
   UINT32                Crc32Checksum;\r
   EFI_STATUS            Status;\r
   CRC32_SECTION_HEADER  *Crc32GuidSect;\r

+  CRC32_SECTION_HEADER2  *Crc32GuidSect2;\r

   EFI_GUID_DEFINED_SECTION  *VendorGuidSect;\r
   EFI_GUID_DEFINED_SECTION  *VendorGuidSect;\r

+  EFI_GUID_DEFINED_SECTION2  *VendorGuidSect2;\r

 \r
   InputLength = 0;\r
   Offset      = 0;\r
   FileBuffer  = NULL;\r
 \r
   InputLength = 0;\r
   Offset      = 0;\r
   FileBuffer  = NULL;\r

-\r
-  if (CompareGuid (VendorGuid, &mZeroGuid) == 0) {\r
-    Offset = sizeof (CRC32_SECTION_HEADER);\r
-  } else {\r
-    Offset = sizeof (EFI_GUID_DEFINED_SECTION);\r
-  }\r
+  TotalLength = 0;\r

 \r
   //\r
   // read all input file contents into a buffer\r
 \r
   //\r
   // read all input file contents into a buffer\r


@@ -804,6 +858,19 @@ Returns:
             );\r
 \r
   if (Status == EFI_BUFFER_TOO_SMALL) {\r
             );\r
 \r
   if (Status == EFI_BUFFER_TOO_SMALL) {\r

+    if (CompareGuid (VendorGuid, &mZeroGuid) == 0) {\r
+      Offset = sizeof (CRC32_SECTION_HEADER);\r
+      if (InputLength + Offset >= MAX_SECTION_SIZE) {\r
+        Offset = sizeof (CRC32_SECTION_HEADER2);\r
+      }\r
+    } else {\r
+      Offset = sizeof (EFI_GUID_DEFINED_SECTION);\r
+      if (InputLength + Offset >= MAX_SECTION_SIZE) {\r
+        Offset = sizeof (EFI_GUID_DEFINED_SECTION2);\r
+      }\r
+    }\r
+    TotalLength = InputLength + Offset;\r
+\r

     FileBuffer = (UINT8 *) malloc (InputLength + Offset);\r
     if (FileBuffer == NULL) {\r
       Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");\r
     FileBuffer = (UINT8 *) malloc (InputLength + Offset);\r
     if (FileBuffer == NULL) {\r
       Error (NULL, 0, 4001, "Resource", "memory cannot be allcoated");\r


@@ -843,42 +910,54 @@ Returns:
     //\r
     Crc32Checksum = 0;\r
     CalculateCrc32 (FileBuffer + Offset, InputLength, &Crc32Checksum);\r
     //\r
     Crc32Checksum = 0;\r
     CalculateCrc32 (FileBuffer + Offset, InputLength, &Crc32Checksum);\r

-\r
-    TotalLength = InputLength + sizeof (CRC32_SECTION_HEADER);\r
+    \r

     if (TotalLength >= MAX_SECTION_SIZE) {\r
     if (TotalLength >= MAX_SECTION_SIZE) {\r

-      Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);\r
-      free (FileBuffer);\r
-      return STATUS_ERROR;\r
+      Crc32GuidSect2 = (CRC32_SECTION_HEADER2 *) FileBuffer;\r
+      Crc32GuidSect2->GuidSectionHeader.CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
+      Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[0]  = (UINT8) 0xff;\r
+      Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[1]  = (UINT8) 0xff;\r
+      Crc32GuidSect2->GuidSectionHeader.CommonHeader.Size[2]  = (UINT8) 0xff;\r
+      Crc32GuidSect2->GuidSectionHeader.CommonHeader.ExtendedSize = TotalLength;\r
+      memcpy (&(Crc32GuidSect2->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));\r
+      Crc32GuidSect2->GuidSectionHeader.Attributes  = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;\r
+      Crc32GuidSect2->GuidSectionHeader.DataOffset  = sizeof (CRC32_SECTION_HEADER2);\r
+      Crc32GuidSect2->CRC32Checksum                 = Crc32Checksum;\r
+      DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect2->GuidSectionHeader.DataOffset);\r
+    } else {\r
+      Crc32GuidSect = (CRC32_SECTION_HEADER *) FileBuffer;\r
+      Crc32GuidSect->GuidSectionHeader.CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
+      Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
+      Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
+      Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
+      memcpy (&(Crc32GuidSect->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));\r
+      Crc32GuidSect->GuidSectionHeader.Attributes  = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;\r
+      Crc32GuidSect->GuidSectionHeader.DataOffset  = sizeof (CRC32_SECTION_HEADER);\r
+      Crc32GuidSect->CRC32Checksum                 = Crc32Checksum;\r
+      DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect->GuidSectionHeader.DataOffset);\r

     }\r
     }\r

-    \r
-    Crc32GuidSect = (CRC32_SECTION_HEADER *) FileBuffer;\r
-    Crc32GuidSect->GuidSectionHeader.CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
-    Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
-    Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
-    Crc32GuidSect->GuidSectionHeader.CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
-    memcpy (&(Crc32GuidSect->GuidSectionHeader.SectionDefinitionGuid), &mEfiCrc32SectionGuid, sizeof (EFI_GUID));\r
-    Crc32GuidSect->GuidSectionHeader.Attributes  = EFI_GUIDED_SECTION_AUTH_STATUS_VALID;\r
-    Crc32GuidSect->GuidSectionHeader.DataOffset  = sizeof (CRC32_SECTION_HEADER);\r
-    Crc32GuidSect->CRC32Checksum                 = Crc32Checksum;\r
-    DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", Crc32GuidSect->GuidSectionHeader.DataOffset);\r
-\r

   } else {\r
   } else {\r

-    TotalLength = InputLength + sizeof (EFI_GUID_DEFINED_SECTION);\r

     if (TotalLength >= MAX_SECTION_SIZE) {\r
     if (TotalLength >= MAX_SECTION_SIZE) {\r

-      Error (NULL, 0, 2000, "Invalid paramter", "The size of all files exceeds section size limit(%uM).", MAX_SECTION_SIZE>>20);\r
-      free (FileBuffer);\r
-      return STATUS_ERROR;\r
+      VendorGuidSect2 = (EFI_GUID_DEFINED_SECTION2 *) FileBuffer;\r
+      VendorGuidSect2->CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
+      VendorGuidSect2->CommonHeader.Size[0]  = (UINT8) 0xff;\r
+      VendorGuidSect2->CommonHeader.Size[1]  = (UINT8) 0xff;\r
+      VendorGuidSect2->CommonHeader.Size[2]  = (UINT8) 0xff;\r
+      VendorGuidSect2->CommonHeader.ExtendedSize = InputLength + sizeof (EFI_GUID_DEFINED_SECTION2);\r
+      memcpy (&(VendorGuidSect2->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));\r
+      VendorGuidSect2->Attributes  = DataAttribute;\r
+      VendorGuidSect2->DataOffset  = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION2) + DataHeaderSize);\r
+      DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect2->DataOffset);\r
+    } else {\r
+      VendorGuidSect = (EFI_GUID_DEFINED_SECTION *) FileBuffer;\r
+      VendorGuidSect->CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
+      VendorGuidSect->CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
+      VendorGuidSect->CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
+      VendorGuidSect->CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
+      memcpy (&(VendorGuidSect->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));\r
+      VendorGuidSect->Attributes  = DataAttribute;\r
+      VendorGuidSect->DataOffset  = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION) + DataHeaderSize);\r
+      DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect->DataOffset);\r

     }\r
     }\r

-\r
-    VendorGuidSect = (EFI_GUID_DEFINED_SECTION *) FileBuffer;\r
-    VendorGuidSect->CommonHeader.Type     = EFI_SECTION_GUID_DEFINED;\r
-    VendorGuidSect->CommonHeader.Size[0]  = (UINT8) (TotalLength & 0xff);\r
-    VendorGuidSect->CommonHeader.Size[1]  = (UINT8) ((TotalLength & 0xff00) >> 8);\r
-    VendorGuidSect->CommonHeader.Size[2]  = (UINT8) ((TotalLength & 0xff0000) >> 16);\r
-    memcpy (&(VendorGuidSect->SectionDefinitionGuid), VendorGuid, sizeof (EFI_GUID));\r
-    VendorGuidSect->Attributes  = DataAttribute;\r
-    VendorGuidSect->DataOffset  = (UINT16) (sizeof (EFI_GUID_DEFINED_SECTION) + DataHeaderSize);\r
-    DebugMsg (NULL, 0, 9, "Guided section", "Data offset is %u", VendorGuidSect->DataOffset);\r

   }\r
   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
   \r
   }\r
   VerboseMsg ("the size of the created section file is %u bytes", (unsigned) TotalLength);\r
   \r


@@ -935,6 +1014,7 @@ Returns:
   UINT64                    LogLevel;\r
   UINT32                    *InputFileAlign;\r
   UINT32                    InputFileAlignNum;\r
   UINT64                    LogLevel;\r
   UINT32                    *InputFileAlign;\r
   UINT32                    InputFileAlignNum;\r

+  EFI_COMMON_SECTION_HEADER *SectionHeader;\r

 \r
   InputFileAlign        = NULL;\r
   InputFileAlignNum     = 0;\r
 \r
   InputFileAlign        = NULL;\r
   InputFileAlignNum     = 0;\r


@@ -1262,8 +1342,8 @@ Returns:
     SectType = EFI_SECTION_SMM_DEPEX;\r
   } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_VERSION]) == 0) {\r
     SectType = EFI_SECTION_VERSION;\r
     SectType = EFI_SECTION_SMM_DEPEX;\r
   } else if (stricmp (SectionName, mSectionTypeName[EFI_SECTION_VERSION]) == 0) {\r
     SectType = EFI_SECTION_VERSION;\r

-    if (VersionNumber < 0 || VersionNumber > 9999) {\r
-      Error (NULL, 0, 1003, "Invalid option value", "%d is not in 0~9999", VersionNumber);\r
+    if (VersionNumber < 0 || VersionNumber > 65535) {\r
+      Error (NULL, 0, 1003, "Invalid option value", "%d is not in 0~65535", VersionNumber);\r

       goto Finish;\r
     }\r
     VerboseMsg ("Version section number is %d", VersionNumber);\r
       goto Finish;\r
     }\r
     VerboseMsg ("Version section number is %d", VersionNumber);\r


@@ -1463,7 +1543,11 @@ Returns:
   // Get output file length\r
   //\r
   if (SectType != EFI_SECTION_ALL) {\r
   // Get output file length\r
   //\r
   if (SectType != EFI_SECTION_ALL) {\r

-    InputLength = SECTION_SIZE (OutFileBuffer);\r
+    SectionHeader = (EFI_COMMON_SECTION_HEADER *)OutFileBuffer;\r
+    InputLength = *(UINT32 *)SectionHeader->Size & 0x00ffffff;\r
+    if (InputLength == 0xffffff) {\r
+      InputLength = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize;\r
+    }\r

   }\r
   \r
   //\r
   }\r
   \r
   //\r

diff --git a/BaseTools/Source/C/Include/Common/BuildVersion.h b/BaseTools/Source/C/Include/Common/BuildVersion.h
index f524cefc9b02bed07cfa33e0599e1037baf9a845..b84bd0571416feef37f4242eef1412902b8cf2c1 100644 (file)
--- a/BaseTools/Source/C/Include/Common/BuildVersion.h
+++ b/BaseTools/Source/C/Include/Common/BuildVersion.h
@@ -14,4 +14,4 @@
 \r
 **/\r
 \r
 \r
 **/\r
 \r

-#define __BUILD_VERSION "Build 2601"\r
+#define __BUILD_VERSION "Build 2610"\r

diff --git a/BaseTools/Source/C/Include/Common/PiFirmwareFile.h b/BaseTools/Source/C/Include/Common/PiFirmwareFile.h
index e66f40ca43a7119140594e5dfbe3bdcc67fb6fd4..1790c3a1e841652bf07e9d0af582234c15262f19 100644 (file)
--- a/BaseTools/Source/C/Include/Common/PiFirmwareFile.h
+++ b/BaseTools/Source/C/Include/Common/PiFirmwareFile.h
@@ -1,7 +1,7 @@
 /** @file\r
   The firmware file related definitions in PI.\r
 \r
 /** @file\r
   The firmware file related definitions in PI.\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
 \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


@@ -64,6 +64,7 @@ typedef UINT8 EFI_FFS_FILE_STATE;
 // \r
 // FFS File Attributes.\r
 // \r
 // \r
 // FFS File Attributes.\r
 // \r

+#define FFS_ATTRIB_LARGE_FILE         0x01\r

 #define FFS_ATTRIB_FIXED              0x04\r
 #define FFS_ATTRIB_DATA_ALIGNMENT     0x38\r
 #define FFS_ATTRIB_CHECKSUM           0x40\r
 #define FFS_ATTRIB_FIXED              0x04\r
 #define FFS_ATTRIB_DATA_ALIGNMENT     0x38\r
 #define FFS_ATTRIB_CHECKSUM           0x40\r


@@ -104,6 +105,17 @@ typedef struct {
   EFI_FFS_FILE_STATE      State;\r
 } EFI_FFS_FILE_HEADER;\r
 \r
   EFI_FFS_FILE_STATE      State;\r
 } EFI_FFS_FILE_HEADER;\r
 \r

+typedef struct {\r
+  EFI_GUID                Name;\r
+  EFI_FFS_INTEGRITY_CHECK IntegrityCheck;\r
+  EFI_FV_FILETYPE         Type;\r
+  EFI_FFS_FILE_ATTRIBUTES Attributes;\r
+  UINT8                   Size[3];\r
+  EFI_FFS_FILE_STATE      State;\r
+  UINT32                  ExtendedSize;\r
+} EFI_FFS_FILE_HEADER2;\r
+\r
+#define MAX_FFS_SIZE        0x1000000\r

 \r
 typedef UINT8 EFI_SECTION_TYPE;\r
 \r
 \r
 typedef UINT8 EFI_SECTION_TYPE;\r
 \r


@@ -142,11 +154,20 @@ typedef struct {
   EFI_SECTION_TYPE  Type;\r
 } EFI_COMMON_SECTION_HEADER;\r
 \r
   EFI_SECTION_TYPE  Type;\r
 } EFI_COMMON_SECTION_HEADER;\r
 \r

+typedef struct {\r
+  UINT8             Size[3];\r
+  EFI_SECTION_TYPE  Type;\r
+  UINT32            ExtendedSize;\r
+} EFI_COMMON_SECTION_HEADER2;\r
+\r
+#define MAX_SECTION_SIZE        0x1000000\r
+\r

 //\r
 // Leaf section type that contains an \r
 // IA-32 16-bit executable image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_COMPATIBILITY16_SECTION;\r
 //\r
 // Leaf section type that contains an \r
 // IA-32 16-bit executable image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_COMPATIBILITY16_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_COMPATIBILITY16_SECTION2;\r

 \r
 //\r
 // CompressionType of EFI_COMPRESSION_SECTION.\r
 \r
 //\r
 // CompressionType of EFI_COMPRESSION_SECTION.\r


@@ -163,15 +184,23 @@ typedef struct {
   UINT8                       CompressionType;\r
 } EFI_COMPRESSION_SECTION;\r
 \r
   UINT8                       CompressionType;\r
 } EFI_COMPRESSION_SECTION;\r
 \r

+typedef struct {\r
+  EFI_COMMON_SECTION_HEADER2  CommonHeader;\r
+  UINT32                      UncompressedLength;\r
+  UINT8                       CompressionType;\r
+} EFI_COMPRESSION_SECTION2;\r
+\r

 //\r
 // Leaf section which could be used to determine the dispatch order of DXEs.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_DXE_DEPEX_SECTION;\r
 //\r
 // Leaf section which could be used to determine the dispatch order of DXEs.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_DXE_DEPEX_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_DXE_DEPEX_SECTION2;\r

 \r
 //\r
 // Leaf section witch contains a PI FV.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_FIRMWARE_VOLUME_IMAGE_SECTION;\r
 \r
 //\r
 // Leaf section witch contains a PI FV.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_FIRMWARE_VOLUME_IMAGE_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_FIRMWARE_VOLUME_IMAGE_SECTION2;\r

 \r
 //\r
 // Leaf section which contains a single GUID.\r
 \r
 //\r
 // Leaf section which contains a single GUID.\r


@@ -181,6 +210,11 @@ typedef struct {
   EFI_GUID                    SubTypeGuid;\r
 } EFI_FREEFORM_SUBTYPE_GUID_SECTION;\r
 \r
   EFI_GUID                    SubTypeGuid;\r
 } EFI_FREEFORM_SUBTYPE_GUID_SECTION;\r
 \r

+typedef struct {\r
+  EFI_COMMON_SECTION_HEADER2  CommonHeader;\r
+  EFI_GUID                    SubTypeGuid;\r
+} EFI_FREEFORM_SUBTYPE_GUID_SECTION2;\r
+\r

 //\r
 // Attributes of EFI_GUID_DEFINED_SECTION\r
 // \r
 //\r
 // Attributes of EFI_GUID_DEFINED_SECTION\r
 // \r


@@ -196,30 +230,42 @@ typedef struct {
   UINT16                      Attributes;\r
 } EFI_GUID_DEFINED_SECTION;\r
 \r
   UINT16                      Attributes;\r
 } EFI_GUID_DEFINED_SECTION;\r
 \r

+typedef struct {\r
+  EFI_COMMON_SECTION_HEADER2  CommonHeader;\r
+  EFI_GUID                    SectionDefinitionGuid;\r
+  UINT16                      DataOffset;\r
+  UINT16                      Attributes;\r
+} EFI_GUID_DEFINED_SECTION2;\r
+\r

 //\r
 // Leaf section which contains PE32+ image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PE32_SECTION;\r
 //\r
 // Leaf section which contains PE32+ image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PE32_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_PE32_SECTION2;\r

 \r
 //\r
 // Leaf section which contains PIC image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PIC_SECTION;\r
 \r
 //\r
 // Leaf section which contains PIC image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PIC_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_PIC_SECTION2;\r

 \r
 //\r
 // Leaf section which used to determine the dispatch order of PEIMs.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PEI_DEPEX_SECTION;\r
 \r
 //\r
 // Leaf section which used to determine the dispatch order of PEIMs.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_PEI_DEPEX_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_PEI_DEPEX_SECTION2;\r

 \r
 //\r
 // Leaf section which constains the position-independent-code image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_TE_SECTION;\r
 \r
 //\r
 // Leaf section which constains the position-independent-code image.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_TE_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_TE_SECTION2;\r

 \r
 //\r
 // Leaf section which contains an array of zero or more bytes.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_RAW_SECTION;\r
 \r
 //\r
 // Leaf section which contains an array of zero or more bytes.\r
 // \r
 typedef EFI_COMMON_SECTION_HEADER EFI_RAW_SECTION;\r

+typedef EFI_COMMON_SECTION_HEADER2 EFI_RAW_SECTION2;\r

 \r
 //\r
 // Leaf section which contains a unicode string that \r
 \r
 //\r
 // Leaf section which contains a unicode string that \r


@@ -234,6 +280,14 @@ typedef struct {
   CHAR16                      FileNameString[1];\r
 } EFI_USER_INTERFACE_SECTION;\r
 \r
   CHAR16                      FileNameString[1];\r
 } EFI_USER_INTERFACE_SECTION;\r
 \r

+typedef struct {\r
+  EFI_COMMON_SECTION_HEADER2  CommonHeader;\r
+\r
+  //\r
+  // Array of unicode string.\r
+  // \r
+  CHAR16                      FileNameString[1];\r
+} EFI_USER_INTERFACE_SECTION2;\r

 \r
 //\r
 // Leaf section which contains a numeric build number and\r
 \r
 //\r
 // Leaf section which contains a numeric build number and\r


@@ -245,6 +299,11 @@ typedef struct {
   CHAR16                      VersionString[1];\r
 } EFI_VERSION_SECTION;\r
 \r
   CHAR16                      VersionString[1];\r
 } EFI_VERSION_SECTION;\r
 \r

+typedef struct {\r
+  EFI_COMMON_SECTION_HEADER2  CommonHeader;\r
+  UINT16                      BuildNumber;\r
+  CHAR16                      VersionString[1];\r
+} EFI_VERSION_SECTION2;\r

 \r
 #define SECTION_SIZE(SectionHeaderPtr) \\r
     ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) SectionHeaderPtr)->Size) & 0x00ffffff))\r
 \r
 #define SECTION_SIZE(SectionHeaderPtr) \\r
     ((UINT32) (*((UINT32 *) ((EFI_COMMON_SECTION_HEADER *) SectionHeaderPtr)->Size) & 0x00ffffff))\r


@@ -266,6 +325,23 @@ typedef union {
   EFI_FIRMWARE_VOLUME_IMAGE_SECTION *FVImageSection;\r
   EFI_FREEFORM_SUBTYPE_GUID_SECTION *FreeformSubtypeSection;\r
   EFI_RAW_SECTION                   *RawSection;\r
   EFI_FIRMWARE_VOLUME_IMAGE_SECTION *FVImageSection;\r
   EFI_FREEFORM_SUBTYPE_GUID_SECTION *FreeformSubtypeSection;\r
   EFI_RAW_SECTION                   *RawSection;\r

+  //\r
+  // For section whose size is equal or greater than 0x1000000\r
+  //\r
+  EFI_COMMON_SECTION_HEADER2         *CommonHeader2;\r
+  EFI_COMPRESSION_SECTION2           *CompressionSection2;\r
+  EFI_GUID_DEFINED_SECTION2          *GuidDefinedSection2;\r
+  EFI_PE32_SECTION2                  *Pe32Section2;\r
+  EFI_PIC_SECTION2                   *PicSection2;\r
+  EFI_TE_SECTION2                    *TeSection2;\r
+  EFI_PEI_DEPEX_SECTION2             *PeimHeaderSection2;\r
+  EFI_DXE_DEPEX_SECTION2             *DependencySection2;\r
+  EFI_VERSION_SECTION2               *VersionSection2;\r
+  EFI_USER_INTERFACE_SECTION2        *UISection2;\r
+  EFI_COMPATIBILITY16_SECTION2       *Code16Section2;\r
+  EFI_FIRMWARE_VOLUME_IMAGE_SECTION2 *FVImageSection2;\r
+  EFI_FREEFORM_SUBTYPE_GUID_SECTION2 *FreeformSubtypeSection2;\r
+  EFI_RAW_SECTION2                   *RawSection2;\r

 } EFI_FILE_SECTION_POINTER;\r
 \r
 #endif\r
 } EFI_FILE_SECTION_POINTER;\r
 \r
 #endif\r

diff --git a/BaseTools/Source/C/Include/Common/PiFirmwareVolume.h b/BaseTools/Source/C/Include/Common/PiFirmwareVolume.h
index 0c8e29e1cec25698f97448089e47a45ca3f0bcf7..ea06eee69508c35a137268b3bbcc20c35b05ec4d 100644 (file)
--- a/BaseTools/Source/C/Include/Common/PiFirmwareVolume.h
+++ b/BaseTools/Source/C/Include/Common/PiFirmwareVolume.h
@@ -1,7 +1,7 @@
 /** @file\r
   The firmware volume related definitions in PI.\r
 \r
 /** @file\r
   The firmware volume related definitions in PI.\r
 \r

-  Copyright (c) 2006 - 2011, 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
   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


@@ -54,6 +54,7 @@ typedef UINT32  EFI_FVB_ATTRIBUTES_2;
 #define EFI_FVB2_WRITE_LOCK_CAP     0x00004000\r
 #define EFI_FVB2_WRITE_LOCK_STATUS  0x00008000\r
 #define EFI_FVB2_ALIGNMENT          0x001F0000\r
 #define EFI_FVB2_WRITE_LOCK_CAP     0x00004000\r
 #define EFI_FVB2_WRITE_LOCK_STATUS  0x00008000\r
 #define EFI_FVB2_ALIGNMENT          0x001F0000\r

+#define EFI_FVB2_WEAK_ALIGNMENT     0x80000000\r

 #define EFI_FVB2_ALIGNMENT_1        0x00000000\r
 #define EFI_FVB2_ALIGNMENT_2        0x00010000\r
 #define EFI_FVB2_ALIGNMENT_4        0x00020000\r
 #define EFI_FVB2_ALIGNMENT_1        0x00000000\r
 #define EFI_FVB2_ALIGNMENT_2        0x00010000\r
 #define EFI_FVB2_ALIGNMENT_4        0x00020000\r

diff --git a/BaseTools/Source/C/Include/Guid/PiFirmwareFileSystem.h b/BaseTools/Source/C/Include/Guid/PiFirmwareFileSystem.h
index a1c6b55f1dcd4de66d387904efaa68a8808a3bcb..3a4be34634dfc812722c03b59041b57d71f3adad 100644 (file)
--- a/BaseTools/Source/C/Include/Guid/PiFirmwareFileSystem.h
+++ b/BaseTools/Source/C/Include/Guid/PiFirmwareFileSystem.h
@@ -2,7 +2,7 @@
   Guid used to define the Firmware File System. See PI spec volume 3 for more\r
   details.\r
 \r
   Guid used to define the Firmware File System. See PI spec volume 3 for more\r
   details.\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
 \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


@@ -30,12 +30,18 @@
     0x8c8ce578, 0x8a3d, 0x4f1c, {0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 } \\r
   }\r
 \r
     0x8c8ce578, 0x8a3d, 0x4f1c, {0x99, 0x35, 0x89, 0x61, 0x85, 0xc3, 0x2d, 0xd3 } \\r
   }\r
 \r

+#define EFI_FIRMWARE_FILE_SYSTEM3_GUID \\r
+  { \\r
+    0x5473c07a, 0x3dcb, 0x4dca, {0xbd, 0x6f, 0x1e, 0x96, 0x89, 0xe7, 0x34, 0x9a } \\r
+  }\r
+\r

 #define EFI_FFS_VOLUME_TOP_FILE_GUID \\r
   { \\r
     0x1BA0062E, 0xC779, 0x4582, {0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x09 } \\r
   }\r
 \r
 extern EFI_GUID gEfiFirmwareFileSystem2Guid;\r
 #define EFI_FFS_VOLUME_TOP_FILE_GUID \\r
   { \\r
     0x1BA0062E, 0xC779, 0x4582, {0x85, 0x66, 0x33, 0x6A, 0xE8, 0xF7, 0x8F, 0x09 } \\r
   }\r
 \r
 extern EFI_GUID gEfiFirmwareFileSystem2Guid;\r

+extern EFI_GUID gEfiFirmwareFileSystem3Guid;\r

 extern EFI_GUID gEfiFirmwareVolumeTopFileGuid;\r
 \r
 #endif\r
 extern EFI_GUID gEfiFirmwareVolumeTopFileGuid;\r
 \r
 #endif\r

diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
index 61b68f5fb7aeea3625bfb74be091c0b39b412ddc..6f15aaa452a38a4350a146c5231f336933338022 100644 (file)
--- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
+++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
@@ -136,6 +136,7 @@ VfrParserStart (
 #token MapTitle("maptitle")                     "maptitle"\r
 #token MapGuid("mapguid")                       "mapguid"\r
 #token Subtitle("subtitle")                     "subtitle"\r
 #token MapTitle("maptitle")                     "maptitle"\r
 #token MapGuid("mapguid")                       "mapguid"\r
 #token Subtitle("subtitle")                     "subtitle"\r

+#token EndSubtitle("endsubtitle")               "endsubtitle"\r

 #token Help("help")                             "help"\r
 #token Text("text")                             "text"\r
 #token Option("option")                         "option"\r
 #token Help("help")                             "help"\r
 #token Text("text")                             "text"\r
 #token Option("option")                         "option"\r


@@ -1018,12 +1019,29 @@ vfrStatementVarStoreNameValue :
   <<\r
      EFI_GUID              Guid;\r
      CIfrVarStoreNameValue VSNVObj;\r
   <<\r
      EFI_GUID              Guid;\r
      CIfrVarStoreNameValue VSNVObj;\r

-     EFI_VARSTORE_ID       VarStoreId;\r
+     EFI_VARSTORE_ID       VarStoreId = EFI_VARSTORE_ID_INVALID;\r
+     BOOLEAN               Created    = FALSE;\r

   >>\r
   L:NameValueVarStore                               << VSNVObj.SetLineNo(L->getLine()); >>\r
   >>\r
   L:NameValueVarStore                               << VSNVObj.SetLineNo(L->getLine()); >>\r

-  SN:StringIdentifier ","                           << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText()), SN); >>\r
+  SN:StringIdentifier ","\r
+  {\r
+    VarId "=" ID:Number ","                         <<\r
+                                                       _PCATCH(\r
+                                                         (INTN)(VarStoreId = _STOU16(ID->getText())) != 0,\r
+                                                         (INTN)TRUE,\r
+                                                         ID,\r
+                                                         "varid 0 is not allowed."\r
+                                                         );\r
+                                                    >>\r
+  }\r

   (\r
   (\r

-    Name "=" "STRING_TOKEN" "\(" N:Number "\)" ","  << _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN); >>\r
+    Name "=" "STRING_TOKEN" "\(" N:Number "\)" ","  << \r
+                                                       if (!Created) {\r
+                                                         _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText(), VarStoreId), SN);\r
+                                                         Created = TRUE;\r
+                                                       }\r
+                                                       _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN); \r
+                                                    >>\r

   )+\r
   Uuid "=" guidDefinition[Guid]                     << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>\r
                                                     <<\r
   )+\r
   Uuid "=" guidDefinition[Guid]                     << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>\r
                                                     <<\r


@@ -1628,8 +1646,14 @@ vfrStatementSubTitle :
   {\r
     "," FLAGS "=" vfrSubtitleFlags[SObj]\r
   }\r
   {\r
     "," FLAGS "=" vfrSubtitleFlags[SObj]\r
   }\r

-  { vfrStatementStatTagList "," }\r
-  E:";"                                                << CRT_END_OP (E); >>\r
+  (\r
+    {vfrStatementStatTagList "," }\r
+    E:";"                                               << CRT_END_OP (E); >>\r
+  |\r
+    { "," vfrStatementStatTagList}\r
+    { "," (vfrStatementStat | vfrStatementQuestions)*}\r
+    E: EndSubtitle ";"                                  << CRT_END_OP (E); >>\r
+  )\r

   ;\r
 \r
 vfrSubtitleFlags [CIfrSubtitle & SObj] :\r
   ;\r
 \r
 vfrSubtitleFlags [CIfrSubtitle & SObj] :\r

diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
index 21a479db68c29b6a4c0e54ebda705401bf8127ed..7c1383eb7a89170852c2d82a21dccb928dfcc2a0 100644 (file)
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
@@ -1512,21 +1512,30 @@ CVfrDataStorage::MarkVarStoreIdUnused (
 \r
 EFI_VFR_RETURN_CODE\r
 CVfrDataStorage::DeclareNameVarStoreBegin (\r
 \r
 EFI_VFR_RETURN_CODE\r
 CVfrDataStorage::DeclareNameVarStoreBegin (\r

-  IN CHAR8    *StoreName\r
+  IN CHAR8           *StoreName,\r
+  IN EFI_VARSTORE_ID VarStoreId\r

   )\r
 {\r
   SVfrVarStorageNode *pNode = NULL;\r
   )\r
 {\r
   SVfrVarStorageNode *pNode = NULL;\r

-  EFI_VARSTORE_ID    VarStoreId;\r
+  EFI_VARSTORE_ID    TmpVarStoreId;\r

 \r
   if (StoreName == NULL) {\r
     return VFR_RETURN_FATAL_ERROR;\r
   }\r
 \r
 \r
   if (StoreName == NULL) {\r
     return VFR_RETURN_FATAL_ERROR;\r
   }\r
 \r

-  if (GetVarStoreId (StoreName, &VarStoreId) == VFR_RETURN_SUCCESS) {\r
+  if (GetVarStoreId (StoreName, &TmpVarStoreId) == VFR_RETURN_SUCCESS) {\r

     return VFR_RETURN_REDEFINED;\r
   }\r
     return VFR_RETURN_REDEFINED;\r
   }\r

+  \r
+  if (VarStoreId == EFI_VARSTORE_ID_INVALID) {\r
+    VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);\r
+  } else {\r
+    if (ChekVarStoreIdFree (VarStoreId) == FALSE) {\r
+      return VFR_RETURN_VARSTOREID_REDEFINED;\r
+    }\r
+    MarkVarStoreIdUsed (VarStoreId);\r
+  }\r

 \r
 \r

-  VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_NAME);\r

   if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) {\r
     return VFR_RETURN_UNDEFINED;\r
   }\r
   if ((pNode = new SVfrVarStorageNode (StoreName, VarStoreId)) == NULL) {\r
     return VFR_RETURN_UNDEFINED;\r
   }\r


@@ -2619,6 +2628,14 @@ CVfrQuestionDB::RegisterNewDateQuestion (
   CHAR8                 Index;\r
 \r
   if (BaseVarId == NULL && Name == NULL) {\r
   CHAR8                 Index;\r
 \r
   if (BaseVarId == NULL && Name == NULL) {\r

+    if (QuestionId == EFI_QUESTION_ID_INVALID) {\r
+      QuestionId = GetFreeQuestionId ();\r
+    } else {\r
+      if (ChekQuestionIdFree (QuestionId) == FALSE) {\r
+        goto Err;\r
+      }\r
+      MarkQuestionIdUsed (QuestionId);\r
+    }\r

     return;\r
   }\r
 \r
     return;\r
   }\r
 \r


@@ -2787,6 +2804,14 @@ CVfrQuestionDB::RegisterNewTimeQuestion (
   CHAR8                 Index;\r
 \r
   if (BaseVarId == NULL && Name == NULL) {\r
   CHAR8                 Index;\r
 \r
   if (BaseVarId == NULL && Name == NULL) {\r

+    if (QuestionId == EFI_QUESTION_ID_INVALID) {\r
+      QuestionId = GetFreeQuestionId ();\r
+    } else {\r
+      if (ChekQuestionIdFree (QuestionId) == FALSE) {\r
+        goto Err;\r
+      }\r
+      MarkQuestionIdUsed (QuestionId);\r
+    }\r

     return;\r
   }\r
 \r
     return;\r
   }\r
 \r

diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
index 2847a74a7b96b51cd658d5c906d75bbcda3647fd..c8f5333641bb6607d59c81d9aa39c7a010fca106 100644 (file)
--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
@@ -300,7 +300,7 @@ public:
   SVfrVarStorageNode * GetEfiVarStoreList () {\r
     return mEfiVarStoreList;\r
   }\r
   SVfrVarStorageNode * GetEfiVarStoreList () {\r
     return mEfiVarStoreList;\r
   }\r

-  EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *);\r
+  EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (CHAR8 *, EFI_VARSTORE_ID);\r

   EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);\r
   EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);\r
 \r
   EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);\r
   EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);\r
 \r

diff --git a/BaseTools/Source/Python/AutoGen/AutoGen.py b/BaseTools/Source/Python/AutoGen/AutoGen.py
index 6711880f60372f2781f8a6a03183de4abe95690f..71d0d757d825936da1bbd654e6e5eb486c28849c 100644 (file)
--- a/BaseTools/Source/Python/AutoGen/AutoGen.py
+++ b/BaseTools/Source/Python/AutoGen/AutoGen.py
@@ -1,7 +1,7 @@
 ## @file\r
 # Generate AutoGen.h, AutoGen.c and *.depex files\r
 #\r
 ## @file\r
 # Generate AutoGen.h, AutoGen.c and *.depex files\r
 #\r

-# Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2007 - 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
 # 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


@@ -34,9 +34,12 @@ import Common.GlobalData as GlobalData
 from GenFds.FdfParser import *\r
 from CommonDataClass.CommonClass import SkuInfoClass\r
 from Workspace.BuildClassObject import *\r
 from GenFds.FdfParser import *\r
 from CommonDataClass.CommonClass import SkuInfoClass\r
 from Workspace.BuildClassObject import *\r

+from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile\r

 import Common.VpdInfoFile as VpdInfoFile\r
 import Common.VpdInfoFile as VpdInfoFile\r

+from GenPcdDb import CreatePcdDatabaseCode\r
+from Workspace.MetaFileCommentParser import UsageList\r

 \r
 \r

-## Regular expression for splitting Dependency Expression stirng into tokens\r
+## Regular expression for splitting Dependency Expression string into tokens\r

 gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
 \r
 ## Mapping Makefile type\r
 gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
 \r
 ## Mapping Makefile type\r


@@ -59,13 +62,7 @@ gAutoGenDepexFileName = "%(module_name)s.depex"
 #\r
 # Template string to generic AsBuilt INF\r
 #\r
 #\r
 # Template string to generic AsBuilt INF\r
 #\r

-gAsBuiltInfHeaderString = TemplateString("""## @file\r
-# ${module_name}\r
-#\r
-# DO NOT EDIT\r
-# FILE auto-generated Binary INF\r
-#\r
-##\r
+gAsBuiltInfHeaderString = TemplateString("""${header_comments}\r

 \r
 [Defines]\r
   INF_VERSION                = 0x00010016\r
 \r
 [Defines]\r
   INF_VERSION                = 0x00010016\r


@@ -73,6 +70,7 @@ gAsBuiltInfHeaderString = TemplateString("""## @file
   FILE_GUID                  = ${module_guid}\r
   MODULE_TYPE                = ${module_module_type}\r
   VERSION_STRING             = ${module_version_string}${BEGIN}\r
   FILE_GUID                  = ${module_guid}\r
   MODULE_TYPE                = ${module_module_type}\r
   VERSION_STRING             = ${module_version_string}${BEGIN}\r

+  PCD_IS_DRIVER              = ${pcd_is_driver_string}${END}${BEGIN}\r

   UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}\r
   PI_SPECIFICATION_VERSION   = ${module_pi_specification_version}${END}\r
 \r
   UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}\r
   PI_SPECIFICATION_VERSION   = ${module_pi_specification_version}${END}\r
 \r


@@ -82,8 +80,21 @@ gAsBuiltInfHeaderString = TemplateString("""## @file
 [Binaries.${module_arch}]${BEGIN}\r
   ${binary_item}${END}\r
 \r
 [Binaries.${module_arch}]${BEGIN}\r
   ${binary_item}${END}\r
 \r

-[PcdEx]${BEGIN}\r
-  ${pcd_item}${END}\r
+[PatchPcd.${module_arch}]${BEGIN}\r
+  ${patchablepcd_item}\r
+${END}\r
+[Protocols.${module_arch}]${BEGIN}\r
+  ${protocol_item}\r
+${END}\r
+[Ppis.${module_arch}]${BEGIN}\r
+  ${ppi_item}\r
+${END}\r
+[Guids.${module_arch}]${BEGIN}\r
+  ${guid_item}\r
+${END}\r
+[PcdEx.${module_arch}]${BEGIN}\r
+  ${pcd_item}\r
+${END}\r

 \r
 ## @AsBuilt${BEGIN}\r
 ##   ${flags_item}${END}\r
 \r
 ## @AsBuilt${BEGIN}\r
 ##   ${flags_item}${END}\r


@@ -228,15 +239,6 @@ class WorkspaceAutoGen(AutoGen):
                             ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
                                       % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
 \r
                             ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
                                       % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
 \r

-        # Validate SKU ID\r
-        if not self.SkuId:\r
-            self.SkuId = 'DEFAULT'\r
-\r
-        if self.SkuId not in self.Platform.SkuIds:\r
-            EdkLogger.error("build", PARAMETER_INVALID, \r
-                            ExtraData="SKU-ID [%s] is not supported by the platform. [Valid SKU-ID: %s]"\r
-                                      % (self.SkuId, " ".join(self.Platform.SkuIds.keys())))\r
-\r

         # parse FDF file to get PCDs in it, if any\r
         if not self.FdfFile:\r
             self.FdfFile = self.Platform.FlashDefinition\r
         # parse FDF file to get PCDs in it, if any\r
         if not self.FdfFile:\r
             self.FdfFile = self.Platform.FlashDefinition\r


@@ -867,7 +869,7 @@ class PlatformAutoGen(AutoGen):
             \r
             for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:\r
                 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
             \r
             for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:\r
                 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r

-                if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize == None:\r
+                if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r

                     NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
 \r
                 if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r
                     NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
 \r
                 if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r


@@ -938,31 +940,19 @@ class PlatformAutoGen(AutoGen):
             # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
             #\r
             for PcdKey in PlatformPcds:\r
             # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
             #\r
             for PcdKey in PlatformPcds:\r

-                Pcd           = self.Platform.Pcds[PcdKey]                            \r
-                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
-                    Pcd           = VpdPcdDict[PcdKey]\r
-                    Sku           = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
-                    Sku.VpdOffset = Sku.VpdOffset.strip()                \r
-                    #\r
-                    # Fix the optional data of VPD PCD.\r
-                    #\r
-                    if (Pcd.DatumType.strip() != "VOID*"):\r
-                        if Sku.DefaultValue == '':\r
-                            Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]].DefaultValue = Pcd.MaxDatumSize\r
-                            Pcd.MaxDatumSize = None\r
-                        else:\r
-                            EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
-                                            File=self.MetaFile,\r
-                                            ExtraData="\n\tPCD: %s.%s format incorrect in DSC: %s\n\t\t\n"\r
-                                                      % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, self.Platform.MetaFile.Path))                                                                            \r
-                    \r
-                    VpdFile.Add(Pcd, Sku.VpdOffset)\r
-                    # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
-                    if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
-                        NeedProcessVpdMapFile = True\r
-                        if self.Platform.VpdToolGuid == None or self.Platform.VpdToolGuid == '':\r
-                            EdkLogger.error("Build", FILE_NOT_FOUND, \\r
-                                            "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
+                Pcd = self.Platform.Pcds[PcdKey]\r
+                if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \\r
+                   PcdKey in VpdPcdDict:\r
+                    Pcd = VpdPcdDict[PcdKey]\r
+                    for (SkuName,Sku) in Pcd.SkuInfoList.items():\r
+                        Sku.VpdOffset = Sku.VpdOffset.strip()\r
+                        VpdFile.Add(Pcd, Sku.VpdOffset)\r
+                        # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
+                        if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
+                            NeedProcessVpdMapFile = True\r
+                            if self.Platform.VpdToolGuid == None or self.Platform.VpdToolGuid == '':\r
+                                EdkLogger.error("Build", FILE_NOT_FOUND, \\r
+                                                "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r

                             \r
                                    \r
             #\r
                             \r
                                    \r
             #\r


@@ -983,32 +973,46 @@ class PlatformAutoGen(AutoGen):
                         # Not found, it should be signature\r
                         if not FoundFlag :\r
                             # just pick the a value to determine whether is unicode string type\r
                         # Not found, it should be signature\r
                         if not FoundFlag :\r
                             # just pick the a value to determine whether is unicode string type\r

-                            Sku           = DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]]\r
-                            Sku.VpdOffset = Sku.VpdOffset.strip() \r
-                            \r
-                            # Need to iterate DEC pcd information to get the value & datumtype\r
-                            for eachDec in self.PackageList:\r
-                                for DecPcd in eachDec.Pcds:\r
-                                    DecPcdEntry = eachDec.Pcds[DecPcd]\r
-                                    if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
-                                       (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):\r
-                                        # Print warning message to let the developer make a determine.\r
-                                        EdkLogger.warn("build", "Unreferenced vpd pcd used!",\r
-                                                        File=self.MetaFile, \\r
-                                                        ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \\r
-                                                        %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))  \r
-                                                                              \r
-                                        DscPcdEntry.DatumType    = DecPcdEntry.DatumType\r
-                                        DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue\r
-                                        # Only fix the value while no value provided in DSC file.\r
-                                        if (Sku.DefaultValue == "" or Sku.DefaultValue==None):\r
-                                            DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
-                                                                                                                \r
+                            for (SkuName,Sku) in DscPcdEntry.SkuInfoList.items():\r
+                                Sku.VpdOffset = Sku.VpdOffset.strip() \r
+                                \r
+                                # Need to iterate DEC pcd information to get the value & datumtype\r
+                                for eachDec in self.PackageList:\r
+                                    for DecPcd in eachDec.Pcds:\r
+                                        DecPcdEntry = eachDec.Pcds[DecPcd]\r
+                                        if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
+                                           (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):\r
+                                            # Print warning message to let the developer make a determine.\r
+                                            EdkLogger.warn("build", "Unreferenced vpd pcd used!",\r
+                                                            File=self.MetaFile, \\r
+                                                            ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \\r
+                                                            %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))  \r
+                                                                                  \r
+                                            DscPcdEntry.DatumType    = DecPcdEntry.DatumType\r
+                                            DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue\r
+                                            DscPcdEntry.TokenValue = DecPcdEntry.TokenValue\r
+                                            DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
+                                            # Only fix the value while no value provided in DSC file.\r
+                                            if (Sku.DefaultValue == "" or Sku.DefaultValue==None):\r
+                                                DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
+                                                                                                                    \r
+                                if DscPcdEntry not in self._DynamicPcdList:\r
+                                    self._DynamicPcdList.append(DscPcdEntry)\r
+#                                Sku = DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]]\r
+                                Sku.VpdOffset = Sku.VpdOffset.strip()\r
+                                PcdValue = Sku.DefaultValue\r
+                                VpdFile.Add(DscPcdEntry, Sku.VpdOffset)\r
+                                if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
+                                    NeedProcessVpdMapFile = True \r
+                            if DscPcdEntry.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
+                                UnicodePcdArray.append(DscPcdEntry)\r
+                            elif len(Sku.VariableName) > 0:\r
+                                HiiPcdArray.append(DscPcdEntry)\r
+                            else:\r
+                                OtherPcdArray.append(DscPcdEntry)\r
+                                \r
+                                # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r

                                                        \r
                                                        \r

-                            VpdFile.Add(DscPcdEntry, Sku.VpdOffset)\r
-                            # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
-                            if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
-                                NeedProcessVpdMapFile = True                        \r

                     \r
                     \r
             if (self.Platform.FlashDefinition == None or self.Platform.FlashDefinition == '') and \\r
                     \r
                     \r
             if (self.Platform.FlashDefinition == None or self.Platform.FlashDefinition == '') and \\r


@@ -1055,9 +1059,11 @@ class PlatformAutoGen(AutoGen):
                         # Fixup "*" offset\r
                         for Pcd in self._DynamicPcdList:\r
                             # just pick the a value to determine whether is unicode string type\r
                         # Fixup "*" offset\r
                         for Pcd in self._DynamicPcdList:\r
                             # just pick the a value to determine whether is unicode string type\r

-                            Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]                        \r
-                            if Sku.VpdOffset == "*":\r
-                                Sku.VpdOffset = VpdFile.GetOffset(Pcd)[0].strip()\r
+                            i = 0\r
+                            for (SkuName,Sku) in Pcd.SkuInfoList.items():                        \r
+                                if Sku.VpdOffset == "*":\r
+                                    Sku.VpdOffset = VpdFile.GetOffset(Pcd)[i].strip()\r
+                                i += 1\r

                     else:\r
                         EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
             \r
                     else:\r
                         EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
             \r


@@ -1605,13 +1611,13 @@ class PlatformAutoGen(AutoGen):
                             % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))\r
             Value = ToPcd.DefaultValue\r
             if Value in [None, '']:\r
                             % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))\r
             Value = ToPcd.DefaultValue\r
             if Value in [None, '']:\r

-                ToPcd.MaxDatumSize = 1\r
+                ToPcd.MaxDatumSize = '1'\r

             elif Value[0] == 'L':\r
             elif Value[0] == 'L':\r

-                ToPcd.MaxDatumSize = str(len(Value) * 2)\r
+                ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)\r

             elif Value[0] == '{':\r
                 ToPcd.MaxDatumSize = str(len(Value.split(',')))\r
             else:\r
             elif Value[0] == '{':\r
                 ToPcd.MaxDatumSize = str(len(Value.split(',')))\r
             else:\r

-                ToPcd.MaxDatumSize = str(len(Value))\r
+                ToPcd.MaxDatumSize = str(len(Value) - 1)\r

 \r
         # apply default SKU for dynamic PCDS if specified one is not available\r
         if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r
 \r
         # apply default SKU for dynamic PCDS if specified one is not available\r
         if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r


@@ -2004,9 +2010,14 @@ class ModuleAutoGen(AutoGen):
         self._DerivedPackageList      = None\r
         self._ModulePcdList           = None\r
         self._LibraryPcdList          = None\r
         self._DerivedPackageList      = None\r
         self._ModulePcdList           = None\r
         self._LibraryPcdList          = None\r

+        self._PcdComments = sdict()\r

         self._GuidList                = None\r
         self._GuidList                = None\r

+        self._GuidsUsedByPcd = None\r
+        self._GuidComments = sdict()\r

         self._ProtocolList            = None\r
         self._ProtocolList            = None\r

+        self._ProtocolComments = sdict()\r

         self._PpiList                 = None\r
         self._PpiList                 = None\r

+        self._PpiComments = sdict()\r

         self._DepexList               = None\r
         self._DepexExpressionList     = None\r
         self._BuildOption             = None\r
         self._DepexList               = None\r
         self._DepexExpressionList     = None\r
         self._BuildOption             = None\r


@@ -2107,6 +2118,10 @@ class ModuleAutoGen(AutoGen):
                 self._LibraryFlag = False\r
         return self._LibraryFlag\r
 \r
                 self._LibraryFlag = False\r
         return self._LibraryFlag\r
 \r

+    ## Check if the module is binary module or not\r
+    def _IsBinaryModule(self):\r
+        return self.Module.IsBinaryModule\r
+\r

     ## Return the directory to store intermediate files of the module\r
     def _GetBuildDir(self):\r
         if self._BuildDir == None:\r
     ## Return the directory to store intermediate files of the module\r
     def _GetBuildDir(self):\r
         if self._BuildDir == None:\r


@@ -2563,6 +2578,12 @@ class ModuleAutoGen(AutoGen):
                     self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
         return self._DependentLibraryList\r
 \r
                     self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
         return self._DependentLibraryList\r
 \r

+    @staticmethod\r
+    def UpdateComments(Recver, Src):\r
+        for Key in Src:\r
+            if Key not in Recver:\r
+                Recver[Key] = []\r
+            Recver[Key].extend(Src[Key])\r

     ## Get the list of PCDs from current module\r
     #\r
     #   @retval     list                    The list of PCD\r
     ## Get the list of PCDs from current module\r
     #\r
     #   @retval     list                    The list of PCD\r


@@ -2571,6 +2592,7 @@ class ModuleAutoGen(AutoGen):
         if self._ModulePcdList == None:\r
             # apply PCD settings from platform\r
             self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
         if self._ModulePcdList == None:\r
             # apply PCD settings from platform\r
             self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r

+            self.UpdateComments(self._PcdComments, self.Module.PcdComments)\r

         return self._ModulePcdList\r
 \r
     ## Get the list of PCDs from dependent libraries\r
         return self._ModulePcdList\r
 \r
     ## Get the list of PCDs from dependent libraries\r


@@ -2583,6 +2605,7 @@ class ModuleAutoGen(AutoGen):
             if not self.IsLibrary:\r
                 # get PCDs from dependent libraries\r
                 for Library in self.DependentLibraryList:\r
             if not self.IsLibrary:\r
                 # get PCDs from dependent libraries\r
                 for Library in self.DependentLibraryList:\r

+                    self.UpdateComments(self._PcdComments, Library.PcdComments)\r

                     for Key in Library.Pcds:\r
                         # skip duplicated PCDs\r
                         if Key in self.Module.Pcds or Key in Pcds:\r
                     for Key in Library.Pcds:\r
                         # skip duplicated PCDs\r
                         if Key in self.Module.Pcds or Key in Pcds:\r


@@ -2603,8 +2626,17 @@ class ModuleAutoGen(AutoGen):
             self._GuidList = self.Module.Guids\r
             for Library in self.DependentLibraryList:\r
                 self._GuidList.update(Library.Guids)\r
             self._GuidList = self.Module.Guids\r
             for Library in self.DependentLibraryList:\r
                 self._GuidList.update(Library.Guids)\r

+                self.UpdateComments(self._GuidComments, Library.GuidComments)\r
+            self.UpdateComments(self._GuidComments, self.Module.GuidComments)\r

         return self._GuidList\r
 \r
         return self._GuidList\r
 \r

+    def GetGuidsUsedByPcd(self):\r
+        if self._GuidsUsedByPcd == None:\r
+            self._GuidsUsedByPcd = sdict()\r
+            self._GuidsUsedByPcd.update(self.Module.GetGuidsUsedByPcd())\r
+            for Library in self.DependentLibraryList:\r
+                self._GuidsUsedByPcd.update(Library.GetGuidsUsedByPcd())\r
+        return self._GuidsUsedByPcd\r

     ## Get the protocol value mapping\r
     #\r
     #   @retval     dict    The mapping between protocol cname and its value\r
     ## Get the protocol value mapping\r
     #\r
     #   @retval     dict    The mapping between protocol cname and its value\r


@@ -2614,6 +2646,8 @@ class ModuleAutoGen(AutoGen):
             self._ProtocolList = self.Module.Protocols\r
             for Library in self.DependentLibraryList:\r
                 self._ProtocolList.update(Library.Protocols)\r
             self._ProtocolList = self.Module.Protocols\r
             for Library in self.DependentLibraryList:\r
                 self._ProtocolList.update(Library.Protocols)\r

+                self.UpdateComments(self._ProtocolComments, Library.ProtocolComments)\r
+            self.UpdateComments(self._ProtocolComments, self.Module.ProtocolComments)\r

         return self._ProtocolList\r
 \r
     ## Get the PPI value mapping\r
         return self._ProtocolList\r
 \r
     ## Get the PPI value mapping\r


@@ -2625,6 +2659,8 @@ class ModuleAutoGen(AutoGen):
             self._PpiList = self.Module.Ppis\r
             for Library in self.DependentLibraryList:\r
                 self._PpiList.update(Library.Ppis)\r
             self._PpiList = self.Module.Ppis\r
             for Library in self.DependentLibraryList:\r
                 self._PpiList.update(Library.Ppis)\r

+                self.UpdateComments(self._PpiComments, Library.PpiComments)\r
+            self.UpdateComments(self._PpiComments, self.Module.PpiComments)\r

         return self._PpiList\r
 \r
     ## Get the list of include search path\r
         return self._PpiList\r
 \r
     ## Get the list of include search path\r


@@ -2681,38 +2717,74 @@ class ModuleAutoGen(AutoGen):
             \r
         ### TODO: How to handles mixed source and binary modules\r
 \r
             \r
         ### TODO: How to handles mixed source and binary modules\r
 \r

-        # Find all DynamicEx PCDs used by this module and dependent libraries\r
+        # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries\r

         # Also find all packages that the DynamicEx PCDs depend on\r
         Pcds = []\r
         # Also find all packages that the DynamicEx PCDs depend on\r
         Pcds = []\r

+        PatchablePcds = {}\r

         Packages = []        \r
         Packages = []        \r

+        PcdCheckList = []\r
+        PcdTokenSpaceList = []\r

         for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
         for Pcd in self.ModulePcdList + self.LibraryPcdList:\r

-          if Pcd.Type in GenC.gDynamicExPcd:\r
-            if Pcd not in Pcds:\r
-              Pcds += [Pcd]\r
-            for Package in self.DerivedPackageList:\r
-              if Package not in Packages:\r
-                if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'DynamicEx') in Package.Pcds:\r
-                  Packages += [Package]\r
-                elif (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'Dynamic') in Package.Pcds:\r
-                  Packages += [Package]\r
+            if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
+                PatchablePcds[Pcd.TokenCName] = Pcd\r
+                PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'PatchableInModule'))\r
+            elif Pcd.Type in GenC.gDynamicExPcd:\r
+                if Pcd not in Pcds:\r
+                    Pcds += [Pcd]\r
+                    PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'DynamicEx'))\r
+                    PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'Dynamic'))\r
+                    PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
+        GuidList = sdict()\r
+        GuidList.update(self.GuidList)\r
+        for TokenSpace in self.GetGuidsUsedByPcd():\r
+            # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list\r
+            # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs\r
+            if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:\r
+                GuidList.pop(TokenSpace)\r
+        CheckList = (GuidList, self.PpiList, self.ProtocolList, PcdCheckList)\r
+        for Package in self.DerivedPackageList:\r
+            if Package in Packages:\r
+                continue\r
+            BeChecked = (Package.Guids, Package.Ppis, Package.Protocols, Package.Pcds)\r
+            Found = False\r
+            for Index in range(len(BeChecked)):\r
+                for Item in CheckList[Index]:\r
+                    if Item in BeChecked[Index]:\r
+                        Packages += [Package]\r
+                        Found = True\r
+                        break\r
+                if Found: break\r

 \r
         ModuleType = self.ModuleType\r
         if ModuleType == 'UEFI_DRIVER' and self.DepexGenerated:\r
 \r
         ModuleType = self.ModuleType\r
         if ModuleType == 'UEFI_DRIVER' and self.DepexGenerated:\r

-          ModuleType = 'DXE_DRIVER'\r
+            ModuleType = 'DXE_DRIVER'\r
+\r
+        DriverType = ''\r
+        if self.PcdIsDriver != '':\r
+            DriverType = self.PcdIsDriver\r

 \r
         AsBuiltInfDict = {\r
           'module_name'                       : self.Name,\r
           'module_guid'                       : self.Guid,\r
           'module_module_type'                : ModuleType,\r
           'module_version_string'             : self.Version,\r
 \r
         AsBuiltInfDict = {\r
           'module_name'                       : self.Name,\r
           'module_guid'                       : self.Guid,\r
           'module_module_type'                : ModuleType,\r
           'module_version_string'             : self.Version,\r

+          'pcd_is_driver_string'              : [],\r

           'module_uefi_specification_version' : [],\r
           'module_pi_specification_version'   : [],\r
           'module_arch'                       : self.Arch,\r
           'package_item'                      : ['%s' % (Package.MetaFile.File.replace('\\','/')) for Package in Packages],\r
           'binary_item'                       : [],\r
           'module_uefi_specification_version' : [],\r
           'module_pi_specification_version'   : [],\r
           'module_arch'                       : self.Arch,\r
           'package_item'                      : ['%s' % (Package.MetaFile.File.replace('\\','/')) for Package in Packages],\r
           'binary_item'                       : [],\r

+          'patchablepcd_item'                 : [],\r

           'pcd_item'                          : [],\r
           'pcd_item'                          : [],\r

-          'flags_item'                        : []\r
+          'protocol_item'                     : [],\r
+          'ppi_item'                          : [],\r
+          'guid_item'                         : [],\r
+          'flags_item'                        : [],\r
+          'libraryclasses_item'               : []\r

         }\r
         }\r

+        AsBuiltInfDict['module_inf_version'] = '0x%08x' % self.AutoGenVersion\r
+        if DriverType:\r
+            AsBuiltInfDict['pcd_is_driver_string'] += [DriverType]\r

 \r
         if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
           AsBuiltInfDict['module_uefi_specification_version'] += [self.Specification['UEFI_SPECIFICATION_VERSION']]\r
 \r
         if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
           AsBuiltInfDict['module_uefi_specification_version'] += [self.Specification['UEFI_SPECIFICATION_VERSION']]\r


@@ -2744,9 +2816,125 @@ class ModuleAutoGen(AutoGen):
             if self.ModuleType in ['DXE_SMM_DRIVER']:\r
               AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
 \r
             if self.ModuleType in ['DXE_SMM_DRIVER']:\r
               AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
 \r

+        for Root, Dirs, Files in os.walk(OutputDir):\r
+            for File in Files:\r
+                if File.lower().endswith('.pdb'):\r
+                    AsBuiltInfDict['binary_item'] += ['DISPOSABLE|' + File]\r
+        HeaderComments = self.Module.HeaderComments\r
+        StartPos = 0\r
+        for Index in range(len(HeaderComments)):\r
+            if HeaderComments[Index].find('@BinaryHeader') != -1:\r
+                HeaderComments[Index] = HeaderComments[Index].replace('@BinaryHeader', '@file')\r
+                StartPos = Index\r
+                break\r
+        AsBuiltInfDict['header_comments'] = '\n'.join(HeaderComments[StartPos:]).replace(':#', '://')\r
+        GenList = [\r
+            (self.ProtocolList, self._ProtocolComments, 'protocol_item'),\r
+            (self.PpiList, self._PpiComments, 'ppi_item'),\r
+            (GuidList, self._GuidComments, 'guid_item')\r
+        ]\r
+        for Item in GenList:\r
+            for CName in Item[0]:\r
+                Comments = ''\r
+                if CName in Item[1]:\r
+                    Comments = '\n  '.join(Item[1][CName])\r
+                Entry = CName\r
+                if Comments:\r
+                    Entry = Comments + '\n  ' + CName\r
+                AsBuiltInfDict[Item[2]].append(Entry)\r
+        PatchList = parsePcdInfoFromMapFile(\r
+                            os.path.join(self.OutputDir, self.Name + '.map'),\r
+                            os.path.join(self.OutputDir, self.Name + '.efi')\r
+                        )\r
+        if PatchList:\r
+            for PatchPcd in PatchList:\r
+                if PatchPcd[0] not in PatchablePcds:\r
+                    continue\r
+                Pcd = PatchablePcds[PatchPcd[0]]\r
+                PcdValue = ''\r
+                if Pcd.DatumType != 'VOID*':\r
+                    HexFormat = '0x%02x'\r
+                    if Pcd.DatumType == 'UINT16':\r
+                        HexFormat = '0x%04x'\r
+                    elif Pcd.DatumType == 'UINT32':\r
+                        HexFormat = '0x%08x'\r
+                    elif Pcd.DatumType == 'UINT64':\r
+                        HexFormat = '0x%016x'\r
+                    PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
+                else:\r
+                    if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
+                        EdkLogger.error("build", AUTOGEN_ERROR,\r
+                                        "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
+                                        )\r
+                    ArraySize = int(Pcd.MaxDatumSize, 0)\r
+                    PcdValue = Pcd.DefaultValue\r
+                    if PcdValue[0] != '{':\r
+                        Unicode = False\r
+                        if PcdValue[0] == 'L':\r
+                            Unicode = True\r
+                        PcdValue = PcdValue.lstrip('L')\r
+                        PcdValue = eval(PcdValue)\r
+                        NewValue = '{'\r
+                        for Index in range(0, len(PcdValue)):\r
+                            if Unicode:\r
+                                CharVal = ord(PcdValue[Index])\r
+                                NewValue = NewValue + '0x%02x' % (CharVal & 0x00FF) + ', ' \\r
+                                        + '0x%02x' % (CharVal >> 8) + ', '\r
+                            else:\r
+                                NewValue = NewValue + '0x%02x' % (ord(PcdValue[Index]) % 0x100) + ', '\r
+                        Padding = '0x00, '\r
+                        if Unicode:\r
+                            Padding = Padding * 2\r
+                            ArraySize = ArraySize / 2\r
+                        if ArraySize < (len(PcdValue) + 1):\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
+                                            )\r
+                        if ArraySize > len(PcdValue) + 1:\r
+                            NewValue = NewValue + Padding * (ArraySize - len(PcdValue) - 1)\r
+                        PcdValue = NewValue + Padding.strip().rstrip(',') + '}'\r
+                    elif len(PcdValue.split(',')) <= ArraySize:\r
+                        PcdValue = PcdValue.rstrip('}') + ', 0x00' * (ArraySize - len(PcdValue.split(',')))\r
+                        PcdValue += '}'\r
+                    else:\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
+                                        )\r
+                PcdItem = '%s.%s|%s|0x%X' % \\r
+                    (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, PcdValue, PatchPcd[1])\r
+                PcdComments = ''\r
+                if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
+                    PcdComments = '\n  '.join(self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName])\r
+                if PcdComments:\r
+                    PcdItem = PcdComments + '\n  ' + PcdItem\r
+                AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r

         for Pcd in Pcds:\r
         for Pcd in Pcds:\r

-          AsBuiltInfDict['pcd_item'] += [Pcd.TokenSpaceGuidCName + '.' + Pcd.TokenCName]\r
-         \r
+            PcdComments = ''\r
+            PcdCommentList = []\r
+            HiiInfo = ''\r
+            if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
+                for SkuName in Pcd.SkuInfoList:\r
+                    SkuInfo = Pcd.SkuInfoList[SkuName]\r
+                    HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
+                    break\r
+            if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
+                PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
+            if HiiInfo:\r
+                UsageIndex = -1\r
+                for Index, Comment in enumerate(PcdCommentList):\r
+                    for Usage in UsageList:\r
+                        if Comment.find(Usage) != -1:\r
+                            UsageIndex = Index\r
+                            break\r
+                if UsageIndex != -1:\r
+                    PcdCommentList[UsageIndex] = PcdCommentList[UsageIndex] + ' ' + HiiInfo\r
+                else:\r
+                    PcdCommentList.append('## ' + HiiInfo)\r
+            PcdComments = '\n  '.join(PcdCommentList)\r
+            PcdEntry = Pcd.TokenSpaceGuidCName + '.' + Pcd.TokenCName\r
+            if PcdComments:\r
+                PcdEntry = PcdComments + '\n  ' + PcdEntry\r
+            AsBuiltInfDict['pcd_item'] += [PcdEntry]\r

         for Item in self.BuildOption:\r
           if 'FLAGS' in self.BuildOption[Item]:\r
             AsBuiltInfDict['flags_item'] += ['%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip())]\r
         for Item in self.BuildOption:\r
           if 'FLAGS' in self.BuildOption[Item]:\r
             AsBuiltInfDict['flags_item'] += ['%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip())]\r


@@ -2793,6 +2981,11 @@ class ModuleAutoGen(AutoGen):
         if self.IsCodeFileCreated:\r
             return\r
 \r
         if self.IsCodeFileCreated:\r
             return\r
 \r

+        # Need to generate PcdDatabase even PcdDriver is binarymodule\r
+        if self.IsBinaryModule and self.PcdIsDriver != '':\r
+            CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
+            return\r
+\r

         if not self.IsLibrary and CreateLibraryCodeFile:\r
             for LibraryAutoGen in self.LibraryAutoGenList:\r
                 LibraryAutoGen.CreateCodeFile()\r
         if not self.IsLibrary and CreateLibraryCodeFile:\r
             for LibraryAutoGen in self.LibraryAutoGenList:\r
                 LibraryAutoGen.CreateCodeFile()\r


@@ -2875,7 +3068,7 @@ class ModuleAutoGen(AutoGen):
     Specification   = property(_GetSpecification)\r
 \r
     IsLibrary       = property(_IsLibrary)\r
     Specification   = property(_GetSpecification)\r
 \r
     IsLibrary       = property(_IsLibrary)\r

-\r
+    IsBinaryModule  = property(_IsBinaryModule)\r

     BuildDir        = property(_GetBuildDir)\r
     OutputDir       = property(_GetOutputDir)\r
     DebugDir        = property(_GetDebugDir)\r
     BuildDir        = property(_GetBuildDir)\r
     OutputDir       = property(_GetOutputDir)\r
     DebugDir        = property(_GetDebugDir)\r

diff --git a/BaseTools/Source/Python/AutoGen/GenC.py b/BaseTools/Source/Python/AutoGen/GenC.py
index 2eb920417e2d5991d4cf085e380073064e722bad..63ba2b241eec259e428565e60ff98199a4574ad3 100644 (file)
--- a/BaseTools/Source/Python/AutoGen/GenC.py
+++ b/BaseTools/Source/Python/AutoGen/GenC.py
@@ -1,7 +1,7 @@
 ## @file
 # Routines for generating AutoGen.h and AutoGen.c
 #
 ## @file
 # Routines for generating AutoGen.h and AutoGen.c
 #

-# Copyright (c) 2007 - 2012, 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
 # which accompanies this distribution.  The full text of the license may be found at
 # This program and the accompanying materials
 # are licensed and made available under the terms and conditions of the BSD License
 # which accompanies this distribution.  The full text of the license may be found at


@@ -22,6 +22,7 @@ from Common.DataType import *
 from Common.Misc import *
 from Common.String import StringToArray
 from StrGather import *
 from Common.Misc import *
 from Common.String import StringToArray
 from StrGather import *

+from GenPcdDb import CreatePcdDatabaseCode

 
 ## PCD type string
 gItemTypeStringDatabase  = {
 
 ## PCD type string
 gItemTypeStringDatabase  = {


@@ -49,252 +50,6 @@ gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64
 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}
 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}
 
 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}
 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}
 

-## Mapping between PCD driver type and EFI phase
-gPcdPhaseMap = {
-    "PEI_PCD_DRIVER"    :   "PEI",
-    "DXE_PCD_DRIVER"    :   "DXE"
-}
-
-gPcdDatabaseCommonAutoGenH = """
-//
-// The following definition will be generated by build tool
-//
-
-//
-// Common definitions
-//
-typedef UINT8 SKU_ID;
-
-#define PCD_TYPE_SHIFT        28
-
-#define PCD_TYPE_DATA         (0x0U << PCD_TYPE_SHIFT)
-#define PCD_TYPE_HII          (0x8U << PCD_TYPE_SHIFT)
-#define PCD_TYPE_VPD          (0x4U << PCD_TYPE_SHIFT)
-#define PCD_TYPE_SKU_ENABLED  (0x2U << PCD_TYPE_SHIFT)
-#define PCD_TYPE_STRING       (0x1U << PCD_TYPE_SHIFT)
-
-#define PCD_TYPE_ALL_SET      (PCD_TYPE_DATA | PCD_TYPE_HII | PCD_TYPE_VPD | PCD_TYPE_SKU_ENABLED | PCD_TYPE_STRING)
-
-#define PCD_DATUM_TYPE_SHIFT  24
-
-#define PCD_DATUM_TYPE_POINTER  (0x0U << PCD_DATUM_TYPE_SHIFT)
-#define PCD_DATUM_TYPE_UINT8    (0x1U << PCD_DATUM_TYPE_SHIFT)
-#define PCD_DATUM_TYPE_UINT16   (0x2U << PCD_DATUM_TYPE_SHIFT)
-#define PCD_DATUM_TYPE_UINT32   (0x4U << PCD_DATUM_TYPE_SHIFT)
-#define PCD_DATUM_TYPE_UINT64   (0x8U << PCD_DATUM_TYPE_SHIFT)
-
-#define PCD_DATUM_TYPE_ALL_SET  (PCD_DATUM_TYPE_POINTER | \\
-                                 PCD_DATUM_TYPE_UINT8   | \\
-                                 PCD_DATUM_TYPE_UINT16  | \\
-                                 PCD_DATUM_TYPE_UINT32  | \\
-                                 PCD_DATUM_TYPE_UINT64)
-
-#define PCD_DATABASE_OFFSET_MASK (~(PCD_TYPE_ALL_SET | PCD_DATUM_TYPE_ALL_SET))
-
-typedef struct  {
-  UINT32  ExTokenNumber;
-  UINT16  LocalTokenNumber;   // PCD Number of this particular platform build
-  UINT16  ExGuidIndex;        // Index of GuidTable
-} DYNAMICEX_MAPPING;
-
-typedef struct {
-  UINT32  SkuDataStartOffset; //We have to use offsetof MACRO as we don't know padding done by compiler
-  UINT32  SkuIdTableOffset;   //Offset from the PCD_DB
-} SKU_HEAD;
-
-typedef struct {
-  UINT32  StringIndex;        // Offset in String Table in units of UINT32.
-  UINT32  DefaultValueOffset; // Offset of the Default Value
-  UINT16  GuidTableIndex;     // Offset in Guid Table in units of GUID.
-  UINT16  Offset;             // Offset in Variable
-} VARIABLE_HEAD;
-
-typedef  struct {
-  UINT32  Offset;
-} VPD_HEAD;
-
-typedef UINT32 STRING_HEAD;
-
-typedef UINT16 SIZE_INFO;
-
-#define offsetof(s,m)  (UINT32) (UINTN) &(((s *)0)->m)
-
-"""
-
-gPcdDatabaseEpilogueAutoGenH = """
-typedef struct {
-  PEI_PCD_DATABASE PeiDb;
-  DXE_PCD_DATABASE DxeDb;
-} PCD_DATABASE;
-
-#define PCD_TOTAL_TOKEN_NUMBER (PEI_LOCAL_TOKEN_NUMBER + DXE_LOCAL_TOKEN_NUMBER)
-
-"""
-
-gPcdDatabaseAutoGenH = TemplateString("""
-#define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}
-#define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}
-#define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}
-#define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}
-#define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}
-#define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}
-#define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}
-#define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}
-#define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}
-#define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}
-#define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}
-#define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}
-#define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}
-
-typedef struct {
-${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];
-${END}
-${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};
-${END}
-${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];
-${END}
-${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};
-${END}
-${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];
-${END}
-  DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];
-  UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];
-  GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];
-${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];
-${END}
-${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}];
-${END}
-${BEGIN}  UINT8              StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
-${END}
-  SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];
-${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];
-${END}
-${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};
-${END}
-${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];
-${END}
-${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};
-${END}
-${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];
-${END}
-${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};
-${END}
-  UINT8              SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];
-${SYSTEM_SKU_ID}
-} ${PHASE}_PCD_DATABASE_INIT;
-
-typedef struct {
-${PCD_DATABASE_UNINIT_EMPTY}
-${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];
-${END}
-${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];
-${END}
-${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];
-${END}
-${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];
-${END}
-${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];
-${END}
-} ${PHASE}_PCD_DATABASE_UNINIT;
-
-#define PCD_${PHASE}_SERVICE_DRIVER_VERSION         2
-
-typedef struct {
-  ${PHASE}_PCD_DATABASE_INIT    Init;
-  ${PHASE}_PCD_DATABASE_UNINIT  Uninit;
-} ${PHASE}_PCD_DATABASE;
-
-#define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)
-""")
-
-gEmptyPcdDatabaseAutoGenC = TemplateString("""
-${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
-  /* ExMapTable */
-  {
-    {0, 0, 0}
-  },
-  /* LocalTokenNumberTable */
-  {
-    0
-  },
-  /* GuidTable */
-  {
-    {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
-  },
-  /* StringTable */
-  { 0 },
-  /* SizeTable */
-  {
-    0, 0
-  },
-  /* SkuIdTable */
-  { 0 },
-  ${SYSTEM_SKU_ID_VALUE}
-};
-""")
-
-gPcdDatabaseAutoGenC = TemplateString("""
-${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {
-${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */
-${END}
-${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */
-${END}
-${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */
-${END}
-${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */
-${END}
-  /* VPD */
-${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */
-${END}
-  /* ExMapTable */
-  {
-${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },
-${END}
-  },
-  /* LocalTokenNumberTable */
-  {
-${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE},
-${END}
-  },
-  /* GuidTable */
-  {
-${BEGIN}    ${GUID_STRUCTURE},
-${END}
-  },
-${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */
-${END}
-${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}] */
-  {
-    ${VARIABLE_HEAD_VALUE}
-  },
-${END}
- /* StringTable */
-${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */
-${END}
-  /* SizeTable */
-  {
-${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */
-${END}
-  },
-${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */
-${END}
-${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */
-${END}
-${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */
-${END}
-${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */
-${END}
-${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */
-${END}
-${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */
-${END}
-  /* SkuIdTable */
-  { ${BEGIN}${SKUID_VALUE}, ${END} },
-  ${SYSTEM_SKU_ID_VALUE}
-};
-""")
-
-

 ## AutoGen File Header Templates
 gAutoGenHeaderString = TemplateString("""\
 /**
 ## AutoGen File Header Templates
 gAutoGenHeaderString = TemplateString("""\
 /**


@@ -907,6 +662,76 @@ gModuleTypeHeaderFile = {
     "USER_DEFINED"      :   [gBasicHeaderFile]
 }
 
     "USER_DEFINED"      :   [gBasicHeaderFile]
 }
 

+## Autogen internal worker macro to define DynamicEx PCD name includes both the TokenSpaceGuidName 
+#  the TokenName and Guid comparison to avoid define name collisions.
+#
+#   @param      Info        The ModuleAutoGen object
+#   @param      AutoGenH    The TemplateString object for header file
+#
+#
+def DynExPcdTokenNumberMapping(Info, AutoGenH):
+    ExTokenCNameList = []
+    PcdExList        = []
+    if Info.IsLibrary:
+        PcdList = Info.LibraryPcdList
+    else:
+        PcdList = Info.ModulePcdList
+    for Pcd in PcdList:
+        if Pcd.Type in gDynamicExPcd:
+            ExTokenCNameList.append(Pcd.TokenCName)
+            PcdExList.append(Pcd)
+    if len(ExTokenCNameList) == 0:
+        return
+    AutoGenH.Append('\n#define COMPAREGUID(Guid1, Guid2) (BOOLEAN)(*(CONST UINT64*)Guid1 == *(CONST UINT64*)Guid2 && *((CONST UINT64*)Guid1 + 1) == *((CONST UINT64*)Guid2 + 1))\n')
+    # AutoGen for each PCD listed in a [PcdEx] section of a Module/Lib INF file.
+    # Auto generate a macro for each TokenName that takes a Guid pointer as a parameter.  
+    # Use the Guid pointer to see if it matches any of the token space GUIDs.
+    TokenCNameList = []
+    for TokenCName in ExTokenCNameList:
+        if TokenCName in TokenCNameList:
+            continue
+        Index = 0
+        Count = ExTokenCNameList.count(TokenCName)
+        for Pcd in PcdExList:
+            if Pcd.TokenCName == TokenCName:
+                Index = Index + 1
+                if Index == 1:
+                    AutoGenH.Append('\n#define __PCD_%s_ADDR_CMP(GuidPtr)  (' % (Pcd.TokenCName))
+                    AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:' 
+                                    % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                else:
+                    AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:' 
+                                    % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                if Index == Count:
+                    AutoGenH.Append('0 \\\n  )\n')
+                TokenCNameList.append(TokenCName)
+    
+    TokenCNameList = []
+    for TokenCName in ExTokenCNameList:
+        if TokenCName in TokenCNameList:
+            continue
+        Index = 0
+        Count = ExTokenCNameList.count(TokenCName)
+        for Pcd in PcdExList:
+            if Pcd.Type in gDynamicExPcd and Pcd.TokenCName == TokenCName:
+                Index = Index + 1
+                if Index == 1:
+                    AutoGenH.Append('\n#define __PCD_%s_VAL_CMP(GuidPtr)  (' % (Pcd.TokenCName))
+                    AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:' 
+                                    % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                else:
+                    AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:' 
+                                    % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
+                if Index == Count:
+                    AutoGenH.Append('0 \\\n  )\n')
+                    # Autogen internal worker macro to compare GUIDs.  Guid1 is a pointer to a GUID.  
+                    # Guid2 is a C name for a GUID. Compare pointers first because optimizing compiler
+                    # can do this at build time on CONST GUID pointers and optimize away call to COMPAREGUID().
+                    #  COMPAREGUID() will only be used if the Guid passed in is local to the module.
+                    AutoGenH.Append('#define _PCD_TOKEN_EX_%s(GuidPtr)   __PCD_%s_ADDR_CMP(GuidPtr) ? __PCD_%s_ADDR_CMP(GuidPtr) : __PCD_%s_VAL_CMP(GuidPtr)  \n'
+                                    % (Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
+                TokenCNameList.append(TokenCName)
+

 ## Create code for module PCDs
 #
 #   @param      Info        The ModuleAutoGen object
 ## Create code for module PCDs
 #
 #   @param      Info        The ModuleAutoGen object


@@ -923,13 +748,29 @@ def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
     if Pcd.Type in gDynamicExPcd:
         TokenNumber = int(Pcd.TokenValue, 0)
     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
     if Pcd.Type in gDynamicExPcd:
         TokenNumber = int(Pcd.TokenValue, 0)

+        # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with 
+        # different Guids but same TokenCName
+        PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + Pcd.TokenCName
+        AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))

     else:
         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
     else:
         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:

-            EdkLogger.error("build", AUTOGEN_ERROR,
-                            "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
-                            ExtraData="[%s]" % str(Info))
-        TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
-    AutoGenH.Append('\n#define %s  %dU\n' % (PcdTokenName, TokenNumber))
+            # If one of the Source built modules listed in the DSC is not listed in FDF modules, 
+            # and the INF lists a PCD can only use the PcdsDynamic access method (it is only 
+            # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will 
+            # report warning message notify the PI that they are attempting to build a module 
+            # that must be included in a flash image in order to be functional. These Dynamic PCD 
+            # will not be added into the Database unless it is used by other modules that are 
+            # included in the FDF file. 
+            # In this case, just assign an invalid token number to make it pass build.
+            if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
+                TokenNumber = 0
+            else:
+                EdkLogger.error("build", AUTOGEN_ERROR,
+                                "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
+                                ExtraData="[%s]" % str(Info))
+        else:
+            TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
+        AutoGenH.Append('\n#define %s  %dU\n' % (PcdTokenName, TokenNumber))

 
     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
     if Pcd.Type not in gItemTypeStringDatabase:
 
     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
     if Pcd.Type not in gItemTypeStringDatabase:


@@ -946,12 +787,33 @@ def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 
     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 

+    PcdExCNameList  = []

     if Pcd.Type in gDynamicExPcd:
     if Pcd.Type in gDynamicExPcd:

-        AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
-        if Pcd.DatumType == 'VOID*':
-            AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+        if Info.IsLibrary:
+            PcdList = Info.LibraryPcdList

         else:
         else:

-            AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            PcdList = Info.ModulePcdList
+        for PcdModule in PcdList:
+            if PcdModule.Type in gDynamicExPcd:
+                PcdExCNameList.append(PcdModule.TokenCName)
+        # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
+        # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
+        # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
+        if PcdExCNameList.count(Pcd.TokenCName) > 1:
+            AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
+            AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
+            AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            if Pcd.DatumType == 'VOID*':
+                AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            else:
+                AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+        else:
+            AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
+            AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            if Pcd.DatumType == 'VOID*':
+                AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            else:
+                AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))

     elif Pcd.Type in gDynamicPcd:
         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
         if Pcd.DatumType == 'VOID*':
     elif Pcd.Type in gDynamicPcd:
         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
         if Pcd.DatumType == 'VOID*':


@@ -1117,16 +979,30 @@ def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
     TokenCName  = Pcd.TokenCName
     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
     TokenCName  = Pcd.TokenCName

-    TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[TokenSpaceGuidCName]
-    if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
-        EdkLogger.error("build", AUTOGEN_ERROR,
-                        "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
-                        ExtraData="[%s]" % str(Info))
-    TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]
-
-    # If PCD is DynamicEx, then use TokenNumber declared in DEC file
+    PcdTokenName = '_PCD_TOKEN_' + TokenCName
+    #
+    # Write PCDs
+    #

     if Pcd.Type in gDynamicExPcd:
         TokenNumber = int(Pcd.TokenValue, 0)
     if Pcd.Type in gDynamicExPcd:
         TokenNumber = int(Pcd.TokenValue, 0)

+    else:
+        if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
+            # If one of the Source built modules listed in the DSC is not listed in FDF modules, 
+            # and the INF lists a PCD can only use the PcdsDynamic access method (it is only 
+            # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will 
+            # report warning message notify the PI that they are attempting to build a module 
+            # that must be included in a flash image in order to be functional. These Dynamic PCD 
+            # will not be added into the Database unless it is used by other modules that are 
+            # included in the FDF file. 
+            # In this case, just assign an invalid token number to make it pass build.
+            if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
+                TokenNumber = 0
+            else:
+                EdkLogger.error("build", AUTOGEN_ERROR,
+                                "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
+                                ExtraData="[%s]" % str(Info))
+        else:
+            TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]

 
     if Pcd.Type not in gItemTypeStringDatabase:
         EdkLogger.error("build", AUTOGEN_ERROR,
 
     if Pcd.Type not in gItemTypeStringDatabase:
         EdkLogger.error("build", AUTOGEN_ERROR,


@@ -1148,23 +1024,40 @@ def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
     if Pcd.DatumType == 'VOID*':
         Type = '(VOID *)'
         Array = '[]'
     if Pcd.DatumType == 'VOID*':
         Type = '(VOID *)'
         Array = '[]'

-
-    AutoGenH.Append('#define _PCD_TOKEN_%s  %dU\n' % (TokenCName, TokenNumber))
-

     PcdItemType = Pcd.Type
     PcdItemType = Pcd.Type

-    #if PcdItemType in gDynamicPcd:
-    #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD
-    #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:
-    #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type
+    PcdExCNameList  = []

     if PcdItemType in gDynamicExPcd:
     if PcdItemType in gDynamicExPcd:

-        PcdTokenName = '_PCD_TOKEN_' + TokenCName
-        AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
-        if DatumType == 'VOID*':
-            AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
+        PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + Pcd.TokenCName
+        AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
+        
+        if Info.IsLibrary:
+            PcdList = Info.LibraryPcdList
+        else:
+            PcdList = Info.ModulePcdList
+        for PcdModule in PcdList:
+            if PcdModule.Type in gDynamicExPcd:
+                PcdExCNameList.append(PcdModule.TokenCName)
+        # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
+        # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
+        # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
+        if PcdExCNameList.count(Pcd.TokenCName) > 1:
+            AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
+            AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
+            AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            if Pcd.DatumType == 'VOID*':
+                AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            else:
+                AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))

         else:
         else:

-            AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))
+            AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
+            AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            if Pcd.DatumType == 'VOID*':
+                AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+            else:
+                AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
+    else:
+        AutoGenH.Append('#define _PCD_TOKEN_%s  %dU\n' % (TokenCName, TokenNumber))

     if PcdItemType in gDynamicPcd:
     if PcdItemType in gDynamicPcd:

-        PcdTokenName = '_PCD_TOKEN_' + TokenCName

         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
         if DatumType == 'VOID*':
             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
         if DatumType == 'VOID*':
             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))


@@ -1172,468 +1065,15 @@ def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName

-        AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )
+        AutoGenH.Append('extern volatile %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )

         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:
         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
         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:
         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))

-        #AutoGenH.Append('#define _PCD_VALUE_%s  _gPcd_FixedAtBuild_%s\n' %(TokenCName, TokenCName))

         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)
 
         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)
 

-## Create code for PCD database in DXE or PEI phase
-#
-#   @param      Platform    The platform object
-#   @retval     tuple       Two TemplateString objects for C code and header file,
-#                           respectively
-#
-def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):
-    AutoGenC = TemplateString()
-    AutoGenH = TemplateString()
-
-    Dict = {
-        'PHASE'                         : Phase,
-        'GUID_TABLE_SIZE'               : '1U',
-        'STRING_TABLE_SIZE'             : '1U',
-        'SKUID_TABLE_SIZE'              : '1U',
-        'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1U',
-        'LOCAL_TOKEN_NUMBER'            : '0U',
-        'EXMAPPING_TABLE_SIZE'          : '1U',
-        'EX_TOKEN_NUMBER'               : '0U',
-        'SIZE_TABLE_SIZE'               : '2U',
-        'GUID_TABLE_EMPTY'              : 'TRUE',
-        'STRING_TABLE_EMPTY'            : 'TRUE',
-        'SKUID_TABLE_EMPTY'             : 'TRUE',
-        'DATABASE_EMPTY'                : 'TRUE',
-        'EXMAP_TABLE_EMPTY'             : 'TRUE',
-        'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',
-        'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',
-        'SYSTEM_SKU_ID_VALUE'           : '0U'
-    }
-
-    for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN', "VOID*"]:
-        Dict['VARDEF_CNAME_' + DatumType] = []
-        Dict['VARDEF_GUID_' + DatumType]  = []
-        Dict['VARDEF_SKUID_' + DatumType] = []
-        Dict['VARDEF_VALUE_' + DatumType] = []
-        for Init in ['INIT','UNINIT']:
-            Dict[Init+'_CNAME_DECL_' + DatumType]   = []
-            Dict[Init+'_GUID_DECL_' + DatumType]    = []
-            Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []
-            Dict[Init+'_VALUE_' + DatumType]        = []
-
-    for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:
-        Dict[Type + '_CNAME_DECL']   = []
-        Dict[Type + '_GUID_DECL']    = []
-        Dict[Type + '_NUMSKUS_DECL'] = []
-        Dict[Type + '_VALUE'] = []
-
-    Dict['STRING_TABLE_INDEX'] = []
-    Dict['STRING_TABLE_LENGTH']  = []
-    Dict['STRING_TABLE_CNAME'] = []
-    Dict['STRING_TABLE_GUID']  = []
-    Dict['STRING_TABLE_VALUE'] = []
-
-    Dict['SIZE_TABLE_CNAME'] = []
-    Dict['SIZE_TABLE_GUID']  = []
-    Dict['SIZE_TABLE_CURRENT_LENGTH']  = []
-    Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []
-
-    Dict['EXMAPPING_TABLE_EXTOKEN'] = []
-    Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []
-    Dict['EXMAPPING_TABLE_GUID_INDEX'] = []
-
-    Dict['GUID_STRUCTURE'] = []
-
-    Dict['SKUID_VALUE'] = []
-    Dict['VARDEF_HEADER'] = []
-    if Phase == 'DXE':
-        Dict['SYSTEM_SKU_ID'] = ''
-        Dict['SYSTEM_SKU_ID_VALUE'] = ''
-
-    StringTableIndex = 0
-    StringTableSize = 0
-    NumberOfLocalTokens = 0
-    NumberOfPeiLocalTokens = 0
-    NumberOfDxeLocalTokens = 0
-    NumberOfExTokens = 0
-    NumberOfSizeItems = 0
-    GuidList = []
-    
-    for Pcd in Platform.DynamicPcdList:
-        CName = Pcd.TokenCName
-        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
-
-        EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))
-        if Pcd.DatumType not in gDatumSizeStringDatabase:
-            EdkLogger.error("build", AUTOGEN_ERROR,
-                            "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
-                            ExtraData="[%s]" % str(Platform))
-
-        if Pcd.Phase == 'PEI':
-            NumberOfPeiLocalTokens += 1
-        if Pcd.Phase == 'DXE':
-            NumberOfDxeLocalTokens += 1
-        if Pcd.Phase != Phase:
-            continue
-
-        #
-        # TODO: need GetGuidValue() definition
-        #
-        TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue
-        TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)
-        if Pcd.Type in gDynamicExPcd:
-            if TokenSpaceGuid not in GuidList:
-                GuidList += [TokenSpaceGuid]
-                Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)
-            NumberOfExTokens += 1

 
 

-        ValueList = []
-        StringHeadOffsetList = []
-        VpdHeadOffsetList = []
-        VariableHeadValueList = []
-        Pcd.InitString = 'UNINIT'
-
-        if Pcd.DatumType == 'VOID*':
-            if Pcd.Type not in ["DynamicVpd", "DynamicExVpd"]:
-                Pcd.TokenTypeList = ['PCD_TYPE_STRING']
-            else:
-                Pcd.TokenTypeList = []
-        elif Pcd.DatumType == 'BOOLEAN':
-            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']
-        else:
-            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]
-
-        if len(Pcd.SkuInfoList) > 1:
-            Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']
-
-        for SkuName in Pcd.SkuInfoList:
-            Sku = Pcd.SkuInfoList[SkuName]
-            SkuId = Sku.SkuId
-            if SkuId == None or SkuId == '':
-                continue
-
-            if (SkuId + 'U') not in Dict['SKUID_VALUE']:
-                Dict['SKUID_VALUE'].append(SkuId + 'U')
-
-            SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId + 'U')
-            if len(Sku.VariableName) > 0:
-                Pcd.TokenTypeList += ['PCD_TYPE_HII']
-                Pcd.InitString = 'INIT'
-                VariableNameStructure = StringToArray(Sku.VariableName)
-                if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:
-                    Dict['STRING_TABLE_CNAME'].append(CName)
-                    Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
-                    if StringTableIndex == 0:
-                        Dict['STRING_TABLE_INDEX'].append('')
-                    else:
-                        Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
-
-                    Dict['STRING_TABLE_LENGTH'].append((len(Sku.VariableName) - 3 + 1) * 2)
-                    Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)
-                    StringTableIndex += 1
-                    StringTableSize += (len(Sku.VariableName) - 3 + 1) * 2
-
-                VariableHeadStringIndex = 0
-                for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):
-                    VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]
-
-                VariableGuidStructure = Sku.VariableGuidValue
-                VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)
-                if VariableGuid not in GuidList:
-                    GuidList += [VariableGuid]
-                    Dict['GUID_STRUCTURE'].append(VariableGuidStructure)
-                VariableHeadGuidIndex = GuidList.index(VariableGuid)
-
-                if "PCD_TYPE_STRING" in Pcd.TokenTypeList:
-                    VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s), %dU, %sU' %
-                                                 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, 
-                                                                                                VariableHeadGuidIndex, Sku.VariableOffset))
-                else:
-                    VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s), %dU, %sU' %
-                                                 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, SkuIdIndex, 
-                                                                                                VariableHeadGuidIndex, Sku.VariableOffset))
-                Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)
-                Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)
-                Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)
-                if "PCD_TYPE_STRING" in  Pcd.TokenTypeList:
-                    Dict['VARDEF_VALUE_' + Pcd.DatumType].append("%s_%s[%d]" % (Pcd.TokenCName, TokenSpaceGuid, SkuIdIndex))
-                else:
-                    #
-                    # ULL (for UINT64) or U(other integer type) should be append to avoid
-                    # warning under linux building environment.
-                    #
-                    if Pcd.DatumType == "UINT64":
-                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "ULL")
-                    elif Pcd.DatumType in ("UINT32", "UINT16", "UINT8"):
-                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "U")
-                    elif Pcd.DatumType == "BOOLEAN":
-                        if Sku.HiiDefaultValue in ["1", "0"]:
-                            Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "U")
-                    else:
-                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)
-
-            elif Sku.VpdOffset != '':
-                Pcd.TokenTypeList += ['PCD_TYPE_VPD']
-                Pcd.InitString = 'INIT'
-                VpdHeadOffsetList.append(str(Sku.VpdOffset) + 'U')
-                continue
-          
-            if Pcd.DatumType == 'VOID*':
-                Pcd.TokenTypeList += ['PCD_TYPE_STRING']
-                Pcd.InitString = 'INIT'
-                if Sku.HiiDefaultValue != '' and Sku.DefaultValue == '':
-                    Sku.DefaultValue = Sku.HiiDefaultValue
-                if Sku.DefaultValue != '':
-                    NumberOfSizeItems += 1
-                    Dict['STRING_TABLE_CNAME'].append(CName)
-                    Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)
-
-                    if StringTableIndex == 0:
-                        Dict['STRING_TABLE_INDEX'].append('')
-                    else:
-                        Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)
-                    if Sku.DefaultValue[0] == 'L':
-                        Size = (len(Sku.DefaultValue) - 3 + 1) * 2
-                        Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))
-                    elif Sku.DefaultValue[0] == '"':
-                        Size = len(Sku.DefaultValue) - 2 + 1
-                        Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))
-                    elif Sku.DefaultValue[0] == '{':
-                        Size = len(Sku.DefaultValue.replace(',',' ').split())
-                        Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)
-
-                    StringHeadOffsetList.append(str(StringTableSize) + 'U')
-                    Dict['SIZE_TABLE_CNAME'].append(CName)
-                    Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)
-                    Dict['SIZE_TABLE_CURRENT_LENGTH'].append(str(Size) + 'U')
-                    Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(str(Pcd.MaxDatumSize) + 'U')
-                    if Pcd.MaxDatumSize != '':
-                        MaxDatumSize = int(Pcd.MaxDatumSize, 0)
-                        if MaxDatumSize < Size:
-                            EdkLogger.error("build", AUTOGEN_ERROR,
-                                            "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
-                                            ExtraData="[%s]" % str(Platform))
-                        Size = MaxDatumSize
-                    Dict['STRING_TABLE_LENGTH'].append(Size)
-                    StringTableIndex += 1
-                    StringTableSize += (Size)
-            else:
-                if "PCD_TYPE_HII" not in Pcd.TokenTypeList:
-                    Pcd.TokenTypeList += ['PCD_TYPE_DATA']
-                    if Sku.DefaultValue == 'TRUE':
-                        Pcd.InitString = 'INIT'
-                    else:
-                        try:
-                            if int(Sku.DefaultValue, 0) != 0:
-                                Pcd.InitString = 'INIT'
-                        except:
-                            pass
-                
-                #
-                # For UNIT64 type PCD's value, ULL should be append to avoid
-                # warning under linux building environment.
-                #
-                if Pcd.DatumType == "UINT64":
-                    ValueList.append(Sku.DefaultValue + "ULL")
-                elif Pcd.DatumType in ("UINT32", "UINT16", "UINT8"):
-                    ValueList.append(Sku.DefaultValue + "U")
-                elif Pcd.DatumType == "BOOLEAN":
-                    if Sku.DefaultValue in ["1", "0"]:
-                        ValueList.append(Sku.DefaultValue + "U")              
-                else:
-                    ValueList.append(Sku.DefaultValue)
-
-        Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))
-        
-
-        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
-            Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)
-            Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)
-            Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
-            Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))
-            Dict['VARDEF_HEADER'].append('_Variable_Header')
-        else:
-            Dict['VARDEF_HEADER'].append('')
-        if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:
-            Dict['VPD_HEAD_CNAME_DECL'].append(CName)
-            Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)
-            Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
-            Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))
-        if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:
-            Dict['STRING_HEAD_CNAME_DECL'].append(CName)
-            Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)
-            Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))
-            Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))
-        if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:
-            Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)
-            Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)
-            Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))
-            if Pcd.InitString == 'UNINIT':
-                Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''
-            else:
-                Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))
-
-    if Phase == 'PEI':
-        NumberOfLocalTokens = NumberOfPeiLocalTokens
-    if Phase == 'DXE':
-        NumberOfLocalTokens = NumberOfDxeLocalTokens
-
-    Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]
-    Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]
-    Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]
-    Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]
-    
-    for Pcd in Platform.DynamicPcdList:
-        CName = Pcd.TokenCName
-        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
-        if Pcd.Phase != Phase:
-            continue
-
-        TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))
-        GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1
-        if Phase == 'DXE':
-            GeneratedTokenNumber -= NumberOfPeiLocalTokens
-
-        EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s.%s" % (CName, TokenSpaceGuidCName))
-        EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)
-        EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))
-
-        Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'
-        if Pcd.InitString == 'UNINIT':
-            Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'
-        Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName
-        Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid
-        Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)
-        
-        Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))
-        #
-        # Update VARDEF_HEADER
-        #
-        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:
-            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = '_Variable_Header'
-        else:
-            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = ''
-        
-        
-        if Pcd.Type in gDynamicExPcd:
-            Dict['EXMAPPING_TABLE_EXTOKEN'].append(str(Pcd.TokenValue) + 'U')
-            if Phase == 'DXE':
-                GeneratedTokenNumber += NumberOfPeiLocalTokens
-            #
-            # Per, PCD architecture specification, PCD Token Number is 1 based and 0 is defined as invalid token number.
-            # For each EX type PCD, a PCD Token Number is assigned. When the
-            # PCD Driver/PEIM map EX_GUID and EX_TOKEN_NUMBER to the PCD Token Number,
-            # the non-EX Protocol/PPI interface can be called to get/set the value. This assumption is made by
-            # Pcd Driver/PEIM in MdeModulePkg.
-            # Therefore, 1 is added to GeneratedTokenNumber to generate a PCD Token Number before being inserted
-            # to the EXMAPPING_TABLE.
-            #
-            Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(str(GeneratedTokenNumber + 1) + 'U')
-            Dict['EXMAPPING_TABLE_GUID_INDEX'].append(str(GuidList.index(TokenSpaceGuid)) + 'U')
-
-    if GuidList != []:
-        Dict['GUID_TABLE_EMPTY'] = 'FALSE'
-        Dict['GUID_TABLE_SIZE'] = str(len(GuidList)) + 'U'
-    else:
-        Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]
-
-    if StringTableIndex == 0:
-        Dict['STRING_TABLE_INDEX'].append('')
-        Dict['STRING_TABLE_LENGTH'].append(1)
-        Dict['STRING_TABLE_CNAME'].append('')
-        Dict['STRING_TABLE_GUID'].append('')
-        Dict['STRING_TABLE_VALUE'].append('{ 0 }')
-    else:
-        Dict['STRING_TABLE_EMPTY'] = 'FALSE'
-        Dict['STRING_TABLE_SIZE'] = str(StringTableSize) + 'U'
-
-    if Dict['SIZE_TABLE_CNAME'] == []:
-        Dict['SIZE_TABLE_CNAME'].append('')
-        Dict['SIZE_TABLE_GUID'].append('')
-        Dict['SIZE_TABLE_CURRENT_LENGTH'].append('0U')
-        Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append('0U')
-
-    if NumberOfLocalTokens != 0:
-        Dict['DATABASE_EMPTY']                = 'FALSE'
-        Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens
-        Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens
-
-    if NumberOfExTokens != 0:
-        Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'
-        Dict['EXMAPPING_TABLE_SIZE'] = str(NumberOfExTokens) + 'U'
-        Dict['EX_TOKEN_NUMBER']      = str(NumberOfExTokens) + 'U'
-    else:
-        Dict['EXMAPPING_TABLE_EXTOKEN'].append('0U')
-        Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append('0U')
-        Dict['EXMAPPING_TABLE_GUID_INDEX'].append('0U')
-
-    if NumberOfSizeItems != 0:
-        Dict['SIZE_TABLE_SIZE'] = str(NumberOfSizeItems * 2) + 'U'
-
-    AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))
-    if NumberOfLocalTokens == 0:
-        AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))
-    else:
-        #
-        # Update Size Table to the right order, it should be same with LocalTokenNumberTable
-        #
-        SizeCNameTempList = []
-        SizeGuidTempList = []
-        SizeCurLenTempList = []
-        SizeMaxLenTempList = []
-        ReOrderFlag = True
-  
-        if len(Dict['SIZE_TABLE_CNAME']) == 1:
-            if not (Dict['SIZE_TABLE_CNAME'][0] and Dict['SIZE_TABLE_GUID'][0]):
-                ReOrderFlag = False
-        
-        if ReOrderFlag:
-            for Count in range(len(Dict['TOKEN_CNAME'])):
-                for Count1 in range(len(Dict['SIZE_TABLE_CNAME'])):
-                    if Dict['TOKEN_CNAME'][Count] == Dict['SIZE_TABLE_CNAME'][Count1] and \
-                        Dict['TOKEN_GUID'][Count] == Dict['SIZE_TABLE_GUID'][Count1]:
-                        SizeCNameTempList.append(Dict['SIZE_TABLE_CNAME'][Count1])
-                        SizeGuidTempList.append(Dict['SIZE_TABLE_GUID'][Count1])
-                        SizeCurLenTempList.append(Dict['SIZE_TABLE_CURRENT_LENGTH'][Count1])
-                        SizeMaxLenTempList.append(Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count1])
-                        
-            for Count in range(len(Dict['SIZE_TABLE_CNAME'])):
-                Dict['SIZE_TABLE_CNAME'][Count] = SizeCNameTempList[Count]
-                Dict['SIZE_TABLE_GUID'][Count] = SizeGuidTempList[Count]
-                Dict['SIZE_TABLE_CURRENT_LENGTH'][Count] = SizeCurLenTempList[Count]
-                Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count] = SizeMaxLenTempList[Count]
-                
-        AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))
-
-    return AutoGenH, AutoGenC
-
-## Create code for PCD database
-#
-#   @param      Info        The ModuleAutoGen object
-#   @param      AutoGenC    The TemplateString object for C code
-#   @param      AutoGenH    The TemplateString object for header file
-#
-def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):
-    if Info.PcdIsDriver == "":
-        return
-    if Info.PcdIsDriver not in gPcdPhaseMap:
-        EdkLogger.error("build", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s" % Info.PcdIsDriver,
-                        ExtraData="[%s]" % str(Info))
-
-    AutoGenH.Append(gPcdDatabaseCommonAutoGenH)
-    AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')
-    AutoGenH.Append(AdditionalAutoGenH.String)
-
-    Phase = gPcdPhaseMap[Info.PcdIsDriver]
-    if Phase == 'PEI':
-        AutoGenC.Append(AdditionalAutoGenC.String)
-
-    if Phase == 'DXE':
-        AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)
-        AutoGenH.Append(AdditionalAutoGenH.String)
-        AutoGenC.Append(AdditionalAutoGenC.String)
-        AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)

 
 ## Create code for library constructor
 #
 
 ## Create code for library constructor
 #


@@ -1920,7 +1360,7 @@ def CreatePcdCode(Info, AutoGenC, AutoGenH):
     # Collect Token Space GUIDs used by DynamicEc PCDs
     TokenSpaceList = []
     for Pcd in Info.ModulePcdList:
     # Collect Token Space GUIDs used by DynamicEc PCDs
     TokenSpaceList = []
     for Pcd in Info.ModulePcdList:

-       if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
+        if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:

             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
             
     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
             
     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found


@@ -1938,13 +1378,14 @@ def CreatePcdCode(Info, AutoGenC, AutoGenH):
             AutoGenH.Append("\n// PCD definitions\n")
         for Pcd in Info.ModulePcdList:
             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
             AutoGenH.Append("\n// PCD definitions\n")
         for Pcd in Info.ModulePcdList:
             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)

+        DynExPcdTokenNumberMapping (Info, AutoGenH)

     else:
         if Info.ModulePcdList:
             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
         for Pcd in Info.ModulePcdList:
             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
     else:
         if Info.ModulePcdList:
             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
         for Pcd in Info.ModulePcdList:
             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)

-
+        DynExPcdTokenNumberMapping (Info, AutoGenH)

         if Info.LibraryPcdList:
             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
         if Info.LibraryPcdList:
             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")

diff --git a/BaseTools/Source/Python/AutoGen/GenPcdDb.py b/BaseTools/Source/Python/AutoGen/GenPcdDb.py
new file mode 100644 (file)
index 0000000..08719fa
--- /dev/null
+++ b/BaseTools/Source/Python/AutoGen/GenPcdDb.py
@@ -0,0 +1,1566 @@
+## @file\r
+# Routines for generating Pcd Database\r
+#\r
+# Copyright (c) 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
+# http://opensource.org/licenses/bsd-license.php\r
+#\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+from StringIO import StringIO\r
+from Common.Misc import *\r
+from Common.String import StringToArray\r
+from struct import pack\r
+\r
+DATABASE_VERSION = 4\r
+\r
+gPcdDatabaseAutoGenC = TemplateString("""\r
+//\r
+// External PCD database debug information\r
+//\r
+#if 0\r
+${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
+${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */\r
+${END}\r
+${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */\r
+${END}\r
+${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */\r
+${END}\r
+${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */\r
+${END}\r
+  /* VPD */\r
+${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */\r
+${END}\r
+  /* ExMapTable */\r
+  {\r
+${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },\r
+${END}\r
+  },\r
+  /* LocalTokenNumberTable */\r
+  {\r
+${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE},\r
+${END}\r
+  },\r
+  /* GuidTable */\r
+  {\r
+${BEGIN}    ${GUID_STRUCTURE},\r
+${END}\r
+  },\r
+${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */\r
+${END}\r
+${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}] */\r
+  {\r
+    ${VARIABLE_HEAD_VALUE}\r
+  },\r
+${END}\r
+/* SkuHead */\r
+  {\r
+  ${BEGIN} offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}${VARDEF_HEADER}) | ${TOKEN_TYPE}, /* */\r
+           offsetof (${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.SkuHead)  /* */\r
+  ${END}\r
+  },\r
+ /* StringTable */\r
+${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
+${END}\r
+  /* SizeTable */\r
+  {\r
+${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */\r
+${END}\r
+  },\r
+${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */\r
+${END}\r
+${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */\r
+${END}\r
+${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */\r
+${END}\r
+${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */\r
+${END}\r
+${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */\r
+${END}\r
+${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */\r
+${END}\r
+  /* SkuIdTable */\r
+  { ${BEGIN}${SKUID_VALUE}, ${END} },\r
+  ${SYSTEM_SKU_ID_VALUE}\r
+};\r
+#endif\r
+""")\r
+\r
+## Mapping between PCD driver type and EFI phase\r
+gPcdPhaseMap = {\r
+    "PEI_PCD_DRIVER"    :   "PEI",\r
+    "DXE_PCD_DRIVER"    :   "DXE"\r
+}\r
+\r
+gPcdDatabaseAutoGenH = TemplateString("""\r
+#define PCD_${PHASE}_SERVICE_DRIVER_VERSION         ${SERVICE_DRIVER_VERSION}\r
+\r
+//\r
+// External PCD database debug information\r
+//\r
+#if 0\r
+#define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}\r
+#define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}\r
+#define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}\r
+#define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}\r
+#define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}\r
+#define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}\r
+#define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}\r
+#define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}\r
+#define ${PHASE}_SKU_HEAD_SIZE                  ${SKU_HEAD_SIZE}\r
+#define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}\r
+#define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}\r
+#define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}\r
+#define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}\r
+#define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}\r
+\r
+typedef struct {\r
+${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];\r
+${END}\r
+${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};\r
+${END}\r
+${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];\r
+${END}\r
+${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};\r
+${END}\r
+${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];\r
+${END}\r
+  DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];\r
+  UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r
+  GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];\r
+${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];\r
+${END}\r
+${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}_Variable_Header[${VARIABLE_HEAD_NUMSKUS_DECL}];\r
+${END}\r
+${BEGIN}  SKU_HEAD           SkuHead[${PHASE}_SKU_HEAD_SIZE];\r
+${END}\r
+${BEGIN}  UINT8              StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
+${END}\r
+  SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];\r
+${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];\r
+${END}\r
+${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};\r
+${END}\r
+${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];\r
+${END}\r
+${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};\r
+${END}\r
+${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];\r
+${END}\r
+${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};\r
+${END}\r
+  UINT8              SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];\r
+${SYSTEM_SKU_ID}\r
+} ${PHASE}_PCD_DATABASE_INIT;\r
+\r
+typedef struct {\r
+${PCD_DATABASE_UNINIT_EMPTY}\r
+${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];\r
+${END}\r
+${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];\r
+${END}\r
+${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];\r
+${END}\r
+${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];\r
+${END}\r
+${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];\r
+${END}\r
+} ${PHASE}_PCD_DATABASE_UNINIT;\r
+\r
+typedef struct {\r
+  //GUID                  Signature;  // PcdDataBaseGuid\r
+  //UINT32                Length;\r
+  //UINT32                UninitDataBaseSize;// Total size for PCD those default value with 0.\r
+  //TABLE_OFFSET          LocalTokenNumberTableOffset;\r
+  //TABLE_OFFSET          ExMapTableOffset;\r
+  //TABLE_OFFSET          GuidTableOffset;     \r
+  //TABLE_OFFSET          StringTableOffset;\r
+  //TABLE_OFFSET          SizeTableOffset;\r
+  //TABLE_OFFSET          SkuIdTableOffset; \r
+  //UINT16                LocalTokenCount;  // LOCAL_TOKEN_NUMBER for all\r
+  //UINT16                ExTokenCount;     // EX_TOKEN_NUMBER for DynamicEx\r
+  //UINT16                GuidTableCount;   // The Number of Guid in GuidTable\r
+  //SKU_ID                SystemSkuId;      // Current SkuId value.\r
+  //UINT8                 Pad;\r
+  ${PHASE}_PCD_DATABASE_INIT    Init;\r
+  ${PHASE}_PCD_DATABASE_UNINIT  Uninit;\r
+} ${PHASE}_PCD_DATABASE;\r
+\r
+#define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)\r
+#endif\r
+""")\r
+\r
+\r
+gEmptyPcdDatabaseAutoGenC = TemplateString("""\r
+//\r
+// External PCD database debug information\r
+//\r
+#if 0\r
+${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
+  /* ExMapTable */\r
+  {\r
+    {0, 0, 0}\r
+  },\r
+  /* LocalTokenNumberTable */\r
+  {\r
+    0\r
+  },\r
+  /* GuidTable */\r
+  {\r
+    {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}\r
+  },\r
+  /* StringTable */\r
+  { 0 },\r
+  /* SkuHead */\r
+  {\r
+    0, 0\r
+  },\r
+  /* SizeTable */\r
+  {\r
+    0, 0\r
+  },\r
+  /* SkuIdTable */\r
+  { 0 },\r
+  ${SYSTEM_SKU_ID_VALUE}\r
+};\r
+#endif\r
+""")\r
+\r
+## PackGuid\r
+#\r
+# Pack the GUID value in C structure format into data array\r
+#\r
+# @param GuidStructureValue:   The GUID value in C structure format\r
+#\r
+# @retval Buffer:  a data array contains the Guid\r
+#\r
+def PackGuid(GuidStructureValue):\r
+    GuidString = GuidStructureStringToGuidString(GuidStructureValue)\r
+    Guid = GuidString.split('-')\r
+    Buffer = pack('=LHHBBBBBBBB', \r
+                int(Guid[0], 16), \r
+                int(Guid[1], 16), \r
+                int(Guid[2], 16), \r
+                int(Guid[3][-4:-2], 16), \r
+                int(Guid[3][-2:], 16),\r
+                int(Guid[4][-12:-10], 16),\r
+                int(Guid[4][-10:-8], 16),\r
+                int(Guid[4][-8:-6], 16),\r
+                int(Guid[4][-6:-4], 16),\r
+                int(Guid[4][-4:-2], 16),\r
+                int(Guid[4][-2:], 16)\r
+                )\r
+    return Buffer\r
+\r
+def toHex(s):\r
+    lst = []\r
+    for ch in s:\r
+        hv = hex(ord(ch)).replace('0x', ' ')\r
+        if len(hv) == 1:\r
+            hv = '0'+hv\r
+        lst.append(hv)\r
+    if lst:\r
+        return reduce(lambda x,y:x+y, lst)\r
+    else:\r
+        return 'empty'\r
+## DbItemList\r
+#\r
+#  The class holds the Pcd database items. ItemSize if not zero should match the item datum type in the C structure. \r
+#  When the structure is changed, remember to check the ItemSize and the related  PackStr in PackData()\r
+#  RawDataList is the RawData that may need some kind of calculation or transformation, \r
+#  the DataList corresponds to the data that need to be written to database. If DataList is not present, then RawDataList\r
+#  will be written to the database. \r
+#\r
+class DbItemList:\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []\r
+        self.ItemSize = ItemSize\r
+        self.DataList = DataList\r
+        self.RawDataList = RawDataList\r
+        self.ListSize = 0\r
+\r
+    def GetInterOffset(self, Index):\r
+        Offset = 0\r
+        if self.ItemSize == 0:\r
+            #\r
+            # Variable length, need to calculate one by one\r
+            #\r
+            assert(Index < len(self.RawDataList))\r
+            for ItemIndex in xrange(Index):\r
+                Offset += len(self.RawDataList[ItemIndex])\r
+        else:\r
+            for Datas in self.RawDataList:\r
+                Offset = self.ItemSize * Index\r
+\r
+        return Offset\r
+\r
+    def GetListSize(self):\r
+        if self.ListSize:\r
+            return self.ListSize\r
+        if len(self.RawDataList) == 0:\r
+            self.ListSize = 0\r
+            return self.ListSize\r
+        if self.ItemSize == 0:\r
+            self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])\r
+        else:\r
+            self.ListSize = self.ItemSize * len(self.RawDataList)\r
+        return self.ListSize\r
+\r
+    def PackData(self):\r
+        if self.ItemSize == 8:\r
+            PackStr = "=Q"\r
+        elif self.ItemSize == 4:\r
+            PackStr = "=L"\r
+        elif self.ItemSize == 2:\r
+            PackStr = "=H"\r
+        elif self.ItemSize == 1:\r
+            PackStr = "=B"\r
+        elif self.ItemSize == 0:\r
+            PackStr = "=B"\r
+        elif self.ItemSize == 16:\r
+            # pack Guid\r
+            PackStr = ''\r
+        else:\r
+            # should not reach here\r
+            assert(False)\r
+\r
+        Buffer = ''\r
+        for Datas in self.RawDataList:\r
+            if type(Datas) in (list, tuple):\r
+                for Data in Datas:\r
+                    if PackStr:\r
+                        Buffer += pack(PackStr, GetIntegerValue(Data))\r
+                    else:\r
+                        Buffer += PackGuid(Data)\r
+            else:\r
+                if PackStr:\r
+                    Buffer += pack(PackStr, GetIntegerValue(Datas))\r
+                else:\r
+                    Buffer += PackGuid(Datas)\r
+\r
+        return Buffer\r
+\r
+## DbExMapTblItemList\r
+#\r
+#  The class holds the ExMap table \r
+#\r
+class DbExMapTblItemList (DbItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []\r
+        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def PackData(self):\r
+        Buffer = ''\r
+        PackStr = "=LHH"\r
+        for Datas in self.RawDataList:\r
+            Buffer += pack(PackStr, \r
+                           GetIntegerValue(Datas[0]),\r
+                           GetIntegerValue(Datas[1]),\r
+                           GetIntegerValue(Datas[2]))      \r
+        return Buffer\r
+\r
+## DbComItemList\r
+#\r
+# The DbComItemList is a special kind of DbItemList in case that the size of the List can not be computed by the \r
+# ItemSize multiply the ItemCount.\r
+#\r
+class DbComItemList (DbItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []\r
+        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def GetInterOffset(self, Index):\r
+        Offset = 0\r
+        if self.ItemSize == 0:\r
+            #\r
+            # Variable length, need to calculte one by one\r
+            # The only variable table is stringtable, it is not Composite item, should not reach here\r
+            #\r
+            assert(False)\r
+        else:\r
+            assert(Index < len(self.RawDataList))\r
+            for ItemIndex in xrange(Index):\r
+                Offset += len(self.RawDataList[ItemIndex]) * self.ItemSize         \r
+\r
+        return Offset\r
+\r
+    def GetListSize(self):\r
+        if self.ListSize:\r
+            return self.ListSize\r
+        if self.ItemSize == 0:\r
+            assert(False)\r
+        else:\r
+            if len(self.RawDataList) == 0:\r
+                self.ListSize = 0\r
+            else:\r
+                self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1]) * self.ItemSize\r
+\r
+        return self.ListSize\r
+\r
+    def PackData(self):\r
+        if self.ItemSize == 8:\r
+            PackStr = "=Q"\r
+        elif self.ItemSize == 4:\r
+            PackStr = "=L"\r
+        elif self.ItemSize == 2:\r
+            PackStr = "=H"\r
+        elif self.ItemSize == 1:\r
+            PackStr = "=B"\r
+        elif self.ItemSize == 0:\r
+            PackStr = "=B"\r
+        else:\r
+            assert(False)\r
+\r
+        Buffer = ''\r
+        for DataList in self.RawDataList:\r
+            for Data in DataList:\r
+                if type(Data) in (list, tuple):\r
+                    for SingleData in Data:\r
+                        Buffer += pack(PackStr, GetIntegerValue(SingleData))\r
+                else:\r
+                    Buffer += pack(PackStr, GetIntegerValue(Data))\r
+        \r
+        return Buffer\r
+\r
+## DbVariableTableItemList\r
+#\r
+#  The class holds the Variable header value table \r
+#\r
+class DbVariableTableItemList (DbComItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []\r
+        DbComItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def PackData(self):\r
+        PackStr = "=LLHH"\r
+        Buffer = ''\r
+        for DataList in self.RawDataList:\r
+            for Data in DataList:\r
+                Buffer += pack(PackStr, \r
+                               GetIntegerValue(Data[0]),\r
+                               GetIntegerValue(Data[1]),\r
+                               GetIntegerValue(Data[2]),\r
+                               GetIntegerValue(Data[3]))\r
+        return Buffer\r
+\r
+class DbStringHeadTableItemList(DbItemList):\r
+    def __init__(self,ItemSize,DataList=None,RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []        \r
+        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+        \r
+    def GetInterOffset(self, Index):\r
+        Offset = 0\r
+        if self.ItemSize == 0:\r
+            #\r
+            # Variable length, need to calculate one by one\r
+            #\r
+            assert(Index < len(self.RawDataList))\r
+            for ItemIndex in xrange(Index):\r
+                Offset += len(self.RawDataList[ItemIndex])\r
+        else:\r
+            for innerIndex in range(Index):\r
+                if type(self.RawDataList[innerIndex]) in (list, tuple):\r
+                    Offset += len(self.RawDataList[innerIndex]) * self.ItemSize\r
+                else:\r
+                    Offset += self.ItemSize\r
+\r
+        return Offset\r
+\r
+    def GetListSize(self):\r
+        if self.ListSize:\r
+            return self.ListSize\r
+        if len(self.RawDataList) == 0:\r
+            self.ListSize = 0\r
+            return self.ListSize\r
+        if self.ItemSize == 0:\r
+            self.ListSize = self.GetInterOffset(len(self.RawDataList) - 1) + len(self.RawDataList[len(self.RawDataList)-1])\r
+        else:\r
+            for Datas in self.RawDataList:\r
+                if type(Datas) in (list, tuple):\r
+                    self.ListSize += len(Datas) * self.ItemSize\r
+                else:\r
+                    self.ListSize += self.ItemSize\r
+        return self.ListSize \r
+\r
+## DbSkuHeadTableItemList\r
+#\r
+#  The class holds the Sku header value table \r
+#\r
+class DbSkuHeadTableItemList (DbItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []        \r
+        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def PackData(self):\r
+        PackStr = "=LL"\r
+        Buffer = ''\r
+        for Data in self.RawDataList:\r
+            Buffer += pack(PackStr, \r
+                           GetIntegerValue(Data[0]),\r
+                           GetIntegerValue(Data[1]))\r
+        return Buffer\r
+\r
+## DbSizeTableItemList\r
+#\r
+#  The class holds the size table \r
+#\r
+class DbSizeTableItemList (DbItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []        \r
+        DbItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def PackData(self):\r
+        PackStr = "=HH"\r
+        Buffer = ''\r
+        for Data in self.RawDataList:\r
+            Buffer += pack(PackStr, \r
+                           GetIntegerValue(Data[0]),\r
+                           GetIntegerValue(Data[1]))\r
+        return Buffer\r
+\r
+## DbStringItemList\r
+#\r
+#  The class holds the string table \r
+#\r
+class DbStringItemList (DbComItemList):\r
+    def __init__(self, ItemSize, DataList=None, RawDataList=None, LenList=None):\r
+        if DataList is None:\r
+            DataList = []\r
+        if RawDataList is None:\r
+            RawDataList = []\r
+        if LenList is None:\r
+            LenList = []\r
+             \r
+        assert(len(RawDataList) == len(LenList))\r
+        DataList = []\r
+        # adjust DataList according to the LenList\r
+        for Index in xrange(len(RawDataList)):\r
+            Len = LenList[Index]\r
+            RawDatas = RawDataList[Index]\r
+            assert(Len >= len(RawDatas))\r
+            ActualDatas = []\r
+            for i in xrange(len(RawDatas)):\r
+                ActualDatas.append(RawDatas[i])\r
+            for i in xrange(len(RawDatas), Len):\r
+                ActualDatas.append(0)\r
+            DataList.append(ActualDatas)\r
+        self.LenList = LenList\r
+        DbComItemList.__init__(self, ItemSize, DataList, RawDataList)\r
+    def GetInterOffset(self, Index):\r
+        Offset = 0\r
+\r
+        assert(Index < len(self.LenList))\r
+        for ItemIndex in xrange(Index):\r
+            Offset += self.LenList[ItemIndex]\r
+\r
+        return Offset\r
+\r
+    def GetListSize(self):\r
+        if self.ListSize:\r
+            return self.ListSize\r
+\r
+        if len(self.LenList) == 0:\r
+            self.ListSize = 0\r
+        else:\r
+            self.ListSize = self.GetInterOffset(len(self.LenList) - 1) + self.LenList[len(self.LenList)-1]\r
+\r
+        return self.ListSize\r
+\r
+    def PackData(self):\r
+        self.RawDataList = self.DataList\r
+        return DbComItemList.PackData(self)\r
+\r
+\r
+\r
+##  Find the index in two list where the item matches the key separately\r
+#\r
+#   @param      Key1   The key used to search the List1\r
+#   @param      List1  The list that Key1 will be searched\r
+#   @param      Key2   The key used to search the List2\r
+#   @param      List2  The list that Key2 will be searched\r
+#\r
+#   @retval     Index  The position inside the list where list1[Index] == Key1 and list2[Index] == Key2\r
+#\r
+def GetMatchedIndex(Key1, List1, Key2, List2):\r
+    StartPos = 0\r
+    while StartPos < len(List1):\r
+        Index = List1.index(Key1, StartPos)\r
+        if List2[Index] == Key2:\r
+            return Index\r
+        else:\r
+            StartPos = Index + 1\r
+    \r
+    return -1\r
+\r
+\r
+##  Get the integer value from string like "14U" or integer like 2\r
+#\r
+#   @param      Input   The object that may be either a integer value or a string \r
+#  \r
+#   @retval     Value    The integer value that the input represents\r
+#\r
+def GetIntegerValue(Input):\r
+    if type(Input) in (int, long):\r
+        return Input\r
+    String = Input\r
+    if String.endswith("U"):\r
+        String = String[:-1]\r
+    if String.endswith("ULL"):\r
+        String = String[:-3]\r
+    if String.endswith("LL"):\r
+        String = String[:-2]\r
+    \r
+    if String.startswith("0x") or String.startswith("0X"):\r
+        return int(String, 16)\r
+    elif String == '':\r
+        return 0\r
+    else:\r
+        return int(String)\r
+\r
+\r
+## convert StringArray like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}\r
+# to List like [0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00]\r
+#\r
+#   @param      StringArray A string array like {0x36, 0x00, 0x34, 0x00, 0x21, 0x00, 0x36, 0x00, 0x34, 0x00, 0x00, 0x00}\r
+#  \r
+#   @retval                 A list object of integer items\r
+#\r
+def StringArrayToList(StringArray):\r
+    StringArray = StringArray[1:-1]\r
+    StringArray = '[' + StringArray + ']'\r
+    return eval(StringArray)\r
+\r
+\r
+## Convert TokenType String like  "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII" to TokenType value\r
+#\r
+#   @param      TokenType  A TokenType string like "PCD_DATUM_TYPE_UINT32 | PCD_TYPE_HII"\r
+#  \r
+#   @retval                A integer representation of the TokenType\r
+#\r
+def GetTokenTypeValue(TokenType):\r
+    TokenTypeDict = {\r
+        "PCD_TYPE_SHIFT":28,\r
+        "PCD_TYPE_DATA":(0x0 << 28),\r
+        "PCD_TYPE_HII":(0x8 << 28),\r
+        "PCD_TYPE_VPD":(0x4 << 28),\r
+        "PCD_TYPE_SKU_ENABLED":(0x2 << 28),\r
+        "PCD_TYPE_STRING":(0x1 << 28),\r
+\r
+        "PCD_DATUM_TYPE_SHIFT":24,\r
+        "PCD_DATUM_TYPE_POINTER":(0x0 << 24),\r
+        "PCD_DATUM_TYPE_UINT8":(0x1 << 24),\r
+        "PCD_DATUM_TYPE_UINT16":(0x2 << 24),\r
+        "PCD_DATUM_TYPE_UINT32":(0x4 << 24),\r
+        "PCD_DATUM_TYPE_UINT64":(0x8 << 24),\r
+\r
+        "PCD_DATUM_TYPE_SHIFT2":20,\r
+        "PCD_DATUM_TYPE_UINT8_BOOLEAN":(0x1 << 20 | 0x1 << 24),\r
+        }\r
+    return eval(TokenType, TokenTypeDict)\r
+\r
+## construct the external Pcd database using data from Dict\r
+#\r
+#   @param      Dict  A dictionary contains Pcd related tables\r
+#  \r
+#   @retval     Buffer A byte stream of the Pcd database\r
+#\r
+def BuildExDataBase(Dict):\r
+    # init Db items\r
+    InitValueUint64 = Dict['INIT_DB_VALUE_UINT64']\r
+    DbInitValueUint64 = DbComItemList(8, RawDataList = InitValueUint64)\r
+    VardefValueUint64 = Dict['VARDEF_DB_VALUE_UINT64']\r
+    DbVardefValueUint64 = DbItemList(8, RawDataList = VardefValueUint64)\r
+    InitValueUint32 = Dict['INIT_DB_VALUE_UINT32']\r
+    DbInitValueUint32 = DbComItemList(4, RawDataList = InitValueUint32)\r
+    VardefValueUint32 = Dict['VARDEF_DB_VALUE_UINT32']\r
+    DbVardefValueUint32 = DbItemList(4, RawDataList = VardefValueUint32)\r
+    VpdHeadValue = Dict['VPD_DB_VALUE']\r
+    DbVpdHeadValue = DbComItemList(4, RawDataList = VpdHeadValue)\r
+    ExMapTable = zip(Dict['EXMAPPING_TABLE_EXTOKEN'], Dict['EXMAPPING_TABLE_LOCAL_TOKEN'], Dict['EXMAPPING_TABLE_GUID_INDEX'])\r
+    DbExMapTable = DbExMapTblItemList(8, RawDataList = ExMapTable)\r
+    LocalTokenNumberTable = Dict['LOCAL_TOKEN_NUMBER_DB_VALUE']\r
+    DbLocalTokenNumberTable = DbItemList(4, RawDataList = LocalTokenNumberTable)\r
+    GuidTable = Dict['GUID_STRUCTURE']\r
+    DbGuidTable = DbItemList(16, RawDataList = GuidTable)\r
+    StringHeadValue = Dict['STRING_DB_VALUE']\r
+    # DbItemList to DbStringHeadTableItemList\r
+    DbStringHeadValue = DbStringHeadTableItemList(4, RawDataList = StringHeadValue)\r
+    VariableTable = Dict['VARIABLE_DB_VALUE']\r
+    DbVariableTable = DbVariableTableItemList(12, RawDataList = VariableTable)\r
+    NumberOfSkuEnabledPcd = GetIntegerValue(Dict['SKU_HEAD_SIZE'])\r
+    Dict['SKUHEAD_TABLE_VALUE'] = [(0,0) for i in xrange(NumberOfSkuEnabledPcd)]\r
+    SkuTable = Dict['SKUHEAD_TABLE_VALUE']  # Generated later\r
+    DbSkuTable = DbSkuHeadTableItemList(8, RawDataList = SkuTable)\r
+    Dict['STRING_TABLE_DB_VALUE'] = [StringArrayToList(x) for x in Dict['STRING_TABLE_VALUE']]\r
+    \r
+    StringTableValue = Dict['STRING_TABLE_DB_VALUE']\r
+    # when calcute the offset, should use StringTableLen instead of StringTableValue, as string maxium len may be different with actual len\r
+    StringTableLen = Dict['STRING_TABLE_LENGTH']\r
+    DbStringTableLen = DbStringItemList(0, RawDataList = StringTableValue, LenList = StringTableLen)\r
+\r
+    \r
+    PcdTokenTable = Dict['PCD_TOKENSPACE']\r
+    PcdTokenLen = Dict['PCD_TOKENSPACE_LENGTH']\r
+    PcdTokenTableValue = [StringArrayToList(x) for x in Dict['PCD_TOKENSPACE']]\r
+    DbPcdTokenTable = DbStringItemList(0, RawDataList = PcdTokenTableValue, LenList = PcdTokenLen)\r
+    \r
+    PcdCNameTable = Dict['PCD_CNAME']\r
+    PcdCNameLen = Dict['PCD_CNAME_LENGTH']\r
+    PcdCNameTableValue = [StringArrayToList(x) for x in Dict['PCD_CNAME']]\r
+    DbPcdCNameTable = DbStringItemList(0, RawDataList = PcdCNameTableValue, LenList = PcdCNameLen)\r
+    \r
+    PcdNameOffsetTable = Dict['PCD_NAME_OFFSET']\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
+    InitValueUint16 = Dict['INIT_DB_VALUE_UINT16']\r
+    DbInitValueUint16 = DbComItemList(2, RawDataList = InitValueUint16)\r
+    VardefValueUint16 = Dict['VARDEF_DB_VALUE_UINT16']\r
+    DbVardefValueUint16 = DbItemList(2, RawDataList = VardefValueUint16)\r
+    InitValueUint8 = Dict['INIT_DB_VALUE_UINT8']\r
+    DbInitValueUint8 = DbComItemList(1, RawDataList = InitValueUint8)\r
+    VardefValueUint8 = Dict['VARDEF_DB_VALUE_UINT8']\r
+    DbVardefValueUint8 = DbItemList(1, RawDataList = VardefValueUint8)\r
+    InitValueBoolean = Dict['INIT_DB_VALUE_BOOLEAN']\r
+    DbInitValueBoolean = DbComItemList(1, RawDataList = InitValueBoolean)\r
+    VardefValueBoolean = Dict['VARDEF_DB_VALUE_BOOLEAN']\r
+    DbVardefValueBoolean = DbItemList(1, RawDataList = VardefValueBoolean)\r
+    SkuidValue = Dict['SKUID_VALUE']\r
+    DbSkuidValue = DbItemList(1, RawDataList = SkuidValue)\r
+    SkuIndexValue = Dict['SKU_INDEX_VALUE']\r
+    DbSkuIndexValue = DbItemList(0,RawDataList = SkuIndexValue)\r
+    \r
+    # Unit Db Items\r
+    UnInitValueUint64 = Dict['UNINIT_GUID_DECL_UINT64']\r
+    DbUnInitValueUint64 = DbItemList(8, RawDataList = UnInitValueUint64)\r
+    UnInitValueUint32 = Dict['UNINIT_GUID_DECL_UINT32']\r
+    DbUnInitValueUint32 = DbItemList(4, RawDataList = UnInitValueUint32)\r
+    UnInitValueUint16 = Dict['UNINIT_GUID_DECL_UINT16']\r
+    DbUnInitValueUint16 = DbItemList(2, RawDataList = UnInitValueUint16)\r
+    UnInitValueUint8 = Dict['UNINIT_GUID_DECL_UINT8']\r
+    DbUnInitValueUint8 = DbItemList(1, RawDataList = UnInitValueUint8)\r
+    UnInitValueBoolean = Dict['UNINIT_GUID_DECL_BOOLEAN']\r
+    DbUnInitValueBoolean = DbItemList(1, RawDataList = UnInitValueBoolean)\r
+ \r
+    DbNameTotle = ["InitValueUint64", "VardefValueUint64", "InitValueUint32", "VardefValueUint32", "VpdHeadValue", "ExMapTable", \r
+               "LocalTokenNumberTable", "GuidTable", "StringHeadValue",  "PcdNameOffsetTable","VariableTable","SkuTable", "StringTableLen", "PcdTokenTable", "PcdCNameTable", \r
+               "SizeTableValue", "InitValueUint16", "VardefValueUint16", "InitValueUint8", "VardefValueUint8", "InitValueBoolean",\r
+               "VardefValueBoolean", "SkuidValue", "SkuIndexValue","UnInitValueUint64", "UnInitValueUint32", "UnInitValueUint16", "UnInitValueUint8", "UnInitValueBoolean"]\r
+ \r
+    DbTotal = [InitValueUint64, VardefValueUint64, InitValueUint32, VardefValueUint32, VpdHeadValue, ExMapTable, \r
+               LocalTokenNumberTable, GuidTable, StringHeadValue,  PcdNameOffsetTable,VariableTable,SkuTable, StringTableLen, PcdTokenTable,PcdCNameTable, \r
+               SizeTableValue, InitValueUint16, VardefValueUint16,InitValueUint8, VardefValueUint8, InitValueBoolean,\r
+               VardefValueBoolean, SkuidValue, SkuIndexValue, UnInitValueUint64, UnInitValueUint32, UnInitValueUint16, UnInitValueUint8, UnInitValueBoolean]\r
+    DbItemTotal = [DbInitValueUint64, DbVardefValueUint64, DbInitValueUint32, DbVardefValueUint32, DbVpdHeadValue, DbExMapTable, \r
+               DbLocalTokenNumberTable, DbGuidTable, DbStringHeadValue,  DbPcdNameOffsetTable,DbVariableTable,DbSkuTable, DbStringTableLen, DbPcdTokenTable, DbPcdCNameTable, \r
+               DbSizeTableValue, DbInitValueUint16, DbVardefValueUint16,DbInitValueUint8, DbVardefValueUint8, DbInitValueBoolean,\r
+               DbVardefValueBoolean, DbSkuidValue, DbSkuIndexValue, DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean]\r
+    \r
+    # SkuidValue is the last table in the init table items\r
+    InitTableNum = DbTotal.index(SkuidValue) + 1 + 1 # +1 is for SkuIndexValue table\r
+    # The FixedHeader length of the PCD_DATABASE_INIT, from Signature to Pad\r
+    FixedHeaderLen = 64\r
+\r
+    # Get offset of SkuId table in the database \r
+    SkuIdTableOffset = FixedHeaderLen\r
+    for DbIndex in xrange(len(DbTotal)):\r
+        if DbTotal[DbIndex] is SkuidValue:\r
+            break\r
+        SkuIdTableOffset += DbItemTotal[DbIndex].GetListSize()\r
+    \r
+    \r
+    # Get offset of SkuValue table in the database    \r
+    SkuTableOffset = FixedHeaderLen\r
+    for DbIndex in xrange(len(DbTotal)):\r
+        if DbTotal[DbIndex] is SkuTable:\r
+            break\r
+        SkuTableOffset += DbItemTotal[DbIndex].GetListSize()\r
+    PcdTokenTableDbOffset = FixedHeaderLen\r
+    for DbIndex in xrange(len(DbTotal)):\r
+        if DbTotal[DbIndex] is PcdTokenTable:\r
+            break\r
+        PcdTokenTableDbOffset += DbItemTotal[DbIndex].GetListSize()\r
+    \r
+    PcdCNameTableDbOffset = FixedHeaderLen\r
+    for DbIndex in xrange(len(DbTotal)):\r
+        if DbTotal[DbIndex] is PcdCNameTable:\r
+            break\r
+        PcdCNameTableDbOffset += DbItemTotal[DbIndex].GetListSize()\r
+    # Fix up the LocalTokenNumberTable, SkuHeader table\r
+    SkuHeaderIndex = 0\r
+    if len(Dict['SKU_INDEX_VALUE']) > 0:\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
+    for (LocalTokenNumberTableIndex, (Offset, Table)) in enumerate(LocalTokenNumberTable):\r
+        DbIndex = 0\r
+        DbOffset = FixedHeaderLen\r
+        for DbIndex in xrange(len(DbTotal)):\r
+            if DbTotal[DbIndex] is Table:\r
+                DbOffset += DbItemTotal[DbIndex].GetInterOffset(Offset)\r
+                break\r
+            DbOffset += DbItemTotal[DbIndex].GetListSize()\r
+        else:\r
+            assert(False)\r
+\r
+        TokenTypeValue = Dict['TOKEN_TYPE'][LocalTokenNumberTableIndex]\r
+        TokenTypeValue = GetTokenTypeValue(TokenTypeValue)\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
+        if (TokenTypeValue & (0x2 << 28)):\r
+            SkuTable[SkuHeaderIndex] = (DbOffset|int(TokenTypeValue & ~(0x2<<28)), SkuIndexTabalOffset + SkuIndexIndexTable[SkuHeaderIndex])\r
+            LocalTokenNumberTable[LocalTokenNumberTableIndex] = (SkuTableOffset + SkuHeaderIndex * 8) | int(TokenTypeValue)\r
+            SkuHeaderIndex += 1\r
+        \r
+    \r
+    if SkuHeaderIndex == 0:\r
+        SkuHeaderIndex = 1\r
+    assert(SkuHeaderIndex == NumberOfSkuEnabledPcd)\r
+\r
+    # resolve variable table offset \r
+    for VariableEntries in VariableTable:\r
+        for VariableEntryPerSku in VariableEntries:\r
+            (VariableHeadGuidIndex, VariableHeadStringIndex, SKUVariableOffset, VariableOffset, VariableRefTable) = VariableEntryPerSku[:]\r
+            DbIndex = 0\r
+            DbOffset = FixedHeaderLen\r
+            for DbIndex in xrange(len(DbTotal)):\r
+                if DbTotal[DbIndex] is VariableRefTable:\r
+                    DbOffset += DbItemTotal[DbIndex].GetInterOffset(VariableOffset)\r
+                    break\r
+                DbOffset += DbItemTotal[DbIndex].GetListSize()\r
+            else:\r
+                assert(False)\r
+            \r
+            if DbIndex >= InitTableNum:\r
+                assert(False)\r
+\r
+            VariableEntryPerSku[:] = (VariableHeadStringIndex, DbOffset, VariableHeadGuidIndex, SKUVariableOffset)\r
+\r
+    # calculate various table offset now\r
+    DbTotalLength = FixedHeaderLen\r
+    for DbIndex in xrange(len(DbItemTotal)):\r
+        if DbItemTotal[DbIndex] is DbLocalTokenNumberTable:\r
+            LocalTokenNumberTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbExMapTable:\r
+            ExMapTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbGuidTable:\r
+            GuidTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbStringTableLen:\r
+            StringTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbSizeTableValue:\r
+            SizeTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbSkuidValue:\r
+            SkuIdTableOffset = DbTotalLength\r
+        elif DbItemTotal[DbIndex] is DbPcdNameOffsetTable:\r
+            DbPcdNameOffset = DbTotalLength\r
+\r
+        DbTotalLength += DbItemTotal[DbIndex].GetListSize()\r
+    if not Dict['PCD_INFO_FLAG']:\r
+        DbPcdNameOffset  = 0   \r
+    LocalTokenCount = GetIntegerValue(Dict['LOCAL_TOKEN_NUMBER'])\r
+    ExTokenCount = GetIntegerValue(Dict['EX_TOKEN_NUMBER'])\r
+    GuidTableCount = GetIntegerValue(Dict['GUID_TABLE_SIZE'])\r
+    SystemSkuId = GetIntegerValue(Dict['SYSTEM_SKU_ID_VALUE'])\r
+    Pad = 0xDA\r
+    \r
+    UninitDataBaseSize  = 0\r
+    for Item in (DbUnInitValueUint64, DbUnInitValueUint32, DbUnInitValueUint16, DbUnInitValueUint8, DbUnInitValueBoolean):\r
+        UninitDataBaseSize += Item.GetListSize()\r
+    \r
+    # Construct the database buffer\r
+    Guid = "{0x3c7d193c, 0x682c, 0x4c14, 0xa6, 0x8f, 0x55, 0x2d, 0xea, 0x4f, 0x43, 0x7e}"\r
+    Guid = StringArrayToList(Guid)\r
+    Buffer = pack('=LHHBBBBBBBB', \r
+                Guid[0], \r
+                Guid[1], \r
+                Guid[2], \r
+                Guid[3], \r
+                Guid[4],  \r
+                Guid[5],\r
+                Guid[6],\r
+                Guid[7],\r
+                Guid[8],\r
+                Guid[9],\r
+                Guid[10],\r
+                )\r
+\r
+    b = pack("=L", DATABASE_VERSION)\r
+    Buffer += b\r
+\r
+    b = pack('=L', DbTotalLength - UninitDataBaseSize)\r
+\r
+    Buffer += b\r
+    b = pack('=L', UninitDataBaseSize)\r
+\r
+    Buffer += b\r
+    b = pack('=L', LocalTokenNumberTableOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=L', ExMapTableOffset)\r
+ \r
+    Buffer += b\r
+    b = pack('=L', GuidTableOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=L', StringTableOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=L', SizeTableOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=L', SkuIdTableOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=L', DbPcdNameOffset)\r
+\r
+    Buffer += b\r
+    b = pack('=H', LocalTokenCount)\r
+\r
+    Buffer += b\r
+    b = pack('=H', ExTokenCount)\r
+\r
+    Buffer += b\r
+    b = pack('=H', GuidTableCount)\r
+ \r
+    Buffer += b\r
+    b = pack('=B', SystemSkuId)\r
+ \r
+    Buffer += b\r
+    b = pack('=B', Pad)\r
+ \r
+    Buffer += b\r
+    \r
+    Index = 0\r
+    for Item in DbItemTotal:\r
+        Index +=1\r
+        b = Item.PackData()\r
+        Buffer += b  \r
+        if Index == InitTableNum:\r
+            break        \r
+    return Buffer\r
+\r
+## Create code for PCD database\r
+#\r
+#   @param      Info        The ModuleAutoGen object\r
+#   @param      AutoGenC    The TemplateString object for C code\r
+#   @param      AutoGenH    The TemplateString object for header file\r
+#\r
+def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
+    if Info.PcdIsDriver == "":\r
+        return\r
+    if Info.PcdIsDriver not in gPcdPhaseMap:\r
+        EdkLogger.error("build", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s" % Info.PcdIsDriver,\r
+                        ExtraData="[%s]" % str(Info))\r
+\r
+    AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
+    AutoGenH.Append(AdditionalAutoGenH.String)\r
+\r
+    Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
+    if Phase == 'PEI':\r
+        AutoGenC.Append(AdditionalAutoGenC.String)\r
+\r
+    if Phase == 'DXE':\r
+        AdditionalAutoGenH, AdditionalAutoGenC, PcdDbBuffer = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
+        AutoGenH.Append(AdditionalAutoGenH.String)\r
+        AutoGenC.Append(AdditionalAutoGenC.String)\r
+\r
+    if Info.IsBinaryModule:\r
+        DbFileName = os.path.join(Info.PlatformInfo.BuildDir, "FV", Phase + "PcdDataBase.raw")\r
+    else:\r
+        DbFileName = os.path.join(Info.OutputDir, Phase + "PcdDataBase.raw")\r
+    DbFile = StringIO()\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
+#   @retval     tuple       Two TemplateString objects for C code and header file,\r
+#                           respectively\r
+#\r
+def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):\r
+    AutoGenC = TemplateString()\r
+    AutoGenH = TemplateString()\r
+\r
+    Dict = {\r
+        'PHASE'                         : Phase,\r
+        'SERVICE_DRIVER_VERSION'        : DATABASE_VERSION,\r
+        'GUID_TABLE_SIZE'               : '1U',\r
+        'STRING_TABLE_SIZE'             : '1U',\r
+        'SKUID_TABLE_SIZE'              : '1U',\r
+        'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '0U',\r
+        'LOCAL_TOKEN_NUMBER'            : '0U',\r
+        'EXMAPPING_TABLE_SIZE'          : '1U',\r
+        'EX_TOKEN_NUMBER'               : '0U',\r
+        'SIZE_TABLE_SIZE'               : '2U',\r
+        'SKU_HEAD_SIZE'                 : '1U',\r
+        'GUID_TABLE_EMPTY'              : 'TRUE',\r
+        'STRING_TABLE_EMPTY'            : 'TRUE',\r
+        'SKUID_TABLE_EMPTY'             : 'TRUE',\r
+        'DATABASE_EMPTY'                : 'TRUE',\r
+        'EXMAP_TABLE_EMPTY'             : 'TRUE',\r
+        'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
+        'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
+        'SYSTEM_SKU_ID_VALUE'           : '0U'\r
+    }\r
+    \r
+   \r
+    SkuObj = SkuClass(Platform.Platform.SkuName,Platform.Platform.SkuIds)\r
+    Dict['SYSTEM_SKU_ID_VALUE'] = Platform.Platform.SkuIds[SkuObj.SystemSkuId]\r
+\r
+    Dict['PCD_INFO_FLAG'] = Platform.Platform.PcdInfoFlag\r
+\r
+    for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN', "VOID*"]:\r
+        Dict['VARDEF_CNAME_' + DatumType] = []\r
+        Dict['VARDEF_GUID_' + DatumType]  = []\r
+        Dict['VARDEF_SKUID_' + DatumType] = []\r
+        Dict['VARDEF_VALUE_' + DatumType] = []\r
+        Dict['VARDEF_DB_VALUE_' + DatumType] = []\r
+        for Init in ['INIT','UNINIT']:\r
+            Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
+            Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
+            Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
+            Dict[Init+'_VALUE_' + DatumType]        = []\r
+            Dict[Init+'_DB_VALUE_'+DatumType] = []\r
+            \r
+    for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:\r
+        Dict[Type + '_CNAME_DECL']   = []\r
+        Dict[Type + '_GUID_DECL']    = []\r
+        Dict[Type + '_NUMSKUS_DECL'] = []\r
+        Dict[Type + '_VALUE'] = []\r
+\r
+    Dict['STRING_DB_VALUE'] = []\r
+    Dict['VPD_DB_VALUE'] = []\r
+    Dict['VARIABLE_DB_VALUE'] = []\r
+    \r
+    Dict['STRING_TABLE_INDEX'] = []\r
+    Dict['STRING_TABLE_LENGTH']  = []\r
+    Dict['STRING_TABLE_CNAME'] = []\r
+    Dict['STRING_TABLE_GUID']  = []\r
+    Dict['STRING_TABLE_VALUE'] = []\r
+    Dict['STRING_TABLE_DB_VALUE'] = []\r
+\r
+    Dict['SIZE_TABLE_CNAME'] = []\r
+    Dict['SIZE_TABLE_GUID']  = []\r
+    Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
+    Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
+\r
+    Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
+    Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
+    Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
+\r
+    Dict['GUID_STRUCTURE'] = []\r
+    Dict['SKUID_VALUE'] = [0] # init Dict length\r
+    Dict['VARDEF_HEADER'] = []\r
+\r
+    Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = []\r
+    Dict['VARIABLE_DB_VALUE'] = []\r
+    Dict['SKUHEAD_TABLE_VALUE'] = []\r
+    Dict['SKU_INDEX_VALUE'] = []\r
+    \r
+    Dict['PCD_TOKENSPACE'] = []\r
+    Dict['PCD_CNAME'] = [] \r
+    Dict['PCD_TOKENSPACE_LENGTH'] = []\r
+    Dict['PCD_CNAME_LENGTH'] = []\r
+    Dict['PCD_TOKENSPACE_OFFSET'] = []\r
+    Dict['PCD_CNAME_OFFSET'] = []\r
+    Dict['PCD_TOKENSPACE_MAP'] = []\r
+    Dict['PCD_NAME_OFFSET'] = []\r
+    \r
+    StringTableIndex = 0\r
+    StringTableSize = 0\r
+    NumberOfLocalTokens = 0\r
+    NumberOfPeiLocalTokens = 0\r
+    NumberOfDxeLocalTokens = 0\r
+    NumberOfExTokens = 0\r
+    NumberOfSizeItems = 0\r
+    NumberOfSkuEnabledPcd = 0\r
+    GuidList = []\r
+    i = 0\r
+    for Pcd in Platform.DynamicPcdList:\r
+        i += 1\r
+        CName = Pcd.TokenCName\r
+        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
+\r
+        EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
+\r
+        if Pcd.Phase == 'PEI':\r
+            NumberOfPeiLocalTokens += 1\r
+        if Pcd.Phase == 'DXE':\r
+            NumberOfDxeLocalTokens += 1\r
+        if Pcd.Phase != Phase:\r
+            continue\r
+\r
+        #\r
+        # TODO: need GetGuidValue() definition\r
+        #\r
+        TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue\r
+        TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
+        if Pcd.Type in gDynamicExPcd:\r
+            if TokenSpaceGuid not in GuidList:\r
+                GuidList += [TokenSpaceGuid]\r
+                Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
+            NumberOfExTokens += 1\r
+\r
+        ValueList = []\r
+        DbValueList = []\r
+        StringHeadOffsetList = []\r
+        StringDbOffsetList = []\r
+        VpdHeadOffsetList = []\r
+        VpdDbOffsetList = []\r
+        VariableHeadValueList = []\r
+        VariableDbValueList = []\r
+        Pcd.InitString = 'UNINIT'\r
+\r
+        if Pcd.DatumType == 'VOID*':\r
+            if Pcd.Type not in ["DynamicVpd", "DynamicExVpd"]:\r
+                Pcd.TokenTypeList = ['PCD_TYPE_STRING']\r
+            else:\r
+                Pcd.TokenTypeList = []\r
+        elif Pcd.DatumType == 'BOOLEAN':\r
+            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8_BOOLEAN']\r
+        else:\r
+            Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
+\r
+        if len(Pcd.SkuInfoList) > 1:\r
+            Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']\r
+            NumberOfSkuEnabledPcd += 1\r
+        \r
+        SkuIndexTableTmp = []\r
+        SkuIndexTableTmp.append(0)  \r
+        SkuIdIndex = 1  \r
+        for SkuName in Pcd.SkuInfoList:\r
+            Sku = Pcd.SkuInfoList[SkuName]\r
+            SkuId = Sku.SkuId\r
+            if SkuId == None or SkuId == '':\r
+                continue\r
+\r
+            if (SkuId + 'U') not in Dict['SKUID_VALUE']:\r
+                Dict['SKUID_VALUE'].append(SkuId + 'U')\r
+                \r
+            SkuIndexTableTmp.append(SkuId+'U')\r
+            SkuIdIndex += 1\r
+    \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 VariableGuid to GuidTable and get the VariableHeadGuidIndex\r
+                VariableGuidStructure = Sku.VariableGuidValue\r
+                VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
+\r
+                if VariableGuid not in GuidList:\r
+                    GuidList += [VariableGuid]\r
+                    Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
+                VariableHeadGuidIndex = GuidList.index(VariableGuid)\r
+\r
+                if "PCD_TYPE_STRING" in Pcd.TokenTypeList:\r
+                    VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s), %dU, %sU' %\r
+                                                 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, \r
+                                                 VariableHeadGuidIndex, Sku.VariableOffset))\r
+                else:\r
+                    VariableHeadValueList.append('%dU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s), %dU, %sU' %\r
+                                                 (VariableHeadStringIndex, Phase, CName, TokenSpaceGuid, SkuIdIndex, \r
+                                                 VariableHeadGuidIndex, Sku.VariableOffset))\r
+                Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
+                Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
+                Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
+                if "PCD_TYPE_STRING" in  Pcd.TokenTypeList:\r
+                    Dict['VARDEF_VALUE_' + Pcd.DatumType].append("%s_%s[%d]" % (Pcd.TokenCName, TokenSpaceGuid, SkuIdIndex))\r
+                else:\r
+                    #\r
+                    # ULL (for UINT64) or U(other integer type) should be append to avoid\r
+                    # warning under linux building environment.\r
+                    #\r
+                    Dict['VARDEF_DB_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
+                    \r
+                    if Pcd.DatumType == "UINT64":\r
+                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "ULL")\r
+                    elif Pcd.DatumType in ("UINT32", "UINT16", "UINT8"):\r
+                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue + "U")\r
+                    elif Pcd.DatumType == "BOOLEAN":\r
+                        if eval(Sku.HiiDefaultValue) in [1,0]:\r
+                            Dict['VARDEF_VALUE_'+Pcd.DatumType].append(str(eval(Sku.HiiDefaultValue)) + "U")\r
+                    else:\r
+                        Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
+\r
+                # construct the VariableHeader value\r
+                if "PCD_TYPE_STRING" in Pcd.TokenTypeList:\r
+                    VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s)' %\r
+                                                 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,\r
+                                                  Phase, CName, TokenSpaceGuid))\r
+                    # the Pcd default value will be filled later on\r
+                    VariableOffset = len(Dict['STRING_DB_VALUE'])\r
+                    VariableRefTable = Dict['STRING_DB_VALUE']\r
+                else:\r
+                    VariableHeadValueList.append('%dU, %dU, %sU, offsetof(%s_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
+                                                 (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset,\r
+                                                  Phase, CName, TokenSpaceGuid, SkuIdIndex))\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
+\r
+            elif Sku.VpdOffset != '':\r
+                Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
+                Pcd.InitString = 'INIT'\r
+                VpdHeadOffsetList.append(str(Sku.VpdOffset) + 'U')\r
+                VpdDbOffsetList.append(Sku.VpdOffset)\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
+                continue\r
+          \r
+            if Pcd.DatumType == 'VOID*':\r
+                Pcd.TokenTypeList += ['PCD_TYPE_STRING']\r
+                Pcd.InitString = 'INIT'\r
+                if Sku.HiiDefaultValue != '' and Sku.DefaultValue == '':\r
+                    Sku.DefaultValue = Sku.HiiDefaultValue\r
+                if Sku.DefaultValue != '':\r
+                    NumberOfSizeItems += 1\r
+                    Dict['STRING_TABLE_CNAME'].append(CName)\r
+                    Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
+\r
+                    if StringTableIndex == 0:\r
+                        Dict['STRING_TABLE_INDEX'].append('')\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
+                    elif Sku.DefaultValue[0] == '"':\r
+                        Size = len(Sku.DefaultValue) - 2 + 1\r
+                        Dict['STRING_TABLE_VALUE'].append(StringToArray(Sku.DefaultValue))\r
+                    elif Sku.DefaultValue[0] == '{':\r
+                        Size = len(Sku.DefaultValue.replace(',',' ').split())\r
+                        Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\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
+                    StringTableIndex += 1\r
+                    StringTableSize += (Size)\r
+            else:\r
+                if "PCD_TYPE_HII" not in Pcd.TokenTypeList:\r
+                    Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
+                    if Sku.DefaultValue == 'TRUE':\r
+                        Pcd.InitString = 'INIT'\r
+                    else:\r
+                        if int(Sku.DefaultValue, 0) != 0:\r
+                            Pcd.InitString = 'INIT'              \r
+                #\r
+                # For UNIT64 type PCD's value, ULL should be append to avoid\r
+                # warning under linux building environment.\r
+                #\r
+                if Pcd.DatumType == "UINT64":\r
+                    ValueList.append(Sku.DefaultValue + "ULL")\r
+                elif Pcd.DatumType in ("UINT32", "UINT16", "UINT8"):\r
+                    ValueList.append(Sku.DefaultValue + "U")\r
+                elif Pcd.DatumType == "BOOLEAN":\r
+                    if Sku.DefaultValue in ["1", "0"]:\r
+                        ValueList.append(Sku.DefaultValue + "U")              \r
+                else:\r
+                    ValueList.append(Sku.DefaultValue)\r
+                \r
+                DbValueList.append(Sku.DefaultValue)\r
+\r
+        Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
+        \r
+        SkuIndexTableTmp[0] = len(SkuIndexTableTmp)\r
+        if len(Pcd.SkuInfoList) > 1:\r
+            Dict['SKU_INDEX_VALUE'].append(SkuIndexTableTmp)            \r
+\r
+        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
+            Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
+            Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
+            Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
+            Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
+            Dict['VARDEF_HEADER'].append('_Variable_Header')\r
+            Dict['VARIABLE_DB_VALUE'].append(VariableDbValueList)\r
+        else:\r
+            Dict['VARDEF_HEADER'].append('')\r
+        if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
+            Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
+            Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
+            Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
+            Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
+            Dict['VPD_DB_VALUE'].append(VpdDbOffsetList)\r
+        if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
+            Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
+            Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\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
+        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
+            Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
+            if Pcd.InitString == 'UNINIT':\r
+                Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
+            else:\r
+                Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
+                Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType].append(DbValueList)\r
+                \r
+    if Phase == 'PEI':\r
+        NumberOfLocalTokens = NumberOfPeiLocalTokens\r
+    if Phase == 'DXE':\r
+        NumberOfLocalTokens = NumberOfDxeLocalTokens\r
+\r
+    Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'] = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['PCD_CNAME']        = ['' for x in range(NumberOfLocalTokens)]\r
+    Dict['PCD_TOKENSPACE_MAP'] = ['' for x in range(NumberOfLocalTokens)]  \r
+    Dict['PCD_CNAME_LENGTH'] = [0 for x in range(NumberOfLocalTokens)]\r
+    for Pcd in Platform.DynamicPcdList:\r
+        CName = Pcd.TokenCName\r
+        TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
+        if Pcd.Phase != Phase:\r
+            continue\r
+\r
+        TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))\r
+        GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
+        if Phase == 'DXE':\r
+            GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
+\r
+        EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s.%s" % (CName, TokenSpaceGuidCName))\r
+        EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
+        EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
+        \r
+        #\r
+        # following four Dict items hold the information for LocalTokenNumberTable\r
+        #\r
+        Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
+        if Pcd.InitString == 'UNINIT':\r
+            Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
+\r
+        Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
+        Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
+        Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
+        \r
+        if Platform.Platform.PcdInfoFlag:\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_MAP'][GeneratedTokenNumber] = Dict['PCD_TOKENSPACE'].index(TokenSpaceGuidCNameArray)\r
+            Dict['PCD_CNAME'][GeneratedTokenNumber] = StringToArray('"' + CName + '"' )\r
+            \r
+            Dict['PCD_CNAME_LENGTH'][GeneratedTokenNumber] = len(CName) + 1\r
+        \r
+        \r
+        Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
+\r
+        # search the Offset and Table, used by LocalTokenNumberTableOffset\r
+        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
+            # Find index by CName, TokenSpaceGuid\r
+            Offset = GetMatchedIndex(CName, Dict['VARIABLE_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VARIABLE_HEAD_GUID_DECL'])\r
+            assert(Offset != -1)\r
+            Table = Dict['VARIABLE_DB_VALUE']\r
+        if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
+            Offset = GetMatchedIndex(CName, Dict['VPD_HEAD_CNAME_DECL'], TokenSpaceGuid, Dict['VPD_HEAD_GUID_DECL'])\r
+            assert(Offset != -1)\r
+            Table = Dict['VPD_DB_VALUE']\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
+            assert(Offset != -1)\r
+            Table = Dict['STRING_DB_VALUE']\r
+        if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
+            # need to store whether it is in init table or not\r
+            Offset = GetMatchedIndex(CName, Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType], TokenSpaceGuid, Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType])\r
+            assert(Offset != -1)\r
+            if Pcd.InitString == 'UNINIT':\r
+                Table =  Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType]\r
+            else:\r
+                Table = Dict[Pcd.InitString+'_DB_VALUE_'+Pcd.DatumType]               \r
+        Dict['LOCAL_TOKEN_NUMBER_DB_VALUE'][GeneratedTokenNumber] = (Offset, Table)\r
+\r
+        #\r
+        # Update VARDEF_HEADER\r
+        #\r
+        if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
+            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = '_Variable_Header'\r
+        else:\r
+            Dict['VARDEF_HEADER'][GeneratedTokenNumber] = ''\r
+       \r
+        \r
+        if Pcd.Type in gDynamicExPcd:\r
+            \r
+            if Phase == 'DXE':\r
+                GeneratedTokenNumber += NumberOfPeiLocalTokens\r
+            #\r
+            # Per, PCD architecture specification, PCD Token Number is 1 based and 0 is defined as invalid token number.\r
+            # For each EX type PCD, a PCD Token Number is assigned. When the\r
+            # PCD Driver/PEIM map EX_GUID and EX_TOKEN_NUMBER to the PCD Token Number,\r
+            # the non-EX Protocol/PPI interface can be called to get/set the value. This assumption is made by\r
+            # Pcd Driver/PEIM in MdeModulePkg.\r
+            # Therefore, 1 is added to GeneratedTokenNumber to generate a PCD Token Number before being inserted\r
+            # to the EXMAPPING_TABLE.\r
+            #\r
+            \r
+\r
+            Dict['EXMAPPING_TABLE_EXTOKEN'].append(str(Pcd.TokenValue) + 'U')\r
+            Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(str(GeneratedTokenNumber + 1) + 'U')\r
+            Dict['EXMAPPING_TABLE_GUID_INDEX'].append(str(GuidList.index(TokenSpaceGuid)) + 'U')\r
+\r
+    if Platform.Platform.PcdInfoFlag:\r
+        for index in range(len(Dict['PCD_TOKENSPACE_MAP'])):\r
+            TokenSpaceIndex = StringTableSize\r
+            for i in range(Dict['PCD_TOKENSPACE_MAP'][index]):\r
+                TokenSpaceIndex += Dict['PCD_TOKENSPACE_LENGTH'][i]\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
+        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
+    if GuidList != []:\r
+        Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
+        Dict['GUID_TABLE_SIZE'] = str(len(GuidList)) + 'U'\r
+    else:\r
+        Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
+\r
+    if StringTableIndex == 0:\r
+        Dict['STRING_TABLE_INDEX'].append('')\r
+        Dict['STRING_TABLE_LENGTH'].append(1)\r
+        Dict['STRING_TABLE_CNAME'].append('')\r
+        Dict['STRING_TABLE_GUID'].append('')\r
+        Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
+    else:\r
+        Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
+        Dict['STRING_TABLE_SIZE'] = str(StringTableSize) + 'U'\r
+\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_MAXIMUM_LENGTH'].append('0U')\r
+\r
+    if NumberOfLocalTokens != 0:\r
+        Dict['DATABASE_EMPTY']                = 'FALSE'\r
+        Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
+        Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
+\r
+    if NumberOfExTokens != 0:\r
+        Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
+        Dict['EXMAPPING_TABLE_SIZE'] = str(NumberOfExTokens) + 'U'\r
+        Dict['EX_TOKEN_NUMBER']      = str(NumberOfExTokens) + 'U'\r
+    else:\r
+        Dict['EXMAPPING_TABLE_EXTOKEN'].append('0U')\r
+        Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append('0U')\r
+        Dict['EXMAPPING_TABLE_GUID_INDEX'].append('0U')\r
+\r
+    if NumberOfSizeItems != 0:\r
+        Dict['SIZE_TABLE_SIZE'] = str(NumberOfSizeItems * 2) + 'U'\r
+    \r
+    if NumberOfSkuEnabledPcd != 0: \r
+        Dict['SKU_HEAD_SIZE'] = str(NumberOfSkuEnabledPcd) + 'U'\r
+    \r
+    Dict['SKUID_VALUE'][0] = len(Dict['SKUID_VALUE'])\r
+    \r
+    AutoGenH.Append(gPcdDatabaseAutoGenH.Replace(Dict))\r
+    if NumberOfLocalTokens == 0:\r
+        AutoGenC.Append(gEmptyPcdDatabaseAutoGenC.Replace(Dict))\r
+    else:\r
+        #\r
+        # Update Size Table to the right order, it should be same with LocalTokenNumberTable\r
+        #\r
+        SizeCNameTempList = []\r
+        SizeGuidTempList = []\r
+        SizeCurLenTempList = []\r
+        SizeMaxLenTempList = []\r
+        ReOrderFlag = True\r
+  \r
+        if len(Dict['SIZE_TABLE_CNAME']) == 1:\r
+            if not (Dict['SIZE_TABLE_CNAME'][0] and Dict['SIZE_TABLE_GUID'][0]):\r
+                ReOrderFlag = False\r
+        \r
+        if ReOrderFlag:\r
+            for Count in range(len(Dict['TOKEN_CNAME'])):\r
+                for Count1 in range(len(Dict['SIZE_TABLE_CNAME'])):\r
+                    if Dict['TOKEN_CNAME'][Count] == Dict['SIZE_TABLE_CNAME'][Count1] and \\r
+                        Dict['TOKEN_GUID'][Count] == Dict['SIZE_TABLE_GUID'][Count1]:\r
+                        SizeCNameTempList.append(Dict['SIZE_TABLE_CNAME'][Count1])\r
+                        SizeGuidTempList.append(Dict['SIZE_TABLE_GUID'][Count1])\r
+                        SizeCurLenTempList.append(Dict['SIZE_TABLE_CURRENT_LENGTH'][Count1])\r
+                        SizeMaxLenTempList.append(Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count1])\r
+                        \r
+            for Count in range(len(Dict['SIZE_TABLE_CNAME'])):\r
+                Dict['SIZE_TABLE_CNAME'][Count] = SizeCNameTempList[Count]\r
+                Dict['SIZE_TABLE_GUID'][Count] = SizeGuidTempList[Count]\r
+                Dict['SIZE_TABLE_CURRENT_LENGTH'][Count] = SizeCurLenTempList[Count]\r
+                Dict['SIZE_TABLE_MAXIMUM_LENGTH'][Count] = SizeMaxLenTempList[Count]\r
+                \r
+        AutoGenC.Append(gPcdDatabaseAutoGenC.Replace(Dict))\r
+    \r
+    Buffer = BuildExDataBase(Dict)\r
+    return AutoGenH, AutoGenC, Buffer\r
+\r

diff --git a/BaseTools/Source/Python/BPDG/GenVpd.py b/BaseTools/Source/Python/BPDG/GenVpd.py
index cc4985062e4d977288092c6704297fe88e6baf58..3564571787551b47ef608f94a87594b5afdbdae1 100644 (file)
--- a/BaseTools/Source/Python/BPDG/GenVpd.py
+++ b/BaseTools/Source/Python/BPDG/GenVpd.py
@@ -34,9 +34,10 @@ _FORMAT_CHAR = {1: 'B',
 #  This class contain method to format and pack pcd's value.          \r
 #\r
 class PcdEntry:\r
 #  This class contain method to format and pack pcd's value.          \r
 #\r
 class PcdEntry:\r

-    def __init__(self, PcdCName, PcdOffset, PcdSize, PcdValue, Lineno=None, FileName=None, PcdUnpackValue=None, \r
+    def __init__(self, PcdCName, SkuId,PcdOffset, PcdSize, PcdValue, Lineno=None, FileName=None, PcdUnpackValue=None, \r

                  PcdBinOffset=None, PcdBinSize=None):\r
         self.PcdCName       = PcdCName.strip()\r
                  PcdBinOffset=None, PcdBinSize=None):\r
         self.PcdCName       = PcdCName.strip()\r

+        self.SkuId          = SkuId.strip()\r

         self.PcdOffset      = PcdOffset.strip()\r
         self.PcdSize        = PcdSize.strip()\r
         self.PcdValue       = PcdValue.strip()\r
         self.PcdOffset      = PcdOffset.strip()\r
         self.PcdSize        = PcdSize.strip()\r
         self.PcdValue       = PcdValue.strip()\r


@@ -284,7 +285,7 @@ class PcdEntry:
                                 "Invalid unicode character %s in unicode string %s(File: %s Line: %s)" % \\r
                                 (Value, UnicodeString, self.FileName, self.Lineno))\r
                 \r
                                 "Invalid unicode character %s in unicode string %s(File: %s Line: %s)" % \\r
                                 (Value, UnicodeString, self.FileName, self.Lineno))\r
                 \r

-        for Index in range(len(UnicodeString) * 2, Size):\r
+        for Index in xrange(len(UnicodeString) * 2, Size):\r

             ReturnArray.append(0)\r
             \r
         self.PcdValue =  ReturnArray.tolist()    \r
             ReturnArray.append(0)\r
             \r
         self.PcdValue =  ReturnArray.tolist()    \r


@@ -343,7 +344,7 @@ class GenVPD :
                 #\r
                 # Enhanced for support "|" character in the string.\r
                 #\r
                 #\r
                 # Enhanced for support "|" character in the string.\r
                 #\r

-                ValueList = ['', '', '', '']    \r
+                ValueList = ['', '', '', '','']    \r

                 \r
                 ValueRe  = re.compile(r'\s*L?\".*\|.*\"\s*$')\r
                 PtrValue = ValueRe.findall(line)\r
                 \r
                 ValueRe  = re.compile(r'\s*L?\".*\|.*\"\s*$')\r
                 PtrValue = ValueRe.findall(line)\r


@@ -358,7 +359,7 @@ class GenVPD :
                 ValueList[0:len(TokenList)] = TokenList\r
                 \r
                 if ValueUpdateFlag:\r
                 ValueList[0:len(TokenList)] = TokenList\r
                 \r
                 if ValueUpdateFlag:\r

-                    ValueList[3] = PtrValue[0]                              \r
+                    ValueList[4] = PtrValue[0]                              \r

                 self.FileLinesList[count] = ValueList\r
                 # Store the line number\r
                 self.FileLinesList[count].append(str(count+1))\r
                 self.FileLinesList[count] = ValueList\r
                 # Store the line number\r
                 self.FileLinesList[count].append(str(count+1))\r


@@ -393,9 +394,10 @@ class GenVPD :
         count = 0\r
         for line in self.FileLinesList:        \r
             if line != None :\r
         count = 0\r
         for line in self.FileLinesList:        \r
             if line != None :\r

-                PCD = PcdEntry(line[0], line[1], line[2], line[3], line[4], self.InputFileName)   \r
+                PCD = PcdEntry(line[0], line[1], line[2], line[3], line[4],line[5], self.InputFileName)   \r

                 # Strip the space char\r
                 PCD.PcdCName     = PCD.PcdCName.strip(' ')\r
                 # Strip the space char\r
                 PCD.PcdCName     = PCD.PcdCName.strip(' ')\r

+                PCD.SkuId        = PCD.SkuId.strip(' ')\r

                 PCD.PcdOffset    = PCD.PcdOffset.strip(' ')\r
                 PCD.PcdSize      = PCD.PcdSize.strip(' ')\r
                 PCD.PcdValue     = PCD.PcdValue.strip(' ')               \r
                 PCD.PcdOffset    = PCD.PcdOffset.strip(' ')\r
                 PCD.PcdSize      = PCD.PcdSize.strip(' ')\r
                 PCD.PcdValue     = PCD.PcdValue.strip(' ')               \r


@@ -639,7 +641,7 @@ class GenVPD :
         for eachPcd in self.PcdFixedOffsetSizeList  :\r
             # write map file\r
             try :\r
         for eachPcd in self.PcdFixedOffsetSizeList  :\r
             # write map file\r
             try :\r

-                fMapFile.write("%s | %s | %s | %s  \n" % (eachPcd.PcdCName, eachPcd.PcdOffset, eachPcd.PcdSize,eachPcd.PcdUnpackValue))\r
+                fMapFile.write("%s | %s | %s | %s | %s  \n" % (eachPcd.PcdCName, eachPcd.SkuId,eachPcd.PcdOffset, eachPcd.PcdSize,eachPcd.PcdUnpackValue))\r

             except:\r
                 EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." %self.MapFileName,None)                                                                      \r
                          \r
             except:\r
                 EdkLogger.error("BPDG", BuildToolError.FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." %self.MapFileName,None)                                                                      \r
                          \r

diff --git a/BaseTools/Source/Python/Common/BuildVersion.py b/BaseTools/Source/Python/Common/BuildVersion.py
index 25546cdfe92094e8e4dbe331db4258c60e309281..2a3b0aa681218c885c30e28503bd03568e040d45 100644 (file)
--- a/BaseTools/Source/Python/Common/BuildVersion.py
+++ b/BaseTools/Source/Python/Common/BuildVersion.py
@@ -13,4 +13,4 @@
 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
 #\r
 \r
 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
 #\r
 \r

-gBUILD_VERSION = "Build 2601"\r
+gBUILD_VERSION = "Build 2610"\r

diff --git a/BaseTools/Source/Python/Common/DataType.py b/BaseTools/Source/Python/Common/DataType.py
index 3a82362100f368021baf5641f6947bc516a9f20f..dbe7215f40a103378911363d65883e9a6ea0e578 100644 (file)
--- a/BaseTools/Source/Python/Common/DataType.py
+++ b/BaseTools/Source/Python/Common/DataType.py
@@ -397,6 +397,7 @@ TAB_DSC_DEFINES_OUTPUT_DIRECTORY = 'OUTPUT_DIRECTORY'
 TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES = 'SUPPORTED_ARCHITECTURES'\r
 TAB_DSC_DEFINES_BUILD_TARGETS = 'BUILD_TARGETS'\r
 TAB_DSC_DEFINES_SKUID_IDENTIFIER = 'SKUID_IDENTIFIER'\r
 TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES = 'SUPPORTED_ARCHITECTURES'\r
 TAB_DSC_DEFINES_BUILD_TARGETS = 'BUILD_TARGETS'\r
 TAB_DSC_DEFINES_SKUID_IDENTIFIER = 'SKUID_IDENTIFIER'\r

+TAB_DSC_DEFINES_PCD_INFO_GENERATION = 'PCD_INFO_GENERATION'\r

 TAB_DSC_DEFINES_FLASH_DEFINITION = 'FLASH_DEFINITION'\r
 TAB_DSC_DEFINES_BUILD_NUMBER = 'BUILD_NUMBER'\r
 TAB_DSC_DEFINES_MAKEFILE_NAME = 'MAKEFILE_NAME'\r
 TAB_DSC_DEFINES_FLASH_DEFINITION = 'FLASH_DEFINITION'\r
 TAB_DSC_DEFINES_BUILD_NUMBER = 'BUILD_NUMBER'\r
 TAB_DSC_DEFINES_MAKEFILE_NAME = 'MAKEFILE_NAME'\r

diff --git a/BaseTools/Source/Python/Common/GlobalData.py b/BaseTools/Source/Python/Common/GlobalData.py
index d566a5784412f0bdfd77a99992a298f23b8b5000..4fbe72182300a20a200cf92337b5c5de3fc73b30 100644 (file)
--- a/BaseTools/Source/Python/Common/GlobalData.py
+++ b/BaseTools/Source/Python/Common/GlobalData.py
@@ -50,3 +50,22 @@ gWideStringPattern = re.compile('(\W|\A)L"')
 #
 gAutoGenPhase = False
 
 #
 gAutoGenPhase = False
 

+#
+# The Conf dir outside the workspace dir
+#
+gConfDirectory = ''
+
+#
+# The relative default database file path
+#
+gDatabasePath = ".cache/build.db"
+
+#
+# Build flag for binary build
+#
+gIgnoreSource = False
+
+#
+# FDF parser
+#
+gFdfParser = None

diff --git a/BaseTools/Source/Python/Common/Misc.py b/BaseTools/Source/Python/Common/Misc.py
index afdfb93ad62c108f37a345b00774555f43774674..960581581a7eb6a731d501afb99434bb0cce4273 100644 (file)
--- a/BaseTools/Source/Python/Common/Misc.py
+++ b/BaseTools/Source/Python/Common/Misc.py
@@ -31,6 +31,7 @@ from Common import GlobalData as GlobalData
 from DataType import *
 from BuildToolError import *
 from CommonDataClass.DataClass import *
 from DataType import *
 from BuildToolError import *
 from CommonDataClass.DataClass import *

+from Parsing import GetSplitValueList

 
 ## Regular expression used to find out place holders in string template
 gPlaceholderPattern = re.compile("\$\{([^$()\s]+)\}", re.MULTILINE|re.UNICODE)
 
 ## Regular expression used to find out place holders in string template
 gPlaceholderPattern = re.compile("\$\{([^$()\s]+)\}", re.MULTILINE|re.UNICODE)


@@ -1248,8 +1249,13 @@ def AnalyzeDscPcd(Setting, PcdType, DataType=''):
         Size = Type = ''
         if len(FieldList) > 1:
             Type = FieldList[1]
         Size = Type = ''
         if len(FieldList) > 1:
             Type = FieldList[1]

+        else:
+            Type = DataType

         if len(FieldList) > 2:
             Size = FieldList[2]
         if len(FieldList) > 2:
             Size = FieldList[2]

+        else:
+            if Type == 'VOID*':
+                Size = str(len(Value))

         if DataType == 'VOID*':
             IsValid = (len(FieldList) <= 3)
         else:
         if DataType == 'VOID*':
             IsValid = (len(FieldList) <= 3)
         else:


@@ -1322,25 +1328,13 @@ def AnalyzePcdData(Setting):
 #  
 #  @retval   ValueList: A List contaian VariableName, VariableGuid, VariableOffset, DefaultValue. 
 #
 #  
 #  @retval   ValueList: A List contaian VariableName, VariableGuid, VariableOffset, DefaultValue. 
 #

-def AnalyzeHiiPcdData(Setting):   
-    ValueList = ['', '', '', '']    
-    
-    ValueRe  = re.compile(r'^\s*L?\".*\|.*\"')
-    PtrValue = ValueRe.findall(Setting)
-    
-    ValueUpdateFlag = False
-    
-    if len(PtrValue) >= 1:
-        Setting = re.sub(ValueRe, '', Setting)
-        ValueUpdateFlag = True   
+def AnalyzeHiiPcdData(Setting):
+    ValueList = ['', '', '', '']

 
 

-    TokenList = Setting.split(TAB_VALUE_SPLIT)
+    TokenList = GetSplitValueList(Setting)

     ValueList[0:len(TokenList)] = TokenList
     ValueList[0:len(TokenList)] = TokenList

-    
-    if ValueUpdateFlag:
-        ValueList[0] = PtrValue[0]
-        
-    return ValueList     
+
+    return ValueList

 
 ## AnalyzeVpdPcdData
 #
 
 ## AnalyzeVpdPcdData
 #


@@ -1679,7 +1673,60 @@ class PeImageClass():
         for index in range(len(ByteList) - 1, -1, -1):
             Value = (Value << 8) | int(ByteList[index])
         return Value
         for index in range(len(ByteList) - 1, -1, -1):
             Value = (Value << 8) | int(ByteList[index])
         return Value

+
+
+class SkuClass():
+    
+    DEFAULT = 0
+    SINGLE = 1
+    MULTIPLE =2
+    
+    def __init__(self,SkuIdentifier='', SkuIds={}):
+        
+        self.AvailableSkuIds = sdict()
+        self.SkuIdSet = []
+        
+        if SkuIdentifier == '' or SkuIdentifier is None:
+            self.SkuIdSet = ['DEFAULT']
+        elif SkuIdentifier == 'ALL':
+            self.SkuIdSet = SkuIds.keys()
+        else:
+            r = SkuIdentifier.split('|') 
+            self.SkuIdSet=[r[k].strip() for k in range(len(r))]      
+        if len(self.SkuIdSet) == 2 and 'DEFAULT' in self.SkuIdSet and SkuIdentifier != 'ALL':
+            self.SkuIdSet.remove('DEFAULT')
+                
+        for each in self.SkuIdSet:
+            if each in SkuIds:
+                self.AvailableSkuIds[each] = SkuIds[each]
+            else:
+                EdkLogger.error("build", PARAMETER_INVALID,
+                            ExtraData="SKU-ID [%s] is not supported by the platform. [Valid SKU-ID: %s]"
+                                      % (each, " ".join(SkuIds.keys())))

         
         

+    def __SkuUsageType(self): 
+        
+        if len(self.SkuIdSet) == 1:
+            if self.SkuIdSet[0] == 'DEFAULT':
+                return SkuClass.DEFAULT
+            else:
+                return SkuClass.SINGLE
+        else:
+            return SkuClass.MULTIPLE
+
+    def __GetAvailableSkuIds(self):
+        return self.AvailableSkuIds
+    
+    def __GetSystemSkuID(self):
+        if self.__SkuUsageType() == SkuClass.SINGLE:
+            return self.SkuIdSet[0]
+        else:
+            return 'DEFAULT'
+            
+    SystemSkuId = property(__GetSystemSkuID)
+    AvailableSkuIdSet = property(__GetAvailableSkuIds)
+    SkuUsageType = property(__SkuUsageType)
+

 ##
 #
 # This acts like the main() function for the script, unless it is 'import'ed into another
 ##
 #
 # This acts like the main() function for the script, unless it is 'import'ed into another

diff --git a/BaseTools/Source/Python/Common/VpdInfoFile.py b/BaseTools/Source/Python/Common/VpdInfoFile.py
index 207cc8735b1c5fea523c25475e977771cf4f3525..18f6f5663c51d4386269988ade67e0e00c1a270e 100644 (file)
--- a/BaseTools/Source/Python/Common/VpdInfoFile.py
+++ b/BaseTools/Source/Python/Common/VpdInfoFile.py
@@ -138,12 +138,14 @@ class VpdInfoFile:
             Pcds = self._VpdArray.keys()\r
             Pcds.sort()\r
             for Pcd in Pcds:\r
             Pcds = self._VpdArray.keys()\r
             Pcds.sort()\r
             for Pcd in Pcds:\r

+                i = 0\r

                 for Offset in self._VpdArray[Pcd]:\r
                 for Offset in self._VpdArray[Pcd]:\r

-                    PcdValue = str(Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]].DefaultValue).strip()\r
+                    PcdValue = str(Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[i]].DefaultValue).strip()\r

                     if PcdValue == "" :\r
                         PcdValue  = Pcd.DefaultValue\r
                         \r
                     if PcdValue == "" :\r
                         PcdValue  = Pcd.DefaultValue\r
                         \r

-                    fd.write("%s.%s|%s|%s|%s  \n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, str(Offset).strip(), str(Pcd.MaxDatumSize).strip(),PcdValue))\r
+                    fd.write("%s.%s|%s|%s|%s|%s  \n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, str(Pcd.SkuInfoList.keys()[i]),str(Offset).strip(), str(Pcd.MaxDatumSize).strip(),PcdValue))\r
+                    i += 1\r

         except:\r
             EdkLogger.error("VpdInfoFile",\r
                             BuildToolError.FILE_WRITE_FAILURE,\r
         except:\r
             EdkLogger.error("VpdInfoFile",\r
                             BuildToolError.FILE_WRITE_FAILURE,\r


@@ -174,21 +176,22 @@ class VpdInfoFile:
             # the line must follow output format defined in BPDG spec.\r
             #\r
             try:\r
             # the line must follow output format defined in BPDG spec.\r
             #\r
             try:\r

-                PcdName, Offset, Size, Value = Line.split("#")[0].split("|")\r
+                PcdName, SkuId,Offset, Size, Value = Line.split("#")[0].split("|")\r
+                PcdName, SkuId,Offset, Size, Value = PcdName.strip(), SkuId.strip(),Offset.strip(), Size.strip(), Value.strip()\r

                 TokenSpaceName, PcdTokenName = PcdName.split(".")\r
             except:\r
                 EdkLogger.error("BPDG", BuildToolError.PARSER_ERROR, "Fail to parse VPD information file %s" % FilePath)\r
             \r
             Found = False\r
                 TokenSpaceName, PcdTokenName = PcdName.split(".")\r
             except:\r
                 EdkLogger.error("BPDG", BuildToolError.PARSER_ERROR, "Fail to parse VPD information file %s" % FilePath)\r
             \r
             Found = False\r

+            \r

             for VpdObject in self._VpdArray.keys():\r
             for VpdObject in self._VpdArray.keys():\r

-                if VpdObject.TokenSpaceGuidCName == TokenSpaceName and VpdObject.TokenCName == PcdTokenName.strip():\r
-                    if self._VpdArray[VpdObject][0] == "*":\r
-                        if Offset == "*":\r
-                            EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "The offset of %s has not been fixed up by third-party BPDG tool." % PcdName)\r
-                            \r
-                        self._VpdArray[VpdObject][0] = Offset\r
-                    Found = True\r
-                    break\r
+                for sku in VpdObject.SkuInfoList.keys(): \r
+                    if VpdObject.TokenSpaceGuidCName == TokenSpaceName and VpdObject.TokenCName == PcdTokenName.strip() and sku == SkuId:\r
+                        if self._VpdArray[VpdObject][VpdObject.SkuInfoList.keys().index(sku)] == "*":\r
+                            if Offset == "*":\r
+                                EdkLogger.error("BPDG", BuildToolError.FORMAT_INVALID, "The offset of %s has not been fixed up by third-party BPDG tool." % PcdName)                              \r
+                            self._VpdArray[VpdObject][VpdObject.SkuInfoList.keys().index(sku)] = Offset\r
+                        Found = True\r

             if not Found:\r
                 EdkLogger.error("BPDG", BuildToolError.PARSER_ERROR, "Can not find PCD defined in VPD guid file.")\r
                 \r
             if not Found:\r
                 EdkLogger.error("BPDG", BuildToolError.PARSER_ERROR, "Can not find PCD defined in VPD guid file.")\r
                 \r

diff --git a/BaseTools/Source/Python/CommonDataClass/DataClass.py b/BaseTools/Source/Python/CommonDataClass/DataClass.py
index 3d971c84cdb8ef991bd0e4c2b1a7a1ce5459c17a..c69152b9b4741f0af7f370490701a4e4c3f7c736 100644 (file)
--- a/BaseTools/Source/Python/CommonDataClass/DataClass.py
+++ b/BaseTools/Source/Python/CommonDataClass/DataClass.py
@@ -77,6 +77,7 @@ MODEL_PCD_DYNAMIC_DEFAULT = 4009
 MODEL_PCD_DYNAMIC_VPD = 4010\r
 MODEL_PCD_DYNAMIC_HII = 4011\r
 \r
 MODEL_PCD_DYNAMIC_VPD = 4010\r
 MODEL_PCD_DYNAMIC_HII = 4011\r
 \r

+MODEL_META_DATA_HEADER_COMMENT = 5000\r

 MODEL_META_DATA_HEADER = 5001\r
 MODEL_META_DATA_INCLUDE = 5002\r
 MODEL_META_DATA_DEFINE = 5003\r
 MODEL_META_DATA_HEADER = 5001\r
 MODEL_META_DATA_INCLUDE = 5002\r
 MODEL_META_DATA_DEFINE = 5003\r

diff --git a/BaseTools/Source/Python/CommonDataClass/FdfClass.py b/BaseTools/Source/Python/CommonDataClass/FdfClass.py
index 996468d6aac251e0576e929f10fc62318b8e80da..ce3df12058c05ac7974dd580d9a0ade6264cccfd 100644 (file)
--- a/BaseTools/Source/Python/CommonDataClass/FdfClass.py
+++ b/BaseTools/Source/Python/CommonDataClass/FdfClass.py
@@ -1,7 +1,7 @@
 ## @file\r
 # classes represent data in FDF\r
 #\r
 ## @file\r
 # classes represent data in FDF\r
 #\r

-#  Copyright (c) 2007 - 2010, 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
 #\r
 #  This program and the accompanying materials\r
 #  are licensed and made available under the terms and conditions of the BSD License\r


@@ -27,7 +27,7 @@ class FDClassObject:
         self.BaseAddressPcd = None\r
         self.Size = None\r
         self.SizePcd = None\r
         self.BaseAddressPcd = None\r
         self.Size = None\r
         self.SizePcd = None\r

-        self.ErasePolarity = '1'\r
+        self.ErasePolarity = None\r

         # 3-tuple list (blockSize, numBlocks, pcd)\r
         self.BlockSizeList = []\r
         # DefineVarDict[var] = value\r
         # 3-tuple list (blockSize, numBlocks, pcd)\r
         self.BlockSizeList = []\r
         # DefineVarDict[var] = value\r

diff --git a/BaseTools/Source/Python/Ecc/MetaFileWorkspace/MetaFileParser.py b/BaseTools/Source/Python/Ecc/MetaFileWorkspace/MetaFileParser.py
index d10265e973c4f2f35f34206ef3e78c31138e6762..98a899e76b0690521a8d3f29dba2778c5a52eb02 100644 (file)
--- a/BaseTools/Source/Python/Ecc/MetaFileWorkspace/MetaFileParser.py
+++ b/BaseTools/Source/Python/Ecc/MetaFileWorkspace/MetaFileParser.py
@@ -719,6 +719,7 @@ class DscParser(MetaFileParser):
         "PLATFORM_GUID",
         "PLATFORM_VERSION",
         "SKUID_IDENTIFIER",
         "PLATFORM_GUID",
         "PLATFORM_VERSION",
         "SKUID_IDENTIFIER",

+        "PCD_INFO_GENERATION",

         "SUPPORTED_ARCHITECTURES",
         "BUILD_TARGETS",
         "OUTPUT_DIRECTORY",
         "SUPPORTED_ARCHITECTURES",
         "BUILD_TARGETS",
         "OUTPUT_DIRECTORY",

diff --git a/BaseTools/Source/Python/GenFds/FdfParser.py b/BaseTools/Source/Python/GenFds/FdfParser.py
index a468a5ec995d082539320c190724043606a288c2..661e16ae40e0c1fe226b6ade2eac661f0266d063 100644 (file)
--- a/BaseTools/Source/Python/GenFds/FdfParser.py
+++ b/BaseTools/Source/Python/GenFds/FdfParser.py
@@ -1,7 +1,7 @@
 ## @file\r
 # parse FDF file\r
 #\r
 ## @file\r
 # parse FDF file\r
 #\r

-#  Copyright (c) 2007 - 2010, 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
 #\r
 #  This program and the accompanying materials\r
 #  are licensed and made available under the terms and conditions of the BSD License\r


@@ -1423,7 +1423,15 @@ class FdfParser:
         if not Status:\r
             raise Warning("FD name error", self.FileName, self.CurrentLineNumber)\r
 \r
         if not Status:\r
             raise Warning("FD name error", self.FileName, self.CurrentLineNumber)\r
 \r

-        self.__GetTokenStatements(FdObj)\r
+        while self.__GetTokenStatements(FdObj):\r
+            pass\r
+        for Attr in ("BaseAddress", "Size", "ErasePolarity"):\r
+            if getattr(FdObj, Attr) == None:\r
+                self.__GetNextToken()\r
+                raise Warning("Keyword %s missing" % Attr, self.FileName, self.CurrentLineNumber)\r
+\r
+        if not FdObj.BlockSizeList:\r
+            FdObj.BlockSizeList.append((1, FdObj.Size, None))\r

 \r
         self.__GetDefineStatements(FdObj)\r
 \r
 \r
         self.__GetDefineStatements(FdObj)\r
 \r


@@ -1480,58 +1488,54 @@ class FdfParser:
     #   @param  Obj         for whom token statement is got\r
     #\r
     def __GetTokenStatements(self, Obj):\r
     #   @param  Obj         for whom token statement is got\r
     #\r
     def __GetTokenStatements(self, Obj):\r

-        if not self.__IsKeyword( "BaseAddress"):\r
-            raise Warning("BaseAddress missing", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextHexNumber():\r
-            raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber)\r
-\r
-        Obj.BaseAddress = self.__Token\r
-\r
-        if self.__IsToken( "|"):\r
-            pcdPair = self.__GetNextPcdName()\r
-            Obj.BaseAddressPcd = pcdPair\r
-            self.Profile.PcdDict[pcdPair] = Obj.BaseAddress\r
-            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
-            self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
-\r
-        if not self.__IsKeyword( "Size"):\r
-            raise Warning("Size missing", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextHexNumber():\r
-            raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber)\r
-\r
-\r
-        Size = self.__Token\r
-        if self.__IsToken( "|"):\r
-            pcdPair = self.__GetNextPcdName()\r
-            Obj.SizePcd = pcdPair\r
-            self.Profile.PcdDict[pcdPair] = Size\r
-            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
-            self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
-        Obj.Size = long(Size, 0)\r
-\r
-        if not self.__IsKeyword( "ErasePolarity"):\r
-            raise Warning("ErasePolarity missing", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if self.__IsKeyword( "BaseAddress"):\r
+            if not self.__IsToken( "="):\r
+                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    \r
+            if not self.__GetNextHexNumber():\r
+                raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber)\r
+    \r
+            Obj.BaseAddress = self.__Token\r
+    \r
+            if self.__IsToken( "|"):\r
+                pcdPair = self.__GetNextPcdName()\r
+                Obj.BaseAddressPcd = pcdPair\r
+                self.Profile.PcdDict[pcdPair] = Obj.BaseAddress\r
+                FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
+                self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
+            return True\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+        if self.__IsKeyword( "Size"):\r
+            if not self.__IsToken( "="):\r
+                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    \r
+            if not self.__GetNextHexNumber():\r
+                raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token != "1" and self.__Token != "0":\r
-            raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+            Size = self.__Token\r
+            if self.__IsToken( "|"):\r
+                pcdPair = self.__GetNextPcdName()\r
+                Obj.SizePcd = pcdPair\r
+                self.Profile.PcdDict[pcdPair] = Size\r
+                FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
+                self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
+            Obj.Size = long(Size, 0)\r
+            return True\r

 \r
 \r

-        Obj.ErasePolarity = self.__Token\r
+        if self.__IsKeyword( "ErasePolarity"):\r
+            if not self.__IsToken( "="):\r
+                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    \r
+            if not self.__GetNextToken():\r
+                raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+    \r
+            if self.__Token != "1" and self.__Token != "0":\r
+                raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+    \r
+            Obj.ErasePolarity = self.__Token\r
+            return True\r

 \r
 \r

-        self.__GetBlockStatements(Obj)\r
+        return self.__GetBlockStatements(Obj)\r

 \r
     ## __GetAddressStatements() method\r
     #\r
 \r
     ## __GetAddressStatements() method\r
     #\r


@@ -1572,18 +1576,14 @@ class FdfParser:
     #   @param  Obj         for whom block statement is got\r
     #\r
     def __GetBlockStatements(self, Obj):\r
     #   @param  Obj         for whom block statement is got\r
     #\r
     def __GetBlockStatements(self, Obj):\r

-\r
-        if not self.__GetBlockStatement(Obj):\r
-            #set default block size is 1\r
-            Obj.BlockSizeList.append((1, Obj.Size, None))\r
-            return\r
-\r
+        IsBlock = False\r

         while self.__GetBlockStatement(Obj):\r
         while self.__GetBlockStatement(Obj):\r

-            pass\r
+            IsBlock = True\r

         \r
         \r

-        for Item in Obj.BlockSizeList:\r
+            Item = Obj.BlockSizeList[-1]\r

             if Item[0] == None or Item[1] == None:\r
                 raise Warning("expected block statement", self.FileName, self.CurrentLineNumber)\r
             if Item[0] == None or Item[1] == None:\r
                 raise Warning("expected block statement", self.FileName, self.CurrentLineNumber)\r

+        return IsBlock\r

 \r
     ## __GetBlockStatement() method\r
     #\r
 \r
     ## __GetBlockStatement() method\r
     #\r


@@ -2038,27 +2038,16 @@ class FdfParser:
 \r
         self.__GetAddressStatements(FvObj)\r
 \r
 \r
         self.__GetAddressStatements(FvObj)\r
 \r

-        while self.__GetBlockStatement(FvObj):\r
-            pass\r
-\r
-        self.__GetSetStatements(FvObj)\r
-        \r
-        self.__GetFvBaseAddress(FvObj)\r
-        \r
-        self.__GetFvForceRebase(FvObj)\r
-\r
-        self.__GetFvAlignment(FvObj)\r
-\r
-        self.__GetFvAttributes(FvObj)\r
-        \r
-        self.__GetFvNameGuid(FvObj)\r
-\r

         FvObj.FvExtEntryTypeValue = []\r
         FvObj.FvExtEntryType = []\r
         FvObj.FvExtEntryData = []\r
         while True:\r
         FvObj.FvExtEntryTypeValue = []\r
         FvObj.FvExtEntryType = []\r
         FvObj.FvExtEntryData = []\r
         while True:\r

-            isFvExtEntry = self.__GetFvExtEntryStatement(FvObj)\r
-            if not isFvExtEntry:\r
+            self.__GetSetStatements(FvObj)\r
+\r
+            if not (self.__GetBlockStatement(FvObj) or self.__GetFvBaseAddress(FvObj) or \r
+                self.__GetFvForceRebase(FvObj) or self.__GetFvAlignment(FvObj) or \r
+                self.__GetFvAttributes(FvObj) or self.__GetFvNameGuid(FvObj) or \r
+                self.__GetFvExtEntryStatement(FvObj)):\r

                 break\r
 \r
         self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r
                 break\r
 \r
         self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r


@@ -2177,9 +2166,9 @@ class FdfParser:
                            "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \\r
                            "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \\r
                            "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \\r
                            "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \\r
                            "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \\r
                            "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \\r

-                           "WRITE_POLICY_RELIABLE"):\r
+                           "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT"):\r

                 self.__UndoToken()\r
                 self.__UndoToken()\r

-                return\r
+                return False\r

 \r
             if not self.__IsToken( "="):\r
                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
 \r
             if not self.__IsToken( "="):\r
                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r


@@ -2189,7 +2178,7 @@ class FdfParser:
 \r
             FvObj.FvAttributeDict[name] = self.__Token\r
 \r
 \r
             FvObj.FvAttributeDict[name] = self.__Token\r
 \r

-        return\r
+        return True\r

     \r
     ## __GetFvNameGuid() method\r
     #\r
     \r
     ## __GetFvNameGuid() method\r
     #\r


@@ -2202,7 +2191,7 @@ class FdfParser:
     def __GetFvNameGuid(self, FvObj):\r
 \r
         if not self.__IsKeyword( "FvNameGuid"):\r
     def __GetFvNameGuid(self, FvObj):\r
 \r
         if not self.__IsKeyword( "FvNameGuid"):\r

-            return\r
+            return False\r

 \r
         if not self.__IsToken( "="):\r
             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
 \r
         if not self.__IsToken( "="):\r
             raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r


@@ -2212,7 +2201,7 @@ class FdfParser:
 \r
         FvObj.FvNameGuid = self.__Token\r
 \r
 \r
         FvObj.FvNameGuid = self.__Token\r
 \r

-        return\r
+        return True\r

 \r
     def __GetFvExtEntryStatement(self, FvObj):\r
 \r
 \r
     def __GetFvExtEntryStatement(self, FvObj):\r
 \r


@@ -3058,7 +3047,7 @@ class FdfParser:
     def __GetCapsuleTokens(self, Obj):\r
         if not self.__GetNextToken():\r
             return False\r
     def __GetCapsuleTokens(self, Obj):\r
         if not self.__GetNextToken():\r
             return False\r

-        while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS"):\r
+        while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS"):\r

             Name = self.__Token.strip()\r
             if not self.__IsToken("="):\r
                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
             Name = self.__Token.strip()\r
             if not self.__IsToken("="):\r
                 raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r


@@ -3075,6 +3064,15 @@ class FdfParser:
                     if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):\r
                         raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
                     Value += self.__Token.strip()\r
                     if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):\r
                         raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
                     Value += self.__Token.strip()\r

+            elif Name == 'OEM_CAPSULE_FLAGS':\r
+                Value = self.__Token.strip()\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
+                if not 0x0000 <= Value <= 0xFFFF:\r
+                    raise Warning("expected integer value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+                Value = self.__Token.strip()\r

             else:\r
                 Value = self.__Token.strip()\r
             Obj.TokensDict[Name] = Value  \r
             else:\r
                 Value = self.__Token.strip()\r
             Obj.TokensDict[Name] = Value  \r

diff --git a/BaseTools/Source/Python/GenFds/FfsInfStatement.py b/BaseTools/Source/Python/GenFds/FfsInfStatement.py
index 71acd2992ca03d8ce8cd8efef9a089ec8db62628..3d16398c32ce4e5e9422b71ca43723c9dbbe4da1 100644 (file)
--- a/BaseTools/Source/Python/GenFds/FfsInfStatement.py
+++ b/BaseTools/Source/Python/GenFds/FfsInfStatement.py
@@ -37,6 +37,7 @@ from GuidSection import GuidSection
 from FvImageSection import FvImageSection\r
 from Common.Misc import PeImageClass\r
 from AutoGen.GenDepex import DependencyExpression\r
 from FvImageSection import FvImageSection\r
 from Common.Misc import PeImageClass\r
 from AutoGen.GenDepex import DependencyExpression\r

+from PatchPcdValue.PatchPcdValue import PatchBinaryFile\r

 \r
 ## generate FFS from INF\r
 #\r
 \r
 ## generate FFS from INF\r
 #\r


@@ -203,14 +204,80 @@ class FfsInfStatement(FfsInfStatementClassObject):
 \r
         if Inf._Defs != None and len(Inf._Defs) > 0:\r
             self.OptRomDefs.update(Inf._Defs)\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
+        DscModules = {}\r
+        for DscModule in Platform.Modules:\r
+            DscModules[str(DscModule).lower()] = Platform.Modules[DscModule]\r
+        for PcdKey in InfPcds:\r
+            Pcd = InfPcds[PcdKey]\r
+            if not hasattr(Pcd, 'Offset'):\r
+                continue\r
+            if Pcd.Type != 'PatchableInModule':\r
+                continue\r
+            PatchPcd = None\r
+            InfLowerPath = str(PathClassObj).lower()\r
+            if InfLowerPath in DscModules and PcdKey in DscModules[InfLowerPath].Pcds:\r
+                PatchPcd = DscModules[InfLowerPath].Pcds[PcdKey]\r
+            elif PcdKey in Platform.Pcds:\r
+                PatchPcd = Platform.Pcds[PcdKey]\r
+            DscOverride = False\r
+            if PatchPcd and Pcd.Type == PatchPcd.Type:\r
+                DefaultValue = PatchPcd.DefaultValue\r
+                DscOverride = True\r
+            FdfOverride = False\r
+            if PcdKey in FdfPcdDict:\r
+                DefaultValue = FdfPcdDict[PcdKey]\r
+                FdfOverride = True\r
+            if not DscOverride and not FdfOverride:\r
+                continue\r
+            if Pcd.DatumType == "VOID*":\r
+                if Pcd.DefaultValue == DefaultValue or DefaultValue in [None, '']:\r
+                    continue\r
+                if DefaultValue[0] == 'L':\r
+                    MaxDatumSize = str((len(DefaultValue) - 2) * 2)\r
+                elif DefaultValue[0] == '{':\r
+                    MaxDatumSize = str(len(DefaultValue.split(',')))\r
+                else:\r
+                    MaxDatumSize = str(len(DefaultValue) - 1)\r
+                if DscOverride:\r
+                    Pcd.MaxDatumSize = PatchPcd.MaxDatumSize\r
+                if Pcd.MaxDatumSize in ['', None]:\r
+                    Pcd.MaxDatumSize = str(len(Pcd.DefaultValue.split(',')))\r
+            else:\r
+                Base1 = Base2 = 10\r
+                if Pcd.DefaultValue.upper().startswith('0X'):\r
+                    Base1 = 16\r
+                if DefaultValue.upper().startswith('0X'):\r
+                    Base2 = 16\r
+                try:\r
+                    PcdValueInImg = int(Pcd.DefaultValue, Base1)\r
+                    PcdValueInDscOrFdf = int(DefaultValue, Base2)\r
+                    if PcdValueInImg == PcdValueInDscOrFdf:\r
+                        continue\r
+                except:\r
+                    continue\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
+                                    % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, int(MaxDatumSize) - int(Pcd.MaxDatumSize)))\r
+            else:\r
+                if PcdValueInDscOrFdf > FfsInfStatement._MAX_SIZE_TYPE[Pcd.DatumType] \\r
+                    or PcdValueInImg > FfsInfStatement._MAX_SIZE_TYPE[Pcd.DatumType]:\r
+                    EdkLogger.error("GenFds", GENFDS_ERROR, "The size of %s type PCD '%s.%s' doesn't match its data type." \\r
+                                    % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
+            Pcd.DefaultValue = DefaultValue\r
+            self.PatchPcds.append(Pcd)\r

         self.InfModule = Inf\r
         self.InfModule = Inf\r

-            \r
-        GenFdsGlobalVariable.VerboseLogger( "BaseName : %s" %self.BaseName)\r
-        GenFdsGlobalVariable.VerboseLogger("ModuleGuid : %s" %self.ModuleGuid)\r
-        GenFdsGlobalVariable.VerboseLogger("ModuleType : %s" %self.ModuleType)\r
-        GenFdsGlobalVariable.VerboseLogger("VersionString : %s" %self.VersionString)\r
-        GenFdsGlobalVariable.VerboseLogger("InfFileName :%s"  %self.InfFileName)\r
+        self.PcdIsDriver = Inf.PcdIsDriver\r
+        self.IsBinaryModule = Inf.IsBinaryModule\r
+        GenFdsGlobalVariable.VerboseLogger("BaseName : %s" % self.BaseName)\r
+        GenFdsGlobalVariable.VerboseLogger("ModuleGuid : %s" % self.ModuleGuid)\r
+        GenFdsGlobalVariable.VerboseLogger("ModuleType : %s" % self.ModuleType)\r
+        GenFdsGlobalVariable.VerboseLogger("VersionString : %s" % self.VersionString)\r
+        GenFdsGlobalVariable.VerboseLogger("InfFileName :%s" % self.InfFileName)\r

 \r
         #\r
         # Set OutputPath = ${WorkSpace}\Build\Fv\Ffs\${ModuleGuid}+ ${MdouleName}\\r
 \r
         #\r
         # Set OutputPath = ${WorkSpace}\Build\Fv\Ffs\${ModuleGuid}+ ${MdouleName}\\r


@@ -224,6 +291,27 @@ class FfsInfStatement(FfsInfStatementClassObject):
         self.EfiOutputPath = self.__GetEFIOutPutPath__()\r
         GenFdsGlobalVariable.VerboseLogger( "ModuelEFIPath: " + self.EfiOutputPath)\r
 \r
         self.EfiOutputPath = self.__GetEFIOutPutPath__()\r
         GenFdsGlobalVariable.VerboseLogger( "ModuelEFIPath: " + self.EfiOutputPath)\r
 \r

+## PatchEfiFile\r
+    #\r
+    #  Patch EFI file with patch PCD\r
+    #\r
+    #  @param EfiFile: EFI file needs to be patched.\r
+    #  @retval: Full path of patched EFI file: self.OutputPath + EfiFile base name\r
+    #           If passed in file does not end with efi, return as is\r
+    #\r
+    def PatchEfiFile(self, EfiFile):\r
+        if os.path.splitext(EfiFile)[1].lower() != '.efi':\r
+            return EfiFile\r
+        if not self.PatchPcds:\r
+            return EfiFile\r
+        Basename = os.path.basename(EfiFile)\r
+        Output = os.path.join(self.OutputPath, Basename)\r
+        CopyLongFilePath(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
+                EdkLogger.error("GenFds", GENFDS_ERROR, RetStr, File=self.InfFileName)\r
+        return Output\r

     ## GenFfs() method\r
     #\r
     #   Generate FFS\r
     ## GenFfs() method\r
     #\r
     #   Generate FFS\r


@@ -668,6 +756,30 @@ class FfsInfStatement(FfsInfStatementClassObject):
         SectAlignments = []\r
         Index = 1\r
         HasGneratedFlag = False\r
         SectAlignments = []\r
         Index = 1\r
         HasGneratedFlag = False\r

+        if self.PcdIsDriver == 'PEI_PCD_DRIVER':\r
+            if self.IsBinaryModule:\r
+                PcdExDbFileName = os.path.join(GenFdsGlobalVariable.FvDir, "PEIPcdDataBase.raw")\r
+            else:\r
+                PcdExDbFileName = os.path.join(self.EfiOutputPath, "PEIPcdDataBase.raw")\r
+            PcdExDbSecName = os.path.join(self.OutputPath, "PEIPcdDataBaseSec.raw")\r
+            GenFdsGlobalVariable.GenerateSection(PcdExDbSecName,\r
+                                                 [PcdExDbFileName],\r
+                                                 "EFI_SECTION_RAW",\r
+                                                 )\r
+            SectFiles.append(PcdExDbSecName)\r
+            SectAlignments.append(None)\r
+        elif self.PcdIsDriver == 'DXE_PCD_DRIVER':\r
+            if self.IsBinaryModule:\r
+                PcdExDbFileName = os.path.join(GenFdsGlobalVariable.FvDir, "DXEPcdDataBase.raw")\r
+            else:\r
+                PcdExDbFileName = os.path.join(self.EfiOutputPath, "DXEPcdDataBase.raw")\r
+            PcdExDbSecName = os.path.join(self.OutputPath, "DXEPcdDataBaseSec.raw")\r
+            GenFdsGlobalVariable.GenerateSection(PcdExDbSecName,\r
+                                                 [PcdExDbFileName],\r
+                                                 "EFI_SECTION_RAW",\r
+                                                 )\r
+            SectFiles.append(PcdExDbSecName)\r
+            SectAlignments.append(None)\r

         for Sect in Rule.SectionList:\r
             SecIndex = '%d' %Index\r
             SectList  = []\r
         for Sect in Rule.SectionList:\r
             SecIndex = '%d' %Index\r
             SectList  = []\r

diff --git a/BaseTools/Source/Python/GenFds/Section.py b/BaseTools/Source/Python/GenFds/Section.py
index 6f57ad568196050b0347cddd2193038c72498a37..819bb51a7879d7430576e19fc419dfc794e30cc4 100644 (file)
--- a/BaseTools/Source/Python/GenFds/Section.py
+++ b/BaseTools/Source/Python/GenFds/Section.py
@@ -131,7 +131,7 @@ class Section (SectionClassObject):
                 if File.Arch == "COMMON" or FfsInf.CurrentArch == File.Arch:\r
                     if File.Type == FileType or (int(FfsInf.PiSpecVersion, 16) >= 0x0001000A and FileType == 'DXE_DPEX'and File.Type == 'SMM_DEPEX'):\r
                         if '*' in FfsInf.TargetOverrideList or File.Target == '*' or File.Target in FfsInf.TargetOverrideList or FfsInf.TargetOverrideList == []:\r
                 if File.Arch == "COMMON" or FfsInf.CurrentArch == File.Arch:\r
                     if File.Type == FileType or (int(FfsInf.PiSpecVersion, 16) >= 0x0001000A and FileType == 'DXE_DPEX'and File.Type == 'SMM_DEPEX'):\r
                         if '*' in FfsInf.TargetOverrideList or File.Target == '*' or File.Target in FfsInf.TargetOverrideList or FfsInf.TargetOverrideList == []:\r

-                            FileList.append(File.Path)\r
+                            FileList.append(FfsInf.PatchEfiFile(File.Path))\r

                         else:\r
                             GenFdsGlobalVariable.InfLogger ("\nBuild Target \'%s\' of File %s is not in the Scope of %s specified by INF %s in FDF" %(File.Target, File.File, FfsInf.TargetOverrideList, FfsInf.InfFileName))\r
                     else:\r
                         else:\r
                             GenFdsGlobalVariable.InfLogger ("\nBuild Target \'%s\' of File %s is not in the Scope of %s specified by INF %s in FDF" %(File.Target, File.File, FfsInf.TargetOverrideList, FfsInf.InfFileName))\r
                     else:\r

diff --git a/BaseTools/Source/Python/GenPatchPcdTable/GenPatchPcdTable.py b/BaseTools/Source/Python/GenPatchPcdTable/GenPatchPcdTable.py
index ca4440f9a2ddb5bb6a761190f81d86c3f48a21ba..6deb0f8471f299c1bde63adf062ea5b7bd2c15a7 100644 (file)
--- a/BaseTools/Source/Python/GenPatchPcdTable/GenPatchPcdTable.py
+++ b/BaseTools/Source/Python/GenPatchPcdTable/GenPatchPcdTable.py
@@ -5,7 +5,7 @@
 #    PCD Name    Offset in binary
 #    ========    ================\r
 #\r
 #    PCD Name    Offset in binary
 #    ========    ================\r
 #\r

-# Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2008 - 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
 # 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


@@ -54,39 +54,54 @@ def parsePcdInfoFromMapFile(mapfilepath, efifilepath):
     
     if len(lines) == 0: return None
     if lines[0].strip().find("Archive member included because of file (symbol)") != -1:
     
     if len(lines) == 0: return None
     if lines[0].strip().find("Archive member included because of file (symbol)") != -1:

-        return _parseForGCC(lines)
+        return _parseForGCC(lines, efifilepath)

     return _parseGeneral(lines, efifilepath)
     return _parseGeneral(lines, efifilepath)

-    
-def _parseForGCC(lines):
+
+def _parseForGCC(lines, efifilepath):

     """ Parse map file generated by GCC linker """
     """ Parse map file generated by GCC linker """

-    status       = 0
-    imageBase    = -1
-    lastSectionName = None
-    pcds         = []
+    status = 0
+    imageBase = -1
+    sections = []
+    bpcds = []

     for line in lines:
         line = line.strip()
         # status machine transection
     for line in lines:
         line = line.strip()
         # status machine transection

-        if status == 0 and line == "Linker script and memory map":
+        if status == 0 and line == "Memory Configuration":

             status = 1
             continue
             status = 1
             continue

-        elif status == 1 and line == 'START GROUP':
+        elif status == 1 and line == 'Linker script and memory map':

             status = 2
             continue
             status = 2
             continue

-        
-        # status handler:
-        if status == 1:
-            m = re.match('^[\da-fA-FxhH]+ +__image_base__ += +([\da-fA-FhxH]+)', line)
-            if m != None:
-                imageBase = int(m.groups(0)[0], 16)
+        elif status ==2 and line == 'START GROUP':
+            status = 3
+            continue
+
+        # status handler\r

         if status == 2:
         if status == 2:

-            m = re.match('^([\w_\.]+) +([\da-fA-Fx]+) +([\da-fA-Fx]+)', line)
+            m = re.match('^([\w_\.]+) +([\da-fA-Fx]+) +([\da-fA-Fx]+)$', line)

             if m != None:
             if m != None:

-                lastSectionName = m.groups(0)[0]
+                sections.append(m.groups(0))

         if status == 2:
         if status == 2:

-            m = re.match("^([\da-fA-Fx]+) +[_]+gPcd_BinaryPatch_([\w_\d]+)", line)
+            m = re.match("^([\da-fA-Fx]+) +[_]+gPcd_BinaryPatch_([\w_\d]+)$", line)

             if m != None:
             if m != None:

-                assert imageBase != -1, "Fail to get Binary PCD offsest for unknown image base address"
-                pcds.append((m.groups(0)[1], int(m.groups(0)[0], 16) - imageBase, lastSectionName))
+                bpcds.append((m.groups(0)[1], int(m.groups(0)[0], 16) , int(sections[-1][1], 16), sections[-1][0]))
+                \r
+    # get section information from efi file\r
+    efisecs = PeImageClass(efifilepath).SectionHeaderList\r
+    if efisecs == None or len(efisecs) == 0:\r
+        return None\r
+    #redirection\r
+    redirection = 0\r
+    for efisec in efisecs:\r
+        for section in sections:\r
+            if section[0].strip() == efisec[0].strip() and section[0].strip() == '.text':\r
+                redirection = int(section[1], 16) - efisec[1]\r
+    pcds = []\r
+    for pcd in bpcds:\r
+        for efisec in efisecs:\r
+            if pcd[1] >= efisec[1] and pcd[1] < efisec[1]+efisec[3]:\r
+                #assert efisec[0].strip() == pcd[3].strip() and efisec[1] + redirection == pcd[2], "There are some differences between map file and efi file"\r
+                pcds.append([pcd[0], efisec[2] + pcd[1] - efisec[1] - redirection, efisec[0]])\r

     return pcds
                 
 def _parseGeneral(lines, efifilepath):
     return pcds
                 
 def _parseGeneral(lines, efifilepath):

diff --git a/BaseTools/Source/Python/PatchPcdValue/PatchPcdValue.py b/BaseTools/Source/Python/PatchPcdValue/PatchPcdValue.py
index 3f6c575128b3bee3911988fc0f8e7d51fda6a346..69c824479071eaf4a95ee5ccc6980a76209fe09d 100644 (file)
--- a/BaseTools/Source/Python/PatchPcdValue/PatchPcdValue.py
+++ b/BaseTools/Source/Python/PatchPcdValue/PatchPcdValue.py
@@ -72,7 +72,7 @@ def PatchBinaryFile(FileName, ValueOffset, TypeName, ValueString, MaxSize=0):
     elif TypeName == 'VOID*':
         if MaxSize == 0:
             return OPTION_MISSING, "PcdMaxSize is not specified for VOID* type PCD."
     elif TypeName == 'VOID*':
         if MaxSize == 0:
             return OPTION_MISSING, "PcdMaxSize is not specified for VOID* type PCD."

-        ValueLength = MaxSize
+        ValueLength = int(MaxSize)

     else:
         return PARAMETER_INVALID,  "PCD type %s is not valid." %(CommandOptions.PcdTypeName)
     #
     else:
         return PARAMETER_INVALID,  "PCD type %s is not valid." %(CommandOptions.PcdTypeName)
     #


@@ -97,6 +97,7 @@ def PatchBinaryFile(FileName, ValueOffset, TypeName, ValueString, MaxSize=0):
     #
     # Patch value into offset
     #
     #
     # Patch value into offset
     #

+    SavedStr = ValueString

     ValueString = ValueString.upper()
     ValueNumber = 0
     if TypeName == 'BOOLEAN':
     ValueString = ValueString.upper()
     ValueNumber = 0
     if TypeName == 'BOOLEAN':


@@ -109,9 +110,9 @@ def PatchBinaryFile(FileName, ValueOffset, TypeName, ValueString, MaxSize=0):
             elif ValueString == 'FALSE':
                 ValueNumber = 0
             elif ValueString.startswith('0X'):
             elif ValueString == 'FALSE':
                 ValueNumber = 0
             elif ValueString.startswith('0X'):

-                ValueNumber = int (Value, 16)
+                ValueNumber = int (ValueString, 16)

             else:
             else:

-                ValueNumber = int (Value)
+                ValueNumber = int (ValueString)

             if ValueNumber != 0:
                 ValueNumber = 1
         except:
             if ValueNumber != 0:
                 ValueNumber = 1
         except:


@@ -138,12 +139,13 @@ def PatchBinaryFile(FileName, ValueOffset, TypeName, ValueString, MaxSize=0):
             ByteList[ValueOffset + Index] = ValueNumber % 0x100
             ValueNumber = ValueNumber / 0x100
     elif TypeName == 'VOID*':
             ByteList[ValueOffset + Index] = ValueNumber % 0x100
             ValueNumber = ValueNumber / 0x100
     elif TypeName == 'VOID*':

-        if ValueString.startswith("L "):
+        ValueString = SavedStr
+        if ValueString.startswith('L"'):

             #
             # Patch Unicode String
             #
             Index = 0
             #
             # Patch Unicode String
             #
             Index = 0

-            for ByteString in ValueString[2:]:
+            for ByteString in ValueString[2:-1]:

                 #
                 # Reserve zero as unicode tail
                 #
                 #
                 # Reserve zero as unicode tail
                 #


@@ -177,7 +179,7 @@ def PatchBinaryFile(FileName, ValueOffset, TypeName, ValueString, MaxSize=0):
             # Patch ascii string 
             #
             Index = 0
             # Patch ascii string 
             #
             Index = 0

-            for ByteString in ValueString:
+            for ByteString in ValueString[1:-1]:

                 #
                 # Reserve zero as string tail
                 #
                 #
                 # Reserve zero as string tail
                 #

diff --git a/BaseTools/Source/Python/UPT/BuildVersion.py b/BaseTools/Source/Python/UPT/BuildVersion.py
index fa6c26aa76a4b12bda2556a01a70d9b4a84b1404..2858e32c0d7a9c646425a4afc227b45c9c33823f 100644 (file)
--- a/BaseTools/Source/Python/UPT/BuildVersion.py
+++ b/BaseTools/Source/Python/UPT/BuildVersion.py
@@ -17,4 +17,4 @@
 Build version information\r
 '''\r
 \r
 Build version information\r
 '''\r
 \r

-gBUILD_VERSION = "Build 2601"\r
+gBUILD_VERSION = "Build 2610"\r

diff --git a/BaseTools/Source/Python/Workspace/MetaFileCommentParser.py b/BaseTools/Source/Python/Workspace/MetaFileCommentParser.py
new file mode 100644 (file)
index 0000000..ee6f5ac
--- /dev/null
+++ b/BaseTools/Source/Python/Workspace/MetaFileCommentParser.py
@@ -0,0 +1,28 @@
+## @file\r
+# This file is used to check format of comments\r
+#\r
+# Copyright (c) 2012, 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
+# http://opensource.org/licenses/bsd-license.php\r
+#\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+\r
+from CommonDataClass.DataClass import (\r
+    MODEL_PCD_PATCHABLE_IN_MODULE,\r
+    MODEL_PCD_DYNAMIC_EX,\r
+    MODEL_PCD_DYNAMIC,\r
+    MODEL_EFI_GUID,\r
+    MODEL_EFI_PPI,\r
+    MODEL_EFI_PROTOCOL\r
+)\r
+from Common.BuildToolError import FORMAT_INVALID\r
+import Common.EdkLogger as EdkLogger\r
+\r
+UsageList = ("PRODUCES", "PRODUCED", "ALWAYS_PRODUCES", "ALWAYS_PRODUCED", "SOMETIMES_PRODUCES",\r
+             "SOMETIMES_PRODUCED", "CONSUMES", "CONSUMED", "ALWAYS_CONSUMES", "ALWAYS_CONSUMED",\r
+             "SOMETIMES_CONSUMES", "SOMETIMES_CONSUMED", "SOMETIME_CONSUMES")\r
+\r

diff --git a/BaseTools/Source/Python/Workspace/MetaFileParser.py b/BaseTools/Source/Python/Workspace/MetaFileParser.py
index 34000b5e8829d76b90e22c3ebe4c752f45a162f7..2419d270aca801c3e3a0e43926e0057e567d12a1 100644 (file)
--- a/BaseTools/Source/Python/Workspace/MetaFileParser.py
+++ b/BaseTools/Source/Python/Workspace/MetaFileParser.py
@@ -287,7 +287,7 @@ class MetaFileParser(object):
             if self._SectionName in self.DataType:
                 self._SectionType = self.DataType[self._SectionName]
                 # Check if the section name is valid
             if self._SectionName in self.DataType:
                 self._SectionType = self.DataType[self._SectionName]
                 # Check if the section name is valid

-                if self._SectionName not in SECTIONS_HAVE_ITEM_AFTER_ARCH and len(ItemList) > 2:
+                if self._SectionName not in SECTIONS_HAVE_ITEM_AFTER_ARCH and len(ItemList) > 3:

                     EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,
                                     self.MetaFile, self._LineIndex + 1, self._CurrentLine)
             elif self._Version >= 0x00010005:
                     EdkLogger.error("Parser", FORMAT_UNKNOWN_ERROR, "%s is not a valid section name" % Item,
                                     self.MetaFile, self._LineIndex + 1, self._CurrentLine)
             elif self._Version >= 0x00010005:


@@ -495,14 +495,18 @@ class InfParser(MetaFileParser):
 
         # parse the file line by line
         IsFindBlockComment = False
 
         # parse the file line by line
         IsFindBlockComment = False

+        GetHeaderComment = False
+        Comments = []

 
         for Index in range(0, len(Content)):
             # skip empty, commented, block commented lines
 
         for Index in range(0, len(Content)):
             # skip empty, commented, block commented lines

-            Line = CleanString(Content[Index], AllowCppStyleComment=True)
+            Line, Comment = CleanString2(Content[Index], AllowCppStyleComment=True)

             NextLine = ''
             if Index + 1 < len(Content):
             NextLine = ''
             if Index + 1 < len(Content):

-                NextLine = CleanString(Content[Index + 1])
+                NextLine, NextComment = CleanString2(Content[Index + 1])

             if Line == '':
             if Line == '':

+                if Comment:
+                    Comments.append((Comment, Index + 1))

                 continue
             if Line.find(DataType.TAB_COMMENT_EDK_START) > -1:
                 IsFindBlockComment = True
                 continue
             if Line.find(DataType.TAB_COMMENT_EDK_START) > -1:
                 IsFindBlockComment = True


@@ -518,6 +522,12 @@ class InfParser(MetaFileParser):
 
             # section header
             if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:
 
             # section header
             if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:

+                if not GetHeaderComment:
+                    for Cmt, LNo in Comments:
+                        self._Store(MODEL_META_DATA_HEADER_COMMENT, Cmt, '', '', 'COMMON',
+                                    'COMMON', self._Owner[-1], LNo, -1, LNo, -1, 0)
+                    GetHeaderComment = True
+                Comments = []

                 self._SectionHeaderParser()
                 # Check invalid sections
                 if self._Version < 0x00010005:
                 self._SectionHeaderParser()
                 # Check invalid sections
                 if self._Version < 0x00010005:


@@ -566,13 +576,16 @@ class InfParser(MetaFileParser):
             self._SectionParser[self._SectionType](self)
             if self._ValueList == None or self._ItemType == MODEL_META_DATA_DEFINE:
                 self._ItemType = -1
             self._SectionParser[self._SectionType](self)
             if self._ValueList == None or self._ItemType == MODEL_META_DATA_DEFINE:
                 self._ItemType = -1

+                Comments = []

                 continue
                 continue

+            if Comment:
+                Comments.append((Comment, Index + 1))

             #
             # Model, Value1, Value2, Value3, Arch, Platform, BelongsToItem=-1,
             # LineBegin=-1, ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, Enabled=-1
             #
             for Arch, Platform in self._Scope:
             #
             # Model, Value1, Value2, Value3, Arch, Platform, BelongsToItem=-1,
             # LineBegin=-1, ColumnBegin=-1, LineEnd=-1, ColumnEnd=-1, Enabled=-1
             #
             for Arch, Platform in self._Scope:

-                self._Store(self._SectionType,
+                LastItem = self._Store(self._SectionType,

                             self._ValueList[0],
                             self._ValueList[1],
                             self._ValueList[2],
                             self._ValueList[0],
                             self._ValueList[1],
                             self._ValueList[2],


@@ -585,6 +598,10 @@ class InfParser(MetaFileParser):
                             - 1,
                             0
                             )
                             - 1,
                             0
                             )

+                for Comment, LineNo in Comments:
+                    self._Store(MODEL_META_DATA_COMMENT, Comment, '', '', Arch, Platform,
+                                LastItem, LineNo, -1, LineNo, -1, 0)
+            Comments = []

         if IsFindBlockComment:
             EdkLogger.error("Parser", FORMAT_INVALID, "Open block comments (starting with /*) are expected to end with */",
                             File=self.MetaFile)
         if IsFindBlockComment:
             EdkLogger.error("Parser", FORMAT_INVALID, "Open block comments (starting with /*) are expected to end with */",
                             File=self.MetaFile)


@@ -770,6 +787,7 @@ class DscParser(MetaFileParser):
         "PLATFORM_GUID",
         "PLATFORM_VERSION",
         "SKUID_IDENTIFIER",
         "PLATFORM_GUID",
         "PLATFORM_VERSION",
         "SKUID_IDENTIFIER",

+        "PCD_INFO_GENERATION",

         "SUPPORTED_ARCHITECTURES",
         "BUILD_TARGETS",
         "OUTPUT_DIRECTORY",
         "SUPPORTED_ARCHITECTURES",
         "BUILD_TARGETS",
         "OUTPUT_DIRECTORY",

diff --git a/BaseTools/Source/Python/Workspace/MetaFileTable.py b/BaseTools/Source/Python/Workspace/MetaFileTable.py
index 088a118de1a1e609864cd9cd99669984d5ded393..607225a0ef6028059a21fada8fdf872cedff6d15 100644 (file)
--- a/BaseTools/Source/Python/Workspace/MetaFileTable.py
+++ b/BaseTools/Source/Python/Workspace/MetaFileTable.py
@@ -134,7 +134,7 @@ class ModuleTable(MetaFileTable):
     #\r
     # @retval:       A recordSet of all found records \r
     #\r
     #\r
     # @retval:       A recordSet of all found records \r
     #\r

-    def Query(self, Model, Arch=None, Platform=None):\r
+    def Query(self, Model, Arch=None, Platform=None, BelongsToItem=None):\r

         ConditionString = "Model=%s AND Enabled>=0" % Model\r
         ValueString = "Value1,Value2,Value3,Scope1,Scope2,ID,StartLine"\r
 \r
         ConditionString = "Model=%s AND Enabled>=0" % Model\r
         ValueString = "Value1,Value2,Value3,Scope1,Scope2,ID,StartLine"\r
 \r


@@ -142,6 +142,8 @@ class ModuleTable(MetaFileTable):
             ConditionString += " AND (Scope1='%s' OR Scope1='COMMON')" % Arch\r
         if Platform != None and Platform != 'COMMON':\r
             ConditionString += " AND (Scope2='%s' OR Scope2='COMMON' OR Scope2='DEFAULT')" % Platform\r
             ConditionString += " AND (Scope1='%s' OR Scope1='COMMON')" % Arch\r
         if Platform != None and Platform != 'COMMON':\r
             ConditionString += " AND (Scope2='%s' OR Scope2='COMMON' OR Scope2='DEFAULT')" % Platform\r

+        if BelongsToItem != None:\r
+            ConditionString += " AND BelongsToItem=%s" % BelongsToItem\r

 \r
         SqlCommand = "SELECT %s FROM %s WHERE %s" % (ValueString, self.Table, ConditionString)\r
         return self.Exec(SqlCommand)\r
 \r
         SqlCommand = "SELECT %s FROM %s WHERE %s" % (ValueString, self.Table, ConditionString)\r
         return self.Exec(SqlCommand)\r

diff --git a/BaseTools/Source/Python/Workspace/WorkspaceDatabase.py b/BaseTools/Source/Python/Workspace/WorkspaceDatabase.py
index 19c00ca78d83e4bc3dd2be82cfae2635c0bf65b3..04e3d14dff7c1cf3b1d494aba3c4a925b2dd7c08 100644 (file)
--- a/BaseTools/Source/Python/Workspace/WorkspaceDatabase.py
+++ b/BaseTools/Source/Python/Workspace/WorkspaceDatabase.py
@@ -70,7 +70,7 @@ class DscBuildData(PlatformBuildClassObject):
         #TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",\r
         #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",\r
         #TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",\r
         #TAB_DSC_DEFINES_OUTPUT_DIRECTORY        :   "_OutputDirectory",\r
         #TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES :   "_SupArchList",\r
         #TAB_DSC_DEFINES_BUILD_TARGETS           :   "_BuildTargets",\r

-        #TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",\r
+        TAB_DSC_DEFINES_SKUID_IDENTIFIER        :   "_SkuName",\r

         #TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",\r
         TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",\r
         TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",\r
         #TAB_DSC_DEFINES_FLASH_DEFINITION        :   "_FlashDefinition",\r
         TAB_DSC_DEFINES_BUILD_NUMBER            :   "_BuildNumber",\r
         TAB_DSC_DEFINES_MAKEFILE_NAME           :   "_MakefileName",\r


@@ -126,6 +126,8 @@ class DscBuildData(PlatformBuildClassObject):
         self._SupArchList       = None\r
         self._BuildTargets      = None\r
         self._SkuName           = None\r
         self._SupArchList       = None\r
         self._BuildTargets      = None\r
         self._SkuName           = None\r

+        self._SkuIdentifier     = None\r
+        self._PcdInfoFlag       = None\r

         self._FlashDefinition   = None\r
         self._BuildNumber       = None\r
         self._MakefileName      = None\r
         self._FlashDefinition   = None\r
         self._BuildNumber       = None\r
         self._MakefileName      = None\r


@@ -181,10 +183,9 @@ class DscBuildData(PlatformBuildClassObject):
         for Record in RecordList:\r
             Name = Record[1]\r
             # items defined _PROPERTY_ don't need additional processing\r
         for Record in RecordList:\r
             Name = Record[1]\r
             # items defined _PROPERTY_ don't need additional processing\r

-            if Name in self:\r
-                self[Name] = Record[2]\r
+            \r

             # some special items in [Defines] section need special treatment\r
             # some special items in [Defines] section need special treatment\r

-            elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r
+            if Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:\r

                 self._OutputDirectory = NormPath(Record[2], self._Macros)\r
                 if ' ' in self._OutputDirectory:\r
                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r
                 self._OutputDirectory = NormPath(Record[2], self._Macros)\r
                 if ' ' in self._OutputDirectory:\r
                     EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",\r


@@ -203,6 +204,9 @@ class DscBuildData(PlatformBuildClassObject):
             elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
                 if self._SkuName == None:\r
                     self._SkuName = Record[2]\r
             elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:\r
                 if self._SkuName == None:\r
                     self._SkuName = Record[2]\r

+                self._SkuIdentifier = Record[2]\r
+            elif Name == TAB_DSC_DEFINES_PCD_INFO_GENERATION:\r
+                self._PcdInfoFlag = Record[2]\r

             elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
                 try:\r
                     self._LoadFixAddress = int (Record[2], 0)\r
             elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:\r
                 try:\r
                     self._LoadFixAddress = int (Record[2], 0)\r


@@ -247,6 +251,8 @@ class DscBuildData(PlatformBuildClassObject):
                 except:\r
                     EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
                 self._VpdToolGuid = Record[2]                   \r
                 except:\r
                     EdkLogger.error("build", FORMAT_INVALID, "Invalid GUID format for VPD_TOOL_GUID", File=self.MetaFile)\r
                 self._VpdToolGuid = Record[2]                   \r

+            elif Name in self:\r
+                self[Name] = Record[2]                 \r

         # set _Header to non-None in order to avoid database re-querying\r
         self._Header = 'DUMMY'\r
 \r
         # set _Header to non-None in order to avoid database re-querying\r
         self._Header = 'DUMMY'\r
 \r


@@ -312,7 +318,20 @@ class DscBuildData(PlatformBuildClassObject):
             if self._BuildTargets == None:\r
                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)\r
         return self._BuildTargets\r
             if self._BuildTargets == None:\r
                 EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BUILD_TARGETS", File=self.MetaFile)\r
         return self._BuildTargets\r

-\r
+    \r
+    def _GetPcdInfoFlag(self):\r
+        if self._PcdInfoFlag == None or self._PcdInfoFlag.upper() == 'FALSE':\r
+            return False\r
+        elif self._PcdInfoFlag.upper() == 'TRUE':\r
+            return True\r
+        else:\r
+            return False\r
+            \r
+    def _GetSkuIdentifier(self):\r
+        if self._SkuIdentifier == None:\r
+            if self._Header == None:\r
+                self._GetHeaderInfo()\r
+        return self._SkuIdentifier\r

     ## Retrieve SKUID_IDENTIFIER\r
     def _GetSkuName(self):\r
         if self._SkuName == None:\r
     ## Retrieve SKUID_IDENTIFIER\r
     def _GetSkuName(self):\r
         if self._SkuName == None:\r


@@ -441,9 +460,11 @@ class DscBuildData(PlatformBuildClassObject):
                 if Record[1] in [None, '']:\r
                     EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',\r
                                     File=self.MetaFile, Line=Record[-1])\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]] = Record[0]\r
+                self._SkuIds[Record[1].upper()] = Record[0]\r

             if 'DEFAULT' not in self._SkuIds:\r
                 self._SkuIds['DEFAULT'] = '0'\r
             if 'DEFAULT' not in self._SkuIds:\r
                 self._SkuIds['DEFAULT'] = '0'\r

+            if 'COMMON' not in self._SkuIds:\r
+                self._SkuIds['COMMON'] = '0'\r

         return self._SkuIds\r
 \r
     ## Retrieve [Components] section information\r
         return self._SkuIds\r
 \r
     ## Retrieve [Components] section information\r


@@ -701,19 +722,45 @@ class DscBuildData(PlatformBuildClassObject):
         # tdict is a special dict kind of type, used for selecting correct\r
         # PCD settings for certain ARCH\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r
         # PCD settings for certain ARCH\r
         #\r

+        \r
+        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
+        \r

         PcdDict = tdict(True, 3)\r
         PcdSet = set()\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r
         PcdDict = tdict(True, 3)\r
         PcdSet = set()\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r

+        PcdValueDict = sdict()\r

         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r

-            PcdSet.add((PcdCName, TokenSpaceGuid, Dummy4))\r
-            PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting\r
-        # Remove redundant PCD candidates\r
-        for PcdCName, TokenSpaceGuid, Dummy4 in PcdSet:\r
-            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]\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
+        #handle pcd value override        \r
+        for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdSet:\r
+            Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid,SkuName]\r

             if Setting == None:\r
                 continue\r
             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
             if Setting == None:\r
                 continue\r
             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r

+            if (PcdCName, TokenSpaceGuid) in PcdValueDict:\r
+                PcdValueDict[PcdCName, TokenSpaceGuid][SkuName] = (PcdValue,DatumType,MaxDatumSize) \r
+            else:\r
+                PcdValueDict[PcdCName, TokenSpaceGuid] = {SkuName:(PcdValue,DatumType,MaxDatumSize)}       \r
+        \r
+        PcdsKeys = PcdValueDict.keys()\r
+        for PcdCName,TokenSpaceGuid in PcdsKeys:\r
+            \r
+            PcdSetting = PcdValueDict[PcdCName, TokenSpaceGuid]\r
+            PcdValue = None\r
+            DatumType = None\r
+            MaxDatumSize = None\r
+            if 'COMMON' in PcdSetting:\r
+                PcdValue,DatumType,MaxDatumSize = PcdSetting['COMMON']\r
+            if 'DEFAULT' in PcdSetting:\r
+                PcdValue,DatumType,MaxDatumSize = PcdSetting['DEFAULT']\r
+            if SkuObj.SystemSkuId in PcdSetting:\r
+                PcdValue,DatumType,MaxDatumSize = PcdSetting[SkuObj.SystemSkuId]\r
+                \r

             Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r
             Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r


@@ -735,6 +782,9 @@ class DscBuildData(PlatformBuildClassObject):
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicPcd(self, Type):\r
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicPcd(self, Type):\r

+        \r
+        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
+        \r

         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r
         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r


@@ -744,30 +794,68 @@ class DscBuildData(PlatformBuildClassObject):
         PcdList = []\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r
         PcdList = []\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r

+        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
+        \r
+        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r

         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r

-            PcdList.append((PcdCName, TokenSpaceGuid, Dummy4))\r
+            SkuName = SkuName.upper()\r
+            if SkuName not in AvailableSkuIdSet:\r
+                continue\r
+            \r
+            PcdList.append((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r

             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r
             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r

-        for PcdCName, TokenSpaceGuid, Dummy4 in PcdList:\r
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+        for PcdCName, TokenSpaceGuid, SkuName, Dummy4 in PcdList:\r
+            \r
+            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r

             if Setting == None:\r
                 continue\r
                       \r
             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
             if Setting == None:\r
                 continue\r
                       \r
             PcdValue, DatumType, MaxDatumSize = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r

+            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', '', PcdValue)\r
+            if (PcdCName,TokenSpaceGuid) in Pcds.keys(): \r
+                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
+                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
+            else:               \r
+                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+                                                    PcdCName,\r
+                                                    TokenSpaceGuid,\r
+                                                    self._PCD_TYPE_STRING_[Type],\r
+                                                    DatumType,\r
+                                                    PcdValue,\r
+                                                    '',\r
+                                                    MaxDatumSize,\r
+                                                    {SkuName : SkuInfo},\r
+                                                    False,\r
+                                                    None\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
+                valuefromDec = pcdDecObject.DefaultValue\r
+                SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '', '', '', valuefromDec)\r
+                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
+            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
+                del(pcd.SkuInfoList['COMMON'])\r
+            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                del(pcd.SkuInfoList['COMMON'])\r
+            if SkuObj.SkuUsageType == SkuObj.SINGLE:\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

-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', '', PcdValue)\r
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
-                                                PcdCName,\r
-                                                TokenSpaceGuid,\r
-                                                self._PCD_TYPE_STRING_[Type],\r
-                                                DatumType,\r
-                                                PcdValue,\r
-                                                '',\r
-                                                MaxDatumSize,\r
-                                                {self.SkuName : SkuInfo},\r
-                                                False,\r
-                                                None\r
-                                                )\r

         return Pcds\r
 \r
     ## Retrieve dynamic HII PCD settings\r
         return Pcds\r
 \r
     ## Retrieve dynamic HII PCD settings\r


@@ -777,6 +865,9 @@ class DscBuildData(PlatformBuildClassObject):
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicHiiPcd(self, Type):\r
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicHiiPcd(self, Type):\r

+        \r
+        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
+        \r

         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r
         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r


@@ -786,17 +877,28 @@ class DscBuildData(PlatformBuildClassObject):
         PcdSet = set()\r
         RecordList = self._RawData[Type, self._Arch]\r
         # Find out all possible PCD candidates for self._Arch\r
         PcdSet = set()\r
         RecordList = self._RawData[Type, self._Arch]\r
         # Find out all possible PCD candidates for self._Arch\r

+        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
+        \r
+        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r

         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r

-            PcdSet.add((PcdCName, TokenSpaceGuid, Dummy4))\r
+            SkuName = SkuName.upper()\r
+            if SkuName not in AvailableSkuIdSet:\r
+                continue\r
+            PcdSet.add((PcdCName, TokenSpaceGuid, SkuName,Dummy4))\r

             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r
             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r

-        for PcdCName, TokenSpaceGuid, Dummy4 in PcdSet:\r
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+        for PcdCName, TokenSpaceGuid,SkuName, Dummy4 in PcdSet:\r
+            \r
+            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r

             if Setting == None:\r
                 continue\r
             VariableName, VariableGuid, VariableOffset, DefaultValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
             if Setting == None:\r
                 continue\r
             VariableName, VariableGuid, VariableOffset, DefaultValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r

-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)\r
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)\r
+            if (PcdCName,TokenSpaceGuid) in Pcds.keys():  \r
+                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
+                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
+            else:\r
+                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r

                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r
                                                 self._PCD_TYPE_STRING_[Type],\r
                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r
                                                 self._PCD_TYPE_STRING_[Type],\r


@@ -804,10 +906,29 @@ class DscBuildData(PlatformBuildClassObject):
                                                 DefaultValue,\r
                                                 '',\r
                                                 '',\r
                                                 DefaultValue,\r
                                                 '',\r
                                                 '',\r

-                                                {self.SkuName : SkuInfo},\r
+                                                {SkuName : SkuInfo},\r

                                                 False,\r
                                                 None\r
                                                 )\r
                                                 False,\r
                                                 None\r
                                                 )\r

+                \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
+                valuefromDec = pcdDecObject.DefaultValue\r
+                SkuInfo = SkuInfoClass('DEFAULT', '0', SkuInfoObj.VariableName, SkuInfoObj.VariableGuid, SkuInfoObj.VariableOffset, valuefromDec)\r
+                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
+            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
+                del(pcd.SkuInfoList['COMMON'])\r
+            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                del(pcd.SkuInfoList['COMMON'])\r
+                \r
+            if SkuObj.SkuUsageType == SkuObj.SINGLE:\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

         return Pcds\r
 \r
     ## Retrieve dynamic VPD PCD settings\r
         return Pcds\r
 \r
     ## Retrieve dynamic VPD PCD settings\r


@@ -817,6 +938,9 @@ class DscBuildData(PlatformBuildClassObject):
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicVpdPcd(self, Type):\r
     #   @retval a dict object contains settings of given PCD type\r
     #\r
     def _GetDynamicVpdPcd(self, Type):\r

+        \r
+        SkuObj = SkuClass(self.SkuIdentifier,self.SkuIds)\r
+        \r

         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r
         Pcds = sdict()\r
         #\r
         # tdict is a special dict kind of type, used for selecting correct\r


@@ -826,12 +950,19 @@ class DscBuildData(PlatformBuildClassObject):
         PcdList = []\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r
         PcdList = []\r
         # Find out all possible PCD candidates for self._Arch\r
         RecordList = self._RawData[Type, self._Arch]\r

+        AvailableSkuIdSet = SkuObj.AvailableSkuIdSet.copy()\r
+        \r
+        AvailableSkuIdSet.update({'DEFAULT':0,'COMMON':0})\r

         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r
         for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:\r

-            PcdList.append((PcdCName, TokenSpaceGuid, Dummy4))\r
+            SkuName = SkuName.upper()\r
+            if SkuName not in AvailableSkuIdSet:\r
+                continue\r
+\r
+            PcdList.append((PcdCName, TokenSpaceGuid,SkuName, Dummy4))\r

             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r
             PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting\r
         # Remove redundant PCD candidates, per the ARCH and SKU\r

-        for PcdCName, TokenSpaceGuid, Dummy4 in PcdList:\r
-            Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]\r
+        for PcdCName, TokenSpaceGuid, SkuName,Dummy4 in PcdList:\r
+            Setting = PcdDict[self._Arch, SkuName, PcdCName, TokenSpaceGuid]\r

             if Setting == None:\r
                 continue\r
             #\r
             if Setting == None:\r
                 continue\r
             #\r


@@ -841,9 +972,12 @@ class DscBuildData(PlatformBuildClassObject):
             # until the DEC parser has been called.\r
             # \r
             VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r
             # until the DEC parser has been called.\r
             # \r
             VpdOffset, MaxDatumSize, InitialValue = self._ValidatePcd(PcdCName, TokenSpaceGuid, Setting, Type, Dummy4)\r

-\r
-            SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', VpdOffset, InitialValue)\r
-            Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r
+            SkuInfo = SkuInfoClass(SkuName, self.SkuIds[SkuName], '', '', '', '', VpdOffset, InitialValue)\r
+            if (PcdCName,TokenSpaceGuid) in Pcds.keys():  \r
+                pcdObject = Pcds[PcdCName,TokenSpaceGuid]\r
+                pcdObject.SkuInfoList[SkuName] = SkuInfo\r
+            else:\r
+                Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(\r

                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r
                                                 self._PCD_TYPE_STRING_[Type],\r
                                                 PcdCName,\r
                                                 TokenSpaceGuid,\r
                                                 self._PCD_TYPE_STRING_[Type],\r


@@ -851,10 +985,35 @@ class DscBuildData(PlatformBuildClassObject):
                                                 '',\r
                                                 '',\r
                                                 MaxDatumSize,\r
                                                 '',\r
                                                 '',\r
                                                 MaxDatumSize,\r

-                                                {self.SkuName : SkuInfo},\r
+                                                {SkuName : SkuInfo},\r

                                                 False,\r
                                                 None\r
                                                 )\r
                                                 False,\r
                                                 None\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
+                valuefromDec = pcdDecObject.DefaultValue\r
+                SkuInfo = SkuInfoClass('DEFAULT', '0', '', '', '','',SkuInfoObj.VpdOffset, valuefromDec)\r
+                pcd.SkuInfoList['DEFAULT'] = SkuInfo\r
+            elif 'DEFAULT' not in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                pcd.SkuInfoList['DEFAULT'] = pcd.SkuInfoList['COMMON']\r
+                del(pcd.SkuInfoList['COMMON'])\r
+            elif 'DEFAULT' in pcd.SkuInfoList.keys() and 'COMMON' in pcd.SkuInfoList.keys():\r
+                del(pcd.SkuInfoList['COMMON'])\r
+            if SkuObj.SkuUsageType == SkuObj.SINGLE:\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.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
         return Pcds\r
 \r
     ## Add external modules\r


@@ -896,6 +1055,8 @@ class DscBuildData(PlatformBuildClassObject):
     SupArchList         = property(_GetSupArch)\r
     BuildTargets        = property(_GetBuildTarget)\r
     SkuName             = property(_GetSkuName, _SetSkuName)\r
     SupArchList         = property(_GetSupArch)\r
     BuildTargets        = property(_GetBuildTarget)\r
     SkuName             = property(_GetSkuName, _SetSkuName)\r

+    SkuIdentifier       = property(_GetSkuIdentifier)\r
+    PcdInfoFlag         = property(_GetPcdInfoFlag)\r

     FlashDefinition     = property(_GetFdfFile)\r
     BuildNumber         = property(_GetBuildNumber)\r
     MakefileName        = property(_GetMakefileName)\r
     FlashDefinition     = property(_GetFdfFile)\r
     BuildNumber         = property(_GetBuildNumber)\r
     MakefileName        = property(_GetMakefileName)\r


@@ -1358,6 +1519,7 @@ class InfBuildData(ModuleBuildClassObject):
 \r
     ## Set all internal used members of InfBuildData to None\r
     def _Clear(self):\r
 \r
     ## Set all internal used members of InfBuildData to None\r
     def _Clear(self):\r

+        self._HeaderComments = None\r

         self._Header_               = None\r
         self._AutoGenVersion        = None\r
         self._BaseName              = None\r
         self._Header_               = None\r
         self._AutoGenVersion        = None\r
         self._BaseName              = None\r


@@ -1384,11 +1546,16 @@ class InfBuildData(ModuleBuildClassObject):
         self._LibraryClasses        = None\r
         self._Libraries             = None\r
         self._Protocols             = None\r
         self._LibraryClasses        = None\r
         self._Libraries             = None\r
         self._Protocols             = None\r

+        self._ProtocolComments = None\r

         self._Ppis                  = None\r
         self._Ppis                  = None\r

+        self._PpiComments = None\r

         self._Guids                 = None\r
         self._Guids                 = None\r

+        self._GuidsUsedByPcd = sdict()\r
+        self._GuidComments = None\r

         self._Includes              = None\r
         self._Packages              = None\r
         self._Pcds                  = None\r
         self._Includes              = None\r
         self._Packages              = None\r
         self._Pcds                  = None\r

+        self._PcdComments = None\r

         self._BuildOptions          = None\r
         self._Depex                 = None\r
         self._DepexExpression       = None\r
         self._BuildOptions          = None\r
         self._Depex                 = None\r
         self._DepexExpression       = None\r


@@ -1438,6 +1605,13 @@ class InfBuildData(ModuleBuildClassObject):
             return\r
         self._Platform = Value\r
         self._Clear()\r
             return\r
         self._Platform = Value\r
         self._Clear()\r

+    def _GetHeaderComments(self):\r
+        if not self._HeaderComments:\r
+            self._HeaderComments = []\r
+            RecordList = self._RawData[MODEL_META_DATA_HEADER_COMMENT]\r
+            for Record in RecordList:\r
+                self._HeaderComments.append(Record[0])\r
+        return self._HeaderComments\r

 \r
     ## Retrieve all information in [Defines] section\r
     #\r
 \r
     ## Retrieve all information in [Defines] section\r
     #\r


@@ -1873,10 +2047,14 @@ class InfBuildData(ModuleBuildClassObject):
                     self._Libraries.append(LibraryName)\r
         return self._Libraries\r
 \r
                     self._Libraries.append(LibraryName)\r
         return self._Libraries\r
 \r

+    def _GetProtocolComments(self):\r
+        self._GetProtocols()\r
+        return self._ProtocolComments\r

     ## Retrieve protocols consumed/produced by this module\r
     def _GetProtocols(self):\r
         if self._Protocols == None:\r
             self._Protocols = sdict()\r
     ## Retrieve protocols consumed/produced by this module\r
     def _GetProtocols(self):\r
         if self._Protocols == None:\r
             self._Protocols = sdict()\r

+            self._ProtocolComments = sdict()\r

             RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r
             RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r


@@ -1887,12 +2065,21 @@ class InfBuildData(ModuleBuildClassObject):
                                     "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Protocols[CName] = Value\r
                                     "Value of Protocol [%s] is not found under [Protocols] section in" % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Protocols[CName] = Value\r

+                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
+                Comments = []\r
+                for CmtRec in CommentRecords:\r
+                    Comments.append(CmtRec[0])\r
+                self._ProtocolComments[CName] = Comments\r

         return self._Protocols\r
 \r
         return self._Protocols\r
 \r

+    def _GetPpiComments(self):\r
+        self._GetPpis()\r
+        return self._PpiComments\r

     ## Retrieve PPIs consumed/produced by this module\r
     def _GetPpis(self):\r
         if self._Ppis == None:\r
             self._Ppis = sdict()\r
     ## Retrieve PPIs consumed/produced by this module\r
     def _GetPpis(self):\r
         if self._Ppis == None:\r
             self._Ppis = sdict()\r

+            self._PpiComments = sdict()\r

             RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r
             RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r


@@ -1903,12 +2090,21 @@ class InfBuildData(ModuleBuildClassObject):
                                     "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Ppis[CName] = Value\r
                                     "Value of PPI [%s] is not found under [Ppis] section in " % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Ppis[CName] = Value\r

+                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
+                Comments = []\r
+                for CmtRec in CommentRecords:\r
+                    Comments.append(CmtRec[0])\r
+                self._PpiComments[CName] = Comments\r

         return self._Ppis\r
 \r
         return self._Ppis\r
 \r

+    def _GetGuidComments(self):\r
+        self._GetGuids()\r
+        return self._GuidComments\r

     ## Retrieve GUIDs consumed/produced by this module\r
     def _GetGuids(self):\r
         if self._Guids == None:\r
             self._Guids = sdict()\r
     ## Retrieve GUIDs consumed/produced by this module\r
     def _GetGuids(self):\r
         if self._Guids == None:\r
             self._Guids = sdict()\r

+            self._GuidComments = sdict()\r

             RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r
             RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]\r
             for Record in RecordList:\r
                 CName = Record[0]\r


@@ -1919,6 +2115,11 @@ class InfBuildData(ModuleBuildClassObject):
                                     "Value of Guid [%s] is not found under [Guids] section in" % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Guids[CName] = Value\r
                                     "Value of Guid [%s] is not found under [Guids] section in" % CName,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])\r
                 self._Guids[CName] = Value\r

+                CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]]\r
+                Comments = []\r
+                for CmtRec in CommentRecords:\r
+                    Comments.append(CmtRec[0])\r
+                self._GuidComments[CName] = Comments\r

         return self._Guids\r
 \r
     ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r
         return self._Guids\r
 \r
     ## Retrieve include paths necessary for this module (for Edk.x style of modules)\r


@@ -1986,10 +2187,15 @@ class InfBuildData(ModuleBuildClassObject):
                 self._Packages.append(Package)\r
         return self._Packages\r
 \r
                 self._Packages.append(Package)\r
         return self._Packages\r
 \r

+    ## Retrieve PCD comments\r
+    def _GetPcdComments(self):\r
+        self._GetPcds()\r
+        return self._PcdComments\r

     ## Retrieve PCDs used in this module\r
     def _GetPcds(self):\r
         if self._Pcds == None:\r
             self._Pcds = sdict()\r
     ## Retrieve PCDs used in this module\r
     def _GetPcds(self):\r
         if self._Pcds == None:\r
             self._Pcds = sdict()\r

+            self._PcdComments = sdict()\r

             self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
             self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
             self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r
             self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))\r
             self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))\r
             self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))\r


@@ -2087,13 +2293,15 @@ class InfBuildData(ModuleBuildClassObject):
                 self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r
         return self._DepexExpression\r
 \r
                 self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]\r
         return self._DepexExpression\r
 \r

+    def GetGuidsUsedByPcd(self):\r
+        return self._GuidsUsedByPcd\r

     ## Retrieve PCD for given type\r
     def _GetPcd(self, Type):\r
         Pcds = sdict()\r
         PcdDict = tdict(True, 4)\r
         PcdList = []\r
         RecordList = self._RawData[Type, self._Arch, self._Platform]\r
     ## Retrieve PCD for given type\r
     def _GetPcd(self, Type):\r
         Pcds = sdict()\r
         PcdDict = tdict(True, 4)\r
         PcdList = []\r
         RecordList = self._RawData[Type, self._Arch, self._Platform]\r

-        for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Dummy1, LineNo in RecordList:\r
+        for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList:\r

             PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
             PcdList.append((PcdCName, TokenSpaceGuid))\r
             # get the guid value\r
             PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)\r
             PcdList.append((PcdCName, TokenSpaceGuid))\r
             # get the guid value\r


@@ -2105,6 +2313,12 @@ class InfBuildData(ModuleBuildClassObject):
                                     "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r
                 self.Guids[TokenSpaceGuid] = Value\r
                                     "Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,\r
                                     ExtraData=PackageList, File=self.MetaFile, Line=LineNo)\r
                 self.Guids[TokenSpaceGuid] = Value\r

+                self._GuidsUsedByPcd[TokenSpaceGuid] = Value\r
+            CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id]\r
+            Comments = []\r
+            for CmtRec in CommentRecords:\r
+                Comments.append(CmtRec[0])\r
+            self._PcdComments[TokenSpaceGuid, PcdCName] = Comments\r

 \r
         # resolve PCD type, value, datum info, etc. by getting its definition from package\r
         for PcdCName, TokenSpaceGuid in PcdList:\r
 \r
         # resolve PCD type, value, datum info, etc. by getting its definition from package\r
         for PcdCName, TokenSpaceGuid in PcdList:\r


@@ -2125,6 +2339,9 @@ class InfBuildData(ModuleBuildClassObject):
                     False,\r
                     self.Guids[TokenSpaceGuid]\r
                     )\r
                     False,\r
                     self.Guids[TokenSpaceGuid]\r
                     )\r

+            if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]:\r
+                # Patch PCD: TokenSpace.PcdCName|Value|Offset\r
+                Pcd.Offset = ValueList[1]\r

 \r
             # get necessary info from package declaring this PCD\r
             for Package in self.Packages:\r
 \r
             # get necessary info from package declaring this PCD\r
             for Package in self.Packages:\r


@@ -2216,10 +2433,20 @@ class InfBuildData(ModuleBuildClassObject):
 \r
         return Pcds\r
 \r
 \r
         return Pcds\r
 \r

-    _Macros                 = property(_GetMacros)\r
-    Arch                    = property(_GetArch, _SetArch)\r
-    Platform                = property(_GetPlatform, _SetPlatform)\r
+    ## check whether current module is binary module\r
+    def _IsBinaryModule(self):\r
+        if self.Binaries and not self.Sources:\r
+            return True\r
+        elif GlobalData.gIgnoreSource:\r
+            return True\r
+        else:\r
+            return False\r
+\r
+    _Macros = property(_GetMacros)\r
+    Arch = property(_GetArch, _SetArch)\r
+    Platform = property(_GetPlatform, _SetPlatform)\r

 \r
 \r

+    HeaderComments = property(_GetHeaderComments)\r

     AutoGenVersion          = property(_GetInfVersion)\r
     BaseName                = property(_GetBaseName)\r
     ModuleType              = property(_GetModuleType)\r
     AutoGenVersion          = property(_GetInfVersion)\r
     BaseName                = property(_GetBaseName)\r
     ModuleType              = property(_GetModuleType)\r


@@ -2244,14 +2471,19 @@ class InfBuildData(ModuleBuildClassObject):
     LibraryClasses          = property(_GetLibraryClassUses)\r
     Libraries               = property(_GetLibraryNames)\r
     Protocols               = property(_GetProtocols)\r
     LibraryClasses          = property(_GetLibraryClassUses)\r
     Libraries               = property(_GetLibraryNames)\r
     Protocols               = property(_GetProtocols)\r

+    ProtocolComments = property(_GetProtocolComments)\r

     Ppis                    = property(_GetPpis)\r
     Ppis                    = property(_GetPpis)\r

+    PpiComments = property(_GetPpiComments)\r

     Guids                   = property(_GetGuids)\r
     Guids                   = property(_GetGuids)\r

+    GuidComments = property(_GetGuidComments)\r

     Includes                = property(_GetIncludes)\r
     Packages                = property(_GetPackages)\r
     Pcds                    = property(_GetPcds)\r
     Includes                = property(_GetIncludes)\r
     Packages                = property(_GetPackages)\r
     Pcds                    = property(_GetPcds)\r

+    PcdComments = property(_GetPcdComments)\r

     BuildOptions            = property(_GetBuildOptions)\r
     Depex                   = property(_GetDepex)\r
     DepexExpression         = property(_GetDepexExpression)\r
     BuildOptions            = property(_GetBuildOptions)\r
     Depex                   = property(_GetDepex)\r
     DepexExpression         = property(_GetDepexExpression)\r

+    IsBinaryModule = property(_IsBinaryModule)\r

 \r
 ## Database\r
 #\r
 \r
 ## Database\r
 #\r

diff --git a/BaseTools/Source/Python/build/build.py b/BaseTools/Source/Python/build/build.py
index 24a6ed8168ba91df9b15449ef101cbf4e17cf644..fca36d18076e0b6db4bf8a382e543c13c54c45e3 100644 (file)
--- a/BaseTools/Source/Python/build/build.py
+++ b/BaseTools/Source/Python/build/build.py
@@ -1433,8 +1433,8 @@ class Build():
                                 Ma.CreateAsBuiltInf()\r
                             if self.Target == "genmake":\r
                                 continue\r
                                 Ma.CreateAsBuiltInf()\r
                             if self.Target == "genmake":\r
                                 continue\r

-                        self.Progress.Stop("done!")\r

                         pModules.append(Ma)\r
                         pModules.append(Ma)\r

+                    self.Progress.Stop("done!")\r

 \r
                     for Ma in pModules:\r
                         # Generate build task for the module\r
 \r
                     for Ma in pModules:\r
                         # Generate build task for the module\r

diff --git a/BaseTools/UserManuals/VfrCompiler_Utility_Man_Page.rtf b/BaseTools/UserManuals/VfrCompiler_Utility_Man_Page.rtf
index 81980fc1932c5c2f8659868c3f5c034ad2f8d34c..e37d7187aa866af872cea89a1d676a44d2a26d2a 100644 (file)
--- a/BaseTools/UserManuals/VfrCompiler_Utility_Man_Page.rtf
+++ b/BaseTools/UserManuals/VfrCompiler_Utility_Man_Page.rtf
@@ -1,27 +1,26 @@
-{\rtf1\adeflang1025\ansi\ansicpg1252\uc2\adeff0\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi0\deflang1033\deflangfe2052\themelang1033\themelangfe2052\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}\r
-{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}{\f13\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}\'cb\'ce\'cc\'e5{\*\falt SimSun};}\r
-{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\f38\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Tahoma;}\r
-{\f39\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Verdana{\*\falt Verdana};}{\f40\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}@\'cb\'ce\'cc\'e5;}\r
-{\f41\fbidi \fmodern\fcharset0\fprq1{\*\panose 020b0609020204030204}Consolas;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}\r
-{\fdbmajor\f31501\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}\'cb\'ce\'cc\'e5{\*\falt SimSun};}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}\r
+{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff0\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi0\deflang1033\deflangfe2052\themelang1033\themelangfe2052\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}\r
+{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}{\f13\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}SimSun{\*\falt SimSun};}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;}\r
+{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\f38\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604030504040204}Tahoma;}{\f39\fbidi \fswiss\fcharset0\fprq2{\*\panose 00000000000000000000}Verdana{\*\falt Verdana};}\r
+{\f40\fbidi \fnil\fcharset134\fprq2{\*\panose 00000000000000000000}@SimSun;}{\f41\fbidi \fmodern\fcharset0\fprq1{\*\panose 00000000000000000000}Consolas;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}\r
+{\fdbmajor\f31501\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}SimSun{\*\falt SimSun};}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}\r

 {\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}\r
 {\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}\r

-{\fdbminor\f31505\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}\'cb\'ce\'cc\'e5{\*\falt SimSun};}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}\r
-{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f43\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f44\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}\r
-{\f46\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f47\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f48\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f49\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}\r
-{\f50\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f51\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f53\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\f54\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;}\r
-{\f56\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\f57\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\f58\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);}{\f59\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);}\r
-{\f60\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\f61\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}{\f63\fbidi \fmodern\fcharset238\fprq1 Courier New CE;}{\f64\fbidi \fmodern\fcharset204\fprq1 Courier New Cyr;}\r
-{\f66\fbidi \fmodern\fcharset161\fprq1 Courier New Greek;}{\f67\fbidi \fmodern\fcharset162\fprq1 Courier New Tur;}{\f68\fbidi \fmodern\fcharset177\fprq1 Courier New (Hebrew);}{\f69\fbidi \fmodern\fcharset178\fprq1 Courier New (Arabic);}\r
-{\f70\fbidi \fmodern\fcharset186\fprq1 Courier New Baltic;}{\f71\fbidi \fmodern\fcharset163\fprq1 Courier New (Vietnamese);}{\f175\fbidi \fnil\fcharset0\fprq2 SimSun Western{\*\falt SimSun};}{\f383\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}\r
-{\f384\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}{\f386\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f387\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f390\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}\r
-{\f391\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}{\f413\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f414\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f416\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}\r
-{\f417\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\f420\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f421\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\f423\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}\r
-{\f424\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;}{\f426\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f427\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;}{\f428\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}\r
-{\f429\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);}{\f430\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f431\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f432\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}\r
-{\f433\fbidi \fswiss\fcharset238\fprq2 Verdana CE{\*\falt Verdana};}{\f434\fbidi \fswiss\fcharset204\fprq2 Verdana Cyr{\*\falt Verdana};}{\f436\fbidi \fswiss\fcharset161\fprq2 Verdana Greek{\*\falt Verdana};}\r
-{\f437\fbidi \fswiss\fcharset162\fprq2 Verdana Tur{\*\falt Verdana};}{\f440\fbidi \fswiss\fcharset186\fprq2 Verdana Baltic{\*\falt Verdana};}{\f441\fbidi \fswiss\fcharset163\fprq2 Verdana (Vietnamese){\*\falt Verdana};}\r
-{\f445\fbidi \fnil\fcharset0\fprq2 @\'cb\'ce\'cc\'e5 Western;}{\f453\fbidi \fmodern\fcharset238\fprq1 Consolas CE;}{\f454\fbidi \fmodern\fcharset204\fprq1 Consolas Cyr;}{\f456\fbidi \fmodern\fcharset161\fprq1 Consolas Greek;}\r
-{\f457\fbidi \fmodern\fcharset162\fprq1 Consolas Tur;}{\f460\fbidi \fmodern\fcharset186\fprq1 Consolas Baltic;}{\f461\fbidi \fmodern\fcharset163\fprq1 Consolas (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}\r
+{\fdbminor\f31505\fbidi \fnil\fcharset134\fprq2{\*\panose 02010600030101010101}SimSun{\*\falt SimSun};}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}\r
+{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f42\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f43\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}\r
+{\f45\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f46\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f47\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f48\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}\r
+{\f49\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f50\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f52\fbidi \fswiss\fcharset238\fprq2 Arial CE;}{\f53\fbidi \fswiss\fcharset204\fprq2 Arial Cyr;}\r
+{\f55\fbidi \fswiss\fcharset161\fprq2 Arial Greek;}{\f56\fbidi \fswiss\fcharset162\fprq2 Arial Tur;}{\f57\fbidi \fswiss\fcharset177\fprq2 Arial (Hebrew);}{\f58\fbidi \fswiss\fcharset178\fprq2 Arial (Arabic);}\r
+{\f59\fbidi \fswiss\fcharset186\fprq2 Arial Baltic;}{\f60\fbidi \fswiss\fcharset163\fprq2 Arial (Vietnamese);}{\f62\fbidi \fmodern\fcharset238\fprq1 Courier New CE;}{\f63\fbidi \fmodern\fcharset204\fprq1 Courier New Cyr;}\r
+{\f65\fbidi \fmodern\fcharset161\fprq1 Courier New Greek;}{\f66\fbidi \fmodern\fcharset162\fprq1 Courier New Tur;}{\f67\fbidi \fmodern\fcharset177\fprq1 Courier New (Hebrew);}{\f68\fbidi \fmodern\fcharset178\fprq1 Courier New (Arabic);}\r
+{\f69\fbidi \fmodern\fcharset186\fprq1 Courier New Baltic;}{\f70\fbidi \fmodern\fcharset163\fprq1 Courier New (Vietnamese);}{\f174\fbidi \fnil\fcharset0\fprq2 SimSun Western{\*\falt SimSun};}{\f382\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}\r
+{\f383\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;}{\f385\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f386\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f389\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}\r
+{\f390\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);}{\f412\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f413\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f415\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}\r
+{\f416\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;}{\f419\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f420\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\f422\fbidi \fswiss\fcharset238\fprq2 Tahoma CE;}\r
+{\f423\fbidi \fswiss\fcharset204\fprq2 Tahoma Cyr;}{\f425\fbidi \fswiss\fcharset161\fprq2 Tahoma Greek;}{\f426\fbidi \fswiss\fcharset162\fprq2 Tahoma Tur;}{\f427\fbidi \fswiss\fcharset177\fprq2 Tahoma (Hebrew);}\r
+{\f428\fbidi \fswiss\fcharset178\fprq2 Tahoma (Arabic);}{\f429\fbidi \fswiss\fcharset186\fprq2 Tahoma Baltic;}{\f430\fbidi \fswiss\fcharset163\fprq2 Tahoma (Vietnamese);}{\f431\fbidi \fswiss\fcharset222\fprq2 Tahoma (Thai);}\r
+{\f432\fbidi \fswiss\fcharset238\fprq2 Verdana CE{\*\falt Verdana};}{\f433\fbidi \fswiss\fcharset204\fprq2 Verdana Cyr{\*\falt Verdana};}{\f435\fbidi \fswiss\fcharset161\fprq2 Verdana Greek{\*\falt Verdana};}\r
+{\f436\fbidi \fswiss\fcharset162\fprq2 Verdana Tur{\*\falt Verdana};}{\f439\fbidi \fswiss\fcharset186\fprq2 Verdana Baltic{\*\falt Verdana};}{\f440\fbidi \fswiss\fcharset163\fprq2 Verdana (Vietnamese){\*\falt Verdana};}\r
+{\f444\fbidi \fnil\fcharset0\fprq2 @SimSun Western;}{\f452\fbidi \fmodern\fcharset238\fprq1 Consolas CE;}{\f453\fbidi \fmodern\fcharset204\fprq1 Consolas Cyr;}{\f455\fbidi \fmodern\fcharset161\fprq1 Consolas Greek;}\r
+{\f456\fbidi \fmodern\fcharset162\fprq1 Consolas Tur;}{\f459\fbidi \fmodern\fcharset186\fprq1 Consolas Baltic;}{\f460\fbidi \fmodern\fcharset163\fprq1 Consolas (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}\r

 {\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}\r
 {\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}\r
 {\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31520\fbidi \fnil\fcharset0\fprq2 SimSun Western{\*\falt SimSun};}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}\r
 {\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}\r
 {\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}\r
 {\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31520\fbidi \fnil\fcharset0\fprq2 SimSun Western{\*\falt SimSun};}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}\r


@@ -58,17 +57,16 @@ Normal Table;}{\*\cs15 \additive \rtlch\fcs1 \ab\af0\afs32 \ltrch\fcs0 \b\fs32\k
 \brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \r
 \trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \r
 \ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe2052\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp2052 \r
 \brdrs\brdrw10 \trbrdrl\brdrs\brdrw10 \trbrdrb\brdrs\brdrw10 \trbrdrr\brdrs\brdrw10 \trbrdrh\brdrs\brdrw10 \trbrdrv\brdrs\brdrw10 \r
 \trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\tblind0\tblindtype3\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \r
 \ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe2052\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp2052 \r

-\sbasedon11 \snext27 \spriority59 \styrsid4289583 Table Grid;}}{\*\rsidtbl \rsid83254\rsid1204842\rsid2570438\rsid3956845\rsid4289583\rsid4999604\rsid5715948\rsid5911148\rsid6448922\rsid6635418\rsid7634258\rsid8089322\rsid8600807\rsid9190531\rsid9200893\r
-\rsid10094212\rsid11500129\rsid11950970\rsid12476259\rsid12931970\rsid14109446\rsid14166490}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\operator Dong, Yong}\r
-{\creatim\yr2010\mo10\dy6\hr16\min18}{\revtim\yr2011\mo9\dy7\hr10\min32}{\version13}{\edmins49}{\nofpages3}{\nofwords681}{\nofchars3883}{\nofcharsws4555}{\vern49255}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}}\r
-\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect \r
+\sbasedon11 \snext27 \spriority59 \styrsid4289583 Table Grid;}}{\*\revtbl {Unknown;}{ydong10;}}{\*\rsidtbl \rsid83254\rsid1204842\rsid2570438\rsid3809922\rsid3956845\rsid4289583\rsid4999604\rsid5008786\rsid5715948\rsid5911148\rsid6448922\rsid6635418\rsid7634258\rsid8089322\r
+\rsid8600807\rsid9190531\rsid9200893\rsid10094212\rsid11500129\rsid11950970\rsid12476259\rsid12931970\rsid14109446\rsid14166490}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1\r
+}{\info{\operator ydong10}{\creatim\yr2010\mo10\dy6\hr16\min18}{\revtim\yr2013\mo10\dy21\hr13\min47}{\version15}{\edmins108}{\nofpages3}{\nofwords696}{\nofchars3968}{\nofcharsws4655}{\vern49167}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/wo\r
+rd/2003/wordml}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect \r

 \deftab360\widowctrl\ftnbj\aenddoc\revisions\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\r
 \deftab360\widowctrl\ftnbj\aenddoc\revisions\trackmoves0\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\r

-\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale135\rsidroot14166490 \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang \r
-{\pntxta \hich .}}{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta \hich .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta \hich .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta \hich )}}{\*\pnseclvl5\r
-\pndec\pnstart1\pnindent720\pnhang {\pntxtb \hich (}{\pntxta \hich )}}{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb \hich (}{\pntxta \hich )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb \hich (}{\pntxta \hich )}}{\*\pnseclvl8\r
-\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb \hich (}{\pntxta \hich )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb \hich (}{\pntxta \hich )}}\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\r
-\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \r
-\b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Name\r
+\dghorigin1701\dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale135\rsidroot14166490 \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}\r
+{\*\pnseclvl2\pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\r
+{\*\pnseclvl6\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\r
+\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
+\fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Name\r

 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r
 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile.exe \hich\f39 \endash \loch\f39  Compile the framework VFR and UEFI VFR file to UEFI IFR opcode table and binary.\r
 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\tx1440\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r
 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile.exe \hich\f39 \endash \loch\f39  Compile the framework VFR and UEFI VFR file to UEFI IFR opcode table and binary.\r
 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\tx1440\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r


@@ -104,8 +102,15 @@ The generated file will be placed into the output directory sp\hich\af39\dbch\af
 \par \hich\af39\dbch\af31505\loch\f39 This }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \hich\af39\dbch\af31505\loch\f39 is not a }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid6635418 \hich\af39\dbch\af31505\loch\f39 standalone. }{\r
 \rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 It is used together with the comp\hich\af39\dbch\af31505\loch\f39 iler preprocessor, }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \r
 \hich\af39\dbch\af31505\loch\f39 and }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 EDKII trim too}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \hich\af39\dbch\af31505\loch\f39 \r
 \par \hich\af39\dbch\af31505\loch\f39 This }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \hich\af39\dbch\af31505\loch\f39 is not a }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid6635418 \hich\af39\dbch\af31505\loch\f39 standalone. }{\r
 \rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 It is used together with the comp\hich\af39\dbch\af31505\loch\f39 iler preprocessor, }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \r
 \hich\af39\dbch\af31505\loch\f39 and }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 EDKII trim too}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \hich\af39\dbch\af31505\loch\f39 \r

-. The VFR file is first preprocessed by the cCompiler and the output file is then trimmed to remove the unused definitions}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 \r
- before being compiled by the VfrCompile tool to generated the UEFI IFR opcode. }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \r
+. The VFR file is first preprocessed by the c}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\revised\revauth1\revdttm656059242\insrsid3809922 \hich\af39\dbch\af31505\loch\f39  }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \r
+\hich\af39\dbch\af31505\loch\f39 Compiler and the output file is then trimmed to remove the unused definitions}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39  before being compiled by the VfrCompile tool to \r
+}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \deleted\fs18\cf1\revauthdel1\revdttmdel656059243\insrsid1204842\delrsid3809922 \hich\af39\dbch\af31505\loch\f39 generated}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
+\fs18\cf1\revised\revauth1\revdttm656059243\insrsid3809922 \hich\af39\dbch\af31505\loch\f39 generate}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39  the UEFI IFR opcode.}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
+\fs18\cf1\revised\revauth1\revdttm656059242\insrsid3809922 \hich\af39\dbch\af31505\loch\f39  So the C\hich\af39\dbch\af31505\loch\f39  style}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\revised\revauth1\revdttm656059243\insrsid3809922 \r
+\hich\af39\dbch\af31505\loch\f39  }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\revised\revauth1\revdttm656059246\insrsid5008786\charrsid5008786 \hich\af39\dbch\af31505\loch\f39 preprocessor directives }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
+\fs18\cf1\revised\revauth1\revdttm656059247\insrsid5008786 \hich\af39\dbch\af31505\loch\f39 are}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\revised\revauth1\revdttm656059243\insrsid3809922 \hich\af39\dbch\af31505\loch\f39 \r
+ supported in VFR file, such as #define, #ifdef}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\revised\revauth1\revdttm656059247\insrsid5008786 .}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
+\deleted\fs18\cf1\revauthdel1\revdttmdel656059243\insrsid1204842\delrsid3809922 \hich\af39\dbch\af31505\loch\f39  }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid9200893 \r

 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Options\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs18 \r
 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Options\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs18 \r


@@ -116,25 +121,24 @@ The generated file will be placed into the output directory sp\hich\af39\dbch\af
 \hich\af39\dbch\af31505\loch\f39  the}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  Trim tool. The generated output file is VfrFileName.c.\r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -o DIR, --output-directory DIR\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 All generated files }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
 \hich\af39\dbch\af31505\loch\f39  the}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  Trim tool. The generated output file is VfrFileName.c.\r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -o DIR, --output-directory DIR\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 All generated files }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r

-\fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 are}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  placed into output directory. If this option is \hich\af39\dbch\af31505\loch\f39 \r
-not specified, the default output directory is current directory.\r
+\fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 are}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 \r
+ placed into output directory. If this option is not specified, the default output directory is current directory.\r

 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -b, --create-ifr-package\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Create}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -b, --create-ifr-package\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Create}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \r

-\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  an UEFI IFR Binary HII pack file. The generated file name is VfrFileName.hpk.\r
+\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  an UEFI IFR Binary HII pack file. The generated file n\hich\af39\dbch\af31505\loch\f39 ame is VfrFileName.hpk.\r

 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -l  create an output IFR listing file\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Create}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -l  create an output IFR listing file\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Create}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \r

-\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  an output IFR listing file (VfrFi\hich\af39\dbch\af31505\loch\f39 leName.lst) to list each IFR opcode for each VFR}{\r
-\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39  }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 statement.}{\rtlch\fcs1 \ab\af0\afs18 \ltrch\fcs0 \r
-\b\f0\fs18\cf1\insrsid14166490 \r
+\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  an output IFR listing file (VfrFileName.lst) to list each IFR opcode for each VFR}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
+\fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39  }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 statement.}{\rtlch\fcs1 \ab\af0\afs18 \ltrch\fcs0 \b\f0\fs18\cf1\insrsid14166490 \r

 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -n, --no-pre-processing\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Do not preprocess}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
 \fs18\cf1\insrsid2570438 \hich\af39\dbch\af31505\loch\f39  t}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 he}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -n, --no-pre-processing\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Do not preprocess}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \r
 \fs18\cf1\insrsid2570438 \hich\af39\dbch\af31505\loch\f39  t}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 he}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 \r

- input vfr file. The input VFR file has been processed. If this option is not specified, the default behavior is same to set this option. \r
+ input vfr file. The input VFR file has been pro\hich\af39\dbch\af31505\loch\f39 cessed. If this option is not specified, the default behavior is same to set this option. \r

 \par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \hich\af39\dbch\af31505\loch\f39 Selecting this option disables preprocessing of VFR files. }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid2570438 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -c, --compatible-framework\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Recognize}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \r
 \par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \hich\af39\dbch\af31505\loch\f39 Selecting this option disables preprocessing of VFR files. }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid2570438 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -c, --compatible-framework\r
 \par }\pard \ltrpar\ql \li360\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin360\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Recognize}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \r

-\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  the input VFR file is the framework VFR syntax. If this option is not specified, the UEFI syntax is default }{\rtlch\fcs1 \r
-\af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \hich\af39\dbch\af31505\loch\f39 the VFR }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 syntax.\r
+\hich\af39\dbch\af31505\loch\f39 s}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39  the input VFR file is the framework VFR syntax. If this option is n\hich\af39\dbch\af31505\loch\f39 \r
+ot specified, the UEFI syntax is default }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid83254 \hich\af39\dbch\af31505\loch\f39 the VFR }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 syntax.\r

 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -h, --help\r
 \par }\pard \ltrpar\ql \fi360\li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Print version and usage of this program and exit.\r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid12931970 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid12931970\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 -s, --string-db\r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 -h, --help\r
 \par }\pard \ltrpar\ql \fi360\li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Print version and usage of this program and exit.\r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid12931970 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid12931970\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 -s, --string-db\r


@@ -180,18 +184,18 @@ n C file (Vfr_Uefi.c) and UEFI IFR Binary File (Vfr_Uefi.hpk)
 \par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n -b -l Vfr_Uefi.iii\r
 \par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 4. Parse the preprocessed Framework VFR file (Vfr_Framework.iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Framework.c).  \r
 \par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n -c Vfr_Framework.iii\r
 \par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n -b -l Vfr_Uefi.iii\r
 \par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 4. Parse the preprocessed Framework VFR file (Vfr_Framework.iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Framework.c).  \r
 \par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n -c Vfr_Framework.iii\r

-\par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14109446 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 5. Parse the preprocessed UEFI VFR file (Vfr_Uefi\r
-\hich\af39\dbch\af31505\loch\f39 .iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Uefi.c), also base on the string token number to get efi varstore name from the string binary file (Vfr_Uefi.hpk).\r
-\par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n \hich\f39 \endash \loch\f39 s Vfr_Uefi.hpk Vfr_Uefi.iii\r
-\par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 6. Parse the preprocessed UEFI \hich\af39\dbch\af31505\loch\f39 \r
-VFR file (Vfr_Uefi.iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Uefi.c), also override class guid with the input one.   \r
+\par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0\pararsid14109446 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 \r
+5. Parse the preprocessed UEFI VFR file (Vfr_Uefi.iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Uefi.c), also base on the string token number to get efi varstore name from the string binary file (Vfr_Uefi.hpk).\r
+\par }{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n \hich\f39 \endash \loch\f39 s Vfr_Uefi\hich\af39\dbch\af31505\loch\f39 .hpk Vfr_Uefi.iii\r
+\par }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 \r
+6. Parse the preprocessed UEFI VFR file (Vfr_Uefi.iii) to generate the UEFI IFR opcode table in autogen C file (Vfr_Uefi.c), also override class guid with the input one.   \r

 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n \hich\f39 \endash \loch\f39 \r
 \par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid6448922 \hich\af39\dbch\af31505\loch\f39 VfrCompile -n \hich\f39 \endash \loch\f39 \r

-g C153B68D-EBFC-488E-B110-662867745B87 Vfr_Uefi.iii}{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid7634258 \r
+g C153B68D-EBFC-488E-B110-662867745B87 Vfr_Uefi.ii\hich\af39\dbch\af31505\loch\f39 i}{\rtlch\fcs1 \ab\af39\afs18 \ltrch\fcs0 \b\fs18\insrsid14109446\charrsid7634258 \r

 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Bugs\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r
 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 No known }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 issues}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 .\r
 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Bugs\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r
 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 No known }{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid1204842 \hich\af39\dbch\af31505\loch\f39 issues}{\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 .\r

-\par \hich\af39\dbch\af31505\loch\f39 Report bugs to edk2-build\hich\af39\dbch\af31505\loch\f39 tools-devel@lists.sourceforge.net}{\rtlch\fcs1 \af0\afs18 \ltrch\fcs0 \f0\fs18\cf1\insrsid14166490 \r
+\par \hich\af39\dbch\af31505\loch\f39 Report bugs to edk2-buildtools-devel@lists.sourceforge.net}{\rtlch\fcs1 \af0\afs18 \ltrch\fcs0 \f0\fs18\cf1\insrsid14166490 \r

 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Files\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r
 \par }\pard\plain \ltrpar\s2\ql \li-1440\ri0\sb400\sa60\sl-340\slmult0\keep\keepn\nowidctlpar\wrapdefault\faauto\outlinelevel1\rin0\lin-1440\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \r
 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af39\afs28 \ltrch\fcs0 \b\fs28\cf18\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 Files\r
 \par }\pard\plain \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 \fs24\lang1033\langfe1033\loch\af39\hich\af39\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af39\afs18 \r


@@ -208,11 +212,11 @@ g C153B68D-EBFC-488E-B110-662867745B87 Vfr_Uefi.iii}{\rtlch\fcs1 \ab\af39\afs18
 \par \hich\af39\dbch\af31505\loch\f39 This program and the accompanying materials are licensed and made available \r
 \par \hich\af39\dbch\af31505\loch\f39 under the terms and conditions of the BSD License which accompanies this \r
 \par \hich\af39\dbch\af31505\loch\f39 distribution.  The full text of the license may be found at\r
 \par \hich\af39\dbch\af31505\loch\f39 This program and the accompanying materials are licensed and made available \r
 \par \hich\af39\dbch\af31505\loch\f39 under the terms and conditions of the BSD License which accompanies this \r
 \par \hich\af39\dbch\af31505\loch\f39 distribution.  The full text of the license may be found at\r

-\par \hich\af39\dbch\af31505\loch\f39 http://opensource.org/licenses/bsd-license.php\r
+\par \hich\af39\dbch\af31505\loch\f39 http://opensource.org/licenses/bsd-license.ph\hich\af39\dbch\af31505\loch\f39 p\r

 \par \r
 \par \hich\af39\dbch\af31505\loch\f39 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
 \par \r
 \par \hich\af39\dbch\af31505\loch\f39 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r

-\par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 WITH\hich\af39\dbch\af31505\loch\f39 \r
-OUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\par }\pard \ltrpar\ql \li0\ri0\sb200\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af39\afs18 \ltrch\fcs0 \fs18\cf1\insrsid14166490 \hich\af39\dbch\af31505\loch\f39 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r

 \par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1\afs20 \ltrch\fcs0 \f1\fs20\insrsid14166490 \r
 \par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a\r
 9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad\r
 \par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af1\afs20 \ltrch\fcs0 \f1\fs20\insrsid14166490 \r
 \par }{\*\themedata 504b030414000600080000002100e9de0fbfff0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb4ec3301045f748fc83e52d4a\r
 9cb2400825e982c78ec7a27cc0c8992416c9d8b2a755fbf74cd25442a820166c2cd933f79e3be372bd1f07b5c3989ca74aaff2422b24eb1b475da5df374fd9ad\r


@@ -319,8 +323,8 @@ fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffff
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r
 ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\r

-ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e5000000000000000000000000f0d4\r
-6273066dcc01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000\r
+ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffff0c6ad98892f1d411a65f0040963251e50000000000000000000000000072\r
+d90d21cece01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000\r

 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000\r
 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000\r
 0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file
 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000\r
 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000\r
 0000000000000000000000000000000000000000000000000105000000000000}}
\ No newline at end of file