UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm

[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 27680019dceb5f8a3c5174187c7710f255c0c358..468772930ca19613a9f751b36b1b77eece2f442b 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


@@ -40,12 +34,13 @@ from Common.BuildToolError import FORMAT_INVALID
 from Common.LongFilePathSupport import OpenLongFilePath as open\r
 from Common.MultipleWorkspace import MultipleWorkspace as mws\r
 import Common.GlobalData as GlobalData\r
 from Common.LongFilePathSupport import OpenLongFilePath as open\r
 from Common.MultipleWorkspace import MultipleWorkspace as mws\r
 import Common.GlobalData as GlobalData\r

-from AutoGen.AutoGen import ModuleAutoGen\r
+from AutoGen.ModuleAutoGen import ModuleAutoGen\r

 from Common.Misc import PathClass\r
 from Common.StringUtils import NormPath\r
 from Common.DataType import *\r
 import collections\r
 from Common.Expression import *\r
 from Common.Misc import PathClass\r
 from Common.StringUtils import NormPath\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


@@ -65,7 +60,7 @@ gPcdGuidPattern = re.compile(r"PCD\((\w+)[.](\w+)\)")
 gOffsetGuidPattern = re.compile(r"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")\r
 \r
 ## Pattern to find module base address and entry point in fixed flash map file\r
 gOffsetGuidPattern = re.compile(r"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")\r
 \r
 ## Pattern to find module base address and entry point in fixed flash map file\r

-gModulePattern = r"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"\r
+gModulePattern = r"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s,\s*Type=\w+\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"\r

 gMapFileItemPattern = re.compile(gModulePattern % {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})\r
 \r
 ## Pattern to find all module referenced header files in source files\r
 gMapFileItemPattern = re.compile(gModulePattern % {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})\r
 \r
 ## Pattern to find all module referenced header files in source files\r


@@ -126,6 +121,9 @@ gDriverTypeMap = {
 ## 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
 ## 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


@@ -139,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


@@ -246,7 +244,7 @@ def FileLinesSplit(Content=None, MaxLength=None):
     for NewLine in NewContentList:\r
         NewContent += NewLine + TAB_LINE_BREAK\r
 \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
+    NewContent = NewContent.replace(gEndOfLine, TAB_LINE_BREAK).replace('\r\r\n', gEndOfLine)\r

     return NewContent\r
 \r
 \r
     return NewContent\r
 \r
 \r


@@ -328,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


@@ -364,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


@@ -569,6 +558,7 @@ class ModuleReport(object):
     def __init__(self, M, ReportType):\r
         self.ModuleName = M.Module.BaseName\r
         self.ModuleInfPath = M.MetaFile.File\r
     def __init__(self, M, ReportType):\r
         self.ModuleName = M.Module.BaseName\r
         self.ModuleInfPath = M.MetaFile.File\r

+        self.ModuleArch = M.Arch\r

         self.FileGuid = M.Guid\r
         self.Size = 0\r
         self.BuildTimeStamp = None\r
         self.FileGuid = M.Guid\r
         self.Size = 0\r
         self.BuildTimeStamp = None\r


@@ -631,7 +621,7 @@ class ModuleReport(object):
     def GenerateReport(self, File, GlobalPcdReport, GlobalPredictionReport, GlobalDepexParser, ReportType):\r
         FileWrite(File, gSectionStart)\r
 \r
     def GenerateReport(self, File, GlobalPcdReport, GlobalPredictionReport, GlobalDepexParser, ReportType):\r
         FileWrite(File, gSectionStart)\r
 \r

-        FwReportFileName = os.path.join(self._BuildDir, "DEBUG", self.ModuleName + ".txt")\r
+        FwReportFileName = os.path.join(self._BuildDir, "OUTPUT", self.ModuleName + ".txt")\r

         if os.path.isfile(FwReportFileName):\r
             try:\r
                 FileContents = open(FwReportFileName).read()\r
         if os.path.isfile(FwReportFileName):\r
             try:\r
                 FileContents = open(FwReportFileName).read()\r


@@ -641,7 +631,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


@@ -679,6 +669,7 @@ class ModuleReport(object):
 \r
         FileWrite(File, "Module Summary")\r
         FileWrite(File, "Module Name:          %s" % self.ModuleName)\r
 \r
         FileWrite(File, "Module Summary")\r
         FileWrite(File, "Module Name:          %s" % self.ModuleName)\r

+        FileWrite(File, "Module Arch:          %s" % self.ModuleArch)\r

         FileWrite(File, "Module INF Path:      %s" % self.ModuleInfPath)\r
         FileWrite(File, "File GUID:            %s" % self.FileGuid)\r
         if self.Size:\r
         FileWrite(File, "Module INF Path:      %s" % self.ModuleInfPath)\r
         FileWrite(File, "File GUID:            %s" % self.FileGuid)\r
         if self.Size:\r


@@ -705,7 +696,7 @@ class ModuleReport(object):
         FileWrite(File, gSectionSep)\r
 \r
         if "PCD" in ReportType:\r
         FileWrite(File, gSectionSep)\r
 \r
         if "PCD" in ReportType:\r

-            GlobalPcdReport.GenerateReport(File, self.ModulePcdSet)\r
+            GlobalPcdReport.GenerateReport(File, self.ModulePcdSet,self.FileGuid)\r

 \r
         if "LIBRARY" in ReportType:\r
             self.LibraryReport.GenerateReport(File)\r
 \r
         if "LIBRARY" in ReportType:\r
             self.LibraryReport.GenerateReport(File)\r


@@ -726,8 +717,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 is not 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


@@ -785,6 +776,13 @@ 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
             for item in Pa.Platform.Pcds:\r
                 Pcd = Pa.Platform.Pcds[item]\r
                 if not Pcd.Type:\r


@@ -819,6 +817,9 @@ class PcdReport(object):
                             break\r
 \r
                 PcdList = self.AllPcds.setdefault(Pcd.TokenSpaceGuidCName, {}).setdefault(Pcd.Type, [])\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


@@ -880,13 +881,23 @@ class PcdReport(object):
                 if DscDefaultValue:\r
                     self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r
 \r
                 if DscDefaultValue:\r
                     self.DscPcdDefault[(TokenCName, TokenSpaceGuidCName)] = DscDefaultValue\r
 \r

-    def GenerateReport(self, File, ModulePcdSet):\r
+    def GenerateReport(self, File, ModulePcdSet,ModuleGuid=None):\r

         if not ModulePcdSet:\r
             if self.ConditionalPcds:\r
                 self.GenerateReportDetail(File, ModulePcdSet, 1)\r
             if self.UnusedPcds:\r
         if not ModulePcdSet:\r
             if self.ConditionalPcds:\r
                 self.GenerateReportDetail(File, ModulePcdSet, 1)\r
             if self.UnusedPcds:\r

-                self.GenerateReportDetail(File, ModulePcdSet, 2)\r
-        self.GenerateReportDetail(File, ModulePcdSet)\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,ModuleGuid = ModuleGuid)\r

 \r
     ##\r
     # Generate report for PCD information\r
 \r
     ##\r
     # Generate report for PCD information\r


@@ -902,7 +913,7 @@ class PcdReport(object):
     #                        directives section report, 2 means Unused Pcds section report\r
     # @param DscOverridePcds Module DSC override PCDs set\r
     #\r
     #                        directives section report, 2 means Unused Pcds section report\r
     # @param DscOverridePcds Module DSC override PCDs set\r
     #\r

-    def GenerateReportDetail(self, File, ModulePcdSet, ReportSubType = 0):\r
+    def GenerateReportDetail(self, File, ModulePcdSet, ReportSubType = 0,ModuleGuid=None):\r

         PcdDict = self.AllPcds\r
         if ReportSubType == 1:\r
             PcdDict = self.ConditionalPcds\r
         PcdDict = self.AllPcds\r
         if ReportSubType == 1:\r
             PcdDict = self.ConditionalPcds\r


@@ -968,7 +979,6 @@ class PcdReport(object):
                     if CName == PcdTokenCName and Guid == Key:\r
                         DscDefaultValue = self.FdfPcdSet[(CName, Guid, Field)]\r
                         break\r
                     if CName == PcdTokenCName and Guid == Key:\r
                         DscDefaultValue = self.FdfPcdSet[(CName, Guid, Field)]\r
                         break\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
                 if DscDefaultValue != DscDefaultValBak:\r
                     try:\r
                         DscDefaultValue = ValueExpressionEx(DscDefaultValue, Pcd.DatumType, self._GuidDict)(True)\r


@@ -980,12 +990,23 @@ class PcdReport(object):
                 PcdValue = DecDefaultValue\r
                 if DscDefaultValue:\r
                     PcdValue = DscDefaultValue\r
                 PcdValue = DecDefaultValue\r
                 if DscDefaultValue:\r
                     PcdValue = DscDefaultValue\r

-                Pcd.DefaultValue = PcdValue\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
+                PcdComponentValue = None\r

                 if ModulePcdSet is not None:\r
                     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:\r
                         continue\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
-                    Pcd.DefaultValue = PcdValue\r
+                    InfDefaultValue, PcdComponentValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r
+                    PcdValue = PcdComponentValue\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
                     if InfDefaultValue == "":\r
                         InfDefaultValue = None\r
 \r


@@ -996,7 +1017,9 @@ class PcdReport(object):
                             if pcd[2]:\r
                                 continue\r
                             PcdValue = pcd[3]\r
                             if pcd[2]:\r
                                 continue\r
                             PcdValue = pcd[3]\r

-                            Pcd.DefaultValue = PcdValue\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
                             BuildOptionMatch = True\r
                             break\r
 \r


@@ -1007,23 +1030,35 @@ class PcdReport(object):
                     First = False\r
 \r
 \r
                     First = False\r
 \r
 \r

-                if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\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
                     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
                         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
                         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
                         DscDefaultValueNumber = int(DscDefaultValue.strip(), 0)\r
                         DscMatch = (DscDefaultValueNumber == PcdValueNumber)\r
                 else:\r


@@ -1043,53 +1078,87 @@ class PcdReport(object):
                         DscMatch = (DscDefaultValue.strip() == PcdValue.strip())\r
 \r
                 IsStructure = False\r
                         DscMatch = (DscDefaultValue.strip() == PcdValue.strip())\r
 \r
                 IsStructure = False\r

-                if GlobalData.gStructurePcd and (self.Arch in GlobalData.gStructurePcd) and ((Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.gStructurePcd[self.Arch]):\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
                     IsStructure = True\r
                     if TypeName in ('DYNVPD', 'DEXVPD'):\r
                         SkuInfoList = Pcd.SkuInfoList\r
                     Pcd = GlobalData.gStructurePcd[self.Arch][(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r

+                    if ModulePcdSet and ModulePcdSet.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type)):\r
+                        InfDefaultValue, PcdComponentValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r
+                        DscDefaultValBak = Pcd.DefaultValue\r
+                        Pcd.DefaultValue = PcdComponentValue\r
+\r

                     Pcd.DatumType = Pcd.StructName\r
                     if TypeName in ('DYNVPD', 'DEXVPD'):\r
                         Pcd.SkuInfoList = SkuInfoList\r
                     Pcd.DatumType = Pcd.StructName\r
                     if TypeName in ('DYNVPD', 'DEXVPD'):\r
                         Pcd.SkuInfoList = SkuInfoList\r

-                    if Pcd.PcdFieldValueFromComm:\r
+                    if Pcd.PcdValueFromComm or Pcd.PcdFieldValueFromComm:\r

                         BuildOptionMatch = True\r
                         DecMatch = False\r
                         BuildOptionMatch = True\r
                         DecMatch = False\r

-                    elif Pcd.SkuOverrideValues:\r
-                        DscOverride = False\r
-                        if not Pcd.SkuInfoList:\r
-                            OverrideValues = Pcd.SkuOverrideValues\r
-                            if OverrideValues:\r
-                                Keys = OverrideValues.keys()\r
-                                Data = OverrideValues[Keys[0]]\r
-                                Struct = Data.values()[0]\r
-                                DscOverride = self.ParseStruct(Struct)\r
-                        else:\r
-                            SkuList = sorted(Pcd.SkuInfoList.keys())\r
-                            for Sku in SkuList:\r
-                                SkuInfo = Pcd.SkuInfoList[Sku]\r
-                                if TypeName in ('DYNHII', 'DEXHII'):\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
+                    elif Pcd.PcdValueFromFdf or Pcd.PcdFieldValueFromFdf:\r
+                        DscDefaultValue = True\r
+                        DscMatch = True\r
+                        DecMatch = False\r
+                    else:\r
+                        if Pcd.Type in PCD_DYNAMIC_TYPE_SET | PCD_DYNAMIC_EX_TYPE_SET:\r
+                            DscOverride = False\r
+                            if Pcd.DefaultFromDSC:\r
+                                DscOverride = True\r
+                            else:\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.get(Sku)\r
+                                                    if OverrideValues:\r
+                                                        DscOverride = self.ParseStruct(OverrideValues[DefaultStore])\r
+                                                        if DscOverride:\r
+                                                            break\r

                                             if DscOverride:\r
                                                 break\r
                                             if DscOverride:\r
                                                 break\r

-                                else:\r
-                                    OverrideValues = Pcd.SkuOverrideValues[Sku]\r
-                                    if OverrideValues:\r
-                                        Keys = OverrideValues.keys()\r
-                                        OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])\r
-                                        DscOverride = self.ParseStruct(OverrideFieldStruct)\r
-                                if DscOverride:\r
-                                    break\r
-                        if DscOverride:\r
-                            DscMatch = True\r
-                            DecMatch = False\r
+                            if DscOverride:\r
+                                DscDefaultValue = True\r
+                                DscMatch = True\r
+                                DecMatch = False\r
+                            else:\r
+                                DecMatch = True\r
+                        else:\r
+                            if Pcd.DscRawValue or (ModuleGuid and ModuleGuid.replace("-","S") in Pcd.PcdValueFromComponents):\r
+                                DscDefaultValue = True\r
+                                DscMatch = True\r
+                                DecMatch = False\r
+                            else:\r
+                                DscDefaultValue = False\r
+                                DecMatch = True\r

 \r
                 #\r
                 # Report PCD item according to their override relationship\r
                 #\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
                 if DecMatch:\r
                     self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '  ')\r
                 elif InfDefaultValue and InfMatch:\r


