BaseTools: Hash false success with back to back builds

[mirror_edk2.git] / BaseTools / Source / Python / build / BuildReport.py

diff --git a/BaseTools/Source/Python/build/BuildReport.py b/BaseTools/Source/Python/build/BuildReport.py
index 53d0039c51495fccd7032bafd771f8c8289dc52a..942631c8795abfa1504cdcf9a8442d7722dfd7d6 100644 (file)
--- a/BaseTools/Source/Python/build/BuildReport.py
+++ b/BaseTools/Source/Python/build/BuildReport.py
@@ -5,13 +5,7 @@
 # build all target completes successfully.\r
 #\r
 # Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>\r
 # build all target completes successfully.\r
 #\r
 # Copyright (c) 2010 - 2018, 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
+# SPDX-License-Identifier: BSD-2-Clause-Patent\r

 #\r
 \r
 ## Import Modules\r
 #\r
 \r
 ## Import Modules\r


@@ -28,12 +22,11 @@ import hashlib
 import subprocess\r
 import threading\r
 from datetime import datetime\r
 import subprocess\r
 import threading\r
 from datetime import datetime\r

-from StringIO import StringIO\r
+from io import BytesIO\r

 from Common import EdkLogger\r
 from Common.Misc import SaveFileOnChange\r
 from Common.Misc import GuidStructureByteArrayToGuidString\r
 from Common.Misc import GuidStructureStringToGuidString\r
 from Common import EdkLogger\r
 from Common.Misc import SaveFileOnChange\r
 from Common.Misc import GuidStructureByteArrayToGuidString\r
 from Common.Misc import GuidStructureStringToGuidString\r

-from Common.InfClassObject import gComponentType2ModuleType\r

 from Common.BuildToolError import FILE_WRITE_FAILURE\r
 from Common.BuildToolError import CODE_ERROR\r
 from Common.BuildToolError import COMMAND_FAILURE\r
 from Common.BuildToolError import FILE_WRITE_FAILURE\r
 from Common.BuildToolError import CODE_ERROR\r
 from Common.BuildToolError import COMMAND_FAILURE\r


@@ -43,10 +36,11 @@ from Common.MultipleWorkspace import MultipleWorkspace as mws
 import Common.GlobalData as GlobalData\r
 from AutoGen.AutoGen import ModuleAutoGen\r
 from Common.Misc import PathClass\r
 import Common.GlobalData as GlobalData\r
 from AutoGen.AutoGen import ModuleAutoGen\r
 from Common.Misc import PathClass\r

-from Common.String import NormPath\r
+from Common.StringUtils import NormPath\r

 from Common.DataType import *\r
 import collections\r
 from Common.Expression import *\r
 from Common.DataType import *\r
 import collections\r
 from Common.Expression import *\r

+from GenFds.AprioriSection import DXE_APRIORI_GUID, PEI_APRIORI_GUID\r

 \r
 ## Pattern to extract contents in EDK DXS files\r
 gDxsDependencyPattern = re.compile(r"DEPENDENCY_START(.+)DEPENDENCY_END", re.DOTALL)\r
 \r
 ## Pattern to extract contents in EDK DXS files\r
 gDxsDependencyPattern = re.compile(r"DEPENDENCY_START(.+)DEPENDENCY_END", re.DOTALL)\r


@@ -95,38 +89,41 @@ gSubSectionSep = "-" * gLineMaxLength
 \r
 ## The look up table to map PCD type to pair of report display type and DEC type\r
 gPcdTypeMap = {\r
 \r
 ## The look up table to map PCD type to pair of report display type and DEC type\r
 gPcdTypeMap = {\r

-  'FixedAtBuild'     : ('FIXED',  'FixedAtBuild'),\r
-  'PatchableInModule': ('PATCH',  'PatchableInModule'),\r
-  'FeatureFlag'      : ('FLAG',   'FeatureFlag'),\r
-  'Dynamic'          : ('DYN',    'Dynamic'),\r
-  'DynamicHii'       : ('DYNHII', 'Dynamic'),\r
-  'DynamicVpd'       : ('DYNVPD', 'Dynamic'),\r
-  'DynamicEx'        : ('DEX',    'DynamicEx'),\r
-  'DynamicExHii'     : ('DEXHII', 'DynamicEx'),\r
-  'DynamicExVpd'     : ('DEXVPD', 'DynamicEx'),\r
+  TAB_PCDS_FIXED_AT_BUILD     : ('FIXED',  TAB_PCDS_FIXED_AT_BUILD),\r
+  TAB_PCDS_PATCHABLE_IN_MODULE: ('PATCH',  TAB_PCDS_PATCHABLE_IN_MODULE),\r
+  TAB_PCDS_FEATURE_FLAG       : ('FLAG',   TAB_PCDS_FEATURE_FLAG),\r
+  TAB_PCDS_DYNAMIC            : ('DYN',    TAB_PCDS_DYNAMIC),\r
+  TAB_PCDS_DYNAMIC_HII        : ('DYNHII', TAB_PCDS_DYNAMIC),\r
+  TAB_PCDS_DYNAMIC_VPD        : ('DYNVPD', TAB_PCDS_DYNAMIC),\r
+  TAB_PCDS_DYNAMIC_EX         : ('DEX',    TAB_PCDS_DYNAMIC_EX),\r
+  TAB_PCDS_DYNAMIC_EX_HII     : ('DEXHII', TAB_PCDS_DYNAMIC_EX),\r
+  TAB_PCDS_DYNAMIC_EX_VPD     : ('DEXVPD', TAB_PCDS_DYNAMIC_EX),\r

   }\r
 \r
 ## The look up table to map module type to driver type\r
 gDriverTypeMap = {\r
   }\r
 \r
 ## The look up table to map module type to driver type\r
 gDriverTypeMap = {\r

-  'SEC'               : '0x3 (SECURITY_CORE)',\r
-  'PEI_CORE'          : '0x4 (PEI_CORE)',\r
-  'PEIM'              : '0x6 (PEIM)',\r
-  'DXE_CORE'          : '0x5 (DXE_CORE)',\r
-  'DXE_DRIVER'        : '0x7 (DRIVER)',\r
-  'DXE_SAL_DRIVER'    : '0x7 (DRIVER)',\r
-  'DXE_SMM_DRIVER'    : '0x7 (DRIVER)',\r
-  'DXE_RUNTIME_DRIVER': '0x7 (DRIVER)',\r
-  'UEFI_DRIVER'       : '0x7 (DRIVER)',\r
-  'UEFI_APPLICATION'  : '0x9 (APPLICATION)',\r
-  'SMM_CORE'          : '0xD (SMM_CORE)',\r
+  SUP_MODULE_SEC               : '0x3 (SECURITY_CORE)',\r
+  SUP_MODULE_PEI_CORE          : '0x4 (PEI_CORE)',\r
+  SUP_MODULE_PEIM              : '0x6 (PEIM)',\r
+  SUP_MODULE_DXE_CORE          : '0x5 (DXE_CORE)',\r
+  SUP_MODULE_DXE_DRIVER        : '0x7 (DRIVER)',\r
+  SUP_MODULE_DXE_SAL_DRIVER    : '0x7 (DRIVER)',\r
+  SUP_MODULE_DXE_SMM_DRIVER    : '0x7 (DRIVER)',\r
+  SUP_MODULE_DXE_RUNTIME_DRIVER: '0x7 (DRIVER)',\r
+  SUP_MODULE_UEFI_DRIVER       : '0x7 (DRIVER)',\r
+  SUP_MODULE_UEFI_APPLICATION  : '0x9 (APPLICATION)',\r
+  SUP_MODULE_SMM_CORE          : '0xD (SMM_CORE)',\r

   'SMM_DRIVER'        : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers\r
   'SMM_DRIVER'        : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers\r

-  'MM_STANDALONE'     : '0xE (MM_STANDALONE)',\r
-  'MM_CORE_STANDALONE' : '0xF (MM_CORE_STANDALONE)'\r
+  SUP_MODULE_MM_STANDALONE     : '0xE (MM_STANDALONE)',\r
+  SUP_MODULE_MM_CORE_STANDALONE : '0xF (MM_CORE_STANDALONE)'\r

   }\r
 \r
 ## The look up table of the supported opcode in the dependency expression binaries\r
 gOpCodeList = ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]\r
 \r
   }\r
 \r
 ## The look up table of the supported opcode in the dependency expression binaries\r
 gOpCodeList = ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]\r
 \r

+## Save VPD Pcd\r
+VPDPcdList = []\r
+\r

 ##\r
 # Writes a string to the file object.\r
 #\r
 ##\r
 # Writes a string to the file object.\r
 #\r


@@ -140,13 +137,13 @@ gOpCodeList = ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "
 def FileWrite(File, String, Wrapper=False):\r
     if Wrapper:\r
         String = textwrap.fill(String, 120)\r
 def FileWrite(File, String, Wrapper=False):\r
     if Wrapper:\r
         String = textwrap.fill(String, 120)\r

-    File.write(String + gEndOfLine)\r
+    File.append(String + gEndOfLine)\r

 \r
 def ByteArrayForamt(Value):\r
     IsByteArray = False\r
     SplitNum = 16\r
     ArrayList = []\r
 \r
 def ByteArrayForamt(Value):\r
     IsByteArray = False\r
     SplitNum = 16\r
     ArrayList = []\r

-    if Value.startswith('{') and Value.endswith('}'):\r
+    if Value.startswith('{') and Value.endswith('}') and not Value.startswith("{CODE("):\r

         Value = Value[1:-1]\r
         ValueList = Value.split(',')\r
         if len(ValueList) >= SplitNum:\r
         Value = Value[1:-1]\r
         ValueList = Value.split(',')\r
         if len(ValueList) >= SplitNum:\r


@@ -209,7 +206,7 @@ def FindIncludeFiles(Source, IncludePathList, IncludeFiles):
             FileName = "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key}\r
         elif "PPI" in Type:\r
             FileName = "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key}\r
             FileName = "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key}\r
         elif "PPI" in Type:\r
             FileName = "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key}\r

-        elif "GUID" in Type:\r
+        elif TAB_GUID in Type:\r

             FileName = "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key}\r
         else:\r
             continue\r
             FileName = "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key}\r
         else:\r
             continue\r


@@ -221,7 +218,7 @@ def FindIncludeFiles(Source, IncludePathList, IncludeFiles):
 \r
 ## Split each lines in file\r
 #\r
 \r
 ## Split each lines in file\r
 #\r

-#  This method is used to split the lines in file to make the length of each line \r
+#  This method is used to split the lines in file to make the length of each line\r

 #  less than MaxLength.\r
 #\r
 #  @param      Content           The content of file\r
 #  less than MaxLength.\r
 #\r
 #  @param      Content           The content of file\r


@@ -246,12 +243,12 @@ def FileLinesSplit(Content=None, MaxLength=None):
             NewContentList.append(Line)\r
     for NewLine in NewContentList:\r
         NewContent += NewLine + TAB_LINE_BREAK\r
             NewContentList.append(Line)\r
     for NewLine in NewContentList:\r
         NewContent += NewLine + TAB_LINE_BREAK\r

