## @file\r
# Generate AutoGen.h, AutoGen.c and *.depex files\r
#\r
-# Copyright (c) 2007 - 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
+# Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>\r
+# Copyright (c) 2019, American Megatrends, Inc. All rights reserved.<BR>\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
+from __future__ import print_function\r
+from __future__ import absolute_import\r
import Common.LongFilePathOs as os\r
import re\r
import os.path as path\r
import copy\r
import uuid\r
\r
-import GenC\r
-import GenMake\r
-import GenDepex\r
-from StringIO import StringIO\r
-\r
-from StrGather import *\r
-from BuildEngine import BuildRule\r
+from . import GenC\r
+from . import GenMake\r
+from . import GenDepex\r
+from io import BytesIO\r
\r
+from .StrGather import *\r
+from .BuildEngine import BuildRule\r
+import shutil\r
from Common.LongFilePathSupport import CopyLongFilePath\r
from Common.BuildToolError import *\r
from Common.DataType import *\r
from Common.Misc import *\r
-from Common.String import *\r
+from Common.StringUtils import *\r
import Common.GlobalData as GlobalData\r
from GenFds.FdfParser import *\r
from CommonDataClass.CommonClass import SkuInfoClass\r
-from Workspace.BuildClassObject import *\r
from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile\r
import Common.VpdInfoFile as VpdInfoFile\r
-from GenPcdDb import CreatePcdDatabaseCode\r
+from .GenPcdDb import CreatePcdDatabaseCode\r
from Workspace.MetaFileCommentParser import UsageList\r
+from Workspace.WorkspaceCommon import GetModuleLibInstances\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
-import InfSectionParser\r
+from . import InfSectionParser\r
import datetime\r
import hashlib\r
-from GenVar import VariableMgr,var_info\r
+from .GenVar import VariableMgr, var_info\r
from collections import OrderedDict\r
from collections import defaultdict\r
+from Workspace.WorkspaceCommon import OrderedListDict\r
+from Common.ToolDefClassObject import gDefaultToolsDefFile\r
+\r
+from Common.caching import cached_property, cached_class_function\r
\r
## Regular expression for splitting Dependency Expression string into tokens\r
gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
gEfiVarStoreGuidPattern = re.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")\r
\r
## Mapping Makefile type\r
-gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}\r
+gMakeTypeMap = {TAB_COMPILER_MSFT:"nmake", "GCC":"gmake"}\r
\r
\r
## Build rule configuration file\r
gDefaultBuildRuleFile = 'build_rule.txt'\r
\r
-## Tools definition configuration file\r
-gDefaultToolsDefFile = 'tools_def.txt'\r
-\r
## Build rule default version\r
AutoGenReqBuildRuleVerNum = "0.1"\r
\r
## @AsBuilt${BEGIN}\r
## ${flags_item}${END}\r
""")\r
+## Split command line option string to list\r
+#\r
+# subprocess.Popen needs the args to be a sequence. Otherwise there's problem\r
+# in non-windows platform to launch command\r
+#\r
+def _SplitOption(OptionString):\r
+ OptionList = []\r
+ LastChar = " "\r
+ OptionStart = 0\r
+ QuotationMark = ""\r
+ for Index in range(0, len(OptionString)):\r
+ CurrentChar = OptionString[Index]\r
+ if CurrentChar in ['"', "'"]:\r
+ if QuotationMark == CurrentChar:\r
+ QuotationMark = ""\r
+ elif QuotationMark == "":\r
+ QuotationMark = CurrentChar\r
+ continue\r
+ elif QuotationMark:\r
+ continue\r
+\r
+ if CurrentChar in ["/", "-"] and LastChar in [" ", "\t", "\r", "\n"]:\r
+ if Index > OptionStart:\r
+ OptionList.append(OptionString[OptionStart:Index - 1])\r
+ OptionStart = Index\r
+ LastChar = CurrentChar\r
+ OptionList.append(OptionString[OptionStart:])\r
+ return OptionList\r
+\r
+#\r
+# Convert string to C format array\r
+#\r
+def _ConvertStringToByteArray(Value):\r
+ Value = Value.strip()\r
+ if not Value:\r
+ return None\r
+ if Value[0] == '{':\r
+ if not Value.endswith('}'):\r
+ return None\r
+ Value = Value.replace(' ', '').replace('{', '').replace('}', '')\r
+ ValFields = Value.split(',')\r
+ try:\r
+ for Index in range(len(ValFields)):\r
+ ValFields[Index] = str(int(ValFields[Index], 0))\r
+ except ValueError:\r
+ return None\r
+ Value = '{' + ','.join(ValFields) + '}'\r
+ return Value\r
+\r
+ Unicode = False\r
+ if Value.startswith('L"'):\r
+ if not Value.endswith('"'):\r
+ return None\r
+ Value = Value[1:]\r
+ Unicode = True\r
+ elif not Value.startswith('"') or not Value.endswith('"'):\r
+ return None\r
+\r
+ Value = eval(Value) # translate escape character\r
+ NewValue = '{'\r
+ for Index in range(0, len(Value)):\r
+ if Unicode:\r
+ NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ','\r
+ else:\r
+ NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ','\r
+ Value = NewValue + '0}'\r
+ return Value\r
\r
## Base class for AutoGen\r
#\r
def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
# check if the object has been created\r
Key = (Target, Toolchain, Arch, MetaFile)\r
- try:\r
+ if Key in cls.__ObjectCache:\r
# if it exists, just return it directly\r
return cls.__ObjectCache[Key]\r
- except:\r
# it didnt exist. create it, cache it, then return it\r
- cls.__ObjectCache[Key] = super(AutoGen, cls).__new__(cls)\r
- return cls.__ObjectCache[Key]\r
+ RetVal = cls.__ObjectCache[Key] = super(AutoGen, cls).__new__(cls)\r
+ return RetVal\r
\r
- def __init__ (self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- super(AutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
\r
## hash() operator\r
#\r
class WorkspaceAutoGen(AutoGen):\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- try:\r
- self._Init\r
- except:\r
- super(WorkspaceAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ if not hasattr(self, "_Init"):\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
self._Init = True\r
- \r
+\r
## Initialize WorkspaceAutoGen\r
#\r
# @param WorkspaceDir Root directory of workspace\r
self.BuildDatabase = MetaFileDb\r
self.MetaFile = ActivePlatform\r
self.WorkspaceDir = WorkspaceDir\r
- self.Platform = self.BuildDatabase[self.MetaFile, 'COMMON', Target, Toolchain]\r
+ self.Platform = self.BuildDatabase[self.MetaFile, TAB_ARCH_COMMON, Target, Toolchain]\r
GlobalData.gActivePlatform = self.Platform\r
self.BuildTarget = Target\r
self.ToolChain = Toolchain\r
self.FvTargetList = Fvs if Fvs else []\r
self.CapTargetList = Caps if Caps else []\r
self.AutoGenObjectList = []\r
- self._BuildDir = None\r
- self._FvDir = None\r
- self._MakeFileDir = None\r
- self._BuildCommand = None\r
self._GuidDict = {}\r
\r
# there's many relative directory operations, so ...\r
ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
% (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
\r
- \r
+\r
# parse FDF file to get PCDs in it, if any\r
if not self.FdfFile:\r
self.FdfFile = self.Platform.FlashDefinition\r
# but the path (self.MetaFile.Path) is the real path\r
for key in self.FdfProfile.InfDict:\r
if key == 'ArchTBD':\r
- MetaFile_cache = {}\r
+ MetaFile_cache = defaultdict(set)\r
for Arch in self.ArchList:\r
Current_Platform_cache = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
- MetaFile_cache[Arch] = set()\r
for Pkey in Current_Platform_cache.Modules:\r
MetaFile_cache[Arch].add(Current_Platform_cache.Modules[Pkey].MetaFile)\r
for Inf in self.FdfProfile.InfDict[key]:\r
Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
PlatformPcds = Platform.Pcds\r
self._GuidDict = Platform._GuidDict\r
- SourcePcdDict = {'DynamicEx':set(), 'PatchableInModule':set(),'Dynamic':set(),'FixedAtBuild':set()}\r
- BinaryPcdDict = {'DynamicEx':set(), 'PatchableInModule':set()}\r
+ SourcePcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set(),TAB_PCDS_DYNAMIC:set(),TAB_PCDS_FIXED_AT_BUILD:set()}\r
+ BinaryPcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set()}\r
SourcePcdDict_Keys = SourcePcdDict.keys()\r
BinaryPcdDict_Keys = BinaryPcdDict.keys()\r
\r
# generate the SourcePcdDict and BinaryPcdDict\r
PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
- for BuildData in PGen.BuildDatabase._CACHE_.values():\r
+ for BuildData in list(PGen.BuildDatabase._CACHE_.values()):\r
if BuildData.Arch != Arch:\r
continue\r
if BuildData.MetaFile.Ext == '.inf':\r
if BuildData.Pcds[key].Pending:\r
if key in Platform.Pcds:\r
PcdInPlatform = Platform.Pcds[key]\r
- if PcdInPlatform.Type not in [None, '']:\r
+ if PcdInPlatform.Type:\r
BuildData.Pcds[key].Type = PcdInPlatform.Type\r
+ BuildData.Pcds[key].Pending = False\r
\r
if BuildData.MetaFile in Platform.Modules:\r
PlatformModule = Platform.Modules[str(BuildData.MetaFile)]\r
if key in PlatformModule.Pcds:\r
PcdInPlatform = PlatformModule.Pcds[key]\r
- if PcdInPlatform.Type not in [None, '']:\r
+ if PcdInPlatform.Type:\r
BuildData.Pcds[key].Type = PcdInPlatform.Type\r
-\r
- if 'DynamicEx' in BuildData.Pcds[key].Type:\r
+ BuildData.Pcds[key].Pending = False\r
+ else:\r
+ #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending\r
+ if BuildData.Pcds[key].Pending:\r
+ MGen = ModuleAutoGen(self, BuildData.MetaFile, Target, Toolchain, Arch, self.MetaFile)\r
+ if MGen and MGen.IsLibrary:\r
+ if MGen in PGen.LibraryAutoGenList:\r
+ ReferenceModules = MGen.ReferenceModules\r
+ for ReferenceModule in ReferenceModules:\r
+ if ReferenceModule.MetaFile in Platform.Modules:\r
+ RefPlatformModule = Platform.Modules[str(ReferenceModule.MetaFile)]\r
+ if key in RefPlatformModule.Pcds:\r
+ PcdInReferenceModule = RefPlatformModule.Pcds[key]\r
+ if PcdInReferenceModule.Type:\r
+ BuildData.Pcds[key].Type = PcdInReferenceModule.Type\r
+ BuildData.Pcds[key].Pending = False\r
+ break\r
+\r
+ if TAB_PCDS_DYNAMIC_EX in BuildData.Pcds[key].Type:\r
if BuildData.IsBinaryModule:\r
- BinaryPcdDict['DynamicEx'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ BinaryPcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
- SourcePcdDict['DynamicEx'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ SourcePcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
\r
- elif 'PatchableInModule' in BuildData.Pcds[key].Type:\r
+ elif TAB_PCDS_PATCHABLE_IN_MODULE in BuildData.Pcds[key].Type:\r
if BuildData.MetaFile.Ext == '.inf':\r
if BuildData.IsBinaryModule:\r
- BinaryPcdDict['PatchableInModule'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ BinaryPcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
- SourcePcdDict['PatchableInModule'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ SourcePcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
\r
- elif 'Dynamic' in BuildData.Pcds[key].Type:\r
- SourcePcdDict['Dynamic'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
- elif 'FixedAtBuild' in BuildData.Pcds[key].Type:\r
- SourcePcdDict['FixedAtBuild'].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ elif TAB_PCDS_DYNAMIC in BuildData.Pcds[key].Type:\r
+ SourcePcdDict[TAB_PCDS_DYNAMIC].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
+ elif TAB_PCDS_FIXED_AT_BUILD in BuildData.Pcds[key].Type:\r
+ SourcePcdDict[TAB_PCDS_FIXED_AT_BUILD].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
else:\r
pass\r
#\r
'build',\r
FORMAT_INVALID,\r
"Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i, j),\r
- ExtraData="%s" % '\n\t'.join([str(P[1]+'.'+P[0]) for P in Intersections])\r
+ ExtraData='\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
)\r
\r
#\r
if NewPcd2 not in GlobalData.MixedPcd[item]:\r
GlobalData.MixedPcd[item].append(NewPcd2)\r
\r
- for BuildData in PGen.BuildDatabase._CACHE_.values():\r
+ for BuildData in list(PGen.BuildDatabase._CACHE_.values()):\r
if BuildData.Arch != Arch:\r
continue\r
for key in BuildData.Pcds:\r
if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
for item in GlobalData.MixedPcd[SinglePcd]:\r
Pcd_Type = item[0].split('_')[-1]\r
- if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in GenC.gDynamicExPcd) or \\r
- (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in GenC.gDynamicPcd):\r
+ if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
+ (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
Value = BuildData.Pcds[key]\r
Value.TokenCName = BuildData.Pcds[key].TokenCName + '_' + Pcd_Type\r
if len(key) == 2:\r
DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))\r
\r
Platform.SkuName = self.SkuId\r
- for Name, Guid in PcdSet:\r
+ for Name, Guid,Fileds in PcdSet:\r
if (Name, Guid) not in DecPcds:\r
EdkLogger.error(\r
'build',\r
PARSER_ERROR,\r
"PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid, Name),\r
- File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
- Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
+ File = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][0],\r
+ Line = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][1]\r
)\r
else:\r
# Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.\r
if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \\r
or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \\r
or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:\r
- Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])\r
continue\r
elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:\r
EdkLogger.error(\r
'build',\r
PARSER_ERROR,\r
"Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid, Name),\r
- File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
- Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
+ File = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][0],\r
+ Line = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][1]\r
)\r
\r
Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
#\r
# Generate Package level hash value\r
#\r
- GlobalData.gPackageHash[Arch] = {}\r
+ GlobalData.gPackageHash = {}\r
if GlobalData.gUseHashCache:\r
for Pkg in Pkgs:\r
self._GenPkgLevelHash(Pkg)\r
#\r
self._CheckPcdDefineAndType()\r
\r
-# if self.FdfFile:\r
-# self._CheckDuplicateInFV(Fdf)\r
-\r
#\r
# Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.\r
#\r
content = 'gCommandLineDefines: '\r
content += str(GlobalData.gCommandLineDefines)\r
- content += os.linesep\r
+ content += TAB_LINE_BREAK\r
content += 'BuildOptionPcd: '\r
content += str(GlobalData.BuildOptionPcd)\r
- content += os.linesep\r
+ content += TAB_LINE_BREAK\r
content += 'Active Platform: '\r
content += str(self.Platform)\r
- content += os.linesep\r
+ content += TAB_LINE_BREAK\r
if self.FdfFile:\r
content += 'Flash Image Definition: '\r
content += str(self.FdfFile)\r
- content += os.linesep\r
+ content += TAB_LINE_BREAK\r
SaveFileOnChange(os.path.join(self.BuildDir, 'BuildOptions'), content, False)\r
\r
#\r
if Pa.PcdTokenNumber:\r
if Pa.DynamicPcdList:\r
for Pcd in Pa.DynamicPcdList:\r
- PcdTokenNumber += os.linesep\r
+ PcdTokenNumber += TAB_LINE_BREAK\r
PcdTokenNumber += str((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
PcdTokenNumber += ' : '\r
PcdTokenNumber += str(Pa.PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName])\r
for files in AllWorkSpaceMetaFiles:\r
if files.endswith('.dec'):\r
continue\r
- f = open(files, 'r')\r
+ f = open(files, 'rb')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
- SaveFileOnChange(os.path.join(self.BuildDir, 'AutoGen.hash'), m.hexdigest(), True)\r
+ SaveFileOnChange(os.path.join(self.BuildDir, 'AutoGen.hash'), m.hexdigest(), False)\r
GlobalData.gPlatformHash = m.hexdigest()\r
\r
#\r
os.makedirs(self.BuildDir)\r
with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:\r
for f in AllWorkSpaceMetaFiles:\r
- print >> file, f\r
+ print(f, file=file)\r
return True\r
\r
def _GenPkgLevelHash(self, Pkg):\r
+ if Pkg.PackageName in GlobalData.gPackageHash:\r
+ return\r
+\r
PkgDir = os.path.join(self.BuildDir, Pkg.Arch, Pkg.PackageName)\r
CreateDirectory(PkgDir)\r
HashFile = os.path.join(PkgDir, Pkg.PackageName + '.hash')\r
m = hashlib.md5()\r
# Get .dec file's hash value\r
- f = open(Pkg.MetaFile.Path, 'r')\r
+ f = open(Pkg.MetaFile.Path, 'rb')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
# Get include files hash value\r
if Pkg.Includes:\r
- for inc in Pkg.Includes:\r
+ for inc in sorted(Pkg.Includes, key=lambda x: str(x)):\r
for Root, Dirs, Files in os.walk(str(inc)):\r
- for File in Files:\r
+ for File in sorted(Files):\r
File_Path = os.path.join(Root, File)\r
- f = open(File_Path, 'r')\r
+ f = open(File_Path, 'rb')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
- SaveFileOnChange(HashFile, m.hexdigest(), True)\r
- if Pkg.PackageName not in GlobalData.gPackageHash[Pkg.Arch]:\r
- GlobalData.gPackageHash[Pkg.Arch][Pkg.PackageName] = m.hexdigest()\r
+ SaveFileOnChange(HashFile, m.hexdigest(), False)\r
+ GlobalData.gPackageHash[Pkg.PackageName] = m.hexdigest()\r
\r
def _GetMetaFiles(self, Target, Toolchain, Arch):\r
AllWorkSpaceMetaFiles = set()\r
#\r
if self.FdfFile:\r
AllWorkSpaceMetaFiles.add (self.FdfFile.Path)\r
- if self.FdfFile:\r
- FdfFiles = GlobalData.gFdfParser.GetAllIncludedFile()\r
- for f in FdfFiles:\r
- AllWorkSpaceMetaFiles.add (f.FileName)\r
+ for f in GlobalData.gFdfParser.GetAllIncludedFile():\r
+ AllWorkSpaceMetaFiles.add (f.FileName)\r
#\r
# add dsc\r
#\r
AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'PcdTokenNumber'))\r
\r
for Arch in self.ArchList:\r
- Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
- PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
-\r
#\r
# add dec\r
#\r
- for Package in PGen.PackageList:\r
+ for Package in PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch).PackageList:\r
AllWorkSpaceMetaFiles.add(Package.MetaFile.Path)\r
\r
#\r
# add included dsc\r
#\r
- for filePath in Platform._RawData.IncludedFiles:\r
+ for filePath in self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]._RawData.IncludedFiles:\r
AllWorkSpaceMetaFiles.add(filePath.Path)\r
\r
return AllWorkSpaceMetaFiles\r
\r
- ## _CheckDuplicateInFV() method\r
- #\r
- # Check whether there is duplicate modules/files exist in FV section. \r
- # The check base on the file GUID;\r
- #\r
- def _CheckDuplicateInFV(self, Fdf):\r
- for Fv in Fdf.Profile.FvDict:\r
- _GuidDict = {}\r
- for FfsFile in Fdf.Profile.FvDict[Fv].FfsList:\r
- if FfsFile.InfFileName and FfsFile.NameGuid is None:\r
- #\r
- # Get INF file GUID\r
- #\r
- InfFoundFlag = False\r
- for Pa in self.AutoGenObjectList:\r
- if InfFoundFlag:\r
- break\r
- for Module in Pa.ModuleAutoGenList:\r
- if path.normpath(Module.MetaFile.File) == path.normpath(FfsFile.InfFileName):\r
- InfFoundFlag = True\r
- if not Module.Guid.upper() in _GuidDict.keys():\r
- _GuidDict[Module.Guid.upper()] = FfsFile\r
- break\r
- else:\r
- EdkLogger.error("build",\r
- FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
- FfsFile.CurrentLineContent,\r
- _GuidDict[Module.Guid.upper()].CurrentLineNum,\r
- _GuidDict[Module.Guid.upper()].CurrentLineContent,\r
- Module.Guid.upper()),\r
- ExtraData=self.FdfFile)\r
- #\r
- # Some INF files not have entity in DSC file. \r
- #\r
- if not InfFoundFlag:\r
- if FfsFile.InfFileName.find('$') == -1:\r
- InfPath = NormPath(FfsFile.InfFileName)\r
- if not os.path.exists(InfPath):\r
- EdkLogger.error('build', GENFDS_ERROR, "Non-existant Module %s !" % (FfsFile.InfFileName))\r
-\r
- PathClassObj = PathClass(FfsFile.InfFileName, self.WorkspaceDir)\r
- #\r
- # Here we just need to get FILE_GUID from INF file, use 'COMMON' as ARCH attribute. and use \r
- # BuildObject from one of AutoGenObjectList is enough.\r
- #\r
- InfObj = self.AutoGenObjectList[0].BuildDatabase.WorkspaceDb.BuildObject[PathClassObj, 'COMMON', self.BuildTarget, self.ToolChain]\r
- if not InfObj.Guid.upper() in _GuidDict.keys():\r
- _GuidDict[InfObj.Guid.upper()] = FfsFile\r
- else:\r
- EdkLogger.error("build",\r
- FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
- FfsFile.CurrentLineContent,\r
- _GuidDict[InfObj.Guid.upper()].CurrentLineNum,\r
- _GuidDict[InfObj.Guid.upper()].CurrentLineContent,\r
- InfObj.Guid.upper()),\r
- ExtraData=self.FdfFile)\r
- InfFoundFlag = False\r
-\r
- if FfsFile.NameGuid is not None:\r
- #\r
- # If the NameGuid reference a PCD name. \r
- # The style must match: PCD(xxxx.yyy)\r
- #\r
- if gPCDAsGuidPattern.match(FfsFile.NameGuid):\r
- #\r
- # Replace the PCD value.\r
- #\r
- _PcdName = FfsFile.NameGuid.lstrip("PCD(").rstrip(")")\r
- PcdFoundFlag = False\r
- for Pa in self.AutoGenObjectList:\r
- if not PcdFoundFlag:\r
- for PcdItem in Pa.AllPcdList:\r
- if (PcdItem.TokenSpaceGuidCName + "." + PcdItem.TokenCName) == _PcdName:\r
- #\r
- # First convert from CFormatGuid to GUID string\r
- #\r
- _PcdGuidString = GuidStructureStringToGuidString(PcdItem.DefaultValue)\r
-\r
- if not _PcdGuidString:\r
- #\r
- # Then try Byte array.\r
- #\r
- _PcdGuidString = GuidStructureByteArrayToGuidString(PcdItem.DefaultValue)\r
-\r
- if not _PcdGuidString:\r
- #\r
- # Not Byte array or CFormat GUID, raise error.\r
- #\r
- EdkLogger.error("build",\r
- FORMAT_INVALID,\r
- "The format of PCD value is incorrect. PCD: %s , Value: %s\n" % (_PcdName, PcdItem.DefaultValue),\r
- ExtraData=self.FdfFile)\r
-\r
- if not _PcdGuidString.upper() in _GuidDict.keys():\r
- _GuidDict[_PcdGuidString.upper()] = FfsFile\r
- PcdFoundFlag = True\r
- break\r
- else:\r
- EdkLogger.error("build",\r
- FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
- FfsFile.CurrentLineContent,\r
- _GuidDict[_PcdGuidString.upper()].CurrentLineNum,\r
- _GuidDict[_PcdGuidString.upper()].CurrentLineContent,\r
- FfsFile.NameGuid.upper()),\r
- ExtraData=self.FdfFile)\r
-\r
- if not FfsFile.NameGuid.upper() in _GuidDict.keys():\r
- _GuidDict[FfsFile.NameGuid.upper()] = FfsFile\r
- else:\r
- #\r
- # Two raw file GUID conflict.\r
- #\r
- EdkLogger.error("build",\r
- FORMAT_INVALID,\r
- "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,\r
- FfsFile.CurrentLineContent,\r
- _GuidDict[FfsFile.NameGuid.upper()].CurrentLineNum,\r
- _GuidDict[FfsFile.NameGuid.upper()].CurrentLineContent,\r
- FfsFile.NameGuid.upper()),\r
- ExtraData=self.FdfFile)\r
-\r
-\r
def _CheckPcdDefineAndType(self):\r
- PcdTypeList = [\r
- "FixedAtBuild", "PatchableInModule", "FeatureFlag",\r
- "Dynamic", #"DynamicHii", "DynamicVpd",\r
- "DynamicEx", # "DynamicExHii", "DynamicExVpd"\r
- ]\r
+ PcdTypeSet = {TAB_PCDS_FIXED_AT_BUILD,\r
+ TAB_PCDS_PATCHABLE_IN_MODULE,\r
+ TAB_PCDS_FEATURE_FLAG,\r
+ TAB_PCDS_DYNAMIC,\r
+ TAB_PCDS_DYNAMIC_EX}\r
\r
# This dict store PCDs which are not used by any modules with specified arches\r
UnusedPcd = OrderedDict()\r
for Pcd in Pa.Platform.Pcds:\r
PcdType = Pa.Platform.Pcds[Pcd].Type\r
\r
- # If no PCD type, this PCD comes from FDF \r
+ # If no PCD type, this PCD comes from FDF\r
if not PcdType:\r
continue\r
\r
# Try to remove Hii and Vpd suffix\r
- if PcdType.startswith("DynamicEx"):\r
- PcdType = "DynamicEx"\r
- elif PcdType.startswith("Dynamic"):\r
- PcdType = "Dynamic"\r
+ if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r
+ PcdType = TAB_PCDS_DYNAMIC_EX\r
+ elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r
+ PcdType = TAB_PCDS_DYNAMIC\r
\r
for Package in Pa.PackageList:\r
# Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
break\r
- for Type in PcdTypeList:\r
+ for Type in PcdTypeSet:\r
if (Pcd[0], Pcd[1], Type) in Package.Pcds:\r
EdkLogger.error(\r
'build',\r
return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))\r
\r
## Return the directory to store FV files\r
- def _GetFvDir(self):\r
- if self._FvDir is None:\r
- self._FvDir = path.join(self.BuildDir, 'FV')\r
- return self._FvDir\r
+ @cached_property\r
+ def FvDir(self):\r
+ return path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
\r
## Return the directory to store all intermediate and final files built\r
- def _GetBuildDir(self):\r
- if self._BuildDir is None:\r
- return self.AutoGenObjectList[0].BuildDir\r
+ @cached_property\r
+ def BuildDir(self):\r
+ return self.AutoGenObjectList[0].BuildDir\r
\r
## Return the build output directory platform specifies\r
- def _GetOutputDir(self):\r
+ @cached_property\r
+ def OutputDir(self):\r
return self.Platform.OutputDirectory\r
\r
## Return platform name\r
- def _GetName(self):\r
+ @cached_property\r
+ def Name(self):\r
return self.Platform.PlatformName\r
\r
## Return meta-file GUID\r
- def _GetGuid(self):\r
+ @cached_property\r
+ def Guid(self):\r
return self.Platform.Guid\r
\r
## Return platform version\r
- def _GetVersion(self):\r
+ @cached_property\r
+ def Version(self):\r
return self.Platform.Version\r
\r
## Return paths of tools\r
- def _GetToolDefinition(self):\r
+ @cached_property\r
+ def ToolDefinition(self):\r
return self.AutoGenObjectList[0].ToolDefinition\r
\r
## Return directory of platform makefile\r
#\r
# @retval string Makefile directory\r
#\r
- def _GetMakeFileDir(self):\r
- if self._MakeFileDir is None:\r
- self._MakeFileDir = self.BuildDir\r
- return self._MakeFileDir\r
+ @cached_property\r
+ def MakeFileDir(self):\r
+ return self.BuildDir\r
\r
## Return build command string\r
#\r
# @retval string Build command string\r
#\r
- def _GetBuildCommand(self):\r
- if self._BuildCommand is None:\r
- # BuildCommand should be all the same. So just get one from platform AutoGen\r
- self._BuildCommand = self.AutoGenObjectList[0].BuildCommand\r
- return self._BuildCommand\r
+ @cached_property\r
+ def BuildCommand(self):\r
+ # BuildCommand should be all the same. So just get one from platform AutoGen\r
+ return self.AutoGenObjectList[0].BuildCommand\r
\r
## Check the PCDs token value conflict in each DEC file.\r
#\r
# Will cause build break and raise error message while two PCDs conflict.\r
- # \r
+ #\r
# @return None\r
#\r
def _CheckAllPcdsTokenValueConflict(self):\r
for Pa in self.AutoGenObjectList:\r
for Package in Pa.PackageList:\r
- PcdList = Package.Pcds.values()\r
- PcdList.sort(lambda x, y: cmp(int(x.TokenValue, 0), int(y.TokenValue, 0))) \r
+ PcdList = list(Package.Pcds.values())\r
+ PcdList.sort(key=lambda x: int(x.TokenValue, 0))\r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
Item = PcdList[Count]\r
#\r
# Sort same token value PCD list with TokenGuid and TokenCName\r
#\r
- SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
+ SameTokenValuePcdList.sort(key=lambda x: "%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName))\r
SameTokenValuePcdListCount = 0\r
while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):\r
Flag = False\r
Count += SameTokenValuePcdListCount\r
Count += 1\r
\r
- PcdList = Package.Pcds.values()\r
- PcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
+ PcdList = list(Package.Pcds.values())\r
+ PcdList.sort(key=lambda x: "%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName))\r
Count = 0\r
while (Count < len(PcdList) - 1) :\r
Item = PcdList[Count]\r
)\r
Count += 1\r
## Generate fds command\r
- def _GenFdsCommand(self):\r
+ @property\r
+ def GenFdsCommand(self):\r
return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()\r
\r
+ @property\r
+ def GenFdsCommandDict(self):\r
+ FdsCommandDict = {}\r
+ LogLevel = EdkLogger.GetLevel()\r
+ if LogLevel == EdkLogger.VERBOSE:\r
+ FdsCommandDict["verbose"] = True\r
+ elif LogLevel <= EdkLogger.DEBUG_9:\r
+ FdsCommandDict["debug"] = LogLevel - 1\r
+ elif LogLevel == EdkLogger.QUIET:\r
+ FdsCommandDict["quiet"] = True\r
+\r
+ if GlobalData.gEnableGenfdsMultiThread:\r
+ FdsCommandDict["GenfdsMultiThread"] = True\r
+ if GlobalData.gIgnoreSource:\r
+ FdsCommandDict["IgnoreSources"] = True\r
+\r
+ FdsCommandDict["OptionPcd"] = []\r
+ for pcd in GlobalData.BuildOptionPcd:\r
+ if pcd[2]:\r
+ pcdname = '.'.join(pcd[0:3])\r
+ else:\r
+ pcdname = '.'.join(pcd[0:2])\r
+ if pcd[3].startswith('{'):\r
+ FdsCommandDict["OptionPcd"].append(pcdname + '=' + 'H' + '"' + pcd[3] + '"')\r
+ else:\r
+ FdsCommandDict["OptionPcd"].append(pcdname + '=' + pcd[3])\r
+\r
+ MacroList = []\r
+ # macros passed to GenFds\r
+ MacroDict = {}\r
+ MacroDict.update(GlobalData.gGlobalDefines)\r
+ MacroDict.update(GlobalData.gCommandLineDefines)\r
+ for MacroName in MacroDict:\r
+ if MacroDict[MacroName] != "":\r
+ MacroList.append('"%s=%s"' % (MacroName, MacroDict[MacroName].replace('\\', '\\\\')))\r
+ else:\r
+ MacroList.append('"%s"' % MacroName)\r
+ FdsCommandDict["macro"] = MacroList\r
+\r
+ FdsCommandDict["fdf_file"] = [self.FdfFile]\r
+ FdsCommandDict["build_target"] = self.BuildTarget\r
+ FdsCommandDict["toolchain_tag"] = self.ToolChain\r
+ FdsCommandDict["active_platform"] = str(self)\r
+\r
+ FdsCommandDict["conf_directory"] = GlobalData.gConfDirectory\r
+ FdsCommandDict["build_architecture_list"] = ','.join(self.ArchList)\r
+ FdsCommandDict["platform_build_directory"] = self.BuildDir\r
+\r
+ FdsCommandDict["fd"] = self.FdTargetList\r
+ FdsCommandDict["fv"] = self.FvTargetList\r
+ FdsCommandDict["cap"] = self.CapTargetList\r
+ return FdsCommandDict\r
+\r
## Create makefile for the platform and modules in it\r
#\r
# @param CreateDepsMakeFile Flag indicating if the makefile for\r
# modules will be created as well\r
#\r
def CreateMakeFile(self, CreateDepsMakeFile=False):\r
- if CreateDepsMakeFile:\r
- for Pa in self.AutoGenObjectList:\r
- Pa.CreateMakeFile(CreateDepsMakeFile)\r
+ if not CreateDepsMakeFile:\r
+ return\r
+ for Pa in self.AutoGenObjectList:\r
+ Pa.CreateMakeFile(True)\r
\r
## Create autogen code for platform and modules\r
#\r
if not CreateDepsCodeFile:\r
return\r
for Pa in self.AutoGenObjectList:\r
- Pa.CreateCodeFile(CreateDepsCodeFile)\r
+ Pa.CreateCodeFile(True)\r
\r
## Create AsBuilt INF file the platform\r
#\r
def CreateAsBuiltInf(self):\r
return\r
\r
- Name = property(_GetName)\r
- Guid = property(_GetGuid)\r
- Version = property(_GetVersion)\r
- OutputDir = property(_GetOutputDir)\r
-\r
- ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
-\r
- BuildDir = property(_GetBuildDir)\r
- FvDir = property(_GetFvDir)\r
- MakeFileDir = property(_GetMakeFileDir)\r
- BuildCommand = property(_GetBuildCommand)\r
- GenFdsCommand = property(_GenFdsCommand)\r
\r
## AutoGen class for platform\r
#\r
class PlatformAutoGen(AutoGen):\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- try:\r
- self._Init\r
- except:\r
- super(PlatformAutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ if not hasattr(self, "_Init"):\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)\r
self._Init = True\r
#\r
- # Used to store all PCDs for both PEI and DXE phase, in order to generate \r
+ # Used to store all PCDs for both PEI and DXE phase, in order to generate\r
# correct PCD database\r
- # \r
+ #\r
_DynaPcdList_ = []\r
_NonDynaPcdList_ = []\r
_PlatformPcds = {}\r
- \r
+\r
#\r
- # The priority list while override build option \r
+ # The priority list while override build option\r
#\r
PrioList = {"0x11111" : 16, # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE (Highest)\r
"0x01111" : 15, # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
"0x10111" : 14, # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE\r
- "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE \r
+ "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE\r
"0x11011" : 12, # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
"0x01011" : 11, # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
"0x10011" : 10, # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE\r
self.BuildTarget = Target\r
self.Arch = Arch\r
self.SourceDir = PlatformFile.SubDir\r
- self.SourceOverrideDir = None\r
self.FdTargetList = self.Workspace.FdTargetList\r
self.FvTargetList = self.Workspace.FvTargetList\r
- self.AllPcdList = []\r
# get the original module/package/platform objects\r
self.BuildDatabase = Workspace.BuildDatabase\r
self.DscBuildDataObj = Workspace.Platform\r
- self._GuidDict = Workspace._GuidDict\r
\r
# flag indicating if the makefile/C-code file has been created or not\r
self.IsMakeFileCreated = False\r
- self.IsCodeFileCreated = False\r
-\r
- self._Platform = None\r
- self._Name = None\r
- self._Guid = None\r
- self._Version = None\r
-\r
- self._BuildRule = None\r
- self._SourceDir = None\r
- self._BuildDir = None\r
- self._OutputDir = None\r
- self._FvDir = None\r
- self._MakeFileDir = None\r
- self._FdfFile = None\r
-\r
- self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
+\r
self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
- self._NonDynamicPcdDict = {}\r
-\r
- self._ToolDefinitions = None\r
- self._ToolDefFile = None # toolcode : tool path\r
- self._ToolChainFamily = None\r
- self._BuildRuleFamily = None\r
- self._BuildOption = None # toolcode : option\r
- self._EdkBuildOption = None # edktoolcode : option\r
- self._EdkIIBuildOption = None # edkiitoolcode : option\r
- self._PackageList = None\r
- self._ModuleAutoGenList = None\r
- self._LibraryAutoGenList = None\r
- self._BuildCommand = None\r
+\r
self._AsBuildInfList = []\r
self._AsBuildModuleList = []\r
\r
for Inf in self._AsBuildInfList:\r
InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)\r
M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
- if not M.IsSupportedArch:\r
+ if not M.IsBinaryModule:\r
continue\r
self._AsBuildModuleList.append(InfClass)\r
# get library/modules for build\r
\r
return True\r
\r
+ @cached_class_function\r
def __repr__(self):\r
return "%s [%s]" % (self.MetaFile, self.Arch)\r
\r
# @param CreateModuleCodeFile Flag indicating if creating module's\r
# autogen code file or not\r
#\r
+ @cached_class_function\r
def CreateCodeFile(self, CreateModuleCodeFile=False):\r
- # only module has code to be greated, so do nothing if CreateModuleCodeFile is False\r
- if self.IsCodeFileCreated or not CreateModuleCodeFile:\r
+ # only module has code to be created, so do nothing if CreateModuleCodeFile is False\r
+ if not CreateModuleCodeFile:\r
return\r
\r
for Ma in self.ModuleAutoGenList:\r
Ma.CreateCodeFile(True)\r
\r
- # don't do this twice\r
- self.IsCodeFileCreated = True\r
-\r
## Generate Fds Command\r
- def _GenFdsCommand(self):\r
+ @cached_property\r
+ def GenFdsCommand(self):\r
return self.Workspace.GenFdsCommand\r
\r
- ## Create makefile for the platform and mdoules in it\r
+ ## Create makefile for the platform and modules in it\r
#\r
# @param CreateModuleMakeFile Flag indicating if the makefile for\r
# modules will be created as well\r
#\r
def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}):\r
if CreateModuleMakeFile:\r
- for ModuleFile in self.Platform.Modules:\r
- Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,\r
- self.ToolChain, self.Arch, self.MetaFile)\r
- if (ModuleFile.File, self.Arch) in FfsCommand:\r
- Ma.CreateMakeFile(True, FfsCommand[ModuleFile.File, self.Arch])\r
+ for Ma in self._MaList:\r
+ key = (Ma.MetaFile.File, self.Arch)\r
+ if key in FfsCommand:\r
+ Ma.CreateMakeFile(True, FfsCommand[key])\r
else:\r
Ma.CreateMakeFile(True)\r
- #Ma.CreateAsBuiltInf()\r
\r
# no need to create makefile for the platform more than once\r
if self.IsMakeFileCreated:\r
\r
self.IsMakeFileCreated = True\r
\r
+ @property\r
+ def AllPcdList(self):\r
+ return self.DynamicPcdList + self.NonDynamicPcdList\r
## Deal with Shared FixedAtBuild Pcds\r
#\r
def CollectFixedAtBuildPcds(self):\r
for LibAuto in self.LibraryAutoGenList:\r
- FixedAtBuildPcds = {} \r
- ShareFixedAtBuildPcdsSameValue = {} \r
- for Module in LibAuto._ReferenceModules: \r
- for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:\r
- key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName)) \r
+ FixedAtBuildPcds = {}\r
+ ShareFixedAtBuildPcdsSameValue = {}\r
+ for Module in LibAuto.ReferenceModules:\r
+ for Pcd in set(Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds):\r
+ DefaultValue = Pcd.DefaultValue\r
+ # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib\r
+ if Pcd in Module.LibraryPcdList:\r
+ Index = Module.LibraryPcdList.index(Pcd)\r
+ DefaultValue = Module.LibraryPcdList[Index].DefaultValue\r
+ key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
if key not in FixedAtBuildPcds:\r
ShareFixedAtBuildPcdsSameValue[key] = True\r
- FixedAtBuildPcds[key] = Pcd.DefaultValue\r
+ FixedAtBuildPcds[key] = DefaultValue\r
else:\r
- if FixedAtBuildPcds[key] != Pcd.DefaultValue:\r
- ShareFixedAtBuildPcdsSameValue[key] = False \r
+ if FixedAtBuildPcds[key] != DefaultValue:\r
+ ShareFixedAtBuildPcdsSameValue[key] = False\r
for Pcd in LibAuto.FixedAtBuildPcds:\r
- key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
- if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
+ key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
+ if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
continue\r
else:\r
- DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
- if DscPcd.Type != "FixedAtBuild":\r
+ DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r
+ if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
continue\r
- if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
+ if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]:\r
LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]\r
\r
def CollectVariables(self, DynamicPcdSet):\r
-\r
VpdRegionSize = 0\r
VpdRegionBase = 0\r
if self.Workspace.FdfFile:\r
VpdRegionBase = FdRegion.Offset\r
break\r
\r
-\r
- VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(),self.DscBuildDataObj._GetSkuIds())\r
+ VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj.SkuIds)\r
VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)\r
VariableInfo.SetVpdRegionOffset(VpdRegionBase)\r
Index = 0\r
for Pcd in DynamicPcdSet:\r
- pcdname = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
+ pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
for SkuName in Pcd.SkuInfoList:\r
Sku = Pcd.SkuInfoList[SkuName]\r
SkuId = Sku.SkuId\r
if SkuId is None or SkuId == '':\r
continue\r
if len(Sku.VariableName) > 0:\r
+ if Sku.VariableAttribute and 'NV' not in Sku.VariableAttribute:\r
+ continue\r
VariableGuidStructure = Sku.VariableGuidValue\r
VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)\r
for StorageName in Sku.DefaultStoreDict:\r
- VariableInfo.append_variable(var_info(Index,pcdname,StorageName,SkuName, StringToArray(Sku.VariableName),VariableGuid, Sku.VariableOffset, Sku.VariableAttribute , Sku.HiiDefaultValue,Sku.DefaultStoreDict[StorageName],Pcd.DatumType))\r
+ VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName] if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES else StringToArray(Sku.DefaultStoreDict[StorageName]), Pcd.DatumType, Pcd.CustomAttribute['DscPosition'], Pcd.CustomAttribute.get('IsStru',False)))\r
Index += 1\r
return VariableInfo\r
\r
- def UpdateNVStoreMaxSize(self,OrgVpdFile):\r
+ def UpdateNVStoreMaxSize(self, OrgVpdFile):\r
if self.VariableInfo:\r
- VpdMapFilePath = os.path.join(self.BuildDir, "FV", "%s.map" % self.Platform.VpdToolGuid)\r
+ VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]\r
\r
if PcdNvStoreDfBuffer:\r
if os.path.exists(VpdMapFilePath):\r
OrgVpdFile.Read(VpdMapFilePath)\r
PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])\r
- NvStoreOffset = PcdItems.values()[0].strip() if PcdItems else '0'\r
+ NvStoreOffset = list(PcdItems.values())[0].strip() if PcdItems else '0'\r
else:\r
EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
\r
- NvStoreOffset = int(NvStoreOffset,16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)\r
- default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get("DEFAULT")\r
+ NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)\r
+ default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)\r
maxsize = self.VariableInfo.VpdRegionSize - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))\r
var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)\r
\r
default_skuobj.DefaultValue = var_data\r
PcdNvStoreDfBuffer[0].DefaultValue = var_data\r
PcdNvStoreDfBuffer[0].SkuInfoList.clear()\r
- PcdNvStoreDfBuffer[0].SkuInfoList['DEFAULT'] = default_skuobj\r
+ PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj\r
PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))\r
\r
return OrgVpdFile\r
# This interface should be invoked explicitly when platform action is created.\r
#\r
def CollectPlatformDynamicPcds(self):\r
-\r
for key in self.Platform.Pcds:\r
for SinglePcd in GlobalData.MixedPcd:\r
if (self.Platform.Pcds[key].TokenCName, self.Platform.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
for item in GlobalData.MixedPcd[SinglePcd]:\r
Pcd_Type = item[0].split('_')[-1]\r
- if (Pcd_Type == self.Platform.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and self.Platform.Pcds[key].Type in GenC.gDynamicExPcd) or \\r
- (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in GenC.gDynamicPcd):\r
+ if (Pcd_Type == self.Platform.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and self.Platform.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
+ (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
Value = self.Platform.Pcds[key]\r
Value.TokenCName = self.Platform.Pcds[key].TokenCName + '_' + Pcd_Type\r
if len(key) == 2:\r
del self.Platform.Pcds[key]\r
self.Platform.Pcds[newkey] = Value\r
break\r
- else:\r
- pass\r
break\r
- else:\r
- pass\r
\r
# for gathering error information\r
NoDatumTypePcdList = set()\r
for InfName in self._AsBuildInfList:\r
InfName = mws.join(self.WorkspaceDir, InfName)\r
FdfModuleList.append(os.path.normpath(InfName))\r
- for F in self.Platform.Modules.keys():\r
- M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)\r
- #GuidValue.update(M.Guids)\r
- \r
- self.Platform.Modules[F].M = M\r
-\r
+ for M in self._MaList:\r
+# F is the Module for which M is the module autogen\r
for PcdFromModule in M.ModulePcdList + M.LibraryPcdList:\r
# make sure that the "VOID*" kind of datum has MaxDatumSize set\r
- if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
- NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
+ if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
+ NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, M.MetaFile))\r
\r
# Check the PCD from Binary INF or Source INF\r
if M.IsBinaryModule == True:\r
PcdFromModule.IsFromBinaryInf = True\r
\r
- # Check the PCD from DSC or not \r
- if (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds.keys():\r
- PcdFromModule.IsFromDsc = True\r
- else:\r
- PcdFromModule.IsFromDsc = False\r
- if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r
- if F.Path not in FdfModuleList:\r
- # If one of the Source built modules listed in the DSC is not listed \r
- # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic \r
- # access method (it is only listed in the DEC file that declares the \r
+ # Check the PCD from DSC or not\r
+ PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds\r
+\r
+ if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
+ if M.MetaFile.Path not in FdfModuleList:\r
+ # If one of the Source built modules listed in the DSC is not listed\r
+ # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic\r
+ # access method (it is only listed in the DEC file that declares the\r
# PCD as PcdsDynamic), then build tool will report warning message\r
- # notify the PI that they are attempting to build a module that must \r
- # be included in a flash image in order to be functional. These Dynamic \r
- # PCD will not be added into the Database unless it is used by other \r
+ # notify the PI that they are attempting to build a module that must\r
+ # be included in a flash image in order to be functional. These Dynamic\r
+ # PCD will not be added into the Database unless it is used by other\r
# modules that are included in the FDF file.\r
- if PcdFromModule.Type in GenC.gDynamicPcd and \\r
+ if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \\r
PcdFromModule.IsFromBinaryInf == False:\r
# Print warning message to let the developer make a determine.\r
continue\r
- # If one of the Source built modules listed in the DSC is not listed in \r
- # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx \r
- # access method (it is only listed in the DEC file that declares the \r
- # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the \r
+ # If one of the Source built modules listed in the DSC is not listed in\r
+ # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx\r
+ # access method (it is only listed in the DEC file that declares the\r
+ # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the\r
# PCD to the Platform's PCD Database.\r
- if PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
continue\r
#\r
# If a dynamic PCD used by a PEM module/PEI module & DXE module,\r
# used by DXE module, it should be stored in DXE PCD database.\r
# The default Phase is DXE\r
#\r
- if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
+ if M.ModuleType in SUP_MODULE_SET_PEI:\r
PcdFromModule.Phase = "PEI"\r
if PcdFromModule not in self._DynaPcdList_:\r
self._DynaPcdList_.append(PcdFromModule)\r
PcdFromModule.Pending = False\r
self._NonDynaPcdList_.append (PcdFromModule)\r
DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}\r
- # add the PCD from modules that listed in FDF but not in DSC to Database \r
+ # add the PCD from modules that listed in FDF but not in DSC to Database\r
for InfName in FdfModuleList:\r
if InfName not in DscModuleSet:\r
InfClass = PathClass(InfName)\r
M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
- # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source) \r
- # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here. \r
- # For binary module, if in current arch, we need to list the PCDs into database. \r
- if not M.IsSupportedArch:\r
+ # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)\r
+ # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.\r
+ # For binary module, if in current arch, we need to list the PCDs into database.\r
+ if not M.IsBinaryModule:\r
continue\r
# Override the module PCD setting by platform setting\r
ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)\r
PcdFromModule.IsFromBinaryInf = True\r
PcdFromModule.IsFromDsc = False\r
# Only allow the DynamicEx and Patchable PCD in AsBuild INF\r
- if PcdFromModule.Type not in GenC.gDynamicExPcd and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:\r
+ if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:\r
EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
File=self.MetaFile,\r
ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"\r
% (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))\r
# make sure that the "VOID*" kind of datum has MaxDatumSize set\r
- if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
+ if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))\r
- if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
+ if M.ModuleType in SUP_MODULE_SET_PEI:\r
PcdFromModule.Phase = "PEI"\r
- if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
self._DynaPcdList_.append(PcdFromModule)\r
elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:\r
self._NonDynaPcdList_.append(PcdFromModule)\r
- if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in GenC.gDynamicExPcd:\r
+ if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
# Overwrite the phase of any the same PCD existing, if Phase is PEI.\r
- # It is to solve the case that a dynamic PCD used by a PEM module/PEI \r
+ # It is to solve the case that a dynamic PCD used by a PEM module/PEI\r
# module & DXE module at a same time.\r
# Overwrite the type of the PCDs in source INF by the type of AsBuild\r
- # INF file as DynamicEx. \r
+ # INF file as DynamicEx.\r
Index = self._DynaPcdList_.index(PcdFromModule)\r
self._DynaPcdList_[Index].Phase = PcdFromModule.Phase\r
self._DynaPcdList_[Index].Type = PcdFromModule.Type\r
for PcdFromModule in self._NonDynaPcdList_:\r
- # If a PCD is not listed in the DSC file, but binary INF files used by \r
- # this platform all (that use this PCD) list the PCD in a [PatchPcds] \r
- # section, AND all source INF files used by this platform the build \r
- # that use the PCD list the PCD in either a [Pcds] or [PatchPcds] \r
+ # If a PCD is not listed in the DSC file, but binary INF files used by\r
+ # this platform all (that use this PCD) list the PCD in a [PatchPcds]\r
+ # section, AND all source INF files used by this platform the build\r
+ # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]\r
# section, then the tools must NOT add the PCD to the Platform's PCD\r
- # Database; the build must assign the access method for this PCD as \r
+ # Database; the build must assign the access method for this PCD as\r
# PcdsPatchableInModule.\r
if PcdFromModule not in self._DynaPcdList_:\r
continue\r
self._DynamicPcdList = self._DynaPcdList_\r
#\r
# Sort dynamic PCD list to:\r
- # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should \r
+ # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should\r
# try to be put header of dynamicd List\r
# 2) If PCD is HII type, the PCD item should be put after unicode type PCD\r
#\r
VpdFile = VpdInfoFile.VpdInfoFile()\r
NeedProcessVpdMapFile = False\r
\r
- for pcd in self.Platform.Pcds.keys():\r
- if pcd not in self._PlatformPcds.keys():\r
+ for pcd in self.Platform.Pcds:\r
+ if pcd not in self._PlatformPcds:\r
self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]\r
\r
for item in self._PlatformPcds:\r
if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- self._PlatformPcds[item].DatumType = "VOID*"\r
+ self._PlatformPcds[item].DatumType = TAB_VOID\r
\r
- if (self.Workspace.ArchList[-1] == self.Arch): \r
+ if (self.Workspace.ArchList[-1] == self.Arch):\r
for Pcd in self._DynamicPcdList:\r
# just pick the a value to determine whether is unicode string type\r
- Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
+ Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
\r
if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- Pcd.DatumType = "VOID*"\r
+ Pcd.DatumType = TAB_VOID\r
\r
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
# if found HII type PCD then insert to right of UnicodeIndex\r
VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
\r
#Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer\r
- PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer","gEfiMdeModulePkgTokenSpaceGuid"))\r
+ PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))\r
if PcdNvStoreDfBuffer:\r
self.VariableInfo = self.CollectVariables(self._DynamicPcdList)\r
vardump = self.VariableInfo.dump()\r
if vardump:\r
+ #\r
+ #According to PCD_DATABASE_INIT in edk2\MdeModulePkg\Include\Guid\PcdDataBaseSignatureGuid.h,\r
+ #the max size for string PCD should not exceed USHRT_MAX 65535(0xffff).\r
+ #typedef UINT16 SIZE_INFO;\r
+ #//SIZE_INFO SizeTable[];\r
+ if len(vardump.split(",")) > 0xffff:\r
+ EdkLogger.error("build", RESOURCE_OVERFLOW, 'The current length of PCD %s value is %d, it exceeds to the max size of String PCD.' %(".".join([PcdNvStoreDfBuffer.TokenSpaceGuidCName,PcdNvStoreDfBuffer.TokenCName]) ,len(vardump.split(","))))\r
PcdNvStoreDfBuffer.DefaultValue = vardump\r
for skuname in PcdNvStoreDfBuffer.SkuInfoList:\r
PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump\r
PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))\r
-\r
- PlatformPcds = self._PlatformPcds.keys()\r
- PlatformPcds.sort()\r
+ else:\r
+ #If the end user define [DefaultStores] and [XXX.Menufacturing] in DSC, but forget to configure PcdNvStoreDefaultValueBuffer to PcdsDynamicVpd\r
+ if [Pcd for Pcd in self._DynamicPcdList if Pcd.UserDefinedDefaultStoresFlag]:\r
+ EdkLogger.warn("build", "PcdNvStoreDefaultValueBuffer should be defined as PcdsDynamicExVpd in dsc file since the DefaultStores is enabled for this platform.\n%s" %self.Platform.MetaFile.Path)\r
+ PlatformPcds = sorted(self._PlatformPcds.keys())\r
#\r
# Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
#\r
PcdKey in VpdPcdDict:\r
Pcd = VpdPcdDict[PcdKey]\r
SkuValueMap = {}\r
- DefaultSku = Pcd.SkuInfoList.get('DEFAULT')\r
+ DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
PcdValue = DefaultSku.DefaultValue\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(Pcd, 'DEFAULT',DefaultSku.VpdOffset)\r
+ VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)\r
SkuValueMap[PcdValue].append(DefaultSku)\r
\r
- for (SkuName,Sku) in Pcd.SkuInfoList.items():\r
+ for (SkuName, Sku) in Pcd.SkuInfoList.items():\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
PcdValue = Sku.DefaultValue\r
if PcdValue == "":\r
PcdValue = Pcd.DefaultValue\r
- if Sku.VpdOffset != '*':\r
+ if Sku.VpdOffset != TAB_STAR:\r
if PcdValue.startswith("{"):\r
Alignment = 8\r
elif PcdValue.startswith("L"):\r
EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(Pcd, SkuName,Sku.VpdOffset)\r
+ VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)\r
SkuValueMap[PcdValue].append(Sku)\r
# if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
- if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
+ if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:\r
NeedProcessVpdMapFile = True\r
if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '':\r
EdkLogger.error("Build", FILE_NOT_FOUND, \\r
#\r
# Fix the PCDs define in VPD PCD section that never referenced by module.\r
# An example is PCD for signature usage.\r
- # \r
+ #\r
for DscPcd in PlatformPcds:\r
DscPcdEntry = self._PlatformPcds[DscPcd]\r
if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):\r
FoundFlag = False\r
- for VpdPcd in VpdFile._VpdArray.keys():\r
+ for VpdPcd in VpdFile._VpdArray:\r
# This PCD has been referenced by module\r
if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
(VpdPcd.TokenCName == DscPcdEntry.TokenCName):\r
if not FoundFlag :\r
# just pick the a value to determine whether is unicode string type\r
SkuValueMap = {}\r
- SkuObjList = DscPcdEntry.SkuInfoList.items()\r
- DefaultSku = DscPcdEntry.SkuInfoList.get('DEFAULT')\r
+ SkuObjList = list(DscPcdEntry.SkuInfoList.items())\r
+ DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)\r
if DefaultSku:\r
- defaultindex = SkuObjList.index(('DEFAULT',DefaultSku))\r
- SkuObjList[0],SkuObjList[defaultindex] = SkuObjList[defaultindex],SkuObjList[0]\r
- for (SkuName,Sku) in SkuObjList:\r
- Sku.VpdOffset = Sku.VpdOffset.strip() \r
- \r
+ defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))\r
+ SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]\r
+ for (SkuName, Sku) in SkuObjList:\r
+ Sku.VpdOffset = Sku.VpdOffset.strip()\r
+\r
# Need to iterate DEC pcd information to get the value & datumtype\r
for eachDec in self.PackageList:\r
for DecPcd in eachDec.Pcds:\r
EdkLogger.warn("build", "Unreferenced vpd pcd used!",\r
File=self.MetaFile, \\r
ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \\r
- %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path)) \r
- \r
+ %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))\r
+\r
DscPcdEntry.DatumType = DecPcdEntry.DatumType\r
DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue\r
DscPcdEntry.TokenValue = DecPcdEntry.TokenValue\r
DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
# Only fix the value while no value provided in DSC file.\r
if not Sku.DefaultValue:\r
- DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
- \r
+ DscPcdEntry.SkuInfoList[list(DscPcdEntry.SkuInfoList.keys())[0]].DefaultValue = DecPcdEntry.DefaultValue\r
+\r
if DscPcdEntry not in self._DynamicPcdList:\r
self._DynamicPcdList.append(DscPcdEntry)\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
PcdValue = Sku.DefaultValue\r
if PcdValue == "":\r
PcdValue = DscPcdEntry.DefaultValue\r
- if Sku.VpdOffset != '*':\r
+ if Sku.VpdOffset != TAB_STAR:\r
if PcdValue.startswith("{"):\r
Alignment = 8\r
elif PcdValue.startswith("L"):\r
EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))\r
if PcdValue not in SkuValueMap:\r
SkuValueMap[PcdValue] = []\r
- VpdFile.Add(DscPcdEntry, SkuName,Sku.VpdOffset)\r
+ VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)\r
SkuValueMap[PcdValue].append(Sku)\r
- if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
- NeedProcessVpdMapFile = True \r
- if DscPcdEntry.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
+ if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR:\r
+ NeedProcessVpdMapFile = True\r
+ if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
UnicodePcdArray.add(DscPcdEntry)\r
elif len(Sku.VariableName) > 0:\r
HiiPcdArray.add(DscPcdEntry)\r
VpdSkuMap[DscPcd] = SkuValueMap\r
if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \\r
VpdFile.GetCount() != 0:\r
- EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, \r
+ EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
"Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))\r
\r
if VpdFile.GetCount() != 0:\r
self.FixVpdOffset(VpdFile)\r
\r
self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile))\r
+ PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]\r
+ if PcdNvStoreDfBuffer:\r
+ PcdName,PcdGuid = PcdNvStoreDfBuffer[0].TokenCName, PcdNvStoreDfBuffer[0].TokenSpaceGuidCName\r
+ if (PcdName,PcdGuid) in VpdSkuMap:\r
+ DefaultSku = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)\r
+ VpdSkuMap[(PcdName,PcdGuid)] = {DefaultSku.DefaultValue:[SkuObj for SkuObj in PcdNvStoreDfBuffer[0].SkuInfoList.values() ]}\r
\r
# Process VPD map file generated by third party BPDG tool\r
if NeedProcessVpdMapFile:\r
- VpdMapFilePath = os.path.join(self.BuildDir, "FV", "%s.map" % self.Platform.VpdToolGuid)\r
+ VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
if os.path.exists(VpdMapFilePath):\r
VpdFile.Read(VpdMapFilePath)\r
\r
- # Fixup "*" offset\r
+ # Fixup TAB_STAR offset\r
for pcd in VpdSkuMap:\r
vpdinfo = VpdFile.GetVpdInfo(pcd)\r
if vpdinfo is None:\r
# Delete the DynamicPcdList At the last time enter into this function\r
for Pcd in self._DynamicPcdList:\r
# just pick the a value to determine whether is unicode string type\r
- Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
+ Sku = Pcd.SkuInfoList.get(TAB_DEFAULT)\r
Sku.VpdOffset = Sku.VpdOffset.strip()\r
\r
if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
- Pcd.DatumType = "VOID*"\r
+ Pcd.DatumType = TAB_VOID\r
\r
PcdValue = Sku.DefaultValue\r
- if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
+ if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
UnicodePcdArray.add(Pcd)\r
elif len(Sku.VariableName) > 0:\r
self._DynamicPcdList.extend(list(UnicodePcdArray))\r
self._DynamicPcdList.extend(list(HiiPcdArray))\r
self._DynamicPcdList.extend(list(OtherPcdArray))\r
- allskuset = [(SkuName,Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName,Sku) in pcd.SkuInfoList.items()]\r
+ allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]\r
for pcd in self._DynamicPcdList:\r
if len(pcd.SkuInfoList) == 1:\r
- for (SkuName,SkuId) in allskuset:\r
- if type(SkuId) in (str,unicode) and eval(SkuId) == 0 or SkuId == 0:\r
+ for (SkuName, SkuId) in allskuset:\r
+ if isinstance(SkuId, str) and eval(SkuId) == 0 or SkuId == 0:\r
continue\r
- pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList['DEFAULT'])\r
+ pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])\r
pcd.SkuInfoList[SkuName].SkuId = SkuId\r
- self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
+ pcd.SkuInfoList[SkuName].SkuIdName = SkuName\r
\r
- def FixVpdOffset(self,VpdFile ):\r
- FvPath = os.path.join(self.BuildDir, "FV")\r
+ def FixVpdOffset(self, VpdFile ):\r
+ FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
if not os.path.exists(FvPath):\r
try:\r
os.makedirs(FvPath)\r
# retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.\r
BPDGToolName = None\r
for ToolDef in self.ToolDefinition.values():\r
- if ToolDef.has_key("GUID") and ToolDef["GUID"] == self.Platform.VpdToolGuid:\r
- if not ToolDef.has_key("PATH"):\r
+ if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:\r
+ if "PATH" not in ToolDef:\r
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)\r
BPDGToolName = ToolDef["PATH"]\r
break\r
EdkLogger.error("Build", FILE_NOT_FOUND, "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
\r
## Return the platform build data object\r
- def _GetPlatform(self):\r
- if self._Platform is None:\r
- self._Platform = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
- return self._Platform\r
+ @cached_property\r
+ def Platform(self):\r
+ return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
\r
## Return platform name\r
- def _GetName(self):\r
+ @cached_property\r
+ def Name(self):\r
return self.Platform.PlatformName\r
\r
## Return the meta file GUID\r
- def _GetGuid(self):\r
+ @cached_property\r
+ def Guid(self):\r
return self.Platform.Guid\r
\r
## Return the platform version\r
- def _GetVersion(self):\r
+ @cached_property\r
+ def Version(self):\r
return self.Platform.Version\r
\r
## Return the FDF file name\r
- def _GetFdfFile(self):\r
- if self._FdfFile is None:\r
- if self.Workspace.FdfFile != "":\r
- self._FdfFile= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
- else:\r
- self._FdfFile = ''\r
- return self._FdfFile\r
+ @cached_property\r
+ def FdfFile(self):\r
+ if self.Workspace.FdfFile:\r
+ RetVal= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
+ else:\r
+ RetVal = ''\r
+ return RetVal\r
\r
## Return the build output directory platform specifies\r
- def _GetOutputDir(self):\r
+ @cached_property\r
+ def OutputDir(self):\r
return self.Platform.OutputDirectory\r
\r
## Return the directory to store all intermediate and final files built\r
- def _GetBuildDir(self):\r
- if self._BuildDir is None:\r
- if os.path.isabs(self.OutputDir):\r
- self._BuildDir = path.join(\r
- path.abspath(self.OutputDir),\r
- self.BuildTarget + "_" + self.ToolChain,\r
- )\r
- else:\r
- self._BuildDir = path.join(\r
- self.WorkspaceDir,\r
- self.OutputDir,\r
- self.BuildTarget + "_" + self.ToolChain,\r
- )\r
- GlobalData.gBuildDirectory = self._BuildDir\r
- return self._BuildDir\r
+ @cached_property\r
+ def BuildDir(self):\r
+ if os.path.isabs(self.OutputDir):\r
+ GlobalData.gBuildDirectory = RetVal = path.join(\r
+ path.abspath(self.OutputDir),\r
+ self.BuildTarget + "_" + self.ToolChain,\r
+ )\r
+ else:\r
+ GlobalData.gBuildDirectory = RetVal = path.join(\r
+ self.WorkspaceDir,\r
+ self.OutputDir,\r
+ self.BuildTarget + "_" + self.ToolChain,\r
+ )\r
+ return RetVal\r
\r
## Return directory of platform makefile\r
#\r
# @retval string Makefile directory\r
#\r
- def _GetMakeFileDir(self):\r
- if self._MakeFileDir is None:\r
- self._MakeFileDir = path.join(self.BuildDir, self.Arch)\r
- return self._MakeFileDir\r
+ @cached_property\r
+ def MakeFileDir(self):\r
+ return path.join(self.BuildDir, self.Arch)\r
\r
## Return build command string\r
#\r
# @retval string Build command string\r
#\r
- def _GetBuildCommand(self):\r
- if self._BuildCommand is None:\r
- self._BuildCommand = []\r
- if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:\r
- self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])\r
- if "FLAGS" in self.ToolDefinition["MAKE"]:\r
- NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()\r
- if NewOption != '':\r
- self._BuildCommand += SplitOption(NewOption)\r
- if "MAKE" in self.EdkIIBuildOption:\r
- if "FLAGS" in self.EdkIIBuildOption["MAKE"]:\r
- Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]\r
- if Flags.startswith('='):\r
- self._BuildCommand = [self._BuildCommand[0]] + [Flags[1:]]\r
- else:\r
- self._BuildCommand += [Flags]\r
- return self._BuildCommand\r
+ @cached_property\r
+ def BuildCommand(self):\r
+ RetVal = []\r
+ if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:\r
+ RetVal += _SplitOption(self.ToolDefinition["MAKE"]["PATH"])\r
+ if "FLAGS" in self.ToolDefinition["MAKE"]:\r
+ NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()\r
+ if NewOption != '':\r
+ RetVal += _SplitOption(NewOption)\r
+ if "MAKE" in self.EdkIIBuildOption:\r
+ if "FLAGS" in self.EdkIIBuildOption["MAKE"]:\r
+ Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]\r
+ if Flags.startswith('='):\r
+ RetVal = [RetVal[0]] + [Flags[1:]]\r
+ else:\r
+ RetVal.append(Flags)\r
+ return RetVal\r
\r
## Get tool chain definition\r
#\r
- # Get each tool defition for given tool chain from tools_def.txt and platform\r
+ # Get each tool definition for given tool chain from tools_def.txt and platform\r
#\r
- def _GetToolDefinition(self):\r
- if self._ToolDefinitions is None:\r
- ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary\r
- if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:\r
- EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",\r
- ExtraData="[%s]" % self.MetaFile)\r
- self._ToolDefinitions = {}\r
- DllPathList = set()\r
- for Def in ToolDefinition:\r
- Target, Tag, Arch, Tool, Attr = Def.split("_")\r
- if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:\r
- continue\r
+ @cached_property\r
+ def ToolDefinition(self):\r
+ ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary\r
+ if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:\r
+ EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",\r
+ ExtraData="[%s]" % self.MetaFile)\r
+ RetVal = {}\r
+ DllPathList = set()\r
+ for Def in ToolDefinition:\r
+ Target, Tag, Arch, Tool, Attr = Def.split("_")\r
+ if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:\r
+ continue\r
\r
- Value = ToolDefinition[Def]\r
- # don't record the DLL\r
- if Attr == "DLL":\r
- DllPathList.add(Value)\r
- continue\r
+ Value = ToolDefinition[Def]\r
+ # don't record the DLL\r
+ if Attr == "DLL":\r
+ DllPathList.add(Value)\r
+ continue\r
\r
- if Tool not in self._ToolDefinitions:\r
- self._ToolDefinitions[Tool] = {}\r
- self._ToolDefinitions[Tool][Attr] = Value\r
-\r
- ToolsDef = ''\r
- if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:\r
- if "FLAGS" not in self._ToolDefinitions["MAKE"]:\r
- self._ToolDefinitions["MAKE"]["FLAGS"] = ""\r
- self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"\r
- MakeFlags = ''\r
- for Tool in self._ToolDefinitions:\r
- for Attr in self._ToolDefinitions[Tool]:\r
- Value = self._ToolDefinitions[Tool][Attr]\r
- if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:\r
- # check if override is indicated\r
- if self.BuildOption[Tool][Attr].startswith('='):\r
- Value = self.BuildOption[Tool][Attr][1:]\r
- else:\r
- if Attr != 'PATH':\r
- Value += " " + self.BuildOption[Tool][Attr]\r
- else:\r
- Value = self.BuildOption[Tool][Attr]\r
-\r
- if Attr == "PATH":\r
- # Don't put MAKE definition in the file\r
- if Tool != "MAKE":\r
- ToolsDef += "%s = %s\n" % (Tool, Value)\r
- elif Attr != "DLL":\r
- # Don't put MAKE definition in the file\r
- if Tool == "MAKE":\r
- if Attr == "FLAGS":\r
- MakeFlags = Value\r
+ if Tool not in RetVal:\r
+ RetVal[Tool] = {}\r
+ RetVal[Tool][Attr] = Value\r
+\r
+ ToolsDef = ''\r
+ if GlobalData.gOptions.SilentMode and "MAKE" in RetVal:\r
+ if "FLAGS" not in RetVal["MAKE"]:\r
+ RetVal["MAKE"]["FLAGS"] = ""\r
+ RetVal["MAKE"]["FLAGS"] += " -s"\r
+ MakeFlags = ''\r
+ for Tool in RetVal:\r
+ for Attr in RetVal[Tool]:\r
+ Value = RetVal[Tool][Attr]\r
+ if Tool in self._BuildOptionWithToolDef(RetVal) and Attr in self._BuildOptionWithToolDef(RetVal)[Tool]:\r
+ # check if override is indicated\r
+ if self._BuildOptionWithToolDef(RetVal)[Tool][Attr].startswith('='):\r
+ Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr][1:]\r
+ else:\r
+ if Attr != 'PATH':\r
+ Value += " " + self._BuildOptionWithToolDef(RetVal)[Tool][Attr]\r
else:\r
- ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)\r
- ToolsDef += "\n"\r
+ Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr]\r
+\r
+ if Attr == "PATH":\r
+ # Don't put MAKE definition in the file\r
+ if Tool != "MAKE":\r
+ ToolsDef += "%s = %s\n" % (Tool, Value)\r
+ elif Attr != "DLL":\r
+ # Don't put MAKE definition in the file\r
+ if Tool == "MAKE":\r
+ if Attr == "FLAGS":\r
+ MakeFlags = Value\r
+ else:\r
+ ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)\r
+ ToolsDef += "\n"\r
\r
- SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)\r
- for DllPath in DllPathList:\r
- os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]\r
- os.environ["MAKE_FLAGS"] = MakeFlags\r
+ SaveFileOnChange(self.ToolDefinitionFile, ToolsDef, False)\r
+ for DllPath in DllPathList:\r
+ os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]\r
+ os.environ["MAKE_FLAGS"] = MakeFlags\r
\r
- return self._ToolDefinitions\r
+ return RetVal\r
\r
## Return the paths of tools\r
- def _GetToolDefFile(self):\r
- if self._ToolDefFile is None:\r
- self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)\r
- return self._ToolDefFile\r
+ @cached_property\r
+ def ToolDefinitionFile(self):\r
+ return os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)\r
\r
## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.\r
- def _GetToolChainFamily(self):\r
- if self._ToolChainFamily is None:\r
- ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
- if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \\r
- or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
- or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:\r
- EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
- % self.ToolChain)\r
- self._ToolChainFamily = "MSFT"\r
- else:\r
- self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]\r
- return self._ToolChainFamily\r
-\r
- def _GetBuildRuleFamily(self):\r
- if self._BuildRuleFamily is None:\r
- ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
- if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \\r
- or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
- or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:\r
- EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
- % self.ToolChain)\r
- self._BuildRuleFamily = "MSFT"\r
- else:\r
- self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]\r
- return self._BuildRuleFamily\r
+ @cached_property\r
+ def ToolChainFamily(self):\r
+ ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
+ if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \\r
+ or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
+ or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:\r
+ EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
+ % self.ToolChain)\r
+ RetVal = TAB_COMPILER_MSFT\r
+ else:\r
+ RetVal = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]\r
+ return RetVal\r
+\r
+ @cached_property\r
+ def BuildRuleFamily(self):\r
+ ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
+ if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \\r
+ or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
+ or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:\r
+ EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
+ % self.ToolChain)\r
+ return TAB_COMPILER_MSFT\r
+\r
+ return ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]\r
\r
## Return the build options specific for all modules in this platform\r
- def _GetBuildOptions(self):\r
- if self._BuildOption is None:\r
- self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)\r
- return self._BuildOption\r
+ @cached_property\r
+ def BuildOption(self):\r
+ return self._ExpandBuildOption(self.Platform.BuildOptions)\r
+\r
+ def _BuildOptionWithToolDef(self, ToolDef):\r
+ return self._ExpandBuildOption(self.Platform.BuildOptions, ToolDef=ToolDef)\r
\r
## Return the build options specific for EDK modules in this platform\r
- def _GetEdkBuildOptions(self):\r
- if self._EdkBuildOption is None:\r
- self._EdkBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)\r
- return self._EdkBuildOption\r
+ @cached_property\r
+ def EdkBuildOption(self):\r
+ return self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)\r
\r
## Return the build options specific for EDKII modules in this platform\r
- def _GetEdkIIBuildOptions(self):\r
- if self._EdkIIBuildOption is None:\r
- self._EdkIIBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)\r
- return self._EdkIIBuildOption\r
+ @cached_property\r
+ def EdkIIBuildOption(self):\r
+ return self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)\r
\r
## Parse build_rule.txt in Conf Directory.\r
#\r
# @retval BuildRule object\r
#\r
- def _GetBuildRule(self):\r
- if self._BuildRule is None:\r
- BuildRuleFile = None\r
- if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:\r
- BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
- if BuildRuleFile in [None, '']:\r
- BuildRuleFile = gDefaultBuildRuleFile\r
- self._BuildRule = BuildRule(BuildRuleFile)\r
- if self._BuildRule._FileVersion == "":\r
- self._BuildRule._FileVersion = AutoGenReqBuildRuleVerNum\r
- else:\r
- if self._BuildRule._FileVersion < AutoGenReqBuildRuleVerNum :\r
- # If Build Rule's version is less than the version number required by the tools, halting the build.\r
- EdkLogger.error("build", AUTOGEN_ERROR,\r
- ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\\r
- % (self._BuildRule._FileVersion, AutoGenReqBuildRuleVerNum))\r
-\r
- return self._BuildRule\r
+ @cached_property\r
+ def BuildRule(self):\r
+ BuildRuleFile = None\r
+ if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:\r
+ BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
+ if not BuildRuleFile:\r
+ BuildRuleFile = gDefaultBuildRuleFile\r
+ RetVal = BuildRule(BuildRuleFile)\r
+ if RetVal._FileVersion == "":\r
+ RetVal._FileVersion = AutoGenReqBuildRuleVerNum\r
+ else:\r
+ if RetVal._FileVersion < AutoGenReqBuildRuleVerNum :\r
+ # If Build Rule's version is less than the version number required by the tools, halting the build.\r
+ EdkLogger.error("build", AUTOGEN_ERROR,\r
+ ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\\r
+ % (RetVal._FileVersion, AutoGenReqBuildRuleVerNum))\r
+ return RetVal\r
\r
## Summarize the packages used by modules in this platform\r
- def _GetPackageList(self):\r
- if self._PackageList is None:\r
- self._PackageList = set()\r
- for La in self.LibraryAutoGenList:\r
- self._PackageList.update(La.DependentPackageList)\r
- for Ma in self.ModuleAutoGenList:\r
- self._PackageList.update(Ma.DependentPackageList)\r
- #Collect package set information from INF of FDF\r
- PkgSet = set()\r
- for ModuleFile in self._AsBuildModuleList:\r
- if ModuleFile in self.Platform.Modules:\r
- continue\r
- ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]\r
- PkgSet.update(ModuleData.Packages)\r
- self._PackageList = list(self._PackageList) + list (PkgSet)\r
- return self._PackageList\r
+ @cached_property\r
+ def PackageList(self):\r
+ RetVal = set()\r
+ for La in self.LibraryAutoGenList:\r
+ RetVal.update(La.DependentPackageList)\r
+ for Ma in self.ModuleAutoGenList:\r
+ RetVal.update(Ma.DependentPackageList)\r
+ #Collect package set information from INF of FDF\r
+ for ModuleFile in self._AsBuildModuleList:\r
+ if ModuleFile in self.Platform.Modules:\r
+ continue\r
+ ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]\r
+ RetVal.update(ModuleData.Packages)\r
+ return list(RetVal)\r
\r
- def _GetNonDynamicPcdDict(self):\r
- if self._NonDynamicPcdDict:\r
- return self._NonDynamicPcdDict\r
- for Pcd in self.NonDynamicPcdList:\r
- self._NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)] = Pcd\r
- return self._NonDynamicPcdDict\r
+ @cached_property\r
+ def NonDynamicPcdDict(self):\r
+ return {(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):Pcd for Pcd in self.NonDynamicPcdList}\r
\r
## Get list of non-dynamic PCDs\r
- def _GetNonDynamicPcdList(self):\r
- if self._NonDynamicPcdList is None:\r
+ @property\r
+ def NonDynamicPcdList(self):\r
+ if not self._NonDynamicPcdList:\r
self.CollectPlatformDynamicPcds()\r
return self._NonDynamicPcdList\r
\r
## Get list of dynamic PCDs\r
- def _GetDynamicPcdList(self):\r
- if self._DynamicPcdList is None:\r
+ @property\r
+ def DynamicPcdList(self):\r
+ if not self._DynamicPcdList:\r
self.CollectPlatformDynamicPcds()\r
return self._DynamicPcdList\r
\r
## Generate Token Number for all PCD\r
- def _GetPcdTokenNumbers(self):\r
- if self._PcdTokenNumber is None:\r
- self._PcdTokenNumber = OrderedDict()\r
- TokenNumber = 1\r
- #\r
- # Make the Dynamic and DynamicEx PCD use within different TokenNumber area. \r
- # Such as:\r
- # \r
- # Dynamic PCD:\r
- # TokenNumber 0 ~ 10\r
- # DynamicEx PCD:\r
- # TokeNumber 11 ~ 20\r
- #\r
- for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "PEI":\r
- if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
-\r
- for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "PEI":\r
- if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
-\r
- for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "DXE":\r
- if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
-\r
- for Pcd in self.DynamicPcdList:\r
- if Pcd.Phase == "DXE":\r
- if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\r
- EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
- TokenNumber += 1\r
-\r
- for Pcd in self.NonDynamicPcdList:\r
- self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ @cached_property\r
+ def PcdTokenNumber(self):\r
+ RetVal = OrderedDict()\r
+ TokenNumber = 1\r
+ #\r
+ # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.\r
+ # Such as:\r
+ #\r
+ # Dynamic PCD:\r
+ # TokenNumber 0 ~ 10\r
+ # DynamicEx PCD:\r
+ # TokeNumber 11 ~ 20\r
+ #\r
+ for Pcd in self.DynamicPcdList:\r
+ if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
+\r
+ for Pcd in self.DynamicPcdList:\r
+ if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
TokenNumber += 1\r
- return self._PcdTokenNumber\r
\r
- ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform\r
- def _GetAutoGenObjectList(self):\r
- self._ModuleAutoGenList = []\r
- self._LibraryAutoGenList = []\r
+ for Pcd in self.DynamicPcdList:\r
+ if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
+\r
+ for Pcd in self.DynamicPcdList:\r
+ if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
+ EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
+ RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
+\r
+ for Pcd in self.NonDynamicPcdList:\r
+ RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
+ TokenNumber += 1\r
+ return RetVal\r
+\r
+ @cached_property\r
+ def _MaList(self):\r
for ModuleFile in self.Platform.Modules:\r
Ma = ModuleAutoGen(\r
- self.Workspace,\r
- ModuleFile,\r
- self.BuildTarget,\r
- self.ToolChain,\r
- self.Arch,\r
- self.MetaFile\r
- )\r
- if Ma not in self._ModuleAutoGenList:\r
- self._ModuleAutoGenList.append(Ma)\r
- for La in Ma.LibraryAutoGenList:\r
- if La not in self._LibraryAutoGenList:\r
- self._LibraryAutoGenList.append(La)\r
- if Ma not in La._ReferenceModules:\r
- La._ReferenceModules.append(Ma)\r
+ self.Workspace,\r
+ ModuleFile,\r
+ self.BuildTarget,\r
+ self.ToolChain,\r
+ self.Arch,\r
+ self.MetaFile\r
+ )\r
+ self.Platform.Modules[ModuleFile].M = Ma\r
+ return [x.M for x in self.Platform.Modules.values()]\r
\r
## Summarize ModuleAutoGen objects of all modules to be built for this platform\r
- def _GetModuleAutoGenList(self):\r
- if self._ModuleAutoGenList is None:\r
- self._GetAutoGenObjectList()\r
- return self._ModuleAutoGenList\r
+ @cached_property\r
+ def ModuleAutoGenList(self):\r
+ RetVal = []\r
+ for Ma in self._MaList:\r
+ if Ma not in RetVal:\r
+ RetVal.append(Ma)\r
+ return RetVal\r
\r
## Summarize ModuleAutoGen objects of all libraries to be built for this platform\r
- def _GetLibraryAutoGenList(self):\r
- if self._LibraryAutoGenList is None:\r
- self._GetAutoGenObjectList()\r
- return self._LibraryAutoGenList\r
+ @cached_property\r
+ def LibraryAutoGenList(self):\r
+ RetVal = []\r
+ for Ma in self._MaList:\r
+ for La in Ma.LibraryAutoGenList:\r
+ if La not in RetVal:\r
+ RetVal.append(La)\r
+ if Ma not in La.ReferenceModules:\r
+ La.ReferenceModules.append(Ma)\r
+ return RetVal\r
\r
## Test if a module is supported by the platform\r
#\r
if str(Module) not in self.Platform.Modules:\r
return []\r
\r
- ModuleType = Module.ModuleType\r
-\r
- # for overridding library instances with module specific setting\r
- PlatformModule = self.Platform.Modules[str(Module)]\r
-\r
- # add forced library instances (specified under LibraryClasses sections)\r
- #\r
- # If a module has a MODULE_TYPE of USER_DEFINED,\r
- # do not link in NULL library class instances from the global [LibraryClasses.*] sections.\r
- #\r
- if Module.ModuleType != SUP_MODULE_USER_DEFINED:\r
- for LibraryClass in self.Platform.LibraryClasses.GetKeys():\r
- if LibraryClass.startswith("NULL") and self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]:\r
- Module.LibraryClasses[LibraryClass] = self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]\r
-\r
- # add forced library instances (specified in module overrides)\r
- for LibraryClass in PlatformModule.LibraryClasses:\r
- if LibraryClass.startswith("NULL"):\r
- Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]\r
-\r
- # EdkII module\r
- LibraryConsumerList = [Module]\r
- Constructor = []\r
- ConsumedByList = OrderedDict()\r
- LibraryInstance = OrderedDict()\r
-\r
- EdkLogger.verbose("")\r
- EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
- while len(LibraryConsumerList) > 0:\r
- M = LibraryConsumerList.pop()\r
- for LibraryClassName in M.LibraryClasses:\r
- if LibraryClassName not in LibraryInstance:\r
- # override library instance for this module\r
- if LibraryClassName in PlatformModule.LibraryClasses:\r
- LibraryPath = PlatformModule.LibraryClasses[LibraryClassName]\r
- else:\r
- LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]\r
- if LibraryPath is None or LibraryPath == "":\r
- LibraryPath = M.LibraryClasses[LibraryClassName]\r
- if LibraryPath is None or LibraryPath == "":\r
- EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
- "Instance of library class [%s] is not found" % LibraryClassName,\r
- File=self.MetaFile,\r
- ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module)))\r
-\r
- LibraryModule = self.BuildDatabase[LibraryPath, self.Arch, self.BuildTarget, self.ToolChain]\r
- # for those forced library instance (NULL library), add a fake library class\r
- if LibraryClassName.startswith("NULL"):\r
- LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))\r
- elif LibraryModule.LibraryClass is None \\r
- or len(LibraryModule.LibraryClass) == 0 \\r
- or (ModuleType != 'USER_DEFINED'\r
- and ModuleType not in LibraryModule.LibraryClass[0].SupModList):\r
- # only USER_DEFINED can link against any library instance despite of its SupModList\r
- EdkLogger.error("build", OPTION_MISSING,\r
- "Module type [%s] is not supported by library instance [%s]" \\r
- % (ModuleType, LibraryPath), File=self.MetaFile,\r
- ExtraData="consumed by [%s]" % str(Module))\r
-\r
- LibraryInstance[LibraryClassName] = LibraryModule\r
- LibraryConsumerList.append(LibraryModule)\r
- EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))\r
- else:\r
- LibraryModule = LibraryInstance[LibraryClassName]\r
-\r
- if LibraryModule is None:\r
- continue\r
-\r
- if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
- Constructor.append(LibraryModule)\r
-\r
- if LibraryModule not in ConsumedByList:\r
- ConsumedByList[LibraryModule] = []\r
- # don't add current module itself to consumer list\r
- if M != Module:\r
- if M in ConsumedByList[LibraryModule]:\r
- continue\r
- ConsumedByList[LibraryModule].append(M)\r
- #\r
- # Initialize the sorted output list to the empty set\r
- #\r
- SortedLibraryList = []\r
- #\r
- # Q <- Set of all nodes with no incoming edges\r
- #\r
- LibraryList = [] #LibraryInstance.values()\r
- Q = []\r
- for LibraryClassName in LibraryInstance:\r
- M = LibraryInstance[LibraryClassName]\r
- LibraryList.append(M)\r
- if ConsumedByList[M] == []:\r
- Q.append(M)\r
-\r
- #\r
- # start the DAG algorithm\r
- #\r
- while True:\r
- EdgeRemoved = True\r
- while Q == [] and EdgeRemoved:\r
- EdgeRemoved = False\r
- # for each node Item with a Constructor\r
- for Item in LibraryList:\r
- if Item not in Constructor:\r
- continue\r
- # for each Node without a constructor with an edge e from Item to Node\r
- for Node in ConsumedByList[Item]:\r
- if Node in Constructor:\r
- continue\r
- # remove edge e from the graph if Node has no constructor\r
- ConsumedByList[Item].remove(Node)\r
- EdgeRemoved = True\r
- if ConsumedByList[Item] == []:\r
- # insert Item into Q\r
- Q.insert(0, Item)\r
- break\r
- if Q != []:\r
- break\r
- # DAG is done if there's no more incoming edge for all nodes\r
- if Q == []:\r
- break\r
-\r
- # remove node from Q\r
- Node = Q.pop()\r
- # output Node\r
- SortedLibraryList.append(Node)\r
-\r
- # for each node Item with an edge e from Node to Item do\r
- for Item in LibraryList:\r
- if Node not in ConsumedByList[Item]:\r
- continue\r
- # remove edge e from the graph\r
- ConsumedByList[Item].remove(Node)\r
-\r
- if ConsumedByList[Item] != []:\r
- continue\r
- # insert Item into Q, if Item has no other incoming edges\r
- Q.insert(0, Item)\r
-\r
- #\r
- # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
- #\r
- for Item in LibraryList:\r
- if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
- ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])\r
- EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),\r
- ExtraData=ErrorMessage, File=self.MetaFile)\r
- if Item not in SortedLibraryList:\r
- SortedLibraryList.append(Item)\r
-\r
- #\r
- # Build the list of constructor and destructir names\r
- # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
- #\r
- SortedLibraryList.reverse()\r
- return SortedLibraryList\r
-\r
+ return GetModuleLibInstances(Module,\r
+ self.Platform,\r
+ self.BuildDatabase,\r
+ self.Arch,\r
+ self.BuildTarget,\r
+ self.ToolChain,\r
+ self.MetaFile,\r
+ EdkLogger)\r
\r
## Override PCD setting (type, value, ...)\r
#\r
- # @param ToPcd The PCD to be overrided\r
- # @param FromPcd The PCD overrideing from\r
+ # @param ToPcd The PCD to be overridden\r
+ # @param FromPcd The PCD overriding from\r
#\r
- def _OverridePcd(self, ToPcd, FromPcd, Module=""):\r
+ def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):\r
#\r
# in case there's PCDs coming from FDF file, which have no type given.\r
# at this point, ToPcd.Type has the type found from dependent\r
TokenCName = PcdItem[0]\r
break\r
if FromPcd is not None:\r
- if ToPcd.Pending and FromPcd.Type not in [None, '']:\r
+ if ToPcd.Pending and FromPcd.Type:\r
ToPcd.Type = FromPcd.Type\r
- elif (ToPcd.Type not in [None, '']) and (FromPcd.Type not in [None, ''])\\r
- and (ToPcd.Type != FromPcd.Type) and (ToPcd.Type in FromPcd.Type):\r
- if ToPcd.Type.strip() == "DynamicEx":\r
+ elif ToPcd.Type and FromPcd.Type\\r
+ and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:\r
+ if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:\r
ToPcd.Type = FromPcd.Type\r
- elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \\r
+ elif ToPcd.Type and FromPcd.Type \\r
and ToPcd.Type != FromPcd.Type:\r
+ if Library:\r
+ Module = str(Module) + " 's library file (" + str(Library) + ")"\r
EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",\r
- ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\\r
+ ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\\r
% (ToPcd.TokenSpaceGuidCName, TokenCName,\r
- ToPcd.Type, Module, FromPcd.Type),\r
+ ToPcd.Type, Module, FromPcd.Type, Msg),\r
File=self.MetaFile)\r
\r
if FromPcd.MaxDatumSize:\r
ToPcd.DatumType = FromPcd.DatumType\r
if FromPcd.SkuInfoList:\r
ToPcd.SkuInfoList = FromPcd.SkuInfoList\r
+ if FromPcd.UserDefinedDefaultStoresFlag:\r
+ ToPcd.UserDefinedDefaultStoresFlag = FromPcd.UserDefinedDefaultStoresFlag\r
# Add Flexible PCD format parse\r
if ToPcd.DefaultValue:\r
try:\r
- ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self._GuidDict)(True)\r
- except BadExpression, Value:\r
+ ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self.Workspace._GuidDict)(True)\r
+ except BadExpression as Value:\r
EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),\r
File=self.MetaFile)\r
\r
ToPcd.validateranges = FromPcd.validateranges\r
ToPcd.validlists = FromPcd.validlists\r
ToPcd.expressions = FromPcd.expressions\r
+ ToPcd.CustomAttribute = FromPcd.CustomAttribute\r
\r
- if FromPcd is not None and ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:\r
+ if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:\r
EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \\r
% (ToPcd.TokenSpaceGuidCName, TokenCName))\r
Value = ToPcd.DefaultValue\r
- if Value in [None, '']:\r
+ if not Value:\r
ToPcd.MaxDatumSize = '1'\r
elif Value[0] == 'L':\r
ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
ToPcd.MaxDatumSize = str(len(Value) - 1)\r
\r
# apply default SKU for dynamic PCDS if specified one is not available\r
- if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r
- and ToPcd.SkuInfoList in [None, {}, '']:\r
+ if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \\r
+ and not ToPcd.SkuInfoList:\r
if self.Platform.SkuName in self.Platform.SkuIds:\r
SkuName = self.Platform.SkuName\r
else:\r
- SkuName = 'DEFAULT'\r
+ SkuName = TAB_DEFAULT\r
ToPcd.SkuInfoList = {\r
SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)\r
}\r
\r
## Apply PCD setting defined platform to a module\r
#\r
- # @param Module The module from which the PCD setting will be overrided\r
+ # @param Module The module from which the PCD setting will be overridden\r
#\r
# @retval PCD_list The list PCDs with settings from platform\r
#\r
- def ApplyPcdSetting(self, Module, Pcds):\r
+ def ApplyPcdSetting(self, Module, Pcds, Library=""):\r
# for each PCD in module\r
for Name, Guid in Pcds:\r
PcdInModule = Pcds[Name, Guid]\r
else:\r
PcdInPlatform = None\r
# then override the settings if any\r
- self._OverridePcd(PcdInModule, PcdInPlatform, Module)\r
+ self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)\r
# resolve the VariableGuid value\r
for SkuId in PcdInModule.SkuInfoList:\r
Sku = PcdInModule.SkuInfoList[SkuId]\r
if Sku.VariableGuid == '': continue\r
Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)\r
if Sku.VariableGuidValue is None:\r
- PackageList = "\n\t".join([str(P) for P in self.PackageList])\r
+ PackageList = "\n\t".join(str(P) for P in self.PackageList)\r
EdkLogger.error(\r
'build',\r
RESOURCE_NOT_AVAILABLE,\r
if Module in self.Platform.Modules:\r
PlatformModule = self.Platform.Modules[str(Module)]\r
for Key in PlatformModule.Pcds:\r
+ if GlobalData.BuildOptionPcd:\r
+ for pcd in GlobalData.BuildOptionPcd:\r
+ (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue, _) = pcd\r
+ if (TokenCName, TokenSpaceGuidCName) == Key and FieldName =="":\r
+ PlatformModule.Pcds[Key].DefaultValue = pcdvalue\r
+ PlatformModule.Pcds[Key].PcdValueFromComm = pcdvalue\r
+ break\r
Flag = False\r
if Key in Pcds:\r
ToPcd = Pcds[Key]\r
Flag = True\r
break\r
if Flag:\r
- self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module)\r
+ self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)\r
# use PCD value to calculate the MaxDatumSize when it is not specified\r
for Name, Guid in Pcds:\r
Pcd = Pcds[Name, Guid]\r
- if Pcd.DatumType == "VOID*" and Pcd.MaxDatumSize in ['', None]:\r
+ if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:\r
Pcd.MaxSizeUserSet = None\r
Value = Pcd.DefaultValue\r
- if Value in [None, '']:\r
+ if not Value:\r
Pcd.MaxDatumSize = '1'\r
elif Value[0] == 'L':\r
Pcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
Pcd.MaxDatumSize = str(len(Value.split(',')))\r
else:\r
Pcd.MaxDatumSize = str(len(Value) - 1)\r
- return Pcds.values()\r
+ return list(Pcds.values())\r
\r
- ## Resolve library names to library modules\r
- #\r
- # (for Edk.x modules)\r
- #\r
- # @param Module The module from which the library names will be resolved\r
- #\r
- # @retval library_list The list of library modules\r
- #\r
- def ResolveLibraryReference(self, Module):\r
- EdkLogger.verbose("")\r
- EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
- LibraryConsumerList = [Module]\r
-\r
- # "CompilerStub" is a must for Edk modules\r
- if Module.Libraries:\r
- Module.Libraries.append("CompilerStub")\r
- LibraryList = []\r
- while len(LibraryConsumerList) > 0:\r
- M = LibraryConsumerList.pop()\r
- for LibraryName in M.Libraries:\r
- Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']\r
- if Library is None:\r
- for Key in self.Platform.LibraryClasses.data.keys():\r
- if LibraryName.upper() == Key.upper():\r
- Library = self.Platform.LibraryClasses[Key, ':dummy:']\r
- break\r
- if Library is None:\r
- EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),\r
- ExtraData="\t%s [%s]" % (str(Module), self.Arch))\r
- continue\r
\r
- if Library not in LibraryList:\r
- LibraryList.append(Library)\r
- LibraryConsumerList.append(Library)\r
- EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))\r
- return LibraryList\r
\r
## Calculate the priority value of the build option\r
#\r
def CalculatePriorityValue(self, Key):\r
Target, ToolChain, Arch, CommandType, Attr = Key.split('_')\r
PriorityValue = 0x11111\r
- if Target == "*":\r
+ if Target == TAB_STAR:\r
PriorityValue &= 0x01111\r
- if ToolChain == "*":\r
+ if ToolChain == TAB_STAR:\r
PriorityValue &= 0x10111\r
- if Arch == "*":\r
+ if Arch == TAB_STAR:\r
PriorityValue &= 0x11011\r
- if CommandType == "*":\r
+ if CommandType == TAB_STAR:\r
PriorityValue &= 0x11101\r
- if Attr == "*":\r
+ if Attr == TAB_STAR:\r
PriorityValue &= 0x11110\r
\r
return self.PrioList["0x%0.5x" % PriorityValue]\r
## Expand * in build option key\r
#\r
# @param Options Options to be expanded\r
+ # @param ToolDef Use specified ToolDef instead of full version.\r
+ # This is needed during initialization to prevent\r
+ # infinite recursion betweeh BuildOptions,\r
+ # ToolDefinition, and this function.\r
#\r
# @retval options Options expanded\r
- # \r
- def _ExpandBuildOption(self, Options, ModuleStyle=None):\r
+ #\r
+ def _ExpandBuildOption(self, Options, ModuleStyle=None, ToolDef=None):\r
+ if not ToolDef:\r
+ ToolDef = self.ToolDefinition\r
BuildOptions = {}\r
FamilyMatch = False\r
FamilyIsNull = True\r
if (Key[0] == self.BuildRuleFamily and\r
(ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):\r
Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')\r
- if Target == self.BuildTarget or Target == "*":\r
- if ToolChain == self.ToolChain or ToolChain == "*":\r
- if Arch == self.Arch or Arch == "*":\r
- if Options[Key].startswith("="):\r
- if OverrideList.get(Key[1]) is not None:\r
- OverrideList.pop(Key[1])\r
- OverrideList[Key[1]] = Options[Key]\r
- \r
+ if (Target == self.BuildTarget or Target == TAB_STAR) and\\r
+ (ToolChain == self.ToolChain or ToolChain == TAB_STAR) and\\r
+ (Arch == self.Arch or Arch == TAB_STAR) and\\r
+ Options[Key].startswith("="):\r
+\r
+ if OverrideList.get(Key[1]) is not None:\r
+ OverrideList.pop(Key[1])\r
+ OverrideList[Key[1]] = Options[Key]\r
+\r
#\r
- # Use the highest priority value. \r
+ # Use the highest priority value.\r
#\r
if (len(OverrideList) >= 2):\r
- KeyList = OverrideList.keys()\r
+ KeyList = list(OverrideList.keys())\r
for Index in range(len(KeyList)):\r
NowKey = KeyList[Index]\r
Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")\r
NextKey = KeyList[Index1 + Index + 1]\r
#\r
# Compare two Key, if one is included by another, choose the higher priority one\r
- # \r
+ #\r
Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")\r
- if Target1 == Target2 or Target1 == "*" or Target2 == "*":\r
- if ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*":\r
- if Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*":\r
- if CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*":\r
- if Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*":\r
- if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
- if Options.get((self.BuildRuleFamily, NextKey)) is not None:\r
- Options.pop((self.BuildRuleFamily, NextKey))\r
- else:\r
- if Options.get((self.BuildRuleFamily, NowKey)) is not None:\r
- Options.pop((self.BuildRuleFamily, NowKey))\r
- \r
+ if (Target1 == Target2 or Target1 == TAB_STAR or Target2 == TAB_STAR) and\\r
+ (ToolChain1 == ToolChain2 or ToolChain1 == TAB_STAR or ToolChain2 == TAB_STAR) and\\r
+ (Arch1 == Arch2 or Arch1 == TAB_STAR or Arch2 == TAB_STAR) and\\r
+ (CommandType1 == CommandType2 or CommandType1 == TAB_STAR or CommandType2 == TAB_STAR) and\\r
+ (Attr1 == Attr2 or Attr1 == TAB_STAR or Attr2 == TAB_STAR):\r
+\r
+ if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
+ if Options.get((self.BuildRuleFamily, NextKey)) is not None:\r
+ Options.pop((self.BuildRuleFamily, NextKey))\r
+ else:\r
+ if Options.get((self.BuildRuleFamily, NowKey)) is not None:\r
+ Options.pop((self.BuildRuleFamily, NowKey))\r
+\r
for Key in Options:\r
if ModuleStyle is not None and len (Key) > 2:\r
# Check Module style is EDK or EDKII.\r
Family = Key[0]\r
Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
# if tool chain family doesn't match, skip it\r
- if Tool in self.ToolDefinition and Family != "":\r
+ if Tool in ToolDef and Family != "":\r
FamilyIsNull = False\r
- if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":\r
- if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:\r
+ if ToolDef[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":\r
+ if Family != ToolDef[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:\r
continue\r
- elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
+ elif Family != ToolDef[Tool][TAB_TOD_DEFINES_FAMILY]:\r
continue\r
FamilyMatch = True\r
# expand any wildcard\r
- if Target == "*" or Target == self.BuildTarget:\r
- if Tag == "*" or Tag == self.ToolChain:\r
- if Arch == "*" or Arch == self.Arch:\r
+ if Target == TAB_STAR or Target == self.BuildTarget:\r
+ if Tag == TAB_STAR or Tag == self.ToolChain:\r
+ if Arch == TAB_STAR or Arch == self.Arch:\r
if Tool not in BuildOptions:\r
BuildOptions[Tool] = {}\r
if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
Family = Key[0]\r
Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
# if tool chain family doesn't match, skip it\r
- if Tool not in self.ToolDefinition or Family == "":\r
+ if Tool not in ToolDef or Family == "":\r
continue\r
# option has been added before\r
- if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
+ if Family != ToolDef[Tool][TAB_TOD_DEFINES_FAMILY]:\r
continue\r
\r
# expand any wildcard\r
- if Target == "*" or Target == self.BuildTarget:\r
- if Tag == "*" or Tag == self.ToolChain:\r
- if Arch == "*" or Arch == self.Arch:\r
+ if Target == TAB_STAR or Target == self.BuildTarget:\r
+ if Tag == TAB_STAR or Tag == self.ToolChain:\r
+ if Arch == TAB_STAR or Arch == self.Arch:\r
if Tool not in BuildOptions:\r
BuildOptions[Tool] = {}\r
if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
\r
## Append build options in platform to a module\r
#\r
- # @param Module The module to which the build options will be appened\r
+ # @param Module The module to which the build options will be appended\r
#\r
# @retval options The options appended with build options in platform\r
#\r
def ApplyBuildOption(self, Module):\r
# Get the different options for the different style module\r
- if Module.AutoGenVersion < 0x00010005:\r
- PlatformOptions = self.EdkBuildOption\r
- ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDK_NAME, Module.ModuleType)\r
- else:\r
- PlatformOptions = self.EdkIIBuildOption\r
- ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)\r
+ PlatformOptions = self.EdkIIBuildOption\r
+ ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)\r
ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)\r
ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)\r
if Module in self.Platform.Modules:\r
if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
BuildRuleOrder = Options[Tool][Attr]\r
\r
- AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() +\r
- PlatformModuleOptions.keys() + ModuleTypeOptions.keys() +\r
- self.ToolDefinition.keys())\r
+ AllTools = set(list(ModuleOptions.keys()) + list(PlatformOptions.keys()) +\r
+ list(PlatformModuleOptions.keys()) + list(ModuleTypeOptions.keys()) +\r
+ list(self.ToolDefinition.keys()))\r
BuildOptions = defaultdict(lambda: defaultdict(str))\r
for Tool in AllTools:\r
for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
else:\r
BuildOptions[Tool][Attr] = mws.handleWsMacro(Value)\r
\r
- if Module.AutoGenVersion < 0x00010005 and self.Workspace.UniFlag is not None:\r
- #\r
- # Override UNI flag only for EDK module.\r
- #\r
- BuildOptions['BUILD']['FLAGS'] = self.Workspace.UniFlag\r
return BuildOptions, BuildRuleOrder\r
\r
- Platform = property(_GetPlatform)\r
- Name = property(_GetName)\r
- Guid = property(_GetGuid)\r
- Version = property(_GetVersion)\r
-\r
- OutputDir = property(_GetOutputDir)\r
- BuildDir = property(_GetBuildDir)\r
- MakeFileDir = property(_GetMakeFileDir)\r
- FdfFile = property(_GetFdfFile)\r
-\r
- PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
- DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
- NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
- NonDynamicPcdDict = property(_GetNonDynamicPcdDict)\r
- PackageList = property(_GetPackageList)\r
-\r
- ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
- ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path\r
- ToolChainFamily = property(_GetToolChainFamily)\r
- BuildRuleFamily = property(_GetBuildRuleFamily)\r
- BuildOption = property(_GetBuildOptions) # toolcode : option\r
- EdkBuildOption = property(_GetEdkBuildOptions) # edktoolcode : option\r
- EdkIIBuildOption = property(_GetEdkIIBuildOptions) # edkiitoolcode : option\r
-\r
- BuildCommand = property(_GetBuildCommand)\r
- BuildRule = property(_GetBuildRule)\r
- ModuleAutoGenList = property(_GetModuleAutoGenList)\r
- LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
- GenFdsCommand = property(_GenFdsCommand)\r
+#\r
+# extend lists contained in a dictionary with lists stored in another dictionary\r
+# if CopyToDict is not derived from DefaultDict(list) then this may raise exception\r
+#\r
+def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict):\r
+ for Key in CopyFromDict:\r
+ CopyToDict[Key].extend(CopyFromDict[Key])\r
+\r
+# Create a directory specified by a set of path elements and return the full path\r
+def _MakeDir(PathList):\r
+ RetVal = path.join(*PathList)\r
+ CreateDirectory(RetVal)\r
+ return RetVal\r
\r
## ModuleAutoGen class\r
#\r
class ModuleAutoGen(AutoGen):\r
# call super().__init__ then call the worker function with different parameter count\r
def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- try:\r
- self._Init\r
- except:\r
- super(ModuleAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+ if not hasattr(self, "_Init"):\r
self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args)\r
self._Init = True\r
\r
- ## Cache the timestamps of metafiles of every module in a class variable\r
+ ## Cache the timestamps of metafiles of every module in a class attribute\r
#\r
TimeDict = {}\r
\r
def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
- obj = super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
# check if this module is employed by active platform\r
if not PlatformAutoGen(Workspace, args[0], Target, Toolchain, Arch).ValidModule(MetaFile):\r
EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
% (MetaFile, Arch))\r
return None\r
- return obj\r
- \r
+ return super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
+\r
## Initialize ModuleAutoGen\r
#\r
# @param Workspace EdkIIWorkspaceBuild object\r
\r
self.Workspace = Workspace\r
self.WorkspaceDir = Workspace.WorkspaceDir\r
- self._GuidDict = Workspace._GuidDict\r
self.MetaFile = ModuleFile\r
self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)\r
\r
self.SourceDir = self.MetaFile.SubDir\r
self.SourceDir = mws.relpath(self.SourceDir, self.WorkspaceDir)\r
\r
- self.SourceOverrideDir = None\r
- # use overrided path defined in DSC file\r
- if self.MetaFile.Key in GlobalData.gOverrideDir:\r
- self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]\r
-\r
self.ToolChain = Toolchain\r
self.BuildTarget = Target\r
self.Arch = Arch\r
self.ToolChainFamily = self.PlatformInfo.ToolChainFamily\r
self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily\r
\r
- self.IsMakeFileCreated = False\r
self.IsCodeFileCreated = False\r
self.IsAsBuiltInfCreated = False\r
self.DepexGenerated = False\r
self.BuildRuleOrder = None\r
self.BuildTime = 0\r
\r
- self._Module = None\r
- self._Name = None\r
- self._Guid = None\r
- self._Version = None\r
- self._ModuleType = None\r
- self._ComponentType = None\r
- self._PcdIsDriver = None\r
- self._AutoGenVersion = None\r
- self._LibraryFlag = None\r
- self._CustomMakefile = None\r
- self._Macro = None\r
-\r
- self._BuildDir = None\r
- self._OutputDir = None\r
- self._FfsOutputDir = None\r
- self._DebugDir = None\r
- self._MakeFileDir = None\r
-\r
- self._IncludePathList = None\r
- self._IncludePathLength = 0\r
- self._AutoGenFileList = None\r
- self._UnicodeFileList = None\r
- self._VfrFileList = None\r
- self._IdfFileList = None\r
- self._SourceFileList = None\r
- self._ObjectFileList = None\r
- self._BinaryFileList = None\r
-\r
- self._DependentPackageList = None\r
- self._DependentLibraryList = None\r
- self._LibraryAutoGenList = None\r
- self._DerivedPackageList = None\r
- self._ModulePcdList = None\r
- self._LibraryPcdList = None\r
- self._PcdComments = OrderedDict()\r
- self._GuidList = None\r
- self._GuidsUsedByPcd = None\r
- self._GuidComments = OrderedDict()\r
- self._ProtocolList = None\r
- self._ProtocolComments = OrderedDict()\r
- self._PpiList = None\r
- self._PpiComments = OrderedDict()\r
- self._DepexList = None\r
- self._DepexExpressionList = None\r
- self._BuildOption = None\r
- self._BuildOptionIncPathList = None\r
+ self._PcdComments = OrderedListDict()\r
+ self._GuidComments = OrderedListDict()\r
+ self._ProtocolComments = OrderedListDict()\r
+ self._PpiComments = OrderedListDict()\r
self._BuildTargets = None\r
self._IntroBuildTargetList = None\r
self._FinalBuildTargetList = None\r
self._FileTypes = None\r
- self._BuildRules = None\r
-\r
- self._TimeStampPath = None\r
\r
self.AutoGenDepSet = set()\r
-\r
- \r
- ## The Modules referenced to this Library\r
- # Only Library has this attribute\r
- self._ReferenceModules = [] \r
- \r
- ## Store the FixedAtBuild Pcds\r
- # \r
- self._FixedAtBuildPcds = []\r
+ self.ReferenceModules = []\r
self.ConstPcd = {}\r
- return True\r
+\r
\r
def __repr__(self):\r
return "%s [%s]" % (self.MetaFile, self.Arch)\r
\r
# Get FixedAtBuild Pcds of this Module\r
- def _GetFixedAtBuildPcds(self):\r
- if self._FixedAtBuildPcds:\r
- return self._FixedAtBuildPcds\r
+ @cached_property\r
+ def FixedAtBuildPcds(self):\r
+ RetVal = []\r
for Pcd in self.ModulePcdList:\r
- if Pcd.Type != "FixedAtBuild":\r
+ if Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
continue\r
- if Pcd not in self._FixedAtBuildPcds:\r
- self._FixedAtBuildPcds.append(Pcd)\r
- \r
- return self._FixedAtBuildPcds \r
-\r
- def _GetUniqueBaseName(self):\r
+ if Pcd not in RetVal:\r
+ RetVal.append(Pcd)\r
+ return RetVal\r
+\r
+ @cached_property\r
+ def FixedVoidTypePcds(self):\r
+ RetVal = {}\r
+ for Pcd in self.FixedAtBuildPcds:\r
+ if Pcd.DatumType == TAB_VOID:\r
+ if '{}.{}'.format(Pcd.TokenSpaceGuidCName, Pcd.TokenCName) not in RetVal:\r
+ RetVal['{}.{}'.format(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)] = Pcd.DefaultValue\r
+ return RetVal\r
+\r
+ @property\r
+ def UniqueBaseName(self):\r
BaseName = self.Name\r
for Module in self.PlatformInfo.ModuleAutoGenList:\r
if Module.MetaFile == self.MetaFile:\r
return BaseName\r
\r
# Macros could be used in build_rule.txt (also Makefile)\r
- def _GetMacros(self):\r
- if self._Macro is None:\r
- self._Macro = OrderedDict()\r
- self._Macro["WORKSPACE" ] = self.WorkspaceDir\r
- self._Macro["MODULE_NAME" ] = self.Name\r
- self._Macro["MODULE_NAME_GUID" ] = self._GetUniqueBaseName()\r
- self._Macro["MODULE_GUID" ] = self.Guid\r
- self._Macro["MODULE_VERSION" ] = self.Version\r
- self._Macro["MODULE_TYPE" ] = self.ModuleType\r
- self._Macro["MODULE_FILE" ] = str(self.MetaFile)\r
- self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName\r
- self._Macro["MODULE_RELATIVE_DIR" ] = self.SourceDir\r
- self._Macro["MODULE_DIR" ] = self.SourceDir\r
-\r
- self._Macro["BASE_NAME" ] = self.Name\r
-\r
- self._Macro["ARCH" ] = self.Arch\r
- self._Macro["TOOLCHAIN" ] = self.ToolChain\r
- self._Macro["TOOLCHAIN_TAG" ] = self.ToolChain\r
- self._Macro["TOOL_CHAIN_TAG" ] = self.ToolChain\r
- self._Macro["TARGET" ] = self.BuildTarget\r
-\r
- self._Macro["BUILD_DIR" ] = self.PlatformInfo.BuildDir\r
- self._Macro["BIN_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)\r
- self._Macro["LIB_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)\r
- self._Macro["MODULE_BUILD_DIR" ] = self.BuildDir\r
- self._Macro["OUTPUT_DIR" ] = self.OutputDir\r
- self._Macro["DEBUG_DIR" ] = self.DebugDir\r
- self._Macro["DEST_DIR_OUTPUT" ] = self.OutputDir\r
- self._Macro["DEST_DIR_DEBUG" ] = self.DebugDir\r
- self._Macro["PLATFORM_NAME" ] = self.PlatformInfo.Name\r
- self._Macro["PLATFORM_GUID" ] = self.PlatformInfo.Guid\r
- self._Macro["PLATFORM_VERSION" ] = self.PlatformInfo.Version\r
- self._Macro["PLATFORM_RELATIVE_DIR" ] = self.PlatformInfo.SourceDir\r
- self._Macro["PLATFORM_DIR" ] = mws.join(self.WorkspaceDir, self.PlatformInfo.SourceDir)\r
- self._Macro["PLATFORM_OUTPUT_DIR" ] = self.PlatformInfo.OutputDir\r
- self._Macro["FFS_OUTPUT_DIR" ] = self.FfsOutputDir\r
- return self._Macro\r
+ @cached_property\r
+ def Macros(self):\r
+ return OrderedDict((\r
+ ("WORKSPACE" ,self.WorkspaceDir),\r
+ ("MODULE_NAME" ,self.Name),\r
+ ("MODULE_NAME_GUID" ,self.UniqueBaseName),\r
+ ("MODULE_GUID" ,self.Guid),\r
+ ("MODULE_VERSION" ,self.Version),\r
+ ("MODULE_TYPE" ,self.ModuleType),\r
+ ("MODULE_FILE" ,str(self.MetaFile)),\r
+ ("MODULE_FILE_BASE_NAME" ,self.MetaFile.BaseName),\r
+ ("MODULE_RELATIVE_DIR" ,self.SourceDir),\r
+ ("MODULE_DIR" ,self.SourceDir),\r
+ ("BASE_NAME" ,self.Name),\r
+ ("ARCH" ,self.Arch),\r
+ ("TOOLCHAIN" ,self.ToolChain),\r
+ ("TOOLCHAIN_TAG" ,self.ToolChain),\r
+ ("TOOL_CHAIN_TAG" ,self.ToolChain),\r
+ ("TARGET" ,self.BuildTarget),\r
+ ("BUILD_DIR" ,self.PlatformInfo.BuildDir),\r
+ ("BIN_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
+ ("LIB_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
+ ("MODULE_BUILD_DIR" ,self.BuildDir),\r
+ ("OUTPUT_DIR" ,self.OutputDir),\r
+ ("DEBUG_DIR" ,self.DebugDir),\r
+ ("DEST_DIR_OUTPUT" ,self.OutputDir),\r
+ ("DEST_DIR_DEBUG" ,self.DebugDir),\r
+ ("PLATFORM_NAME" ,self.PlatformInfo.Name),\r
+ ("PLATFORM_GUID" ,self.PlatformInfo.Guid),\r
+ ("PLATFORM_VERSION" ,self.PlatformInfo.Version),\r
+ ("PLATFORM_RELATIVE_DIR" ,self.PlatformInfo.SourceDir),\r
+ ("PLATFORM_DIR" ,mws.join(self.WorkspaceDir, self.PlatformInfo.SourceDir)),\r
+ ("PLATFORM_OUTPUT_DIR" ,self.PlatformInfo.OutputDir),\r
+ ("FFS_OUTPUT_DIR" ,self.FfsOutputDir)\r
+ ))\r
\r
## Return the module build data object\r
- def _GetModule(self):\r
- if self._Module is None:\r
- self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
- return self._Module\r
+ @cached_property\r
+ def Module(self):\r
+ return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
\r
## Return the module name\r
- def _GetBaseName(self):\r
+ @cached_property\r
+ def Name(self):\r
return self.Module.BaseName\r
\r
## Return the module DxsFile if exist\r
- def _GetDxsFile(self):\r
+ @cached_property\r
+ def DxsFile(self):\r
return self.Module.DxsFile\r
\r
- ## Return the module SourceOverridePath\r
- def _GetSourceOverridePath(self):\r
- return self.Module.SourceOverridePath\r
-\r
## Return the module meta-file GUID\r
- def _GetGuid(self):\r
+ @cached_property\r
+ def Guid(self):\r
#\r
# To build same module more than once, the module path with FILE_GUID overridden has\r
- # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the realy path\r
+ # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the real path\r
# in DSC. The overridden GUID can be retrieved from file name\r
#\r
if os.path.basename(self.MetaFile.File) != os.path.basename(self.MetaFile.Path):\r
return self.Module.Guid\r
\r
## Return the module version\r
- def _GetVersion(self):\r
+ @cached_property\r
+ def Version(self):\r
return self.Module.Version\r
\r
## Return the module type\r
- def _GetModuleType(self):\r
+ @cached_property\r
+ def ModuleType(self):\r
return self.Module.ModuleType\r
\r
## Return the component type (for Edk.x style of module)\r
- def _GetComponentType(self):\r
+ @cached_property\r
+ def ComponentType(self):\r
return self.Module.ComponentType\r
\r
## Return the build type\r
- def _GetBuildType(self):\r
+ @cached_property\r
+ def BuildType(self):\r
return self.Module.BuildType\r
\r
## Return the PCD_IS_DRIVER setting\r
- def _GetPcdIsDriver(self):\r
+ @cached_property\r
+ def PcdIsDriver(self):\r
return self.Module.PcdIsDriver\r
\r
## Return the autogen version, i.e. module meta-file version\r
- def _GetAutoGenVersion(self):\r
+ @cached_property\r
+ def AutoGenVersion(self):\r
return self.Module.AutoGenVersion\r
\r
## Check if the module is library or not\r
- def _IsLibrary(self):\r
- if self._LibraryFlag is None:\r
- if self.Module.LibraryClass is not None and self.Module.LibraryClass != []:\r
- self._LibraryFlag = True\r
- else:\r
- self._LibraryFlag = False\r
- return self._LibraryFlag\r
+ @cached_property\r
+ def IsLibrary(self):\r
+ return bool(self.Module.LibraryClass)\r
\r
## Check if the module is binary module or not\r
- def _IsBinaryModule(self):\r
+ @cached_property\r
+ def IsBinaryModule(self):\r
return self.Module.IsBinaryModule\r
\r
## Return the directory to store intermediate files of the module\r
- def _GetBuildDir(self):\r
- if self._BuildDir is None:\r
- self._BuildDir = path.join(\r
+ @cached_property\r
+ def BuildDir(self):\r
+ return _MakeDir((\r
self.PlatformInfo.BuildDir,\r
self.Arch,\r
self.SourceDir,\r
self.MetaFile.BaseName\r
- )\r
- CreateDirectory(self._BuildDir)\r
- return self._BuildDir\r
-\r
- ## Return the directory to store the intermediate object files of the mdoule\r
- def _GetOutputDir(self):\r
- if self._OutputDir is None:\r
- self._OutputDir = path.join(self.BuildDir, "OUTPUT")\r
- CreateDirectory(self._OutputDir)\r
- return self._OutputDir\r
-\r
- ## Return the directory to store ffs file\r
- def _GetFfsOutputDir(self):\r
- if self._FfsOutputDir is None:\r
- if GlobalData.gFdfParser is not None:\r
- self._FfsOutputDir = path.join(self.PlatformInfo.BuildDir, "FV", "Ffs", self.Guid + self.Name)\r
- else:\r
- self._FfsOutputDir = ''\r
- return self._FfsOutputDir\r
+ ))\r
+\r
+ ## Return the directory to store the intermediate object files of the module\r
+ @cached_property\r
+ def OutputDir(self):\r
+ return _MakeDir((self.BuildDir, "OUTPUT"))\r
\r
- ## Return the directory to store auto-gened source files of the mdoule\r
- def _GetDebugDir(self):\r
- if self._DebugDir is None:\r
- self._DebugDir = path.join(self.BuildDir, "DEBUG")\r
- CreateDirectory(self._DebugDir)\r
- return self._DebugDir\r
+ ## Return the directory path to store ffs file\r
+ @cached_property\r
+ def FfsOutputDir(self):\r
+ if GlobalData.gFdfParser:\r
+ return path.join(self.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
+ return ''\r
+\r
+ ## Return the directory to store auto-gened source files of the module\r
+ @cached_property\r
+ def DebugDir(self):\r
+ return _MakeDir((self.BuildDir, "DEBUG"))\r
\r
## Return the path of custom file\r
- def _GetCustomMakefile(self):\r
- if self._CustomMakefile is None:\r
- self._CustomMakefile = {}\r
- for Type in self.Module.CustomMakefile:\r
- if Type in gMakeTypeMap:\r
- MakeType = gMakeTypeMap[Type]\r
- else:\r
- MakeType = 'nmake'\r
- if self.SourceOverrideDir is not None:\r
- File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])\r
- if not os.path.exists(File):\r
- File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
- else:\r
- File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
- self._CustomMakefile[MakeType] = File\r
- return self._CustomMakefile\r
+ @cached_property\r
+ def CustomMakefile(self):\r
+ RetVal = {}\r
+ for Type in self.Module.CustomMakefile:\r
+ MakeType = gMakeTypeMap[Type] if Type in gMakeTypeMap else 'nmake'\r
+ File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
+ RetVal[MakeType] = File\r
+ return RetVal\r
\r
## Return the directory of the makefile\r
#\r
# @retval string The directory string of module's makefile\r
#\r
- def _GetMakeFileDir(self):\r
+ @cached_property\r
+ def MakeFileDir(self):\r
return self.BuildDir\r
\r
## Return build command string\r
#\r
# @retval string Build command string\r
#\r
- def _GetBuildCommand(self):\r
+ @cached_property\r
+ def BuildCommand(self):\r
return self.PlatformInfo.BuildCommand\r
\r
## Get object list of all packages the module and its dependent libraries belong to\r
#\r
# @retval list The list of package object\r
#\r
- def _GetDerivedPackageList(self):\r
+ @cached_property\r
+ def DerivedPackageList(self):\r
PackageList = []\r
for M in [self.Module] + self.DependentLibraryList:\r
for Package in M.Packages:\r
continue\r
PackageList.append(Package)\r
return PackageList\r
- \r
+\r
## Get the depex string\r
#\r
- # @return : a string contain all depex expresion.\r
+ # @return : a string contain all depex expression.\r
def _GetDepexExpresionString(self):\r
DepexStr = ''\r
DepexList = []\r
for M in [self.Module] + self.DependentLibraryList:\r
Filename = M.MetaFile.Path\r
InfObj = InfSectionParser.InfSectionParser(Filename)\r
- DepexExpresionList = InfObj.GetDepexExpresionList()\r
- for DepexExpresion in DepexExpresionList:\r
- for key in DepexExpresion.keys():\r
+ DepexExpressionList = InfObj.GetDepexExpresionList()\r
+ for DepexExpression in DepexExpressionList:\r
+ for key in DepexExpression:\r
Arch, ModuleType = key\r
- DepexExpr = [x for x in DepexExpresion[key] if not str(x).startswith('#')]\r
+ DepexExpr = [x for x in DepexExpression[key] if not str(x).startswith('#')]\r
# the type of build module is USER_DEFINED.\r
# All different DEPEX section tags would be copied into the As Built INF file\r
# and there would be separate DEPEX section tags\r
(Arch.upper() == self.Arch.upper() and \\r
ModuleType.upper() in [TAB_ARCH_COMMON, self.ModuleType.upper()]):\r
DepexList.append({(Arch, ModuleType): DepexExpr})\r
- \r
+\r
#the type of build module is USER_DEFINED.\r
if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
for Depex in DepexList:\r
- for key in Depex.keys():\r
+ for key in Depex:\r
DepexStr += '[Depex.%s.%s]\n' % key\r
- DepexStr += '\n'.join(['# '+ val for val in Depex[key]])\r
+ DepexStr += '\n'.join('# '+ val for val in Depex[key])\r
DepexStr += '\n\n'\r
if not DepexStr:\r
return '[Depex.%s]\n' % self.Arch\r
return DepexStr\r
- \r
+\r
#the type of build module not is USER_DEFINED.\r
Count = 0\r
for Depex in DepexList:\r
DepexStr += ' AND '\r
DepexStr += '('\r
for D in Depex.values():\r
- DepexStr += ' '.join([val for val in D])\r
+ DepexStr += ' '.join(val for val in D)\r
Index = DepexStr.find('END')\r
if Index > -1 and Index == len(DepexStr) - 3:\r
DepexStr = DepexStr[:-3]\r
if not DepexStr:\r
return '[Depex.%s]\n' % self.Arch\r
return '[Depex.%s]\n# ' % self.Arch + DepexStr\r
- \r
+\r
## Merge dependency expression\r
#\r
# @retval list The token list of the dependency expression after parsed\r
#\r
- def _GetDepexTokenList(self):\r
- if self._DepexList is None:\r
- self._DepexList = {}\r
- if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
- return self._DepexList\r
-\r
- self._DepexList[self.ModuleType] = []\r
+ @cached_property\r
+ def DepexList(self):\r
+ if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
+ return {}\r
\r
- for ModuleType in self._DepexList:\r
- DepexList = self._DepexList[ModuleType]\r
- #\r
- # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
- #\r
- for M in [self.Module] + self.DependentLibraryList:\r
- Inherited = False\r
- for D in M.Depex[self.Arch, ModuleType]:\r
- if DepexList != []:\r
- DepexList.append('AND')\r
- DepexList.append('(')\r
- DepexList.extend(D)\r
- if DepexList[-1] == 'END': # no need of a END at this time\r
- DepexList.pop()\r
- DepexList.append(')')\r
- Inherited = True\r
- if Inherited:\r
- EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))\r
- if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
- break\r
- if len(DepexList) > 0:\r
- EdkLogger.verbose('')\r
- return self._DepexList\r
+ DepexList = []\r
+ #\r
+ # Append depex from dependent libraries, if not "BEFORE", "AFTER" expression\r
+ #\r
+ for M in [self.Module] + self.DependentLibraryList:\r
+ Inherited = False\r
+ for D in M.Depex[self.Arch, self.ModuleType]:\r
+ if DepexList != []:\r
+ DepexList.append('AND')\r
+ DepexList.append('(')\r
+ #replace D with value if D is FixedAtBuild PCD\r
+ NewList = []\r
+ for item in D:\r
+ if '.' not in item:\r
+ NewList.append(item)\r
+ else:\r
+ FixedVoidTypePcds = {}\r
+ if item in self.FixedVoidTypePcds:\r
+ FixedVoidTypePcds = self.FixedVoidTypePcds\r
+ elif M in self.PlatformInfo.LibraryAutoGenList:\r
+ Index = self.PlatformInfo.LibraryAutoGenList.index(M)\r
+ FixedVoidTypePcds = self.PlatformInfo.LibraryAutoGenList[Index].FixedVoidTypePcds\r
+ if item not in FixedVoidTypePcds:\r
+ EdkLogger.error("build", FORMAT_INVALID, "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type in the module.".format(item))\r
+ else:\r
+ Value = FixedVoidTypePcds[item]\r
+ if len(Value.split(',')) != 16:\r
+ EdkLogger.error("build", FORMAT_INVALID,\r
+ "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type and 16 bytes in the module.".format(item))\r
+ NewList.append(Value)\r
+ DepexList.extend(NewList)\r
+ if DepexList[-1] == 'END': # no need of a END at this time\r
+ DepexList.pop()\r
+ DepexList.append(')')\r
+ Inherited = True\r
+ if Inherited:\r
+ EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))\r
+ if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
+ break\r
+ if len(DepexList) > 0:\r
+ EdkLogger.verbose('')\r
+ return {self.ModuleType:DepexList}\r
\r
## Merge dependency expression\r
#\r
# @retval list The token list of the dependency expression after parsed\r
#\r
- def _GetDepexExpressionTokenList(self):\r
- if self._DepexExpressionList is None:\r
- self._DepexExpressionList = {}\r
- if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
- return self._DepexExpressionList\r
+ @cached_property\r
+ def DepexExpressionDict(self):\r
+ if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
+ return {}\r
\r
- self._DepexExpressionList[self.ModuleType] = ''\r
+ DepexExpressionString = ''\r
+ #\r
+ # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
+ #\r
+ for M in [self.Module] + self.DependentLibraryList:\r
+ Inherited = False\r
+ for D in M.DepexExpression[self.Arch, self.ModuleType]:\r
+ if DepexExpressionString != '':\r
+ DepexExpressionString += ' AND '\r
+ DepexExpressionString += '('\r
+ DepexExpressionString += D\r
+ DepexExpressionString = DepexExpressionString.rstrip('END').strip()\r
+ DepexExpressionString += ')'\r
+ Inherited = True\r
+ if Inherited:\r
+ EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionString))\r
+ if 'BEFORE' in DepexExpressionString or 'AFTER' in DepexExpressionString:\r
+ break\r
+ if len(DepexExpressionString) > 0:\r
+ EdkLogger.verbose('')\r
\r
- for ModuleType in self._DepexExpressionList:\r
- DepexExpressionList = self._DepexExpressionList[ModuleType]\r
- #\r
- # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
- #\r
- for M in [self.Module] + self.DependentLibraryList:\r
- Inherited = False\r
- for D in M.DepexExpression[self.Arch, ModuleType]:\r
- if DepexExpressionList != '':\r
- DepexExpressionList += ' AND '\r
- DepexExpressionList += '('\r
- DepexExpressionList += D\r
- DepexExpressionList = DepexExpressionList.rstrip('END').strip()\r
- DepexExpressionList += ')'\r
- Inherited = True\r
- if Inherited:\r
- EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionList))\r
- if 'BEFORE' in DepexExpressionList or 'AFTER' in DepexExpressionList:\r
- break\r
- if len(DepexExpressionList) > 0:\r
- EdkLogger.verbose('')\r
- self._DepexExpressionList[ModuleType] = DepexExpressionList\r
- return self._DepexExpressionList\r
+ return {self.ModuleType:DepexExpressionString}\r
\r
# Get the tiano core user extension, it is contain dependent library.\r
# @retval: a list contain tiano core userextension.\r
InfObj = InfSectionParser.InfSectionParser(Filename)\r
TianoCoreUserExtenList = InfObj.GetUserExtensionTianoCore()\r
for TianoCoreUserExtent in TianoCoreUserExtenList:\r
- for Section in TianoCoreUserExtent.keys():\r
+ for Section in TianoCoreUserExtent:\r
ItemList = Section.split(TAB_SPLIT)\r
Arch = self.Arch\r
if len(ItemList) == 4:\r
#\r
# @retval list The list of specification defined in module file\r
#\r
- def _GetSpecification(self):\r
+ @cached_property\r
+ def Specification(self):\r
return self.Module.Specification\r
\r
## Tool option for the module build\r
# @param PlatformInfo The object of PlatformBuildInfo\r
# @retval dict The dict containing valid options\r
#\r
- def _GetModuleBuildOption(self):\r
- if self._BuildOption is None:\r
- self._BuildOption, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)\r
- if self.BuildRuleOrder:\r
- self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]\r
- return self._BuildOption\r
+ @cached_property\r
+ def BuildOption(self):\r
+ RetVal, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)\r
+ if self.BuildRuleOrder:\r
+ self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]\r
+ return RetVal\r
\r
## Get include path list from tool option for the module build\r
#\r
# @retval list The include path list\r
#\r
- def _GetBuildOptionIncPathList(self):\r
- if self._BuildOptionIncPathList is None:\r
+ @cached_property\r
+ def BuildOptionIncPathList(self):\r
+ #\r
+ # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
+ # is the former use /I , the Latter used -I to specify include directories\r
+ #\r
+ if self.PlatformInfo.ToolChainFamily in (TAB_COMPILER_MSFT):\r
+ BuildOptIncludeRegEx = gBuildOptIncludePatternMsft\r
+ elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
+ BuildOptIncludeRegEx = gBuildOptIncludePatternOther\r
+ else:\r
#\r
- # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
- # is the former use /I , the Latter used -I to specify include directories\r
+ # New ToolChainFamily, don't known whether there is option to specify include directories\r
#\r
- if self.PlatformInfo.ToolChainFamily in ('MSFT'):\r
- BuildOptIncludeRegEx = gBuildOptIncludePatternMsft\r
- elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
- BuildOptIncludeRegEx = gBuildOptIncludePatternOther\r
+ return []\r
+\r
+ RetVal = []\r
+ for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
+ try:\r
+ FlagOption = self.BuildOption[Tool]['FLAGS']\r
+ except KeyError:\r
+ FlagOption = ''\r
+\r
+ if self.ToolChainFamily != 'RVCT':\r
+ IncPathList = [NormPath(Path, self.Macros) for Path in BuildOptIncludeRegEx.findall(FlagOption)]\r
else:\r
#\r
- # New ToolChainFamily, don't known whether there is option to specify include directories\r
+ # RVCT may specify a list of directory seperated by commas\r
#\r
- self._BuildOptionIncPathList = []\r
- return self._BuildOptionIncPathList\r
- \r
- BuildOptionIncPathList = []\r
- for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
- Attr = 'FLAGS'\r
- try:\r
- FlagOption = self.BuildOption[Tool][Attr]\r
- except KeyError:\r
- FlagOption = ''\r
- \r
- if self.PlatformInfo.ToolChainFamily != 'RVCT':\r
- IncPathList = [NormPath(Path, self.Macros) for Path in BuildOptIncludeRegEx.findall(FlagOption)]\r
- else:\r
- #\r
- # RVCT may specify a list of directory seperated by commas\r
- #\r
- IncPathList = []\r
- for Path in BuildOptIncludeRegEx.findall(FlagOption):\r
- PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
- IncPathList += [NormPath(PathEntry, self.Macros) for PathEntry in PathList]\r
+ IncPathList = []\r
+ for Path in BuildOptIncludeRegEx.findall(FlagOption):\r
+ PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
+ IncPathList.extend(NormPath(PathEntry, self.Macros) for PathEntry in PathList)\r
+\r
+ #\r
+ # EDK II modules must not reference header files outside of the packages they depend on or\r
+ # within the module's directory tree. Report error if violation.\r
+ #\r
+ if GlobalData.gDisableIncludePathCheck == False:\r
+ for Path in IncPathList:\r
+ if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
+ ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)\r
+ EdkLogger.error("build",\r
+ PARAMETER_INVALID,\r
+ ExtraData=ErrMsg,\r
+ File=str(self.MetaFile))\r
+ RetVal += IncPathList\r
+ return RetVal\r
\r
- #\r
- # EDK II modules must not reference header files outside of the packages they depend on or \r
- # within the module's directory tree. Report error if violation.\r
- #\r
- if self.AutoGenVersion >= 0x00010005 and len(IncPathList) > 0:\r
- for Path in IncPathList:\r
- if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
- ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)\r
- EdkLogger.error("build",\r
- PARAMETER_INVALID,\r
- ExtraData=ErrMsg,\r
- File=str(self.MetaFile))\r
-\r
- \r
- BuildOptionIncPathList += IncPathList\r
- \r
- self._BuildOptionIncPathList = BuildOptionIncPathList\r
- \r
- return self._BuildOptionIncPathList\r
- \r
## Return a list of files which can be built from source\r
#\r
# What kind of files can be built is determined by build rules in\r
# $(CONF_DIRECTORY)/build_rule.txt and toolchain family.\r
#\r
- def _GetSourceFileList(self):\r
- if self._SourceFileList is None:\r
- self._SourceFileList = []\r
- for F in self.Module.Sources:\r
- # match tool chain\r
- if F.TagName not in ("", "*", self.ToolChain):\r
- EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "\r
- "but [%s] is needed" % (F.TagName, str(F), self.ToolChain))\r
- continue\r
- # match tool chain family or build rule family\r
- if F.ToolChainFamily not in ("", "*", self.ToolChainFamily, self.BuildRuleFamily):\r
- EdkLogger.debug(\r
- EdkLogger.DEBUG_0,\r
- "The file [%s] must be built by tools of [%s], " \\r
- "but current toolchain family is [%s], buildrule family is [%s]" \\r
- % (str(F), F.ToolChainFamily, self.ToolChainFamily, self.BuildRuleFamily))\r
- continue\r
+ @cached_property\r
+ def SourceFileList(self):\r
+ RetVal = []\r
+ ToolChainTagSet = {"", TAB_STAR, self.ToolChain}\r
+ ToolChainFamilySet = {"", TAB_STAR, self.ToolChainFamily, self.BuildRuleFamily}\r
+ for F in self.Module.Sources:\r
+ # match tool chain\r
+ if F.TagName not in ToolChainTagSet:\r
+ EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "\r
+ "but [%s] is currently used" % (F.TagName, str(F), self.ToolChain))\r
+ continue\r
+ # match tool chain family or build rule family\r
+ if F.ToolChainFamily not in ToolChainFamilySet:\r
+ EdkLogger.debug(\r
+ EdkLogger.DEBUG_0,\r
+ "The file [%s] must be built by tools of [%s], " \\r
+ "but current toolchain family is [%s], buildrule family is [%s]" \\r
+ % (str(F), F.ToolChainFamily, self.ToolChainFamily, self.BuildRuleFamily))\r
+ continue\r
\r
- # add the file path into search path list for file including\r
- if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:\r
- self.IncludePathList.insert(0, F.Dir)\r
- self._SourceFileList.append(F)\r
+ # add the file path into search path list for file including\r
+ if F.Dir not in self.IncludePathList:\r
+ self.IncludePathList.insert(0, F.Dir)\r
+ RetVal.append(F)\r
\r
- self._MatchBuildRuleOrder(self._SourceFileList)\r
+ self._MatchBuildRuleOrder(RetVal)\r
\r
- for F in self._SourceFileList:\r
- self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)\r
- return self._SourceFileList\r
+ for F in RetVal:\r
+ self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)\r
+ return RetVal\r
\r
def _MatchBuildRuleOrder(self, FileList):\r
Order_Dict = {}\r
- self._GetModuleBuildOption()\r
+ self.BuildOption\r
for SingleFile in FileList:\r
if self.BuildRuleOrder and SingleFile.Ext in self.BuildRuleOrder and SingleFile.Ext in self.BuildRules:\r
- key = SingleFile.Path.split(SingleFile.Ext)[0]\r
+ key = SingleFile.Path.rsplit(SingleFile.Ext,1)[0]\r
if key in Order_Dict:\r
Order_Dict[key].append(SingleFile.Ext)\r
else:\r
Order_Dict[F].sort(key=lambda i: self.BuildRuleOrder.index(i))\r
for Ext in Order_Dict[F][1:]:\r
RemoveList.append(F + Ext)\r
- \r
+\r
for item in RemoveList:\r
FileList.remove(item)\r
\r
return FileList\r
\r
## Return the list of unicode files\r
- def _GetUnicodeFileList(self):\r
- if self._UnicodeFileList is None:\r
- if TAB_UNICODE_FILE in self.FileTypes:\r
- self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE]\r
- else:\r
- self._UnicodeFileList = []\r
- return self._UnicodeFileList\r
+ @cached_property\r
+ def UnicodeFileList(self):\r
+ return self.FileTypes.get(TAB_UNICODE_FILE,[])\r
\r
## Return the list of vfr files\r
- def _GetVfrFileList(self):\r
- if self._VfrFileList is None:\r
- if TAB_VFR_FILE in self.FileTypes:\r
- self._VfrFileList = self.FileTypes[TAB_VFR_FILE]\r
- else:\r
- self._VfrFileList = []\r
- return self._VfrFileList\r
+ @cached_property\r
+ def VfrFileList(self):\r
+ return self.FileTypes.get(TAB_VFR_FILE, [])\r
\r
## Return the list of Image Definition files\r
- def _GetIdfFileList(self):\r
- if self._IdfFileList is None:\r
- if TAB_IMAGE_FILE in self.FileTypes:\r
- self._IdfFileList = self.FileTypes[TAB_IMAGE_FILE]\r
- else:\r
- self._IdfFileList = []\r
- return self._IdfFileList\r
+ @cached_property\r
+ def IdfFileList(self):\r
+ return self.FileTypes.get(TAB_IMAGE_FILE,[])\r
\r
## Return a list of files which can be built from binary\r
#\r
#\r
# @retval list The list of files which can be built later\r
#\r
- def _GetBinaryFiles(self):\r
- if self._BinaryFileList is None:\r
- self._BinaryFileList = []\r
- for F in self.Module.Binaries:\r
- if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget:\r
- continue\r
- self._BinaryFileList.append(F)\r
- self._ApplyBuildRule(F, F.Type)\r
- return self._BinaryFileList\r
-\r
- def _GetBuildRules(self):\r
- if self._BuildRules is None:\r
- BuildRules = {}\r
- BuildRuleDatabase = self.PlatformInfo.BuildRule\r
- for Type in BuildRuleDatabase.FileTypeList:\r
- #first try getting build rule by BuildRuleFamily\r
- RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]\r
+ @cached_property\r
+ def BinaryFileList(self):\r
+ RetVal = []\r
+ for F in self.Module.Binaries:\r
+ if F.Target not in [TAB_ARCH_COMMON, TAB_STAR] and F.Target != self.BuildTarget:\r
+ continue\r
+ RetVal.append(F)\r
+ self._ApplyBuildRule(F, F.Type, BinaryFileList=RetVal)\r
+ return RetVal\r
+\r
+ @cached_property\r
+ def BuildRules(self):\r
+ RetVal = {}\r
+ BuildRuleDatabase = self.PlatformInfo.BuildRule\r
+ for Type in BuildRuleDatabase.FileTypeList:\r
+ #first try getting build rule by BuildRuleFamily\r
+ RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]\r
+ if not RuleObject:\r
+ # build type is always module type, but ...\r
+ if self.ModuleType != self.BuildType:\r
+ RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]\r
+ #second try getting build rule by ToolChainFamily\r
+ if not RuleObject:\r
+ RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]\r
if not RuleObject:\r
# build type is always module type, but ...\r
if self.ModuleType != self.BuildType:\r
- RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]\r
- #second try getting build rule by ToolChainFamily\r
- if not RuleObject:\r
- RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]\r
- if not RuleObject:\r
- # build type is always module type, but ...\r
- if self.ModuleType != self.BuildType:\r
- RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]\r
- if not RuleObject:\r
- continue\r
- RuleObject = RuleObject.Instantiate(self.Macros)\r
- BuildRules[Type] = RuleObject\r
- for Ext in RuleObject.SourceFileExtList:\r
- BuildRules[Ext] = RuleObject\r
- self._BuildRules = BuildRules\r
- return self._BuildRules\r
-\r
- def _ApplyBuildRule(self, File, FileType):\r
+ RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]\r
+ if not RuleObject:\r
+ continue\r
+ RuleObject = RuleObject.Instantiate(self.Macros)\r
+ RetVal[Type] = RuleObject\r
+ for Ext in RuleObject.SourceFileExtList:\r
+ RetVal[Ext] = RuleObject\r
+ return RetVal\r
+\r
+ def _ApplyBuildRule(self, File, FileType, BinaryFileList=None):\r
if self._BuildTargets is None:\r
self._IntroBuildTargetList = set()\r
self._FinalBuildTargetList = set()\r
self._BuildTargets = defaultdict(set)\r
self._FileTypes = defaultdict(set)\r
\r
+ if not BinaryFileList:\r
+ BinaryFileList = self.BinaryFileList\r
+\r
SubDirectory = os.path.join(self.OutputDir, File.SubDir)\r
if not os.path.exists(SubDirectory):\r
CreateDirectory(SubDirectory)\r
LastTarget = None\r
- RuleChain = []\r
+ RuleChain = set()\r
SourceList = [File]\r
Index = 0\r
#\r
# Make sure to get build rule order value\r
#\r
- self._GetModuleBuildOption()\r
+ self.BuildOption\r
\r
while Index < len(SourceList):\r
Source = SourceList[Index]\r
if Source != File:\r
CreateDirectory(Source.Dir)\r
\r
- if File.IsBinary and File == Source and self._BinaryFileList is not None and File in self._BinaryFileList:\r
+ if File.IsBinary and File == Source and File in BinaryFileList:\r
# Skip all files that are not binary libraries\r
if not self.IsLibrary:\r
continue\r
if FileType in RuleChain:\r
break\r
\r
- RuleChain.append(FileType)\r
+ RuleChain.add(FileType)\r
SourceList.extend(Target.Outputs)\r
LastTarget = Target\r
FileType = TAB_UNKNOWN_FILE\r
\r
- def _GetTargets(self):\r
+ @cached_property\r
+ def Targets(self):\r
if self._BuildTargets is None:\r
self._IntroBuildTargetList = set()\r
self._FinalBuildTargetList = set()\r
self._BuildTargets = defaultdict(set)\r
self._FileTypes = defaultdict(set)\r
\r
- #TRICK: call _GetSourceFileList to apply build rule for source files\r
- if self.SourceFileList:\r
- pass\r
+ #TRICK: call SourceFileList property to apply build rule for source files\r
+ self.SourceFileList\r
\r
#TRICK: call _GetBinaryFileList to apply build rule for binary files\r
- if self.BinaryFileList:\r
- pass\r
+ self.BinaryFileList\r
\r
return self._BuildTargets\r
\r
- def _GetIntroTargetList(self):\r
- self._GetTargets()\r
+ @cached_property\r
+ def IntroTargetList(self):\r
+ self.Targets\r
return self._IntroBuildTargetList\r
\r
- def _GetFinalTargetList(self):\r
- self._GetTargets()\r
+ @cached_property\r
+ def CodaTargetList(self):\r
+ self.Targets\r
return self._FinalBuildTargetList\r
\r
- def _GetFileTypes(self):\r
- self._GetTargets()\r
+ @cached_property\r
+ def FileTypes(self):\r
+ self.Targets\r
return self._FileTypes\r
\r
## Get the list of package object the module depends on\r
#\r
# @retval list The package object list\r
#\r
- def _GetDependentPackageList(self):\r
+ @cached_property\r
+ def DependentPackageList(self):\r
return self.Module.Packages\r
\r
## Return the list of auto-generated code file\r
#\r
# @retval list The list of auto-generated file\r
#\r
- def _GetAutoGenFileList(self):\r
- UniStringAutoGenC = True\r
- IdfStringAutoGenC = True\r
- UniStringBinBuffer = StringIO()\r
- IdfGenBinBuffer = StringIO()\r
- if self.BuildType == 'UEFI_HII':\r
- UniStringAutoGenC = False\r
- IdfStringAutoGenC = False\r
- if self._AutoGenFileList is None:\r
- self._AutoGenFileList = {}\r
- AutoGenC = TemplateString()\r
- AutoGenH = TemplateString()\r
- StringH = TemplateString()\r
- StringIdf = TemplateString()\r
- GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer, StringIdf, IdfStringAutoGenC, IdfGenBinBuffer)\r
- #\r
- # AutoGen.c is generated if there are library classes in inf, or there are object files\r
- #\r
- if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
- or TAB_OBJECT_FILE in self.FileTypes):\r
- AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
- self._AutoGenFileList[AutoFile] = str(AutoGenC)\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if str(AutoGenH) != "":\r
- AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)\r
- self._AutoGenFileList[AutoFile] = str(AutoGenH)\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if str(StringH) != "":\r
- AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
- self._AutoGenFileList[AutoFile] = str(StringH)\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != "":\r
- AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
- self._AutoGenFileList[AutoFile] = UniStringBinBuffer.getvalue()\r
- AutoFile.IsBinary = True\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if UniStringBinBuffer is not None:\r
- UniStringBinBuffer.close()\r
- if str(StringIdf) != "":\r
- AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)\r
- self._AutoGenFileList[AutoFile] = str(StringIdf)\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != "":\r
- AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)\r
- self._AutoGenFileList[AutoFile] = IdfGenBinBuffer.getvalue()\r
- AutoFile.IsBinary = True\r
- self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
- if IdfGenBinBuffer is not None:\r
- IdfGenBinBuffer.close()\r
- return self._AutoGenFileList\r
-\r
- ## Return the list of library modules explicitly or implicityly used by this module\r
- def _GetLibraryList(self):\r
- if self._DependentLibraryList is None:\r
- # only merge library classes and PCD for non-library module\r
- if self.IsLibrary:\r
- self._DependentLibraryList = []\r
- else:\r
- if self.AutoGenVersion < 0x00010005:\r
- self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)\r
- else:\r
- self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
- return self._DependentLibraryList\r
-\r
- @staticmethod\r
- def UpdateComments(Recver, Src):\r
- for Key in Src:\r
- if Key not in Recver:\r
- Recver[Key] = []\r
- Recver[Key].extend(Src[Key])\r
+ @cached_property\r
+ def AutoGenFileList(self):\r
+ AutoGenUniIdf = self.BuildType != 'UEFI_HII'\r
+ UniStringBinBuffer = BytesIO()\r
+ IdfGenBinBuffer = BytesIO()\r
+ RetVal = {}\r
+ AutoGenC = TemplateString()\r
+ AutoGenH = TemplateString()\r
+ StringH = TemplateString()\r
+ StringIdf = TemplateString()\r
+ GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, AutoGenUniIdf, UniStringBinBuffer, StringIdf, AutoGenUniIdf, IdfGenBinBuffer)\r
+ #\r
+ # AutoGen.c is generated if there are library classes in inf, or there are object files\r
+ #\r
+ if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
+ or TAB_OBJECT_FILE in self.FileTypes):\r
+ AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
+ RetVal[AutoFile] = str(AutoGenC)\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if str(AutoGenH) != "":\r
+ AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)\r
+ RetVal[AutoFile] = str(AutoGenH)\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if str(StringH) != "":\r
+ AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
+ RetVal[AutoFile] = str(StringH)\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != b"":\r
+ AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
+ RetVal[AutoFile] = UniStringBinBuffer.getvalue()\r
+ AutoFile.IsBinary = True\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if UniStringBinBuffer is not None:\r
+ UniStringBinBuffer.close()\r
+ if str(StringIdf) != "":\r
+ AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)\r
+ RetVal[AutoFile] = str(StringIdf)\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != b"":\r
+ AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)\r
+ RetVal[AutoFile] = IdfGenBinBuffer.getvalue()\r
+ AutoFile.IsBinary = True\r
+ self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
+ if IdfGenBinBuffer is not None:\r
+ IdfGenBinBuffer.close()\r
+ return RetVal\r
+\r
+ ## Return the list of library modules explicitly or implicitly used by this module\r
+ @cached_property\r
+ def DependentLibraryList(self):\r
+ # only merge library classes and PCD for non-library module\r
+ if self.IsLibrary:\r
+ return []\r
+ return self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
+\r
## Get the list of PCDs from current module\r
#\r
# @retval list The list of PCD\r
#\r
- def _GetModulePcdList(self):\r
- if self._ModulePcdList is None:\r
- # apply PCD settings from platform\r
- self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
- self.UpdateComments(self._PcdComments, self.Module.PcdComments)\r
- return self._ModulePcdList\r
+ @cached_property\r
+ def ModulePcdList(self):\r
+ # apply PCD settings from platform\r
+ RetVal = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
+ ExtendCopyDictionaryLists(self._PcdComments, self.Module.PcdComments)\r
+ return RetVal\r
\r
## Get the list of PCDs from dependent libraries\r
#\r
# @retval list The list of PCD\r
#\r
- def _GetLibraryPcdList(self):\r
- if self._LibraryPcdList is None:\r
- Pcds = OrderedDict()\r
- if not self.IsLibrary:\r
- # get PCDs from dependent libraries\r
- for Library in self.DependentLibraryList:\r
- self.UpdateComments(self._PcdComments, Library.PcdComments)\r
- for Key in Library.Pcds:\r
- # skip duplicated PCDs\r
- if Key in self.Module.Pcds or Key in Pcds:\r
- continue\r
- Pcds[Key] = copy.copy(Library.Pcds[Key])\r
- # apply PCD settings from platform\r
- self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds)\r
- else:\r
- self._LibraryPcdList = []\r
- return self._LibraryPcdList\r
+ @cached_property\r
+ def LibraryPcdList(self):\r
+ if self.IsLibrary:\r
+ return []\r
+ RetVal = []\r
+ Pcds = set()\r
+ # get PCDs from dependent libraries\r
+ for Library in self.DependentLibraryList:\r
+ PcdsInLibrary = OrderedDict()\r
+ ExtendCopyDictionaryLists(self._PcdComments, Library.PcdComments)\r
+ for Key in Library.Pcds:\r
+ # skip duplicated PCDs\r
+ if Key in self.Module.Pcds or Key in Pcds:\r
+ continue\r
+ Pcds.add(Key)\r
+ PcdsInLibrary[Key] = copy.copy(Library.Pcds[Key])\r
+ RetVal.extend(self.PlatformInfo.ApplyPcdSetting(self.Module, PcdsInLibrary, Library=Library))\r
+ return RetVal\r
\r
## Get the GUID value mapping\r
#\r
# @retval dict The mapping between GUID cname and its value\r
#\r
- def _GetGuidList(self):\r
- if self._GuidList is None:\r
- self._GuidList = OrderedDict()\r
- self._GuidList.update(self.Module.Guids)\r
- for Library in self.DependentLibraryList:\r
- self._GuidList.update(Library.Guids)\r
- self.UpdateComments(self._GuidComments, Library.GuidComments)\r
- self.UpdateComments(self._GuidComments, self.Module.GuidComments)\r
- return self._GuidList\r
-\r
+ @cached_property\r
+ def GuidList(self):\r
+ RetVal = OrderedDict(self.Module.Guids)\r
+ for Library in self.DependentLibraryList:\r
+ RetVal.update(Library.Guids)\r
+ ExtendCopyDictionaryLists(self._GuidComments, Library.GuidComments)\r
+ ExtendCopyDictionaryLists(self._GuidComments, self.Module.GuidComments)\r
+ return RetVal\r
+\r
+ @cached_property\r
def GetGuidsUsedByPcd(self):\r
- if self._GuidsUsedByPcd is None:\r
- self._GuidsUsedByPcd = OrderedDict()\r
- self._GuidsUsedByPcd.update(self.Module.GetGuidsUsedByPcd())\r
- for Library in self.DependentLibraryList:\r
- self._GuidsUsedByPcd.update(Library.GetGuidsUsedByPcd())\r
- return self._GuidsUsedByPcd\r
+ RetVal = OrderedDict(self.Module.GetGuidsUsedByPcd())\r
+ for Library in self.DependentLibraryList:\r
+ RetVal.update(Library.GetGuidsUsedByPcd())\r
+ return RetVal\r
## Get the protocol value mapping\r
#\r
# @retval dict The mapping between protocol cname and its value\r
#\r
- def _GetProtocolList(self):\r
- if self._ProtocolList is None:\r
- self._ProtocolList = OrderedDict()\r
- self._ProtocolList.update(self.Module.Protocols)\r
- for Library in self.DependentLibraryList:\r
- self._ProtocolList.update(Library.Protocols)\r
- self.UpdateComments(self._ProtocolComments, Library.ProtocolComments)\r
- self.UpdateComments(self._ProtocolComments, self.Module.ProtocolComments)\r
- return self._ProtocolList\r
+ @cached_property\r
+ def ProtocolList(self):\r
+ RetVal = OrderedDict(self.Module.Protocols)\r
+ for Library in self.DependentLibraryList:\r
+ RetVal.update(Library.Protocols)\r
+ ExtendCopyDictionaryLists(self._ProtocolComments, Library.ProtocolComments)\r
+ ExtendCopyDictionaryLists(self._ProtocolComments, self.Module.ProtocolComments)\r
+ return RetVal\r
\r
## Get the PPI value mapping\r
#\r
# @retval dict The mapping between PPI cname and its value\r
#\r
- def _GetPpiList(self):\r
- if self._PpiList is None:\r
- self._PpiList = OrderedDict()\r
- self._PpiList.update(self.Module.Ppis)\r
- for Library in self.DependentLibraryList:\r
- self._PpiList.update(Library.Ppis)\r
- self.UpdateComments(self._PpiComments, Library.PpiComments)\r
- self.UpdateComments(self._PpiComments, self.Module.PpiComments)\r
- return self._PpiList\r
+ @cached_property\r
+ def PpiList(self):\r
+ RetVal = OrderedDict(self.Module.Ppis)\r
+ for Library in self.DependentLibraryList:\r
+ RetVal.update(Library.Ppis)\r
+ ExtendCopyDictionaryLists(self._PpiComments, Library.PpiComments)\r
+ ExtendCopyDictionaryLists(self._PpiComments, self.Module.PpiComments)\r
+ return RetVal\r
\r
## Get the list of include search path\r
#\r
# @retval list The list path\r
#\r
- def _GetIncludePathList(self):\r
- if self._IncludePathList is None:\r
- self._IncludePathList = []\r
- if self.AutoGenVersion < 0x00010005:\r
- for Inc in self.Module.Includes:\r
- if Inc not in self._IncludePathList:\r
- self._IncludePathList.append(Inc)\r
- # for Edk modules\r
- Inc = path.join(Inc, self.Arch.capitalize())\r
- if os.path.exists(Inc) and Inc not in self._IncludePathList:\r
- self._IncludePathList.append(Inc)\r
- # Edk module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time\r
- self._IncludePathList.append(self.DebugDir)\r
- else:\r
- self._IncludePathList.append(self.MetaFile.Dir)\r
- self._IncludePathList.append(self.DebugDir)\r
-\r
- for Package in self.Module.Packages:\r
- PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
- if PackageDir not in self._IncludePathList:\r
- self._IncludePathList.append(PackageDir)\r
- IncludesList = Package.Includes\r
- if Package._PrivateIncludes:\r
- if not self.MetaFile.Path.startswith(PackageDir):\r
- IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))\r
- for Inc in IncludesList:\r
- if Inc not in self._IncludePathList:\r
- self._IncludePathList.append(str(Inc))\r
- return self._IncludePathList\r
-\r
- def _GetIncludePathLength(self):\r
- self._IncludePathLength = 0\r
- if self._IncludePathList:\r
- for inc in self._IncludePathList:\r
- self._IncludePathLength += len(' ' + inc)\r
- return self._IncludePathLength\r
+ @cached_property\r
+ def IncludePathList(self):\r
+ RetVal = []\r
+ RetVal.append(self.MetaFile.Dir)\r
+ RetVal.append(self.DebugDir)\r
+\r
+ for Package in self.Module.Packages:\r
+ PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
+ if PackageDir not in RetVal:\r
+ RetVal.append(PackageDir)\r
+ IncludesList = Package.Includes\r
+ if Package._PrivateIncludes:\r
+ if not self.MetaFile.OriginalPath.Path.startswith(PackageDir):\r
+ IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))\r
+ for Inc in IncludesList:\r
+ if Inc not in RetVal:\r
+ RetVal.append(str(Inc))\r
+ return RetVal\r
+\r
+ @cached_property\r
+ def IncludePathLength(self):\r
+ return sum(len(inc)+1 for inc in self.IncludePathList)\r
\r
## Get HII EX PCDs which maybe used by VFR\r
#\r
Guid = gEfiVarStoreGuidPattern.search(Content, Pos)\r
if not Guid:\r
break\r
- NameArray = ConvertStringToByteArray('L"' + Name.group(1) + '"')\r
+ NameArray = _ConvertStringToByteArray('L"' + Name.group(1) + '"')\r
NameGuids.add((NameArray, GuidStructureStringToGuidString(Guid.group(1))))\r
Pos = Content.find('efivarstore', Name.end())\r
if not NameGuids:\r
for Pcd in self.PlatformInfo.Platform.Pcds.values():\r
if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:\r
continue\r
- for SkuName in Pcd.SkuInfoList:\r
- SkuInfo = Pcd.SkuInfoList[SkuName]\r
- Name = ConvertStringToByteArray(SkuInfo.VariableName)\r
+ for SkuInfo in Pcd.SkuInfoList.values():\r
Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList, self.MetaFile.Path)\r
if not Value:\r
continue\r
+ Name = _ConvertStringToByteArray(SkuInfo.VariableName)\r
Guid = GuidStructureStringToGuidString(Value)\r
if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:\r
HiiExPcds.append(Pcd)\r
for SourceFile in self.Module.Sources:\r
if SourceFile.Type.upper() == ".VFR" :\r
#\r
- # search the .map file to find the offset of vfr binary in the PE32+/TE file. \r
+ # search the .map file to find the offset of vfr binary in the PE32+/TE file.\r
#\r
VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")\r
- if SourceFile.Type.upper() == ".UNI" :\r
+ elif SourceFile.Type.upper() == ".UNI" :\r
#\r
- # search the .map file to find the offset of Uni strings binary in the PE32+/TE file. \r
+ # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.\r
#\r
VfrUniBaseName["UniOffsetName"] = (self.Name + "Strings")\r
\r
- if len(VfrUniBaseName) == 0:\r
+ if not VfrUniBaseName:\r
return None\r
MapFileName = os.path.join(self.OutputDir, self.Name + ".map")\r
EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")\r
- VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())\r
+ VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, list(VfrUniBaseName.values()))\r
if not VfrUniOffsetList:\r
return None\r
\r
try:\r
fInputfile = open(UniVfrOffsetFileName, "wb+", 0)\r
except:\r
- EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName,None)\r
+ EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)\r
\r
- # Use a instance of StringIO to cache data\r
- fStringIO = StringIO('') \r
+ # Use a instance of BytesIO to cache data\r
+ fStringIO = BytesIO()\r
\r
for Item in VfrUniOffsetList:\r
if (Item[0].find("Strings") != -1):\r
# GUID + Offset\r
# { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }\r
#\r
- UniGuid = [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]\r
- UniGuid = [chr(ItemGuid) for ItemGuid in UniGuid]\r
- fStringIO.write(''.join(UniGuid)) \r
+ UniGuid = b'\xe0\xc5\x13\x89\xf63\x86M\x9b\xf1C\xef\x89\xfc\x06f'\r
+ fStringIO.write(UniGuid)\r
UniValue = pack ('Q', int (Item[1], 16))\r
fStringIO.write (UniValue)\r
else:\r
# GUID + Offset\r
# { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };\r
#\r
- VfrGuid = [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]\r
- VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]\r
- fStringIO.write(''.join(VfrGuid)) \r
+ VfrGuid = b'\xb4|\xbc\xd0Gj_I\xaa\x11q\x07F\xda\x06\xa2'\r
+ fStringIO.write(VfrGuid)\r
VfrValue = pack ('Q', int (Item[1], 16))\r
fStringIO.write (VfrValue)\r
#\r
# write data into file.\r
#\r
- try : \r
+ try :\r
fInputfile.write (fStringIO.getvalue())\r
except:\r
EdkLogger.error("build", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the "\r
- "file been locked or using by other applications." %UniVfrOffsetFileName,None)\r
+ "file been locked or using by other applications." %UniVfrOffsetFileName, None)\r
\r
fStringIO.close ()\r
fInputfile.close ()\r
#\r
def CreateAsBuiltInf(self, IsOnlyCopy = False):\r
self.OutputFile = set()\r
- if IsOnlyCopy:\r
- if GlobalData.gBinCacheDest:\r
- self.CopyModuleToCache()\r
- return\r
+ if IsOnlyCopy and GlobalData.gBinCacheDest:\r
+ self.CopyModuleToCache()\r
+ return\r
\r
if self.IsAsBuiltInfCreated:\r
return\r
- \r
- # Skip the following code for EDK I inf\r
- if self.AutoGenVersion < 0x00010005:\r
- return\r
- \r
+\r
# Skip the following code for libraries\r
if self.IsLibrary:\r
return\r
- \r
+\r
# Skip the following code for modules with no source files\r
if not self.SourceFileList:\r
return\r
\r
# Skip the following code for modules without any binary files\r
- if not self.BinaryFileList:\r
+ if self.BinaryFileList:\r
return\r
- \r
+\r
### TODO: How to handles mixed source and binary modules\r
\r
# Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries\r
PcdTokenSpaceList = []\r
for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
- PatchablePcds += [Pcd]\r
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'PatchableInModule'))\r
- elif Pcd.Type in GenC.gDynamicExPcd:\r
+ PatchablePcds.append(Pcd)\r
+ PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))\r
+ elif Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
if Pcd not in Pcds:\r
- Pcds += [Pcd]\r
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'DynamicEx'))\r
- PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'Dynamic'))\r
+ Pcds.append(Pcd)\r
+ PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX))\r
+ PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC))\r
PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
- GuidList = OrderedDict()\r
- GuidList.update(self.GuidList)\r
- for TokenSpace in self.GetGuidsUsedByPcd():\r
+ GuidList = OrderedDict(self.GuidList)\r
+ for TokenSpace in self.GetGuidsUsedByPcd:\r
# If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list\r
# The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs\r
if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:\r
for Index in range(len(BeChecked)):\r
for Item in CheckList[Index]:\r
if Item in BeChecked[Index]:\r
- Packages += [Package]\r
+ Packages.append(Package)\r
Found = True\r
break\r
- if Found: break\r
+ if Found:\r
+ break\r
\r
VfrPcds = self._GetPcdsMaybeUsedByVfr()\r
for Pkg in self.PlatformInfo.PackageList:\r
if Pkg in Packages:\r
continue\r
for VfrPcd in VfrPcds:\r
- if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'DynamicEx') in Pkg.Pcds or\r
- (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'Dynamic') in Pkg.Pcds):\r
- Packages += [Pkg]\r
+ if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX) in Pkg.Pcds or\r
+ (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC) in Pkg.Pcds):\r
+ Packages.append(Pkg)\r
break\r
\r
- ModuleType = self.ModuleType\r
- if ModuleType == 'UEFI_DRIVER' and self.DepexGenerated:\r
- ModuleType = 'DXE_DRIVER'\r
-\r
- DriverType = ''\r
- if self.PcdIsDriver != '':\r
- DriverType = self.PcdIsDriver\r
-\r
+ ModuleType = SUP_MODULE_DXE_DRIVER if self.ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated else self.ModuleType\r
+ DriverType = self.PcdIsDriver if self.PcdIsDriver else ''\r
Guid = self.Guid\r
MDefs = self.Module.Defines\r
\r
'module_uefi_hii_resource_section' : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],\r
'module_uni_file' : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],\r
'module_arch' : self.Arch,\r
- 'package_item' : ['%s' % (Package.MetaFile.File.replace('\\', '/')) for Package in Packages],\r
+ 'package_item' : [Package.MetaFile.File.replace('\\', '/') for Package in Packages],\r
'binary_item' : [],\r
'patchablepcd_item' : [],\r
'pcd_item' : [],\r
AsBuiltInfDict['module_inf_version'] = gInfSpecVersion\r
\r
if DriverType:\r
- AsBuiltInfDict['pcd_is_driver_string'] += [DriverType]\r
+ AsBuiltInfDict['pcd_is_driver_string'].append(DriverType)\r
\r
if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
- AsBuiltInfDict['module_uefi_specification_version'] += [self.Specification['UEFI_SPECIFICATION_VERSION']]\r
+ AsBuiltInfDict['module_uefi_specification_version'].append(self.Specification['UEFI_SPECIFICATION_VERSION'])\r
if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
- AsBuiltInfDict['module_pi_specification_version'] += [self.Specification['PI_SPECIFICATION_VERSION']]\r
+ AsBuiltInfDict['module_pi_specification_version'].append(self.Specification['PI_SPECIFICATION_VERSION'])\r
\r
OutputDir = self.OutputDir.replace('\\', '/').strip('/')\r
DebugDir = self.DebugDir.replace('\\', '/').strip('/')\r
if os.path.isabs(File):\r
File = File.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
if Item.Target.Ext.lower() == '.aml':\r
- AsBuiltInfDict['binary_item'] += ['ASL|' + File]\r
+ AsBuiltInfDict['binary_item'].append('ASL|' + File)\r
elif Item.Target.Ext.lower() == '.acpi':\r
- AsBuiltInfDict['binary_item'] += ['ACPI|' + File]\r
+ AsBuiltInfDict['binary_item'].append('ACPI|' + File)\r
elif Item.Target.Ext.lower() == '.efi':\r
- AsBuiltInfDict['binary_item'] += ['PE32|' + self.Name + '.efi']\r
+ AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')\r
else:\r
- AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
+ AsBuiltInfDict['binary_item'].append('BIN|' + File)\r
+ if not self.DepexGenerated:\r
+ DepexFile = os.path.join(self.OutputDir, self.Name + '.depex')\r
+ if os.path.exists(DepexFile):\r
+ self.DepexGenerated = True\r
if self.DepexGenerated:\r
self.OutputFile.add(self.Name + '.depex')\r
- if self.ModuleType in ['PEIM']:\r
- AsBuiltInfDict['binary_item'] += ['PEI_DEPEX|' + self.Name + '.depex']\r
- if self.ModuleType in ['DXE_DRIVER', 'DXE_RUNTIME_DRIVER', 'DXE_SAL_DRIVER', 'UEFI_DRIVER']:\r
- AsBuiltInfDict['binary_item'] += ['DXE_DEPEX|' + self.Name + '.depex']\r
- if self.ModuleType in ['DXE_SMM_DRIVER']:\r
- AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
+ if self.ModuleType in [SUP_MODULE_PEIM]:\r
+ AsBuiltInfDict['binary_item'].append('PEI_DEPEX|' + self.Name + '.depex')\r
+ elif self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
+ AsBuiltInfDict['binary_item'].append('DXE_DEPEX|' + self.Name + '.depex')\r
+ elif self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
+ AsBuiltInfDict['binary_item'].append('SMM_DEPEX|' + self.Name + '.depex')\r
\r
Bin = self._GenOffsetBin()\r
if Bin:\r
- AsBuiltInfDict['binary_item'] += ['BIN|%s' % Bin]\r
+ AsBuiltInfDict['binary_item'].append('BIN|%s' % Bin)\r
self.OutputFile.add(Bin)\r
\r
for Root, Dirs, Files in os.walk(OutputDir):\r
for File in Files:\r
if File.lower().endswith('.pdb'):\r
- AsBuiltInfDict['binary_item'] += ['DISPOSABLE|' + File]\r
+ AsBuiltInfDict['binary_item'].append('DISPOSABLE|' + File)\r
self.OutputFile.add(File)\r
HeaderComments = self.Module.HeaderComments\r
StartPos = 0\r
]\r
for Item in GenList:\r
for CName in Item[0]:\r
- Comments = ''\r
- if CName in Item[1]:\r
- Comments = '\n '.join(Item[1][CName])\r
- Entry = CName\r
- if Comments:\r
- Entry = Comments + '\n ' + CName\r
+ Comments = '\n '.join(Item[1][CName]) if CName in Item[1] else ''\r
+ Entry = Comments + '\n ' + CName if Comments else CName\r
AsBuiltInfDict[Item[2]].append(Entry)\r
PatchList = parsePcdInfoFromMapFile(\r
os.path.join(self.OutputDir, self.Name + '.map'),\r
elif BoolValue == 'FALSE':\r
Pcd.DefaultValue = '0'\r
\r
- if Pcd.DatumType in ['UINT8', 'UINT16', 'UINT32', 'UINT64', 'BOOLEAN']:\r
+ if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
HexFormat = '0x%02x'\r
- if Pcd.DatumType == 'UINT16':\r
+ if Pcd.DatumType == TAB_UINT16:\r
HexFormat = '0x%04x'\r
- elif Pcd.DatumType == 'UINT32':\r
+ elif Pcd.DatumType == TAB_UINT32:\r
HexFormat = '0x%08x'\r
- elif Pcd.DatumType == 'UINT64':\r
+ elif Pcd.DatumType == TAB_UINT64:\r
HexFormat = '0x%016x'\r
PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
else:\r
Padding = '0x00, '\r
if Unicode:\r
Padding = Padding * 2\r
- ArraySize = ArraySize / 2\r
+ ArraySize = ArraySize // 2\r
if ArraySize < (len(PcdValue) + 1):\r
if Pcd.MaxSizeUserSet:\r
EdkLogger.error("build", AUTOGEN_ERROR,\r
PcdItem = PcdComments + '\n ' + PcdItem\r
AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r
\r
- HiiPcds = set()\r
for Pcd in Pcds + VfrPcds:\r
- PcdComments = ''\r
PcdCommentList = []\r
HiiInfo = ''\r
- SkuId = ''\r
TokenCName = Pcd.TokenCName\r
for PcdItem in GlobalData.MixedPcd:\r
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
for SkuName in Pcd.SkuInfoList:\r
SkuInfo = Pcd.SkuInfoList[SkuName]\r
- SkuId = SkuInfo.SkuId\r
HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
break\r
- if SkuId:\r
- #\r
- # Don't generate duplicated HII PCD\r
- #\r
- if (SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in HiiPcds:\r
- continue\r
- HiiPcds.add((SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
if HiiInfo:\r
UsageIndex = Index\r
break\r
if UsageIndex != -1:\r
- PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, '')) \r
+ PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, ''))\r
else:\r
PcdCommentList.append('## UNDEFINED ' + HiiInfo)\r
PcdComments = '\n '.join(PcdCommentList)\r
PcdEntry = Pcd.TokenSpaceGuidCName + '.' + TokenCName\r
if PcdComments:\r
PcdEntry = PcdComments + '\n ' + PcdEntry\r
- AsBuiltInfDict['pcd_item'] += [PcdEntry]\r
+ AsBuiltInfDict['pcd_item'].append(PcdEntry)\r
for Item in self.BuildOption:\r
if 'FLAGS' in self.BuildOption[Item]:\r
- AsBuiltInfDict['flags_item'] += ['%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip())]\r
+ AsBuiltInfDict['flags_item'].append('%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip()))\r
\r
# Generated LibraryClasses section in comments.\r
for Library in self.LibraryAutoGenList:\r
- AsBuiltInfDict['libraryclasses_item'] += [Library.MetaFile.File.replace('\\', '/')]\r
- \r
+ AsBuiltInfDict['libraryclasses_item'].append(Library.MetaFile.File.replace('\\', '/'))\r
+\r
# Generated UserExtensions TianoCore section.\r
# All tianocore user extensions are copied.\r
UserExtStr = ''\r
AsBuiltInfDict['userextension_tianocore_item'] = UserExtStr\r
\r
# Generated depex expression section in comments.\r
- AsBuiltInfDict['depexsection_item'] = ''\r
- DepexExpresion = self._GetDepexExpresionString()\r
- if DepexExpresion:\r
- AsBuiltInfDict['depexsection_item'] = DepexExpresion\r
- \r
+ DepexExpression = self._GetDepexExpresionString()\r
+ AsBuiltInfDict['depexsection_item'] = DepexExpression if DepexExpression else ''\r
+\r
AsBuiltInf = TemplateString()\r
AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))\r
- \r
+\r
SaveFileOnChange(os.path.join(self.OutputDir, self.Name + '.inf'), str(AsBuiltInf), False)\r
- \r
+\r
self.IsAsBuiltInfCreated = True\r
if GlobalData.gBinCacheDest:\r
self.CopyModuleToCache()\r
\r
def CopyModuleToCache(self):\r
- FileDir = path.join(GlobalData.gBinCacheDest, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
+ FileDir = path.join(GlobalData.gBinCacheDest, self.PlatformInfo.Name, self.BuildTarget + "_" + self.ToolChain, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
CreateDirectory (FileDir)\r
HashFile = path.join(self.BuildDir, self.Name + '.hash')\r
- ModuleFile = path.join(self.OutputDir, self.Name + '.inf')\r
if os.path.exists(HashFile):\r
shutil.copy2(HashFile, FileDir)\r
- if os.path.exists(ModuleFile):\r
- shutil.copy2(ModuleFile, FileDir)\r
+ if not self.IsLibrary:\r
+ ModuleFile = path.join(self.OutputDir, self.Name + '.inf')\r
+ if os.path.exists(ModuleFile):\r
+ shutil.copy2(ModuleFile, FileDir)\r
if not self.OutputFile:\r
- Ma = self.Workspace.BuildDatabase[PathClass(ModuleFile), self.Arch, self.BuildTarget, self.ToolChain]\r
+ Ma = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
self.OutputFile = Ma.Binaries\r
if self.OutputFile:\r
for File in self.OutputFile:\r
if not os.path.isabs(File):\r
File = os.path.join(self.OutputDir, File)\r
if os.path.exists(File):\r
- shutil.copy2(File, FileDir)\r
+ sub_dir = os.path.relpath(File, self.OutputDir)\r
+ destination_file = os.path.join(FileDir, sub_dir)\r
+ destination_dir = os.path.dirname(destination_file)\r
+ CreateDirectory(destination_dir)\r
+ shutil.copy2(File, destination_dir)\r
\r
def AttemptModuleCacheCopy(self):\r
+ # If library or Module is binary do not skip by hash\r
if self.IsBinaryModule:\r
return False\r
- FileDir = path.join(GlobalData.gBinCacheSource, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
+ # .inc is contains binary information so do not skip by hash as well\r
+ for f_ext in self.SourceFileList:\r
+ if '.inc' in str(f_ext):\r
+ return False\r
+ FileDir = path.join(GlobalData.gBinCacheSource, self.PlatformInfo.Name, self.BuildTarget + "_" + self.ToolChain, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
HashFile = path.join(FileDir, self.Name + '.hash')\r
if os.path.exists(HashFile):\r
f = open(HashFile, 'r')\r
CacheHash = f.read()\r
f.close()\r
+ self.GenModuleHash()\r
if GlobalData.gModuleHash[self.Arch][self.Name]:\r
if CacheHash == GlobalData.gModuleHash[self.Arch][self.Name]:\r
for root, dir, files in os.walk(FileDir):\r
shutil.copy2(HashFile, self.BuildDir)\r
else:\r
File = path.join(root, f)\r
- shutil.copy2(File, self.OutputDir)\r
+ sub_dir = os.path.relpath(File, FileDir)\r
+ destination_file = os.path.join(self.OutputDir, sub_dir)\r
+ destination_dir = os.path.dirname(destination_file)\r
+ CreateDirectory(destination_dir)\r
+ shutil.copy2(File, destination_dir)\r
if self.Name == "PcdPeim" or self.Name == "PcdDxe":\r
CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
return True\r
# @param CreateLibraryMakeFile Flag indicating if or not the makefiles of\r
# dependent libraries will be created\r
#\r
+ @cached_class_function\r
def CreateMakeFile(self, CreateLibraryMakeFile=True, GenFfsList = []):\r
+ # nest this function inside it's only caller.\r
+ def CreateTimeStamp():\r
+ FileSet = {self.MetaFile.Path}\r
+\r
+ for SourceFile in self.Module.Sources:\r
+ FileSet.add (SourceFile.Path)\r
+\r
+ for Lib in self.DependentLibraryList:\r
+ FileSet.add (Lib.MetaFile.Path)\r
+\r
+ for f in self.AutoGenDepSet:\r
+ FileSet.add (f.Path)\r
+\r
+ if os.path.exists (self.TimeStampPath):\r
+ os.remove (self.TimeStampPath)\r
+ with open(self.TimeStampPath, 'w+') as file:\r
+ for f in FileSet:\r
+ print(f, file=file)\r
+\r
# Ignore generating makefile when it is a binary module\r
if self.IsBinaryModule:\r
return\r
\r
- if self.IsMakeFileCreated:\r
- return\r
self.GenFfsList = GenFfsList\r
if not self.IsLibrary and CreateLibraryMakeFile:\r
for LibraryAutoGen in self.LibraryAutoGenList:\r
EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %\r
(self.Name, self.Arch))\r
\r
- self.CreateTimeStamp(Makefile)\r
- self.IsMakeFileCreated = True\r
+ CreateTimeStamp()\r
\r
def CopyBinaryFiles(self):\r
for File in self.Module.Binaries:\r
SrcPath = File.Path\r
- DstPath = os.path.join(self.OutputDir , os.path.basename(SrcPath))\r
+ DstPath = os.path.join(self.OutputDir, os.path.basename(SrcPath))\r
CopyLongFilePath(SrcPath, DstPath)\r
## Create autogen code for the module and its dependent libraries\r
#\r
\r
for File in self.AutoGenFileList:\r
if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):\r
- #Ignore Edk AutoGen.c\r
- if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':\r
- continue\r
-\r
AutoGenList.append(str(File))\r
else:\r
IgoredAutoGenList.append(str(File))\r
\r
- # Skip the following code for EDK I inf\r
- if self.AutoGenVersion < 0x00010005:\r
- return\r
\r
for ModuleType in self.DepexList:\r
- # Ignore empty [depex] section or [depex] section for "USER_DEFINED" module\r
- if len(self.DepexList[ModuleType]) == 0 or ModuleType == "USER_DEFINED":\r
+ # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module\r
+ if len(self.DepexList[ModuleType]) == 0 or ModuleType == SUP_MODULE_USER_DEFINED:\r
continue\r
\r
Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
\r
- if len(Dpx.PostfixNotation) <> 0:\r
+ if len(Dpx.PostfixNotation) != 0:\r
self.DepexGenerated = True\r
\r
if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
return AutoGenList\r
\r
## Summarize the ModuleAutoGen objects of all libraries used by this module\r
- def _GetLibraryAutoGenList(self):\r
- if self._LibraryAutoGenList is None:\r
- self._LibraryAutoGenList = []\r
- for Library in self.DependentLibraryList:\r
- La = ModuleAutoGen(\r
+ @cached_property\r
+ def LibraryAutoGenList(self):\r
+ RetVal = []\r
+ for Library in self.DependentLibraryList:\r
+ La = ModuleAutoGen(\r
self.Workspace,\r
Library.MetaFile,\r
self.BuildTarget,\r
self.Arch,\r
self.PlatformInfo.MetaFile\r
)\r
- if La not in self._LibraryAutoGenList:\r
- self._LibraryAutoGenList.append(La)\r
- for Lib in La.CodaTargetList:\r
- self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)\r
- return self._LibraryAutoGenList\r
+ if La not in RetVal:\r
+ RetVal.append(La)\r
+ for Lib in La.CodaTargetList:\r
+ self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)\r
+ return RetVal\r
\r
def GenModuleHash(self):\r
+ # Initialize a dictionary for each arch type\r
if self.Arch not in GlobalData.gModuleHash:\r
GlobalData.gModuleHash[self.Arch] = {}\r
+\r
+ # Early exit if module or library has been hashed and is in memory\r
+ if self.Name in GlobalData.gModuleHash[self.Arch]:\r
+ return GlobalData.gModuleHash[self.Arch][self.Name].encode('utf-8')\r
+\r
+ # Initialze hash object\r
m = hashlib.md5()\r
+\r
# Add Platform level hash\r
- m.update(GlobalData.gPlatformHash)\r
+ m.update(GlobalData.gPlatformHash.encode('utf-8'))\r
+\r
# Add Package level hash\r
if self.DependentPackageList:\r
- for Pkg in self.DependentPackageList:\r
- if Pkg.PackageName in GlobalData.gPackageHash[self.Arch]:\r
- m.update(GlobalData.gPackageHash[self.Arch][Pkg.PackageName])\r
+ for Pkg in sorted(self.DependentPackageList, key=lambda x: x.PackageName):\r
+ if Pkg.PackageName in GlobalData.gPackageHash:\r
+ m.update(GlobalData.gPackageHash[Pkg.PackageName].encode('utf-8'))\r
\r
# Add Library hash\r
if self.LibraryAutoGenList:\r
- for Lib in self.LibraryAutoGenList:\r
+ for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.Name):\r
if Lib.Name not in GlobalData.gModuleHash[self.Arch]:\r
Lib.GenModuleHash()\r
- m.update(GlobalData.gModuleHash[self.Arch][Lib.Name])\r
+ m.update(GlobalData.gModuleHash[self.Arch][Lib.Name].encode('utf-8'))\r
\r
# Add Module self\r
- f = open(str(self.MetaFile), 'r')\r
+ f = open(str(self.MetaFile), 'rb')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
+\r
# Add Module's source files\r
if self.SourceFileList:\r
- for File in self.SourceFileList:\r
- f = open(str(File), 'r')\r
+ for File in sorted(self.SourceFileList, key=lambda x: str(x)):\r
+ f = open(str(File), 'rb')\r
Content = f.read()\r
f.close()\r
m.update(Content)\r
\r
- ModuleHashFile = path.join(self.BuildDir, self.Name + ".hash")\r
- if self.Name not in GlobalData.gModuleHash[self.Arch]:\r
- GlobalData.gModuleHash[self.Arch][self.Name] = m.hexdigest()\r
- if GlobalData.gBinCacheSource:\r
- CacheValid = self.AttemptModuleCacheCopy()\r
- if CacheValid:\r
- return False\r
- return SaveFileOnChange(ModuleHashFile, m.hexdigest(), True)\r
+ GlobalData.gModuleHash[self.Arch][self.Name] = m.hexdigest()\r
+\r
+ return GlobalData.gModuleHash[self.Arch][self.Name].encode('utf-8')\r
\r
## Decide whether we can skip the ModuleAutoGen process\r
def CanSkipbyHash(self):\r
- if GlobalData.gUseHashCache:\r
- return not self.GenModuleHash()\r
+ # Hashing feature is off\r
+ if not GlobalData.gUseHashCache:\r
+ return False\r
+\r
+ # Initialize a dictionary for each arch type\r
+ if self.Arch not in GlobalData.gBuildHashSkipTracking:\r
+ GlobalData.gBuildHashSkipTracking[self.Arch] = dict()\r
+\r
+ # If library or Module is binary do not skip by hash\r
+ if self.IsBinaryModule:\r
+ return False\r
+\r
+ # .inc is contains binary information so do not skip by hash as well\r
+ for f_ext in self.SourceFileList:\r
+ if '.inc' in str(f_ext):\r
+ return False\r
+\r
+ # Use Cache, if exists and if Module has a copy in cache\r
+ if GlobalData.gBinCacheSource and self.AttemptModuleCacheCopy():\r
+ return True\r
+\r
+ # Early exit for libraries that haven't yet finished building\r
+ HashFile = path.join(self.BuildDir, self.Name + ".hash")\r
+ if self.IsLibrary and not os.path.exists(HashFile):\r
+ return False\r
+\r
+ # Return a Boolean based on if can skip by hash, either from memory or from IO.\r
+ if self.Name not in GlobalData.gBuildHashSkipTracking[self.Arch]:\r
+ # If hashes are the same, SaveFileOnChange() will return False.\r
+ GlobalData.gBuildHashSkipTracking[self.Arch][self.Name] = not SaveFileOnChange(HashFile, self.GenModuleHash(), True)\r
+ return GlobalData.gBuildHashSkipTracking[self.Arch][self.Name]\r
+ else:\r
+ return GlobalData.gBuildHashSkipTracking[self.Arch][self.Name]\r
\r
## Decide whether we can skip the ModuleAutoGen process\r
# If any source file is newer than the module than we cannot skip\r
#\r
def CanSkip(self):\r
- if not os.path.exists(self.GetTimeStampPath()):\r
+ if self.MakeFileDir in GlobalData.gSikpAutoGenCache:\r
+ return True\r
+ if not os.path.exists(self.TimeStampPath):\r
return False\r
#last creation time of the module\r
- DstTimeStamp = os.stat(self.GetTimeStampPath())[8]\r
+ DstTimeStamp = os.stat(self.TimeStampPath)[8]\r
\r
SrcTimeStamp = self.Workspace._SrcTimeStamp\r
if SrcTimeStamp > DstTimeStamp:\r
return False\r
\r
- with open(self.GetTimeStampPath(),'r') as f:\r
+ with open(self.TimeStampPath,'r') as f:\r
for source in f:\r
source = source.rstrip('\n')\r
if not os.path.exists(source):\r
ModuleAutoGen.TimeDict[source] = os.stat(source)[8]\r
if ModuleAutoGen.TimeDict[source] > DstTimeStamp:\r
return False\r
+ GlobalData.gSikpAutoGenCache.add(self.MakeFileDir)\r
return True\r
\r
- def GetTimeStampPath(self):\r
- if self._TimeStampPath is None:\r
- self._TimeStampPath = os.path.join(self.MakeFileDir, 'AutoGenTimeStamp')\r
- return self._TimeStampPath\r
- def CreateTimeStamp(self, Makefile):\r
-\r
- FileSet = set()\r
-\r
- FileSet.add (self.MetaFile.Path)\r
-\r
- for SourceFile in self.Module.Sources:\r
- FileSet.add (SourceFile.Path)\r
-\r
- for Lib in self.DependentLibraryList:\r
- FileSet.add (Lib.MetaFile.Path)\r
-\r
- for f in self.AutoGenDepSet:\r
- FileSet.add (f.Path)\r
-\r
- if os.path.exists (self.GetTimeStampPath()):\r
- os.remove (self.GetTimeStampPath())\r
- with open(self.GetTimeStampPath(), 'w+') as file:\r
- for f in FileSet:\r
- print >> file, f\r
-\r
- Module = property(_GetModule)\r
- Name = property(_GetBaseName)\r
- Guid = property(_GetGuid)\r
- Version = property(_GetVersion)\r
- ModuleType = property(_GetModuleType)\r
- ComponentType = property(_GetComponentType)\r
- BuildType = property(_GetBuildType)\r
- PcdIsDriver = property(_GetPcdIsDriver)\r
- AutoGenVersion = property(_GetAutoGenVersion)\r
- Macros = property(_GetMacros)\r
- Specification = property(_GetSpecification)\r
-\r
- IsLibrary = property(_IsLibrary)\r
- IsBinaryModule = property(_IsBinaryModule)\r
- BuildDir = property(_GetBuildDir)\r
- OutputDir = property(_GetOutputDir)\r
- FfsOutputDir = property(_GetFfsOutputDir)\r
- DebugDir = property(_GetDebugDir)\r
- MakeFileDir = property(_GetMakeFileDir)\r
- CustomMakefile = property(_GetCustomMakefile)\r
-\r
- IncludePathList = property(_GetIncludePathList)\r
- IncludePathLength = property(_GetIncludePathLength)\r
- AutoGenFileList = property(_GetAutoGenFileList)\r
- UnicodeFileList = property(_GetUnicodeFileList)\r
- VfrFileList = property(_GetVfrFileList)\r
- SourceFileList = property(_GetSourceFileList)\r
- BinaryFileList = property(_GetBinaryFiles) # FileType : [File List]\r
- Targets = property(_GetTargets)\r
- IntroTargetList = property(_GetIntroTargetList)\r
- CodaTargetList = property(_GetFinalTargetList)\r
- FileTypes = property(_GetFileTypes)\r
- BuildRules = property(_GetBuildRules)\r
- IdfFileList = property(_GetIdfFileList)\r
-\r
- DependentPackageList = property(_GetDependentPackageList)\r
- DependentLibraryList = property(_GetLibraryList)\r
- LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
- DerivedPackageList = property(_GetDerivedPackageList)\r
-\r
- ModulePcdList = property(_GetModulePcdList)\r
- LibraryPcdList = property(_GetLibraryPcdList)\r
- GuidList = property(_GetGuidList)\r
- ProtocolList = property(_GetProtocolList)\r
- PpiList = property(_GetPpiList)\r
- DepexList = property(_GetDepexTokenList)\r
- DxsFile = property(_GetDxsFile)\r
- DepexExpressionList = property(_GetDepexExpressionTokenList)\r
- BuildOption = property(_GetModuleBuildOption)\r
- BuildOptionIncPathList = property(_GetBuildOptionIncPathList)\r
- BuildCommand = property(_GetBuildCommand)\r
- \r
- FixedAtBuildPcds = property(_GetFixedAtBuildPcds)\r
-\r
-# This acts like the main() function for the script, unless it is 'import'ed into another script.\r
-if __name__ == '__main__':\r
- pass\r
-\r
+ @cached_property\r
+ def TimeStampPath(self):\r
+ return os.path.join(self.MakeFileDir, 'AutoGenTimeStamp')\r
projects / mirror_edk2.git / blobdiff