@@ -1097,13 +1166,14 @@ class PcdReport(object):
                 elif BuildOptionMatch:\r
                     self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*B')\r
                 else:\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 PcdComponentValue:\r
+                        self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, PcdComponentValue, DecMatch, DecDefaultValue, '*M', ModuleGuid)\r
+                    elif 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
                             self.PrintPcdValue(File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValBak, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, '*P')\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
                             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 is None:\r
                     if IsStructure:\r
 \r
                 if ModulePcdSet is None:\r
                     if IsStructure:\r


@@ -1114,9 +1184,14 @@ class PcdReport(object):
                         ModuleOverride = self.ModulePcdOverride.get((Pcd.TokenCName, Pcd.TokenSpaceGuidCName), {})\r
                         for ModulePath in ModuleOverride:\r
                             ModuleDefault = ModuleOverride[ModulePath]\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_CLEAN_NUMERIC_TYPES:\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
                                 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
                             else:\r
                                 Match = (ModuleDefault.strip() == PcdValue.strip())\r
                             if Match:\r


@@ -1127,7 +1202,13 @@ class PcdReport(object):
                                 for Array in ArrayList:\r
                                     FileWrite(File, Array)\r
                             else:\r
                                 for Array in ArrayList:\r
                                     FileWrite(File, Array)\r
                             else:\r