-    \r
-    NewContent = NewContent.replace(TAB_LINE_BREAK, gEndOfLine).replace('\r\r\n', gEndOfLine)\r
+\r
+    NewContent = NewContent.replace(gEndOfLine, TAB_LINE_BREAK).replace('\r\r\n', gEndOfLine)\r

     return NewContent\r
     return NewContent\r

-    \r
-    \r
-    \r
+\r
+\r
+\r

 ##\r
 # Parse binary dependency expression section\r
 #\r
 ##\r
 # Parse binary dependency expression section\r
 #\r


@@ -281,10 +278,15 @@ class DepexParser(object):
                 for Guid in Package.Guids:\r
                     GuidValue = GuidStructureStringToGuidString(Package.Guids[Guid])\r
                     self._GuidDb[GuidValue.upper()] = Guid\r
                 for Guid in Package.Guids:\r
                     GuidValue = GuidStructureStringToGuidString(Package.Guids[Guid])\r
                     self._GuidDb[GuidValue.upper()] = Guid\r

-    \r
+            for Ma in Pa.ModuleAutoGenList:\r
+                for Pcd in Ma.FixedVoidTypePcds:\r
+                    PcdValue = Ma.FixedVoidTypePcds[Pcd]\r
+                    if len(PcdValue.split(',')) == 16:\r
+                        GuidValue = GuidStructureByteArrayToGuidString(PcdValue)\r
+                        self._GuidDb[GuidValue.upper()] = Pcd\r

     ##\r
     # Parse the binary dependency expression files.\r
     ##\r
     # Parse the binary dependency expression files.\r

-    # \r
+    #\r

     # This function parses the binary dependency expression file and translate it\r
     # to the instruction list.\r
     #\r
     # This function parses the binary dependency expression file and translate it\r
     # to the instruction list.\r
     #\r


@@ -299,14 +301,14 @@ class DepexParser(object):
             Statement = gOpCodeList[struct.unpack("B", OpCode)[0]]\r
             if Statement in ["BEFORE", "AFTER", "PUSH"]:\r
                 GuidValue = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \\r
             Statement = gOpCodeList[struct.unpack("B", OpCode)[0]]\r
             if Statement in ["BEFORE", "AFTER", "PUSH"]:\r
                 GuidValue = "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \\r

-                            struct.unpack("=LHHBBBBBBBB", DepexFile.read(16))\r
+                            struct.unpack(PACK_PATTERN_GUID, DepexFile.read(16))\r

                 GuidString = self._GuidDb.get(GuidValue, GuidValue)\r
                 Statement = "%s %s" % (Statement, GuidString)\r
             DepexStatement.append(Statement)\r
             OpCode = DepexFile.read(1)\r
 \r
         return DepexStatement\r
                 GuidString = self._GuidDb.get(GuidValue, GuidValue)\r
                 Statement = "%s %s" % (Statement, GuidString)\r
             DepexStatement.append(Statement)\r
             OpCode = DepexFile.read(1)\r
 \r
         return DepexStatement\r

-    \r
+\r

 ##\r
 # Reports library information\r
 #\r
 ##\r
 # Reports library information\r
 #\r


@@ -324,10 +326,6 @@ class LibraryReport(object):
     #\r
     def __init__(self, M):\r
         self.LibraryList = []\r
     #\r
     def __init__(self, M):\r
         self.LibraryList = []\r

-        if int(str(M.AutoGenVersion), 0) >= 0x00010005:\r
-            self._EdkIIModule = True\r
-        else:\r
-            self._EdkIIModule = False\r

 \r
         for Lib in M.DependentLibraryList:\r
             LibInfPath = str(Lib)\r
 \r
         for Lib in M.DependentLibraryList:\r
             LibInfPath = str(Lib)\r


@@ -360,28 +358,23 @@ class LibraryReport(object):
                 LibInfPath = LibraryItem[0]\r
                 FileWrite(File, LibInfPath)\r
 \r
                 LibInfPath = LibraryItem[0]\r
                 FileWrite(File, LibInfPath)\r
 \r

-                #\r
-                # Report library class, library constructor and destructor for\r
-                # EDKII style module.\r
-                #\r
-                if self._EdkIIModule:\r
-                    LibClass = LibraryItem[1]\r
-                    EdkIILibInfo = ""\r
-                    LibConstructor = " ".join(LibraryItem[2])\r
-                    if LibConstructor:\r
-                        EdkIILibInfo += " C = " + LibConstructor\r
-                    LibDestructor = " ".join(LibraryItem[3])\r
-                    if LibDestructor:\r
-                        EdkIILibInfo += " D = " + LibDestructor\r
-                    LibDepex = " ".join(LibraryItem[4])\r
-                    if LibDepex:\r
-                        EdkIILibInfo += " Depex = " + LibDepex\r
-                    if LibraryItem[5]:\r
-                        EdkIILibInfo += " Time = " + LibraryItem[5]\r
-                    if EdkIILibInfo:\r
-                        FileWrite(File, "{%s: %s}" % (LibClass, EdkIILibInfo))\r
-                    else:\r
-                        FileWrite(File, "{%s}" % LibClass)\r
+                LibClass = LibraryItem[1]\r
+                EdkIILibInfo = ""\r
+                LibConstructor = " ".join(LibraryItem[2])\r
+                if LibConstructor:\r
+                    EdkIILibInfo += " C = " + LibConstructor\r
+                LibDestructor = " ".join(LibraryItem[3])\r
+                if LibDestructor:\r
+                    EdkIILibInfo += " D = " + LibDestructor\r
+                LibDepex = " ".join(LibraryItem[4])\r
+                if LibDepex:\r
+                    EdkIILibInfo += " Depex = " + LibDepex\r
+                if LibraryItem[5]:\r
+                    EdkIILibInfo += " Time = " + LibraryItem[5]\r
+                if EdkIILibInfo:\r
+                    FileWrite(File, "{%s: %s}" % (LibClass, EdkIILibInfo))\r
+                else:\r
+                    FileWrite(File, "{%s}" % LibClass)\r

 \r
             FileWrite(File, gSubSectionEnd)\r
 \r
 \r
             FileWrite(File, gSubSectionEnd)\r
 \r


@@ -408,11 +401,11 @@ class DepexReport(object):
         self._DepexFileName = os.path.join(M.BuildDir, "OUTPUT", M.Module.BaseName + ".depex")\r
         ModuleType = M.ModuleType\r
         if not ModuleType:\r
         self._DepexFileName = os.path.join(M.BuildDir, "OUTPUT", M.Module.BaseName + ".depex")\r
         ModuleType = M.ModuleType\r
         if not ModuleType:\r

-            ModuleType = gComponentType2ModuleType.get(M.ComponentType, "")\r
+            ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")\r

 \r
 \r

-        if ModuleType in ["SEC", "PEI_CORE", "DXE_CORE", "SMM_CORE", "MM_CORE_STANDALONE", "UEFI_APPLICATION"]:\r
+        if ModuleType in [SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_DXE_CORE, SUP_MODULE_SMM_CORE, SUP_MODULE_MM_CORE_STANDALONE, SUP_MODULE_UEFI_APPLICATION]:\r

             return\r
             return\r

-      \r
+\r

         for Source in M.SourceFileList:\r
             if os.path.splitext(Source.Path)[1].lower() == ".dxs":\r
                 Match = gDxsDependencyPattern.search(open(Source.Path).read())\r
         for Source in M.SourceFileList:\r
             if os.path.splitext(Source.Path)[1].lower() == ".dxs":\r
                 Match = gDxsDependencyPattern.search(open(Source.Path).read())\r


@@ -421,7 +414,7 @@ class DepexReport(object):
                     self.Source = "DXS"\r
                     break\r
         else:\r
                     self.Source = "DXS"\r
                     break\r
         else:\r

-            self.Depex = M.DepexExpressionList.get(M.ModuleType, "")\r
+            self.Depex = M.DepexExpressionDict.get(M.ModuleType, "")\r

             self.ModuleDepex = " ".join(M.Module.DepexExpression[M.Arch, M.ModuleType])\r
             if not self.ModuleDepex:\r
                 self.ModuleDepex = "(None)"\r
             self.ModuleDepex = " ".join(M.Module.DepexExpression[M.Arch, M.ModuleType])\r
             if not self.ModuleDepex:\r
                 self.ModuleDepex = "(None)"\r


@@ -458,16 +451,16 @@ class DepexReport(object):
                 FileWrite(File, gSubSectionSep)\r
             except:\r
                 EdkLogger.warn(None, "Dependency expression file is corrupted", self._DepexFileName)\r
                 FileWrite(File, gSubSectionSep)\r
             except:\r
                 EdkLogger.warn(None, "Dependency expression file is corrupted", self._DepexFileName)\r

-        \r
+\r

         FileWrite(File, "Dependency Expression (DEPEX) from %s" % self.Source)\r
 \r
         if self.Source == "INF":\r
         FileWrite(File, "Dependency Expression (DEPEX) from %s" % self.Source)\r
 \r
         if self.Source == "INF":\r

-            FileWrite(File, "%s" % self.Depex, True)\r
+            FileWrite(File, self.Depex, True)\r

             FileWrite(File, gSubSectionSep)\r
             FileWrite(File, "From Module INF:  %s" % self.ModuleDepex, True)\r
             FileWrite(File, "From Library INF: %s" % self.LibraryDepex, True)\r
         else:\r
             FileWrite(File, gSubSectionSep)\r
             FileWrite(File, "From Module INF:  %s" % self.ModuleDepex, True)\r
             FileWrite(File, "From Library INF: %s" % self.LibraryDepex, True)\r
         else:\r

-            FileWrite(File, "%s" % self.Depex)\r
+            FileWrite(File, self.Depex)\r

         FileWrite(File, gSubSectionEnd)\r
 \r
 ##\r
         FileWrite(File, gSubSectionEnd)\r
 \r
 ##\r


@@ -573,11 +566,11 @@ class ModuleReport(object):
         if not M.IsLibrary:\r
             ModuleType = M.ModuleType\r
             if not ModuleType:\r
         if not M.IsLibrary:\r
             ModuleType = M.ModuleType\r
             if not ModuleType:\r

-                ModuleType = gComponentType2ModuleType.get(M.ComponentType, "")\r
+                ModuleType = COMPONENT_TO_MODULE_MAP_DICT.get(M.ComponentType, "")\r

             #\r
             # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"\r
             #\r
             #\r
             # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"\r
             #\r

-            if ModuleType == "DXE_SMM_DRIVER":\r
+            if ModuleType == SUP_MODULE_DXE_SMM_DRIVER:\r

                 PiSpec = M.Module.Specification.get("PI_SPECIFICATION_VERSION", "0x00010000")\r
                 if int(PiSpec, 0) >= 0x0001000A:\r
                     ModuleType = "SMM_DRIVER"\r
                 PiSpec = M.Module.Specification.get("PI_SPECIFICATION_VERSION", "0x00010000")\r
                 if int(PiSpec, 0) >= 0x0001000A:\r
                     ModuleType = "SMM_DRIVER"\r


