# 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
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.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 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
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
## 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
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
- 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
\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
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
- \r
- \r
- \r
+\r
+\r
+\r
##\r
# Parse binary dependency expression section\r
#\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
+ #\r
# This function parses the binary dependency expression file and translate it\r
# to the instruction list.\r
#\r
OpCode = DepexFile.read(1)\r
\r
return DepexStatement\r
- \r
+\r
##\r
# Reports library information\r
#\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
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
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
- \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
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
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
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
\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
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
\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, 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
# 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
# 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
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 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
- 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
# 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
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
+ 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, DscDefaultValue:\r
+ except BadExpression as DscDefaultValue:\r
EdkLogger.error('BuildReport', FORMAT_INVALID, "PCD Value: %s, Type: %s" %(DscDefaultValue, Pcd.DatumType))\r
\r
InfDefaultValue = None\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
+ PcdComponentValue = None\r
if ModulePcdSet is not None:\r
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type) not in ModulePcdSet:\r
continue\r
- InfDefault, PcdValue = ModulePcdSet[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Type]\r
- Pcd.DefaultValue = PcdValue\r
- if InfDefault == "":\r
- InfDefault = None\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
BuildOptionMatch = False\r
if GlobalData.BuildOptionPcd:\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
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
+ 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
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
+ 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
- if Pcd.PcdFieldValueFromComm:\r
+ if Pcd.PcdValueFromComm or Pcd.PcdFieldValueFromComm:\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
- 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
- if DecMatch and InfMatch:\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 DscMatch:\r
- if (Pcd.TokenCName, Key) in self.FdfPcdSet:\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
- 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
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
+ if Pcd.DatumType == 'BOOLEAN':\r
+ ModuleDefault = str(ModulePcdDefaultValueNumber)\r
else:\r
Match = (ModuleDefault.strip() == PcdValue.strip())\r
if Match:\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
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
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
- self.PrintStructureInfo(File, Pcd.DefaultValues)\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
+ 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
FileWrite(File, Array)\r
else:\r
if Pcd.DatumType in TAB_PCD_CLEAN_NUMERIC_TYPES:\r
- if Value.startswith(('0x','0X')):\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
- 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
- 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
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
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
+ if Pcd.DatumType == 'BOOLEAN':\r
+ Value = str(int(Value, 0))\r
if FirstPrint:\r
FirstPrint = False\r
if IsByteArray:\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
- 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
FileWrite(File, Array)\r
else:\r
else:\r
Value = "0x{:X} ({})".format(int(Value, 0), Value)\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
- 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
+ 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
- OverrideValues = Pcd.SkuOverrideValues[Sku]\r
+ FiledOverrideFlag = False\r
+ OverrideValues = Pcd.SkuOverrideValues.get(Sku)\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
+ 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
- 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 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
- 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
+ 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
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
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
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
- 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
- TempFile.close()\r
+ SaveFileOnChange(GuidList, "".join(TempFile), False)\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
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
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
#\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
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
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.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
+ 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
- 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
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
- 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
- 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
- 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
self.DepexParser = None\r
if "DEPEX" in ReportType:\r
self.DepexParser = DepexParser(Wa)\r
- \r
+\r
self.ModuleReportList = []\r
if MaList is not None:\r
self._IsModuleBuild = True\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 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 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
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
- 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
- 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