-                                FileWrite(File, ' *M     %-*s = %s' % (self.MaxLen + 15, ModulePath, ModuleDefault.strip()))\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
         if ModulePcdSet is None:\r
             FileWrite(File, gSectionEnd)\r
 \r
         if ModulePcdSet is None:\r
             FileWrite(File, gSectionEnd)\r


@@ -1138,9 +1219,12 @@ class PcdReport(object):
     def ParseStruct(self, struct):\r
         HasDscOverride = False\r
         if struct:\r
     def ParseStruct(self, struct):\r
         HasDscOverride = False\r
         if struct:\r

-            for _, Values in struct.items():\r
-                if Values[1] and Values[1].endswith('.dsc'):\r
-                    HasDscOverride = True\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
                     break\r
         return HasDscOverride\r
 \r


@@ -1189,11 +1273,13 @@ class PcdReport(object):
                         Value = "0x{:X} ({})".format(int(Value, 0), Value)\r
                 FileWrite(File, '    %*s = %s' % (self.MaxLen + 19, 'DEC DEFAULT', Value))\r
             if IsStructure:\r
                         Value = "0x{:X} ({})".format(int(Value, 0), Value)\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
         if DecMatch and IsStructure:\r

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

 \r
 \r

-    def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = '  '):\r
+    def PrintPcdValue(self, File, Pcd, PcdTokenCName, TypeName, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue, Flag = '  ',ModuleGuid=None):\r

         if not Pcd.SkuInfoList:\r
             Value = Pcd.DefaultValue\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r
         if not Pcd.SkuInfoList:\r
             Value = Pcd.DefaultValue\r
             IsByteArray, ArrayList = ByteArrayForamt(Value)\r