@@ -637,7 +630,7 @@ class ModuleReport(object):
 \r
                 Match = gTimeStampPattern.search(FileContents)\r
                 if Match:\r
 \r
                 Match = gTimeStampPattern.search(FileContents)\r
                 if Match:\r

-                    self.BuildTimeStamp = datetime.fromtimestamp(int(Match.group(1)))\r
+                    self.BuildTimeStamp = datetime.utcfromtimestamp(int(Match.group(1)))\r

             except IOError:\r
                 EdkLogger.warn(None, "Fail to read report file", FwReportFileName)\r
 \r
             except IOError:\r
                 EdkLogger.warn(None, "Fail to read report file", FwReportFileName)\r
 \r


@@ -650,7 +643,7 @@ class ModuleReport(object):
                 cmd = ["GenFw", "--rebase", str(0), "-o", Tempfile, DefaultEFIfile]\r
                 try:\r
                     PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\r
                 cmd = ["GenFw", "--rebase", str(0), "-o", Tempfile, DefaultEFIfile]\r
                 try:\r
                     PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\r

-                except Exception, X:\r
+                except Exception as X:\r

                     EdkLogger.error("GenFw", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))\r
                 EndOfProcedure = threading.Event()\r
                 EndOfProcedure.clear()\r
                     EdkLogger.error("GenFw", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))\r
                 EndOfProcedure = threading.Event()\r
                 EndOfProcedure.clear()\r


@@ -722,8 +715,8 @@ def ReadMessage(From, To, ExitFlag):
         # read one line a time\r
         Line = From.readline()\r
         # empty string means "end"\r
         # read one line a time\r
         Line = From.readline()\r
         # empty string means "end"\r

-        if Line != None and Line != "":\r
-            To(Line.rstrip())\r
+        if Line is not None and Line != b"":\r
+            To(Line.rstrip().decode(encoding='utf-8', errors='ignore'))\r

         else:\r
             break\r
         if ExitFlag.isSet():\r
         else:\r
             break\r
         if ExitFlag.isSet():\r


@@ -781,11 +774,18 @@ class PcdReport(object):
             # Collect the PCD defined in DSC/FDF file, but not used in module\r
             #\r
             UnusedPcdFullList = []\r
             # Collect the PCD defined in DSC/FDF file, but not used in module\r
             #\r
             UnusedPcdFullList = []\r

+            StructPcdDict = GlobalData.gStructurePcd.get(self.Arch, collections.OrderedDict())\r
+            for Name, Guid in StructPcdDict:\r
+                if (Name, Guid) not in Pa.Platform.Pcds:\r
+                    Pcd = StructPcdDict[(Name, Guid)]\r
+                    PcdList = self.AllPcds.setdefault(Guid, {}).setdefault(Pcd.Type, [])\r
+                    if Pcd not in PcdList and Pcd not in UnusedPcdFullList:\r
+                        UnusedPcdFullList.append(Pcd)\r

             for item in Pa.Platform.Pcds:\r
                 Pcd = Pa.Platform.Pcds[item]\r
                 if not Pcd.Type:\r
                     # check the Pcd in FDF file, whether it is used in module first\r
             for item in Pa.Platform.Pcds:\r
                 Pcd = Pa.Platform.Pcds[item]\r
                 if not Pcd.Type:\r
                     # check the Pcd in FDF file, whether it is used in module first\r

-                    for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
+                    for T in PCD_TYPE_LIST:\r

                         PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(T, [])\r
                         if Pcd in PcdList:\r
                             Pcd.Type = T\r
                         PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(T, [])\r
                         if Pcd in PcdList:\r
                             Pcd.Type = T\r


@@ -793,7 +793,7 @@ class PcdReport(object):
                 if not Pcd.Type:\r
                     PcdTypeFlag = False\r
                     for package in Pa.PackageList:\r
                 if not Pcd.Type:\r
                     PcdTypeFlag = False\r
                     for package in Pa.PackageList:\r

-                        for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:\r
+                        for T in PCD_TYPE_LIST:\r

                             if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T) in package.Pcds:\r
                                 Pcd.Type = T\r
                                 PcdTypeFlag = True\r
                             if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, T) in package.Pcds:\r
                                 Pcd.Type = T\r
                                 PcdTypeFlag = True\r


@@ -805,16 +805,19 @@ class PcdReport(object):
                 if not Pcd.DatumType:\r
                     PcdType = Pcd.Type\r
                     # Try to remove Hii and Vpd suffix\r
                 if not Pcd.DatumType:\r
                     PcdType = Pcd.Type\r
                     # Try to remove Hii and Vpd suffix\r

-                    if PcdType.startswith("DynamicEx"):\r
-                        PcdType = "DynamicEx"\r
-                    elif PcdType.startswith("Dynamic"):\r
-                        PcdType = "Dynamic"\r
+                    if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r
+                        PcdType = TAB_PCDS_DYNAMIC_EX\r
+                    elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r
+                        PcdType = TAB_PCDS_DYNAMIC\r

                     for package in Pa.PackageList:\r
                         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType) in package.Pcds:\r
                             Pcd.DatumType = package.Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType)].DatumType\r
                             break\r
 \r
                 PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r
                     for package in Pa.PackageList:\r
                         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType) in package.Pcds:\r
                             Pcd.DatumType = package.Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName, PcdType)].DatumType\r
                             break\r
 \r
                 PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r

+                UnusedPcdList = self.UnusedPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r
+                if Pcd in UnusedPcdList:\r
+                    UnusedPcdList.remove(Pcd)\r

                 if Pcd not in PcdList and Pcd not in UnusedPcdFullList:\r
                     UnusedPcdFullList.append(Pcd)\r
                 if len(Pcd.TokenCName) > self.MaxLen:\r
                 if Pcd not in PcdList and Pcd not in UnusedPcdFullList:\r
                     UnusedPcdFullList.append(Pcd)\r
                 if len(Pcd.TokenCName) > self.MaxLen:\r


@@ -824,7 +827,7 @@ class PcdReport(object):
                 for PcdItem in GlobalData.gConditionalPcds:\r
                     if '.' in PcdItem:\r
                         (TokenSpaceGuidCName, TokenCName) = PcdItem.split('.')\r
                 for PcdItem in GlobalData.gConditionalPcds:\r
                     if '.' in PcdItem:\r
                         (TokenSpaceGuidCName, TokenCName) = PcdItem.split('.')\r

-                        if (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds.keys():\r
+                        if (TokenCName, TokenSpaceGuidCName) in Pa.Platform.Pcds:\r

                             Pcd = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)]\r
                             PcdList = self.ConditionalPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r
                             if Pcd not in PcdList:\r
                             Pcd = Pa.Platform.Pcds[(TokenCName, TokenSpaceGuidCName)]\r
                             PcdList = self.ConditionalPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\r
                             if Pcd not in PcdList:\r


@@ -877,10 +880,21 @@ class PcdReport(object):
                     self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r
 \r
     def GenerateReport(self, File, ModulePcdSet):\r
                     self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r
 \r
     def GenerateReport(self, File, ModulePcdSet):\r

-        if self.ConditionalPcds:\r
-            self.GenerateReportDetail(File, ModulePcdSet, 1)\r
-        if self.UnusedPcds:\r
-            self.GenerateReportDetail(File, ModulePcdSet, 2)\r
+        if not ModulePcdSet:\r
+            if self.ConditionalPcds:\r
+                self.GenerateReportDetail(File, ModulePcdSet, 1)\r
+            if self.UnusedPcds:\r
+                IsEmpty = True\r
+                for Token in self.UnusedPcds:\r
+                    TokenDict = self.UnusedPcds[Token]\r
+                    for Type in TokenDict:\r
+                        if TokenDict[Type]:\r
+                            IsEmpty = False\r
+                            break\r
+                    if not IsEmpty:\r
+                        break\r
+                if not IsEmpty:\r
+                    self.GenerateReportDetail(File, ModulePcdSet, 2)\r

         self.GenerateReportDetail(File, ModulePcdSet)\r
 \r
     ##\r
         self.GenerateReportDetail(File, ModulePcdSet)\r
 \r
     ##\r


@@ -904,7 +918,7 @@ class PcdReport(object):
         elif ReportSubType == 2:\r
             PcdDict = self.UnusedPcds\r
 \r
         elif ReportSubType == 2:\r
             PcdDict = self.UnusedPcds\r
 \r

-        if ModulePcdSet == None:\r
+        if not ModulePcdSet:\r

             FileWrite(File, gSectionStart)\r
             if ReportSubType == 1:\r
                 FileWrite(File, "Conditional Directives used by the build system")\r
             FileWrite(File, gSectionStart)\r
             if ReportSubType == 1:\r
                 FileWrite(File, "Conditional Directives used by the build system")\r


@@ -927,192 +941,327 @@ class PcdReport(object):
                 FileWrite(File, gSubSectionStart)\r
                 FileWrite(File, TAB_BRG_PCD)\r
                 FileWrite(File, gSubSectionSep)\r
                 FileWrite(File, gSubSectionStart)\r
                 FileWrite(File, TAB_BRG_PCD)\r
                 FileWrite(File, gSubSectionSep)\r

-\r
+        AllPcdDict = {}\r

         for Key in PcdDict:\r
         for Key in PcdDict:\r

+            AllPcdDict[Key] = {}\r
+            for Type in PcdDict[Key]:\r
+                for Pcd in PcdDict[Key][Type]:\r
+                    AllPcdDict[Key][(Pcd.TokenCName, Type)] = Pcd\r
+        for Key in sorted(AllPcdDict):\r

             #\r
             # Group PCD by their token space GUID C Name\r
             #\r
             First = True\r
             #\r
             # Group PCD by their token space GUID C Name\r
             #\r
             First = True\r

-            for Type in PcdDict[Key]:\r
+            for PcdTokenCName, Type in sorted(AllPcdDict[Key]):\r

                 #\r
                 # Group PCD by their usage type\r
                 #\r
                 #\r
                 # Group PCD by their usage type\r
                 #\r

+                Pcd = AllPcdDict[Key][(PcdTokenCName, Type)]\r

                 TypeName, DecType = gPcdTypeMap.get(Type, ("", Type))\r
                 TypeName, DecType = gPcdTypeMap.get(Type, ("", Type))\r

-                for Pcd in PcdDict[Key][Type]:\r
-                    PcdTokenCName = Pcd.TokenCName\r
-                    MixedPcdFlag = False\r
-                    if GlobalData.MixedPcd:\r
-                        for PcdKey in GlobalData.MixedPcd:\r
-                            if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdKey]:\r
-                                PcdTokenCName = PcdKey[0]\r
-                                MixedPcdFlag = True\r
-                        if MixedPcdFlag and not ModulePcdSet:\r
-                            continue\r
-                    #\r
-                    # Get PCD default value and their override relationship\r
-                    #\r
-                    DecDefaultValue = self.DecPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType))\r
-                    DscDefaultValue = self.DscPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
-                    DscDefaultValBak = DscDefaultValue\r
-                    DscDefaultValue = self.FdfPcdSet.get((Pcd.TokenCName, Key), DscDefaultValue)\r
-                    if DscDefaultValue != DscDefaultValBak:\r
-                        try:\r
-                            DscDefaultValue = ValueExpressionEx(DscDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r
-                        except BadExpression, Value:\r
-                            EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" %(DscDefaultValue, Pcd.DatumType))\r
+                MixedPcdFlag = False\r
+                if GlobalData.MixedPcd:\r
+                    for PcdKey in GlobalData.MixedPcd:\r
+                        if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdKey]:\r
+                            PcdTokenCName = PcdKey[0]\r
+                            MixedPcdFlag = True\r
+                    if MixedPcdFlag and not ModulePcdSet:\r
+                        continue\r
+                #\r
+                # Get PCD default value and their override relationship\r
+                #\r
+                DecDefaultValue = self.DecPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType))\r
+                DscDefaultValue = self.DscPcdDefault.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
+                DscDefaultValBak = DscDefaultValue\r
+                Field = ''\r
+                for (CName, Guid, Field) in self.FdfPcdSet:\r
+                    if CName == PcdTokenCName and Guid == Key:\r
+                        DscDefaultValue = self.FdfPcdSet[(CName, Guid, Field)]\r
+                        break\r
+                if DscDefaultValue != DscDefaultValBak:\r
+                    try:\r
+                        DscDefaultValue = ValueExpressionEx(DscDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r
+                    except BadExpression as DscDefaultValue:\r
+                        EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" %(DscDefaultValue, Pcd.DatumType))\r

 \r
 \r

-                    InfDefaultValue = None\r
-                    \r
-                    PcdValue = DecDefaultValue\r
-                    if DscDefaultValue:\r
-                        PcdValue = DscDefaultValue\r
-                    if ModulePcdSet != None:\r
-                        if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:\r
-                            continue\r
-                        InfDefault, PcdValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r
-                        if InfDefault == "":\r
-                            InfDefault = None\r
-\r
-                    BuildOptionMatch = False\r
-                    if GlobalData.BuildOptionPcd:\r
-                        for pcd in GlobalData.BuildOptionPcd:\r
-                            if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (pcd[0], pcd[1]):\r
-                                PcdValue = pcd[2]\r
-                                BuildOptionMatch = True\r
-                                break\r
+                InfDefaultValue = None\r

 \r
 \r

-                    if First:\r
-                        if ModulePcdSet == None:\r
-                            FileWrite(File, "")\r
-                        FileWrite(File, Key)\r
-                        First = False\r
+                PcdValue = DecDefaultValue\r
+                if DscDefaultValue:\r
+                    PcdValue = DscDefaultValue\r
+                #The DefaultValue of StructurePcd already be the latest, no need to update.\r
+                if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r
+                    Pcd.DefaultValue = PcdValue\r
+                if ModulePcdSet is not None:\r
+                    if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:\r
+                        continue\r
+                    InfDefaultValue, PcdValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r
+                    #The DefaultValue of StructurePcd already be the latest, no need to update.\r
+                    if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r
+                        Pcd.DefaultValue = PcdValue\r
+                    if InfDefaultValue:\r
+                        try:\r
+                            InfDefaultValue = ValueExpressionEx(InfDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r
+                        except BadExpression as InfDefaultValue:\r
+                            EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" % (InfDefaultValue, Pcd.DatumType))\r
+                    if InfDefaultValue == "":\r
+                        InfDefaultValue = None\r
+\r
+                BuildOptionMatch = False\r
+                if GlobalData.BuildOptionPcd:\r
+                    for pcd in GlobalData.BuildOptionPcd:\r
+                        if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) == (pcd[0], pcd[1]):\r
+                            if pcd[2]:\r
+                                continue\r
+                            PcdValue = pcd[3]\r
+                            #The DefaultValue of StructurePcd already be the latest, no need to update.\r
+                            if not self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r
+                                Pcd.DefaultValue = PcdValue\r
+                            BuildOptionMatch = True\r
+                            break\r

 \r
 \r

+                if First:\r
+                    if ModulePcdSet is None:\r
+                        FileWrite(File, "")\r
+                    FileWrite(File, Key)\r
+                    First = False\r

 \r
 \r

-                    if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):\r
-                        PcdValueNumber = int(PcdValue.strip(), 0)\r
-                        if DecDefaultValue == None:\r
-                            DecMatch = True\r
-                        else:\r
-                            DecDefaultValueNumber = int(DecDefaultValue.strip(), 0)\r
-                            DecMatch = (DecDefaultValueNumber == PcdValueNumber)\r

 \r
 \r

-                        if InfDefaultValue == None:\r
-                            InfMatch = True\r
-                        else:\r
-                            InfDefaultValueNumber = int(InfDefaultValue.strip(), 0)\r
-                            InfMatch = (InfDefaultValueNumber == PcdValueNumber)\r
+                if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
+                    if PcdValue.startswith('0') and not PcdValue.lower().startswith('0x') and \\r
+                            len(PcdValue) > 1 and PcdValue.lstrip('0'):\r
+                        PcdValue = PcdValue.lstrip('0')\r
+                    PcdValueNumber = int(PcdValue.strip(), 0)\r
+                    if DecDefaultValue is None:\r
+                        DecMatch = True\r
+                    else:\r
+                        if DecDefaultValue.startswith('0') and not DecDefaultValue.lower().startswith('0x') and \\r
+                                len(DecDefaultValue) > 1 and DecDefaultValue.lstrip('0'):\r
+                            DecDefaultValue = DecDefaultValue.lstrip('0')\r
+                        DecDefaultValueNumber = int(DecDefaultValue.strip(), 0)\r
+                        DecMatch = (DecDefaultValueNumber == PcdValueNumber)\r
+\r
+                    if InfDefaultValue is None:\r
+                        InfMatch = True\r
+                    else:\r
+                        if InfDefaultValue.startswith('0') and not InfDefaultValue.lower().startswith('0x') and \\r
+                                len(InfDefaultValue) > 1 and InfDefaultValue.lstrip('0'):\r
+                            InfDefaultValue = InfDefaultValue.lstrip('0')\r
+                        InfDefaultValueNumber = int(InfDefaultValue.strip(), 0)\r
+                        InfMatch = (InfDefaultValueNumber == PcdValueNumber)\r
+\r
+                    if DscDefaultValue is None:\r
+                        DscMatch = True\r
+                    else:\r
+                        if DscDefaultValue.startswith('0') and not DscDefaultValue.lower().startswith('0x') and \\r
+                                len(DscDefaultValue) > 1 and DscDefaultValue.lstrip('0'):\r
+                            DscDefaultValue = DscDefaultValue.lstrip('0')\r
+                        DscDefaultValueNumber = int(DscDefaultValue.strip(), 0)\r
+                        DscMatch = (DscDefaultValueNumber == PcdValueNumber)\r
+                else:\r
+                    if DecDefaultValue is None:\r
+                        DecMatch = True\r
+                    else:\r
+                        DecMatch = (DecDefaultValue.strip() == PcdValue.strip())\r

 \r
 \r

-                        if DscDefaultValue == None:\r
-                            DscMatch = True\r
-                        else:\r
-                            DscDefaultValueNumber = int(DscDefaultValue.strip(), 0)\r
-                            DscMatch = (DscDefaultValueNumber == PcdValueNumber)\r
+                    if InfDefaultValue is None:\r
+                        InfMatch = True\r

                     else:\r
                     else:\r

-                        if DecDefaultValue == None:\r
-                            DecMatch = True\r
-                        else:\r
-                            DecMatch = (DecDefaultValue.strip() == PcdValue.strip())\r
+                        InfMatch = (InfDefaultValue.strip() == PcdValue.strip())\r

 \r
 \r

-                        if InfDefaultValue == None:\r
-                            InfMatch = True\r
-                        else:\r
-                            InfMatch = (InfDefaultValue.strip() == PcdValue.strip())\r
+                    if DscDefaultValue is None:\r
+                        DscMatch = True\r
+                    else:\r
+                        DscMatch = (DscDefaultValue.strip() == PcdValue.strip())\r

 \r
 \r