@@ -1203,18 +1289,35 @@ class PcdReport(object):
                     FileWrite(File, Array)\r
             else:\r
                 if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
                     FileWrite(File, Array)\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
                     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

-                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
+                FieldOverrideValues = None\r

                 if OverrideValues:\r
                 if OverrideValues:\r

-                    Keys = OverrideValues.keys()\r
-                    Data = OverrideValues[Keys[0]]\r
-                    Struct = Data.values()[0]\r
-                    OverrideFieldStruct = self.OverrideFieldValue(Pcd, Struct)\r
+                    for Data in OverrideValues.values():\r
+                        Struct = list(Data.values())\r
+                        if Struct:\r
+                            FieldOverrideValues = Struct[0]\r
+                            FiledOverrideFlag = True\r
+                            break\r
+                if Pcd.PcdFiledValueFromDscComponent and ModuleGuid and ModuleGuid.replace("-","S") in Pcd.PcdFiledValueFromDscComponent:\r
+                    FieldOverrideValues = Pcd.PcdFiledValueFromDscComponent[ModuleGuid.replace("-","S")]\r
+                if FieldOverrideValues:\r
+                    OverrideFieldStruct = self.OverrideFieldValue(Pcd, FieldOverrideValues)\r
+                    self.PrintStructureInfo(File, OverrideFieldStruct)\r
+\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
                     self.PrintStructureInfo(File, OverrideFieldStruct)\r
             self.PrintPcdDefault(File, Pcd, IsStructure, DscMatch, DscDefaultValue, InfMatch, InfDefaultValue, DecMatch, DecDefaultValue)\r
         else:\r