-                        if DscDefaultValue == None:\r
-                            DscMatch = True\r
+                IsStructure = False\r
+                if self.IsStructurePcd(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):\r
+                    IsStructure = True\r
+                    if TypeName in ('DYNVPD', 'DEXVPD'):\r
+                        SkuInfoList = Pcd.SkuInfoList\r
+                    Pcd = GlobalData.gStructurePcd[self.Arch][(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r
+                    Pcd.DatumType = Pcd.StructName\r
+                    if TypeName in ('DYNVPD', 'DEXVPD'):\r
+                        Pcd.SkuInfoList = SkuInfoList\r
+                    if Pcd.PcdValueFromComm or Pcd.PcdFieldValueFromComm:\r
+                        BuildOptionMatch = True\r
+                        DecMatch = False\r
+                    elif Pcd.PcdValueFromFdf or Pcd.PcdFieldValueFromFdf:\r
+                        DscDefaultValue = True\r
+                        DscMatch = True\r
+                        DecMatch = False\r
+                    elif Pcd.SkuOverrideValues:\r
+                        DscOverride = False\r
+                        if Pcd.DefaultFromDSC:\r
+                            DscOverride = True\r

                         else:\r
                         else:\r

-                            DscMatch = (DscDefaultValue.strip() == PcdValue.strip())\r
-\r
-                    IsStructure = False\r
-                    if GlobalData.gStructurePcd and (self.Arch in GlobalData.gStructurePcd.keys()) and ((Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.gStructurePcd[self.Arch]):\r
-                        IsStructure = True\r
-                        if TypeName in ('DYNVPD', 'DEXVPD'):\r
-                            SkuInfoList = Pcd.SkuInfoList\r
-                        Pcd = GlobalData.gStructurePcd[self.Arch][(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r
-                        Pcd.DatumType = Pcd.StructName\r
-                        if TypeName in ('DYNVPD', 'DEXVPD'):\r
-                            Pcd.SkuInfoList = SkuInfoList\r
-                        if Pcd.SkuOverrideValues:\r
+                            DictLen = 0\r
+                            for item in Pcd.SkuOverrideValues:\r
+                                DictLen += len(Pcd.SkuOverrideValues[item])\r
+                            if not DictLen:\r
+                                DscOverride = False\r
+                            else:\r
+                                if not Pcd.SkuInfoList:\r
+                                    OverrideValues = Pcd.SkuOverrideValues\r
+                                    if OverrideValues:\r
+                                        for Data in OverrideValues.values():\r
+                                            Struct = list(Data.values())\r
+                                            if Struct:\r
+                                                DscOverride = self.ParseStruct(Struct[0])\r
+                                                break\r
+                                else:\r
+                                    SkuList = sorted(Pcd.SkuInfoList.keys())\r
+                                    for Sku in SkuList:\r
+                                        SkuInfo = Pcd.SkuInfoList[Sku]\r
+                                        if SkuInfo.DefaultStoreDict:\r
+                                            DefaultStoreList = sorted(SkuInfo.DefaultStoreDict.keys())\r
+                                            for DefaultStore in DefaultStoreList:\r
+                                                OverrideValues = Pcd.SkuOverrideValues[Sku]\r
+                                                DscOverride = self.ParseStruct(OverrideValues[DefaultStore])\r
+                                                if DscOverride:\r
+                                                    break\r
+                                        if DscOverride:\r
+                                            break\r
+                        if DscOverride:\r
+                            DscDefaultValue = True\r

                             DscMatch = True\r
                             DecMatch = False\r
                             DscMatch = True\r
                             DecMatch = False\r

-                    #\r
-                    # Report PCD item according to their override relationship\r
-                    #\r
-                    if DecMatch and InfMatch:\r
-                        self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '  ')\r
-                    elif BuildOptionMatch:\r
-                        self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*B')\r
+                        else:\r
+                            DecMatch = True\r

                     else:\r
                     else:\r

-                        if DscMatch:\r
-                            if (Pcd.TokenCName, Key) in self.FdfPcdSet:\r
-                                self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*F')\r
-                            else:\r
-                                self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*P')\r
+                        DscDefaultValue = True\r
+                        DscMatch = True\r
+                        DecMatch = False\r
+\r
+                #\r
+                # Report PCD item according to their override relationship\r
+                #\r
+                if Pcd.DatumType == 'BOOLEAN':\r
+                    if DscDefaultValue:\r
+                        DscDefaultValue = str(int(DscDefaultValue, 0))\r
+                    if DecDefaultValue:\r
+                        DecDefaultValue = str(int(DecDefaultValue, 0))\r
+                    if InfDefaultValue:\r
+                        InfDefaultValue = str(int(InfDefaultValue, 0))\r
+                    if Pcd.DefaultValue:\r
+                        Pcd.DefaultValue = str(int(Pcd.DefaultValue, 0))\r
+                if DecMatch:\r
+                    self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '  ')\r
+                elif InfDefaultValue and InfMatch:\r
+                    self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*M')\r
+                elif BuildOptionMatch:\r
+                    self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*B')\r
+                else:\r
+                    if DscDefaultValue and DscMatch:\r
+                        if (Pcd.TokenCName, Key, Field) in self.FdfPcdSet:\r
+                            self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*F')\r

                         else:\r
                         else:\r

-                            self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*M')\r
+                            self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*P')\r
+                    else:\r
+                        self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*M')\r

 \r
 \r

-                    if ModulePcdSet == None:\r
-                        if IsStructure:\r
-                            continue\r
-                        if not TypeName in ('PATCH', 'FLAG', 'FIXED'):\r
-                            continue\r
-                        if not BuildOptionMatch:\r
-                            ModuleOverride = self.ModulePcdOverride.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName), {})\r
-                            for ModulePath in ModuleOverride:\r
-                                ModuleDefault = ModuleOverride[ModulePath]\r
-                                if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):\r
-                                    ModulePcdDefaultValueNumber = int(ModuleDefault.strip(), 0)\r
-                                    Match = (ModulePcdDefaultValueNumber == PcdValueNumber)\r
-                                else:\r
-                                    Match = (ModuleDefault.strip() == PcdValue.strip())\r
-                                if Match:\r
-                                    continue\r
-                                IsByteArray, ArrayList = ByteArrayForamt(ModuleDefault.strip())\r
-                                if IsByteArray:\r
-                                    FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 19, ModulePath, '{'))\r
-                                    for Array in ArrayList:\r
-                                        FileWrite(File, '%s' % (Array))\r
-                                else:\r
-                                    FileWrite(File, ' *M %-*s = %s' % (self.MaxLen + 19, ModulePath, ModuleDefault.strip()))\r
+                if ModulePcdSet is None:\r
+                    if IsStructure:\r
+                        continue\r
+                    if not TypeName in ('PATCH', 'FLAG', 'FIXED'):\r
+                        continue\r
+                    if not BuildOptionMatch:\r
+                        ModuleOverride = self.ModulePcdOverride.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName), {})\r
+                        for ModulePath in ModuleOverride:\r
+                            ModuleDefault = ModuleOverride[ModulePath]\r
+                            if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
+                                if ModuleDefault.startswith('0') and not ModuleDefault.lower().startswith('0x') and \\r
+                                        len(ModuleDefault) > 1 and ModuleDefault.lstrip('0'):\r
+                                    ModuleDefault = ModuleDefault.lstrip('0')\r
+                                ModulePcdDefaultValueNumber = int(ModuleDefault.strip(), 0)\r
+                                Match = (ModulePcdDefaultValueNumber == PcdValueNumber)\r
+                                if Pcd.DatumType == 'BOOLEAN':\r
+                                    ModuleDefault = str(ModulePcdDefaultValueNumber)\r
+                            else:\r
+                                Match = (ModuleDefault.strip() == PcdValue.strip())\r
+                            if Match:\r
+                                continue\r
+                            IsByteArray, ArrayList = ByteArrayForamt(ModuleDefault.strip())\r
+                            if IsByteArray:\r
+                                FileWrite(File, ' *M     %-*s = %s' % (self.MaxLen + 15, ModulePath, '{'))\r
+                                for Array in ArrayList:\r
+                                    FileWrite(File, Array)\r
+                            else:\r
+                                Value =  ModuleDefault.strip()\r
+                                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                                    if Value.startswith(('0x', '0X')):\r
+                                        Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                                    else:\r
+                                        Value = "0x{:X} ({})".format(int(Value, 0), Value)\r
+                                FileWrite(File, ' *M     %-*s = %s' % (self.MaxLen + 15, ModulePath, Value))\r

 \r
 \r

-        if ModulePcdSet == None:\r
+        if ModulePcdSet is None:\r

             FileWrite(File, gSectionEnd)\r
         else:\r
             if not ReportSubType and ModulePcdSet:\r
                 FileWrite(File, gSubSectionEnd)\r
 \r
             FileWrite(File, gSectionEnd)\r
         else:\r
             if not ReportSubType and ModulePcdSet:\r
                 FileWrite(File, gSubSectionEnd)\r
 \r

+    def ParseStruct(self, struct):\r
+        HasDscOverride = False\r
+        if struct:\r
+            for _, Values in list(struct.items()):\r
+                for Key, value in Values.items():\r
+                    if value[1] and value[1].endswith('.dsc'):\r
+                        HasDscOverride = True\r
+                        break\r
+                if HasDscOverride == True:\r
+                    break\r
+        return HasDscOverride\r

 \r
     def PrintPcdDefault(self, File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue):\r
 \r
     def PrintPcdDefault(self, File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue):\r

-        if not DscMatch and DscDefaultValue != None:\r
+        if not DscMatch and DscDefaultValue is not None:\r

             Value = DscDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', "{"))\r
                 for Array in ArrayList:\r
             Value = DscDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', "{"))\r
                 for Array in ArrayList:\r

-                    FileWrite(File, '%s' % (Array))\r
+                    FileWrite(File, Array)\r

             else:\r
             else:\r

+                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                    if Value.startswith(('0x', '0X')):\r
+                        Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                    else:\r
+                        Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', Value))\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DSC DEFAULT', Value))\r

-        if not InfMatch and InfDefaultValue != None:\r
+        if not InfMatch and InfDefaultValue is not None:\r

             Value = InfDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', "{"))\r
                 for Array in ArrayList:\r
             Value = InfDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', "{"))\r
                 for Array in ArrayList:\r

-                    FileWrite(File, '%s' % (Array))\r
+                    FileWrite(File, Array)\r

             else:\r
             else:\r

+                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                    if Value.startswith(('0x', '0X')):\r
+                        Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                    else:\r
+                        Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', Value))\r
 \r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'INF DEFAULT', Value))\r
 \r

-        if not DecMatch and DecDefaultValue != None:\r
+        if not DecMatch and DecDefaultValue is not None:\r

             Value = DecDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', "{"))\r
                 for Array in ArrayList:\r
             Value = DecDefaultValue.strip()\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
             if IsByteArray:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', "{"))\r
                 for Array in ArrayList:\r

-                    FileWrite(File, '%s' % (Array))\r
+                    FileWrite(File, Array)\r

             else:\r
             else:\r

+                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                    if Value.startswith(('0x', '0X')):\r
+                        Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                    else:\r
+                        Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', Value))\r
             if IsStructure:\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', Value))\r
             if IsStructure:\r

-                self.PrintStructureInfo(File, Pcd.DefaultValues)\r
+                for filedvalues in Pcd.DefaultValues.values():\r
+                    self.PrintStructureInfo(File, filedvalues)\r
+        if DecMatch and IsStructure:\r
+            for filedvalues in Pcd.DefaultValues.values():\r
+                self.PrintStructureInfo(File, filedvalues)\r

 \r
     def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = '  '):\r
         if not Pcd.SkuInfoList:\r
 \r
     def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = '  '):\r
         if not Pcd.SkuInfoList:\r


@@ -1121,16 +1270,33 @@ class PcdReport(object):
             if IsByteArray:\r
                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))\r
                 for Array in ArrayList:\r
             if IsByteArray:\r
                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '{'))\r
                 for Array in ArrayList:\r

-                    FileWrite(File, '%s' % (Array))\r
+                    FileWrite(File, Array)\r

             else:\r
             else:\r

+                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                    if Value.startswith('0') and not Value.lower().startswith('0x') and len(Value) > 1 and Value.lstrip('0'):\r
+                        Value = Value.lstrip('0')\r
+                    if Value.startswith(('0x', '0X')):\r
+                        Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                    else:\r
+                        Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
             if IsStructure:\r
                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
             if IsStructure:\r

-                OverrideValues = Pcd.SkuOverrideValues\r
+                FiledOverrideFlag = False\r
+                if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) in GlobalData.gPcdSkuOverrides:\r
+                    OverrideValues = GlobalData.gPcdSkuOverrides[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
+                else:\r
+                    OverrideValues = Pcd.SkuOverrideValues\r

                 if OverrideValues:\r
                 if OverrideValues:\r

-                    Keys = OverrideValues.keys()\r
-                    Data = OverrideValues[Keys[0]]\r
-                    Struct = Data.values()[0]\r
-                    self.PrintStructureInfo(File, Struct)\r
+                    for Data in OverrideValues.values():\r
+                        Struct = list(Data.values())\r
+                        if Struct:\r
+                            OverrideFieldStruct = self.OverrideFieldValue(Pcd, Struct[0])\r
+                            self.PrintStructureInfo(File, OverrideFieldStruct)\r
+                            FiledOverrideFlag = True\r
+                            break\r
+                if not FiledOverrideFlag and (Pcd.PcdFieldValueFromComm or Pcd.PcdFieldValueFromFdf):\r
+                    OverrideFieldStruct = self.OverrideFieldValue(Pcd, {})\r
+                    self.PrintStructureInfo(File, OverrideFieldStruct)\r

             self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
         else:\r
             FirstPrint = True\r
             self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
         else:\r
             FirstPrint = True\r


@@ -1144,6 +1310,8 @@ class PcdReport(object):
                         for DefaultStore in DefaultStoreList:\r
                             Value = SkuInfo.DefaultStoreDict[DefaultStore]\r
                             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
                         for DefaultStore in DefaultStoreList:\r
                             Value = SkuInfo.DefaultStoreDict[DefaultStore]\r
                             IsByteArray, ArrayList = ByteArrayForamt(Value)\r

+                            if Pcd.DatumType == 'BOOLEAN':\r
+                                Value = str(int(Value, 0))\r

                             if FirstPrint:\r
                                 FirstPrint = False\r
                                 if IsByteArray:\r
                             if FirstPrint:\r
                                 FirstPrint = False\r
                                 if IsByteArray:\r


@@ -1156,8 +1324,13 @@ class PcdReport(object):
                                     else:\r
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r
                                     for Array in ArrayList:\r
                                     else:\r
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r
                                     for Array in ArrayList:\r

-                                        FileWrite(File, '%s' % (Array))\r
+                                        FileWrite(File, Array)\r

                                 else:\r
                                 else:\r

+                                    if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                                        if Value.startswith(('0x', '0X')):\r
+                                            Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                                        else:\r
+                                            Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                                     if self.DefaultStoreSingle and self.SkuSingle:\r
                                         FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
                                     elif self.DefaultStoreSingle and not self.SkuSingle:\r
                                     if self.DefaultStoreSingle and self.SkuSingle:\r
                                         FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
                                     elif self.DefaultStoreSingle and not self.SkuSingle:\r


@@ -1177,8 +1350,13 @@ class PcdReport(object):
                                     else:\r
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r
                                     for Array in ArrayList:\r
                                     else:\r
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', '{'))\r
                                     for Array in ArrayList:\r

-                                        FileWrite(File, '%s' % (Array))\r
+                                        FileWrite(File, Array)\r

                                 else:\r
                                 else:\r

+                                    if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                                        if Value.startswith(('0x', '0X')):\r
+                                            Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                                        else:\r
+                                            Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                                     if self.DefaultStoreSingle and self.SkuSingle:\r
                                         FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')',  Value))\r
                                     elif self.DefaultStoreSingle and not self.SkuSingle:\r
                                     if self.DefaultStoreSingle and self.SkuSingle:\r
                                         FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')',  Value))\r
                                     elif self.DefaultStoreSingle and not self.SkuSingle:\r


@@ -1190,12 +1368,14 @@ class PcdReport(object):
                             FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))\r
                             if IsStructure:\r
                                 OverrideValues = Pcd.SkuOverrideValues[Sku]\r
                             FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))\r
                             if IsStructure:\r
                                 OverrideValues = Pcd.SkuOverrideValues[Sku]\r

-                                Struct = OverrideValues[DefaultStore]\r
-                                self.PrintStructureInfo(File, Struct)\r
+                                OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[DefaultStore])\r
+                                self.PrintStructureInfo(File, OverrideFieldStruct)\r

                             self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
                 else:\r
                     Value = SkuInfo.DefaultValue\r
                     IsByteArray, ArrayList = ByteArrayForamt(Value)\r
                             self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
                 else:\r
                     Value = SkuInfo.DefaultValue\r
                     IsByteArray, ArrayList = ByteArrayForamt(Value)\r

+                    if Pcd.DatumType == 'BOOLEAN':\r
+                        Value = str(int(Value, 0))\r

                     if FirstPrint:\r
                         FirstPrint = False\r
                         if IsByteArray:\r
                     if FirstPrint:\r
                         FirstPrint = False\r
                         if IsByteArray:\r


@@ -1204,8 +1384,13 @@ class PcdReport(object):
                             else:\r
                                 FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r
                             for Array in ArrayList:\r
                             else:\r
                                 FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r
                             for Array in ArrayList:\r

-                                FileWrite(File, '%s' % (Array))\r
+                                FileWrite(File, Array)\r

                         else:\r
                         else:\r

+                            if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                                if Value.startswith(('0x', '0X')):\r
+                                    Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                                else:\r
+                                    Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                             if self.SkuSingle:\r
                                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
                             else:\r
                             if self.SkuSingle:\r
                                 FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, Flag + ' ' + PcdTokenCName, TypeName, '(' + Pcd.DatumType + ')', Value))\r
                             else:\r


@@ -1213,37 +1398,66 @@ class PcdReport(object):
                     else:\r
                         if IsByteArray:\r
                             if self.SkuSingle:\r
                     else:\r
                         if IsByteArray:\r
                             if self.SkuSingle:\r

-                                FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', "{"))\r
+                                FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', "{"))\r

                             else:\r
                             else:\r

-                                FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r
+                                FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', "{"))\r

                             for Array in ArrayList:\r
                             for Array in ArrayList:\r

-                                FileWrite(File, '%s' % (Array))\r
+                                FileWrite(File, Array)\r

                         else:\r
                         else:\r

+                            if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
+                                if Value.startswith(('0x', '0X')):\r
+                                    Value = '{} ({:d})'.format(Value, int(Value, 0))\r
+                                else:\r
+                                    Value = "0x{:X} ({})".format(int(Value, 0), Value)\r

                             if self.SkuSingle:\r
                             if self.SkuSingle:\r

-                                FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', Value))\r
+                                FileWrite(File, ' %-*s   : %6s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', Value))\r

                             else:\r
                             else:\r

-                                FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, ' ' , TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r
+                                FileWrite(File, ' %-*s   : %6s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', Value))\r

                     if TypeName in ('DYNVPD', 'DEXVPD'):\r
                         FileWrite(File, '%*s' % (self.MaxLen + 4, SkuInfo.VpdOffset))\r
                     if TypeName in ('DYNVPD', 'DEXVPD'):\r
                         FileWrite(File, '%*s' % (self.MaxLen + 4, SkuInfo.VpdOffset))\r

+                        VPDPcdItem = (Pcd.TokenSpaceGuidCName + '.' + PcdTokenCName, SkuIdName, SkuInfo.VpdOffset, Pcd.MaxDatumSize, SkuInfo.DefaultValue)\r
+                        if VPDPcdItem not in VPDPcdList:\r
+                            VPDPcdList.append(VPDPcdItem)\r

                     if IsStructure:\r
                     if IsStructure:\r

+                        FiledOverrideFlag = False\r

                         OverrideValues = Pcd.SkuOverrideValues[Sku]\r
                         if OverrideValues:\r
                         OverrideValues = Pcd.SkuOverrideValues[Sku]\r
                         if OverrideValues:\r

-                            Keys = OverrideValues.keys()\r
-                            Struct = OverrideValues[Keys[0]]\r
-                            self.PrintStructureInfo(File, Struct)\r
+                            Keys = list(OverrideValues.keys())\r
+                            OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])\r
+                            self.PrintStructureInfo(File, OverrideFieldStruct)\r
+                            FiledOverrideFlag = True\r
+                        if not FiledOverrideFlag and (Pcd.PcdFieldValueFromComm or Pcd.PcdFieldValueFromFdf):\r
+                            OverrideFieldStruct = self.OverrideFieldValue(Pcd, {})\r
+                            self.PrintStructureInfo(File, OverrideFieldStruct)\r

                     self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
 \r
                     self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
 \r

+    def OverrideFieldValue(self, Pcd, OverrideStruct):\r
+        OverrideFieldStruct = collections.OrderedDict()\r
+        if OverrideStruct:\r
+            for _, Values in OverrideStruct.items():\r
+                for Key,value in Values.items():\r
+                    if value[1] and value[1].endswith('.dsc'):\r
+                        OverrideFieldStruct[Key] = value\r
+        if Pcd.PcdFieldValueFromFdf:\r
+            for Key, Values in Pcd.PcdFieldValueFromFdf.items():\r
+                if Key in OverrideFieldStruct and Values[0] == OverrideFieldStruct[Key][0]:\r
+                    continue\r
+                OverrideFieldStruct[Key] = Values\r
+        if Pcd.PcdFieldValueFromComm:\r
+            for Key, Values in Pcd.PcdFieldValueFromComm.items():\r
+                if Key in OverrideFieldStruct and Values[0] == OverrideFieldStruct[Key][0]:\r
+                    continue\r
+                OverrideFieldStruct[Key] = Values\r
+        return OverrideFieldStruct\r
+\r

     def PrintStructureInfo(self, File, Struct):\r
     def PrintStructureInfo(self, File, Struct):\r