@@ -1229,6 +1332,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


@@ -1284,13 +1389,16 @@ class PcdReport(object):
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))\r
                             FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))\r
                             if IsStructure:\r
                                         FileWrite(File, ' %-*s   : %6s %10s %10s %10s = %s' % (self.MaxLen, ' ', TypeName, '(' + Pcd.DatumType + ')', '(' + SkuIdName + ')', '(' + DefaultStore + ')', Value))\r
                             FileWrite(File, '%*s: %s: %s' % (self.MaxLen + 4, SkuInfo.VariableGuid, SkuInfo.VariableName, SkuInfo.VariableOffset))\r
                             if IsStructure:\r

-                                OverrideValues = Pcd.SkuOverrideValues[Sku]\r
-                                OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[DefaultStore])\r
-                                self.PrintStructureInfo(File, OverrideFieldStruct)\r
+                                OverrideValues = Pcd.SkuOverrideValues.get(Sku)\r
+                                if OverrideValues:\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


@@ -1330,32 +1438,56 @@ class PcdReport(object):
                                 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
                                 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

+                        VPDPcdItem = (Pcd.TokenSpaceGuidCName + '.' + PcdTokenCName, SkuIdName, SkuInfo.VpdOffset, Pcd.MaxDatumSize, SkuInfo.DefaultValue)\r
+                        if VPDPcdItem not in VPDPcdList:\r
+                            PcdGuidList = self.UnusedPcds.get(Pcd.TokenSpaceGuidCName)\r
+                            if PcdGuidList:\r
+                                PcdList = PcdGuidList.get(Pcd.Type)\r
+                                if not PcdList:\r
+                                    VPDPcdList.append(VPDPcdItem)\r
+                                for VpdPcd in PcdList:\r
+                                    if PcdTokenCName == VpdPcd.TokenCName:\r
+                                        break\r
+                                else:\r
+                                    VPDPcdList.append(VPDPcdItem)\r

                     if IsStructure:\r
                     if IsStructure:\r