-        NewInfo = collections.OrderedDict()\r
-        for Key, Value in Struct.items():\r
-            if Key not in NewInfo:\r
-                NewInfo[Key] = Value[0]\r
+        for Key, Value in sorted(Struct.items(), key=lambda x: x[0]):\r
+            if Value[1] and 'build command options' in Value[1]:\r
+                FileWrite(File, '    *B  %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r
+            elif Value[1] and Value[1].endswith('.fdf'):\r
+                FileWrite(File, '    *F  %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r

             else:\r
             else:\r

-                del NewInfo[Key]\r
-                NewInfo[Key] = Value[0]\r
-        if NewInfo:\r
-            for item in NewInfo:\r
-                FileWrite(File, '        %-*s = %s' % (self.MaxLen + 4, '.' + item, NewInfo[item]))\r
+                FileWrite(File, '        %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r

 \r
     def StrtoHex(self, value):\r
         try:\r
 \r
     def StrtoHex(self, value):\r
         try:\r


@@ -1275,6 +1489,12 @@ class PcdReport(object):
             else:\r
                 return value\r
 \r
             else:\r
                 return value\r
 \r

+    def IsStructurePcd(self, PcdToken, PcdTokenSpaceGuid):\r
+        if GlobalData.gStructurePcd and (self.Arch in GlobalData.gStructurePcd) and ((PcdToken, PcdTokenSpaceGuid) in GlobalData.gStructurePcd[self.Arch]):\r
+            return True\r
+        else:\r
+            return False\r
+\r

 ##\r
 # Reports platform and module Prediction information\r
 #\r
 ##\r
 # Reports platform and module Prediction information\r
 #\r


@@ -1313,7 +1533,7 @@ class PredictionReport(object):
                 # their source code to find PPI/Protocol produce or consume\r
                 # information.\r
                 #\r
                 # their source code to find PPI/Protocol produce or consume\r
                 # information.\r
                 #\r

-                if Module.ModuleType == "BASE":\r
+                if Module.ModuleType == SUP_MODULE_BASE:\r

                     continue\r
                 #\r
                 # Add module referenced source files\r
                     continue\r
                 #\r
                 # Add module referenced source files\r


@@ -1336,15 +1556,8 @@ class PredictionReport(object):
 \r
                 if Module.Guid and not Module.IsLibrary:\r
                     EntryPoint = " ".join(Module.Module.ModuleEntryPointList)\r
 \r
                 if Module.Guid and not Module.IsLibrary:\r
                     EntryPoint = " ".join(Module.Module.ModuleEntryPointList)\r

-                    if int(str(Module.AutoGenVersion), 0) >= 0x00010005:\r
-                        RealEntryPoint = "_ModuleEntryPoint"\r
-                    else:\r
-                        RealEntryPoint = EntryPoint\r
-                        if EntryPoint == "_ModuleEntryPoint":\r
-                            CCFlags = Module.BuildOption.get("CC", {}).get("FLAGS", "")\r
-                            Match = gGlueLibEntryPoint.search(CCFlags)\r
-                            if Match:\r
-                                EntryPoint = Match.group(1)\r
+\r
+                    RealEntryPoint = "_ModuleEntryPoint"\r

 \r
                     self._FfsEntryPoint[Module.Guid.upper()] = (EntryPoint, RealEntryPoint)\r
 \r
 \r
                     self._FfsEntryPoint[Module.Guid.upper()] = (EntryPoint, RealEntryPoint)\r
 \r


@@ -1356,7 +1569,7 @@ class PredictionReport(object):
         if Wa.FdfProfile:\r
             for Fd in Wa.FdfProfile.FdDict:\r
                 for FdRegion in Wa.FdfProfile.FdDict[Fd].RegionList:\r
         if Wa.FdfProfile:\r
             for Fd in Wa.FdfProfile.FdDict:\r
                 for FdRegion in Wa.FdfProfile.FdDict[Fd].RegionList:\r

-                    if FdRegion.RegionType != "FV":\r
+                    if FdRegion.RegionType != BINARY_FILE_TYPE_FV:\r

                         continue\r
                     for FvName in FdRegion.RegionDataList:\r
                         if FvName in self._FvList:\r
                         continue\r
                     for FvName in FdRegion.RegionDataList:\r
                         if FvName in self._FvList:\r


@@ -1429,17 +1642,17 @@ class PredictionReport(object):
         GuidList = os.path.join(self._EotDir, "GuidList.txt")\r
         DispatchList = os.path.join(self._EotDir, "Dispatch.txt")\r
 \r
         GuidList = os.path.join(self._EotDir, "GuidList.txt")\r
         DispatchList = os.path.join(self._EotDir, "Dispatch.txt")\r
 \r

-        TempFile = open(SourceList, "w+")\r
+        TempFile = []\r

         for Item in self._SourceList:\r
             FileWrite(TempFile, Item)\r
         for Item in self._SourceList:\r
             FileWrite(TempFile, Item)\r

-        TempFile.close()\r
-        TempFile = open(GuidList, "w+")\r
+        SaveFileOnChange(SourceList, "".join(TempFile), False)\r
+        TempFile = []\r

         for Key in self._GuidMap:\r
             FileWrite(TempFile, "%s %s" % (Key, self._GuidMap[Key]))\r
         for Key in self._GuidMap:\r
             FileWrite(TempFile, "%s %s" % (Key, self._GuidMap[Key]))\r

-        TempFile.close()\r
+        SaveFileOnChange(GuidList, "".join(TempFile), False)\r

 \r
         try:\r
 \r
         try:\r

-            from Eot.Eot import Eot\r
+            from Eot.EotMain import Eot\r

 \r
             #\r
             # Invoke EOT tool and echo its runtime performance\r
 \r
             #\r
             # Invoke EOT tool and echo its runtime performance\r


@@ -1450,7 +1663,7 @@ class PredictionReport(object):
             EotEndTime = time.time()\r
             EotDuration = time.strftime("%H:%M:%S", time.gmtime(int(round(EotEndTime - EotStartTime))))\r
             EdkLogger.quiet("EOT run time: %s\n" % EotDuration)\r
             EotEndTime = time.time()\r
             EotDuration = time.strftime("%H:%M:%S", time.gmtime(int(round(EotEndTime - EotStartTime))))\r
             EdkLogger.quiet("EOT run time: %s\n" % EotDuration)\r

-            \r
+\r

             #\r
             # Parse the output of EOT tool\r
             #\r
             #\r
             # Parse the output of EOT tool\r
             #\r


@@ -1626,12 +1839,13 @@ class FdRegionReport(object):
         self.FvInfo = {}\r
         self._GuidsDb = {}\r
         self._FvDir = Wa.FvDir\r
         self.FvInfo = {}\r
         self._GuidsDb = {}\r
         self._FvDir = Wa.FvDir\r

+        self._WorkspaceDir = Wa.WorkspaceDir\r

 \r
         #\r
         # If the input FdRegion is not a firmware volume,\r
         # we are done.\r
         #\r
 \r
         #\r
         # If the input FdRegion is not a firmware volume,\r
         # we are done.\r
         #\r

-        if self.Type != "FV":\r
+        if self.Type != BINARY_FILE_TYPE_FV:\r

             return\r
 \r
         #\r
             return\r
 \r
         #\r


@@ -1647,7 +1861,7 @@ class FdRegionReport(object):
         PlatformPcds = {}\r
         #\r
         # Collect PCDs declared in DEC files.\r
         PlatformPcds = {}\r
         #\r
         # Collect PCDs declared in DEC files.\r

-        #        \r
+        #\r

         for Pa in Wa.AutoGenObjectList:\r
             for Package in Pa.PackageList:\r
                 for (TokenCName, TokenSpaceGuidCName, DecType) in Package.Pcds:\r
         for Pa in Wa.AutoGenObjectList:\r
             for Package in Pa.PackageList:\r
                 for (TokenCName, TokenSpaceGuidCName, DecType) in Package.Pcds:\r


@@ -1664,8 +1878,8 @@ class FdRegionReport(object):
         #\r
         # Add PEI and DXE a priori files GUIDs defined in PI specification.\r
         #\r
         #\r
         # Add PEI and DXE a priori files GUIDs defined in PI specification.\r
         #\r

-        self._GuidsDb["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"\r
-        self._GuidsDb["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"\r
+        self._GuidsDb[PEI_APRIORI_GUID] = "PEI Apriori"\r
+        self._GuidsDb[DXE_APRIORI_GUID] = "DXE Apriori"\r

         #\r
         # Add ACPI table storage file\r
         #\r
         #\r
         # Add ACPI table storage file\r
         #\r


@@ -1725,11 +1939,19 @@ class FdRegionReport(object):
         FileWrite(File, "Type:               %s" % Type)\r
         FileWrite(File, "Base Address:       0x%X" % BaseAddress)\r
 \r
         FileWrite(File, "Type:               %s" % Type)\r
         FileWrite(File, "Base Address:       0x%X" % BaseAddress)\r
 \r

-        if self.Type == "FV":\r
+        if self.Type == BINARY_FILE_TYPE_FV:\r

             FvTotalSize = 0\r
             FvTakenSize = 0\r
             FvFreeSize  = 0\r
             FvTotalSize = 0\r
             FvTakenSize = 0\r
             FvFreeSize  = 0\r

-            FvReportFileName = os.path.join(self._FvDir, FvName + ".Fv.txt")\r
+            if FvName.upper().endswith('.FV'):\r
+                FileExt = FvName + ".txt"\r
+            else:\r
+                FileExt = FvName + ".Fv.txt"\r
+\r
+            if not os.path.isfile(FileExt):\r
+                FvReportFileName = mws.join(self._WorkspaceDir, FileExt)\r
+                if not os.path.isfile(FvReportFileName):\r
+                    FvReportFileName = os.path.join(self._FvDir, FileExt)\r

             try:\r
                 #\r
                 # Collect size info in the firmware volume.\r
             try:\r
                 #\r
                 # Collect size info in the firmware volume.\r


@@ -1758,8 +1980,7 @@ class FdRegionReport(object):
                 for Match in gOffsetGuidPattern.finditer(FvReport):\r
                     Guid = Match.group(2).upper()\r
                     OffsetInfo[Match.group(1)] = self._GuidsDb.get(Guid, Guid)\r
                 for Match in gOffsetGuidPattern.finditer(FvReport):\r
                     Guid = Match.group(2).upper()\r
                     OffsetInfo[Match.group(1)] = self._GuidsDb.get(Guid, Guid)\r

-                OffsetList = OffsetInfo.keys()\r
-                OffsetList.sort()\r
+                OffsetList = sorted(OffsetInfo.keys())\r

                 for Offset in OffsetList:\r
                     FileWrite (File, "%s %s" % (Offset, OffsetInfo[Offset]))\r
             except IOError:\r
                 for Offset in OffsetList:\r
                     FileWrite (File, "%s %s" % (Offset, OffsetInfo[Offset]))\r
             except IOError:\r


@@ -1780,7 +2001,7 @@ class FdRegionReport(object):
         if (len(self.FvList) > 0):\r
             for FvItem in self.FvList:\r
                 Info = self.FvInfo[FvItem]\r
         if (len(self.FvList) > 0):\r
             for FvItem in self.FvList:\r
                 Info = self.FvInfo[FvItem]\r

-                self._GenerateReport(File, Info[0], "FV", Info[1], Info[2], FvItem)\r
+                self._GenerateReport(File, Info[0], TAB_FV_DIRECTORY, Info[1], Info[2], FvItem)\r

         else:\r
             self._GenerateReport(File, "FD Region", self.Type, self.BaseAddress, self.Size)\r
 \r
         else:\r
             self._GenerateReport(File, "FD Region", self.Type, self.BaseAddress, self.Size)\r
 \r


@@ -1806,36 +2027,15 @@ class FdReport(object):
         self.BaseAddress = Fd.BaseAddress\r
         self.Size = Fd.Size\r
         self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]\r
         self.BaseAddress = Fd.BaseAddress\r
         self.Size = Fd.Size\r
         self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]\r

-        self.FvPath = os.path.join(Wa.BuildDir, "FV")\r
-        self.VpdFilePath = os.path.join(self.FvPath, "%s.map" % Wa.Platform.VpdToolGuid)\r
+        self.FvPath = os.path.join(Wa.BuildDir, TAB_FV_DIRECTORY)\r

         self.VPDBaseAddress = 0\r
         self.VPDSize = 0\r
         self.VPDBaseAddress = 0\r
         self.VPDSize = 0\r

-        self.VPDInfoList = []\r

         for index, FdRegion in enumerate(Fd.RegionList):\r
             if str(FdRegion.RegionType) is 'FILE' and Wa.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r
                 self.VPDBaseAddress = self.FdRegionList[index].BaseAddress\r
                 self.VPDSize = self.FdRegionList[index].Size\r
                 break\r
 \r
         for index, FdRegion in enumerate(Fd.RegionList):\r
             if str(FdRegion.RegionType) is 'FILE' and Wa.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r
                 self.VPDBaseAddress = self.FdRegionList[index].BaseAddress\r
                 self.VPDSize = self.FdRegionList[index].Size\r
                 break\r
 \r

-        if os.path.isfile(self.VpdFilePath):\r
-            fd = open(self.VpdFilePath, "r")\r
-            Lines = fd.readlines()\r
-            for Line in Lines:\r
-                Line = Line.strip()\r
-                if len(Line) == 0 or Line.startswith("#"):\r
-                    continue\r
-                try:\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
-                    if Offset.lower().startswith('0x'):\r
-                        Offset = '0x%08X' % (int(Offset, 16) + self.VPDBaseAddress)\r
-                    else:\r
-                        Offset = '0x%08X' % (int(Offset, 10) + self.VPDBaseAddress)\r
-                    self.VPDInfoList.append("%s | %s | %s | %s | %s" % (PcdName, SkuId, Offset, Size, Value))\r
-                except:\r
-                    EdkLogger.error("BuildReport", CODE_ERROR, "Fail to parse VPD information file %s" % self.VpdFilePath)\r
-            fd.close()\r
-\r

     ##\r
     # Generate report for the firmware device.\r
     #\r
     ##\r
     # Generate report for the firmware device.\r
     #\r


@@ -1855,23 +2055,26 @@ class FdReport(object):
             for FdRegionItem in self.FdRegionList:\r
                 FdRegionItem.GenerateReport(File)\r
 \r
             for FdRegionItem in self.FdRegionList:\r
                 FdRegionItem.GenerateReport(File)\r
 \r

-        if len(self.VPDInfoList) > 0:\r
+        if VPDPcdList:\r
+            VPDPcdList.sort(key=lambda x: int(x[2], 0))\r

             FileWrite(File, gSubSectionStart)\r
             FileWrite(File, "FD VPD Region")\r
             FileWrite(File, "Base Address:       0x%X" % self.VPDBaseAddress)\r
             FileWrite(File, "Size:               0x%X (%.0fK)" % (self.VPDSize, self.VPDSize / 1024.0))\r
             FileWrite(File, gSubSectionSep)\r
             FileWrite(File, gSubSectionStart)\r
             FileWrite(File, "FD VPD Region")\r
             FileWrite(File, "Base Address:       0x%X" % self.VPDBaseAddress)\r
             FileWrite(File, "Size:               0x%X (%.0fK)" % (self.VPDSize, self.VPDSize / 1024.0))\r
             FileWrite(File, gSubSectionSep)\r

-            for item in self.VPDInfoList:\r
-                ValueList = item.split('|')\r
-                Value = ValueList[-1].strip()\r
-                IsByteArray, ArrayList = ByteArrayForamt(Value)\r
+            for item in VPDPcdList:\r
+                # Add BaseAddress for offset\r
+                Offset = '0x%08X' % (int(item[2], 16) + self.VPDBaseAddress)\r
+                IsByteArray, ArrayList = ByteArrayForamt(item[-1])\r
+                Skuinfo = item[1]\r
+                if len(GlobalData.gSkuids) == 1 :\r
+                    Skuinfo = GlobalData.gSkuids[0]\r

                 if IsByteArray:\r
                 if IsByteArray:\r

-                    ValueList[-1] = ' {'\r
-                    FileWrite(File, '|'.join(ValueList))\r
+                    FileWrite(File, "%s | %s | %s | %s | %s" % (item[0], Skuinfo, Offset, item[3], '{'))\r

                     for Array in ArrayList:\r
                     for Array in ArrayList:\r

-                        FileWrite(File, '%s' % (Array))\r
+                        FileWrite(File, Array)\r

                 else:\r
                 else:\r

-                    FileWrite(File, item)\r
+                    FileWrite(File, "%s | %s | %s | %s | %s" % (item[0], Skuinfo, Offset, item[3], item[-1]))\r

             FileWrite(File, gSubSectionEnd)\r
         FileWrite(File, gSectionEnd)\r
 \r
             FileWrite(File, gSubSectionEnd)\r
         FileWrite(File, gSectionEnd)\r
 \r


@@ -1909,7 +2112,7 @@ class PlatformReport(object):
             self.PcdReport = PcdReport(Wa)\r
 \r
         self.FdReportList = []\r
             self.PcdReport = PcdReport(Wa)\r
 \r
         self.FdReportList = []\r

-        if "FLASH" in ReportType and Wa.FdfProfile and MaList == None:\r
+        if "FLASH" in ReportType and Wa.FdfProfile and MaList is None:\r

             for Fd in Wa.FdfProfile.FdDict:\r
                 self.FdReportList.append(FdReport(Wa.FdfProfile.FdDict[Fd], Wa))\r
 \r
             for Fd in Wa.FdfProfile.FdDict:\r
                 self.FdReportList.append(FdReport(Wa.FdfProfile.FdDict[Fd], Wa))\r
 \r


@@ -1920,9 +2123,9 @@ class PlatformReport(object):
         self.DepexParser = None\r
         if "DEPEX" in ReportType:\r
             self.DepexParser = DepexParser(Wa)\r
         self.DepexParser = None\r
         if "DEPEX" in ReportType:\r
             self.DepexParser = DepexParser(Wa)\r

-            \r
+\r

         self.ModuleReportList = []\r
         self.ModuleReportList = []\r

-        if MaList != None:\r
+        if MaList is not None:\r

             self._IsModuleBuild = True\r
             for Ma in MaList:\r
                 self.ModuleReportList.append(ModuleReport(Ma, ReportType))\r
             self._IsModuleBuild = True\r
             for Ma in MaList:\r
                 self.ModuleReportList.append(ModuleReport(Ma, ReportType))\r


@@ -1932,13 +2135,13 @@ class PlatformReport(object):
                 ModuleAutoGenList = []\r
                 for ModuleKey in Pa.Platform.Modules:\r
                     ModuleAutoGenList.append(Pa.Platform.Modules[ModuleKey].M)\r
                 ModuleAutoGenList = []\r
                 for ModuleKey in Pa.Platform.Modules:\r
                     ModuleAutoGenList.append(Pa.Platform.Modules[ModuleKey].M)\r

-                if GlobalData.gFdfParser != None:\r
+                if GlobalData.gFdfParser is not None:\r

                     if Pa.Arch in GlobalData.gFdfParser.Profile.InfDict:\r
                         INFList = GlobalData.gFdfParser.Profile.InfDict[Pa.Arch]\r
                         for InfName in INFList:\r
                             InfClass = PathClass(NormPath(InfName), Wa.WorkspaceDir, Pa.Arch)\r
                             Ma = ModuleAutoGen(Wa, InfClass, Pa.BuildTarget, Pa.ToolChain, Pa.Arch, Wa.MetaFile)\r
                     if Pa.Arch in GlobalData.gFdfParser.Profile.InfDict:\r
                         INFList = GlobalData.gFdfParser.Profile.InfDict[Pa.Arch]\r
                         for InfName in INFList:\r
                             InfClass = PathClass(NormPath(InfName), Wa.WorkspaceDir, Pa.Arch)\r
                             Ma = ModuleAutoGen(Wa, InfClass, Pa.BuildTarget, Pa.ToolChain, Pa.Arch, Wa.MetaFile)\r

-                            if Ma == None:\r
+                            if Ma is None:\r

                                 continue\r
                             if Ma not in ModuleAutoGenList:\r
                                 ModuleAutoGenList.append(Ma)\r
                                 continue\r
                             if Ma not in ModuleAutoGenList:\r
                                 ModuleAutoGenList.append(Ma)\r


@@ -1995,7 +2198,7 @@ class PlatformReport(object):
         if not self._IsModuleBuild:\r
             if "PCD" in ReportType:\r
                 self.PcdReport.GenerateReport(File, None)\r
         if not self._IsModuleBuild:\r
             if "PCD" in ReportType:\r
                 self.PcdReport.GenerateReport(File, None)\r

-    \r
+\r

             if "FLASH" in ReportType:\r
                 for FdReportListItem in self.FdReportList:\r
                     FdReportListItem.GenerateReport(File)\r
             if "FLASH" in ReportType:\r
                 for FdReportListItem in self.FdReportList:\r
                     FdReportListItem.GenerateReport(File)\r


@@ -2029,7 +2232,7 @@ class BuildReport(object):
         if ReportFile:\r
             self.ReportList = []\r
             self.ReportType = []\r
         if ReportFile:\r
             self.ReportList = []\r
             self.ReportType = []\r

-            if ReportType: \r
+            if ReportType:\r

                 for ReportTypeItem in ReportType:\r
                     if ReportTypeItem not in self.ReportType:\r
                         self.ReportType.append(ReportTypeItem)\r
                 for ReportTypeItem in ReportType:\r
                     if ReportTypeItem not in self.ReportType:\r
                         self.ReportType.append(ReportTypeItem)\r


@@ -2063,19 +2266,18 @@ class BuildReport(object):
     def GenerateReport(self, BuildDuration, AutoGenTime, MakeTime, GenFdsTime):\r
         if self.ReportFile:\r
             try:\r
     def GenerateReport(self, BuildDuration, AutoGenTime, MakeTime, GenFdsTime):\r
         if self.ReportFile:\r
             try:\r

-                File = StringIO('')\r
+                File = []\r

                 for (Wa, MaList) in self.ReportList:\r
                     PlatformReport(Wa, MaList, self.ReportType).GenerateReport(File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, self.ReportType)\r
                 for (Wa, MaList) in self.ReportList:\r
                     PlatformReport(Wa, MaList, self.ReportType).GenerateReport(File, BuildDuration, AutoGenTime, MakeTime, GenFdsTime, self.ReportType)\r

-                Content = FileLinesSplit(File.getvalue(), gLineMaxLength)\r
-                SaveFileOnChange(self.ReportFile, Content, True)\r
+                Content = FileLinesSplit(''.join(File), gLineMaxLength)\r
+                SaveFileOnChange(self.ReportFile, Content, False)\r

                 EdkLogger.quiet("Build report can be found at %s" % os.path.abspath(self.ReportFile))\r
             except IOError:\r
                 EdkLogger.error(None, FILE_WRITE_FAILURE, ExtraData=self.ReportFile)\r
             except:\r
                 EdkLogger.error("BuildReport", CODE_ERROR, "Unknown fatal error when generating build report", ExtraData=self.ReportFile, RaiseError=False)\r
                 EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))\r
                 EdkLogger.quiet("Build report can be found at %s" % os.path.abspath(self.ReportFile))\r
             except IOError:\r
                 EdkLogger.error(None, FILE_WRITE_FAILURE, ExtraData=self.ReportFile)\r
             except:\r
                 EdkLogger.error("BuildReport", CODE_ERROR, "Unknown fatal error when generating build report", ExtraData=self.ReportFile, RaiseError=False)\r
                 EdkLogger.quiet("(Python %s on %s\n%s)" % (platform.python_version(), sys.platform, traceback.format_exc()))\r

-            File.close()\r
-            \r
+\r

 # This acts like the main() function for the script, unless it is 'import'ed into another script.\r
 if __name__ == '__main__':\r
     pass\r
 # This acts like the main() function for the script, unless it is 'import'ed into another script.\r
 if __name__ == '__main__':\r
     pass\r