-                        OverrideValues = Pcd.SkuOverrideValues[Sku]\r
+                        FiledOverrideFlag = False\r
+                        OverrideValues = Pcd.SkuOverrideValues.get(Sku)\r

                         if OverrideValues:\r
                         if OverrideValues:\r

-                            Keys = OverrideValues.keys()\r
+                            Keys = list(OverrideValues.keys())\r

                             OverrideFieldStruct = self.OverrideFieldValue(Pcd, OverrideValues[Keys[0]])\r
                             self.PrintStructureInfo(File, OverrideFieldStruct)\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
     def OverrideFieldValue(self, Pcd, OverrideStruct):\r
         OverrideFieldStruct = collections.OrderedDict()\r
         if OverrideStruct:\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 Key, Values in OverrideStruct.items():\r
-                if Values[1] and Values[1].endswith('.dsc'):\r
-                    OverrideFieldStruct[Key] = Values\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 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
                 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
                 OverrideFieldStruct[Key] = Values\r
         return OverrideFieldStruct\r
 \r
     def PrintStructureInfo(self, File, Struct):\r

-        for Key, Value in Struct.items():\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
             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
                 FileWrite(File, '        %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r
 \r
             else:\r
                 FileWrite(File, '        %-*s = %s' % (self.MaxLen + 4, '.' + Key, Value[0]))\r
 \r


@@ -1389,6 +1521,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


@@ -1450,15 +1588,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


@@ -1543,17 +1674,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


@@ -1779,8 +1910,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


@@ -1929,35 +2060,14 @@ class FdReport(object):
         self.Size = Fd.Size\r
         self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]\r
         self.FvPath = os.path.join(Wa.BuildDir, TAB_FV_DIRECTORY)\r
         self.Size = Fd.Size\r
         self.FdRegionList = [FdRegionReport(FdRegion, Wa) for FdRegion in Fd.RegionList]\r
         self.FvPath = os.path.join(Wa.BuildDir, TAB_FV_DIRECTORY)\r

-        self.VpdFilePath = os.path.join(self.FvPath, "%s.map" % Wa.Platform.VpdToolGuid)\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
         for index, FdRegion in enumerate(Fd.RegionList):\r

-            if str(FdRegion.RegionType) is 'FILE' and Wa.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r
+            if str(FdRegion.RegionType) == '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
                 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


@@ -1977,23 +2087,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
                         FileWrite(File, Array)\r
                 else:\r
                     for Array in ArrayList:\r
                         FileWrite(File, Array)\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


@@ -2059,7 +2172,7 @@ class PlatformReport(object):
                         INFList = GlobalData.gFdfParser.Profile.InfDict[Pa.Arch]\r
                         for InfName in INFList:\r
                             InfClass = PathClass(NormPath(InfName), Wa.WorkspaceDir, Pa.Arch)\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
+                            Ma = ModuleAutoGen(Wa, InfClass, Pa.BuildTarget, Pa.ToolChain, Pa.Arch, Wa.MetaFile, Pa.DataPipe)\r

                             if Ma is None:\r
                                 continue\r
                             if Ma not in ModuleAutoGenList:\r
                             if Ma is None:\r
                                 continue\r
                             if Ma not in ModuleAutoGenList:\r


@@ -2185,18 +2298,17 @@ 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 = BytesIO('')\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
 # This acts like the main() function for the script, unless it is 'import'ed into another script.\r
 if __name__ == '__main__':\r
 \r
 # This acts like the main() function for the script, unless it is 'import'ed into another script.\r
 if __name__ == '__main__':\r