diff options
| author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-11 08:17:27 +0000 |
|---|---|---|
| committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-11 08:17:27 +0000 |
| commit | f215e02bf85f68d3a6106c2a1f4f7f063f819064 (patch) | |
| tree | 6bb5b92c046312c4e95ac2620b10ddf482d3fa8b /src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py | |
| parent | Initial commit. (diff) | |
| download | virtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.tar.xz virtualbox-f215e02bf85f68d3a6106c2a1f4f7f063f819064.zip | |
Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py')
| -rwxr-xr-x | src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py | 1603 |
1 files changed, 1603 insertions, 0 deletions
diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py new file mode 100755 index 00000000..29bc5439 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/Python/AutoGen/PlatformAutoGen.py @@ -0,0 +1,1603 @@ +## @file +# Create makefile for MS nmake and GNU make +# +# Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR> +# Copyright (c) 2020, ARM Limited. All rights reserved.<BR> +# SPDX-License-Identifier: BSD-2-Clause-Patent +# + +## Import Modules +# +from __future__ import print_function +from __future__ import absolute_import +import os.path as path +import copy +from collections import defaultdict + +from .BuildEngine import BuildRule,gDefaultBuildRuleFile,AutoGenReqBuildRuleVerNum +from .GenVar import VariableMgr, var_info +from . import GenMake +from AutoGen.DataPipe import MemoryDataPipe +from AutoGen.ModuleAutoGen import ModuleAutoGen +from AutoGen.AutoGen import AutoGen +from AutoGen.AutoGen import CalculatePriorityValue +from Workspace.WorkspaceCommon import GetModuleLibInstances +from CommonDataClass.CommonClass import SkuInfoClass +from Common.caching import cached_class_function +from Common.Expression import ValueExpressionEx +from Common.StringUtils import StringToArray,NormPath +from Common.BuildToolError import * +from Common.DataType import * +from Common.Misc import * +import Common.VpdInfoFile as VpdInfoFile + +## Split command line option string to list +# +# subprocess.Popen needs the args to be a sequence. Otherwise there's problem +# in non-windows platform to launch command +# +def _SplitOption(OptionString): + OptionList = [] + LastChar = " " + OptionStart = 0 + QuotationMark = "" + for Index in range(0, len(OptionString)): + CurrentChar = OptionString[Index] + if CurrentChar in ['"', "'"]: + if QuotationMark == CurrentChar: + QuotationMark = "" + elif QuotationMark == "": + QuotationMark = CurrentChar + continue + elif QuotationMark: + continue + + if CurrentChar in ["/", "-"] and LastChar in [" ", "\t", "\r", "\n"]: + if Index > OptionStart: + OptionList.append(OptionString[OptionStart:Index - 1]) + OptionStart = Index + LastChar = CurrentChar + OptionList.append(OptionString[OptionStart:]) + return OptionList + +## AutoGen class for platform +# +# PlatformAutoGen class will process the original information in platform +# file in order to generate makefile for platform. +# +class PlatformAutoGen(AutoGen): + # call super().__init__ then call the worker function with different parameter count + def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs): + if not hasattr(self, "_Init"): + self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch) + self._Init = True + # + # Used to store all PCDs for both PEI and DXE phase, in order to generate + # correct PCD database + # + _DynaPcdList_ = [] + _NonDynaPcdList_ = [] + _PlatformPcds = {} + + + + ## Initialize PlatformAutoGen + # + # + # @param Workspace WorkspaceAutoGen object + # @param PlatformFile Platform file (DSC file) + # @param Target Build target (DEBUG, RELEASE) + # @param Toolchain Name of tool chain + # @param Arch arch of the platform supports + # + def _InitWorker(self, Workspace, PlatformFile, Target, Toolchain, Arch): + EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch)) + GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target) + + self.MetaFile = PlatformFile + self.Workspace = Workspace + self.WorkspaceDir = Workspace.WorkspaceDir + self.ToolChain = Toolchain + self.BuildTarget = Target + self.Arch = Arch + self.SourceDir = PlatformFile.SubDir + self.FdTargetList = self.Workspace.FdTargetList + self.FvTargetList = self.Workspace.FvTargetList + # get the original module/package/platform objects + self.BuildDatabase = Workspace.BuildDatabase + self.DscBuildDataObj = Workspace.Platform + + # MakeFileName is used to get the Makefile name and as a flag + # indicating whether the file has been created. + self.MakeFileName = "" + + self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] + self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] + + self._AsBuildInfList = [] + self._AsBuildModuleList = [] + + self.VariableInfo = None + + if GlobalData.gFdfParser is not None: + self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList + for Inf in self._AsBuildInfList: + InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch) + M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain] + if not M.IsBinaryModule: + continue + self._AsBuildModuleList.append(InfClass) + # get library/modules for build + self.LibraryBuildDirectoryList = [] + self.ModuleBuildDirectoryList = [] + + self.DataPipe = MemoryDataPipe(self.BuildDir) + self.DataPipe.FillData(self) + + return True + def FillData_LibConstPcd(self): + libConstPcd = {} + for LibAuto in self.LibraryAutoGenList: + if LibAuto.ConstPcd: + libConstPcd[(LibAuto.MetaFile.File,LibAuto.MetaFile.Root,LibAuto.Arch,LibAuto.MetaFile.Path)] = LibAuto.ConstPcd + self.DataPipe.DataContainer = {"LibConstPcd":libConstPcd} + ## hash() operator of PlatformAutoGen + # + # The platform file path and arch string will be used to represent + # hash value of this object + # + # @retval int Hash value of the platform file path and arch + # + @cached_class_function + def __hash__(self): + return hash((self.MetaFile, self.Arch,self.ToolChain,self.BuildTarget)) + @cached_class_function + def __repr__(self): + return "%s [%s]" % (self.MetaFile, self.Arch) + + ## Create autogen code for platform and modules + # + # Since there's no autogen code for platform, this method will do nothing + # if CreateModuleCodeFile is set to False. + # + # @param CreateModuleCodeFile Flag indicating if creating module's + # autogen code file or not + # + @cached_class_function + def CreateCodeFile(self, CreateModuleCodeFile=False): + # only module has code to be created, so do nothing if CreateModuleCodeFile is False + if not CreateModuleCodeFile: + return + + for Ma in self.ModuleAutoGenList: + Ma.CreateCodeFile(CreateModuleCodeFile) + + ## Generate Fds Command + @cached_property + def GenFdsCommand(self): + return self.Workspace.GenFdsCommand + + ## Create makefile for the platform and modules in it + # + # @param CreateModuleMakeFile Flag indicating if the makefile for + # modules will be created as well + # + def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}): + if CreateModuleMakeFile: + for Ma in self._MaList: + key = (Ma.MetaFile.File, self.Arch) + if key in FfsCommand: + Ma.CreateMakeFile(CreateModuleMakeFile, FfsCommand[key]) + else: + Ma.CreateMakeFile(CreateModuleMakeFile) + self.CreateLibModuelDirs() + + def CreateLibModuelDirs(self): + # No need to create makefile for the platform more than once. + if self.MakeFileName: + return + + # create library/module build dirs for platform + Makefile = GenMake.PlatformMakefile(self) + self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList() + self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList() + self.MakeFileName = Makefile.getMakefileName() + + @property + def AllPcdList(self): + return self.DynamicPcdList + self.NonDynamicPcdList + ## Deal with Shared FixedAtBuild Pcds + # + def CollectFixedAtBuildPcds(self): + for LibAuto in self.LibraryAutoGenList: + FixedAtBuildPcds = {} + ShareFixedAtBuildPcdsSameValue = {} + for Module in LibAuto.ReferenceModules: + for Pcd in set(Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds): + DefaultValue = Pcd.DefaultValue + # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib + if Pcd in Module.LibraryPcdList: + Index = Module.LibraryPcdList.index(Pcd) + DefaultValue = Module.LibraryPcdList[Index].DefaultValue + key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName)) + if key not in FixedAtBuildPcds: + ShareFixedAtBuildPcdsSameValue[key] = True + FixedAtBuildPcds[key] = DefaultValue + else: + if FixedAtBuildPcds[key] != DefaultValue: + ShareFixedAtBuildPcdsSameValue[key] = False + for Pcd in LibAuto.FixedAtBuildPcds: + key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName)) + if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict: + continue + else: + DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] + if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD: + continue + if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: + LibAuto.ConstPcd[key] = FixedAtBuildPcds[key] + + def CollectVariables(self, DynamicPcdSet): + VpdRegionSize = 0 + VpdRegionBase = 0 + if self.Workspace.FdfFile: + FdDict = self.Workspace.FdfProfile.FdDict[GlobalData.gFdfParser.CurrentFdName] + for FdRegion in FdDict.RegionList: + for item in FdRegion.RegionDataList: + if self.Platform.VpdToolGuid.strip() and self.Platform.VpdToolGuid in item: + VpdRegionSize = FdRegion.Size + VpdRegionBase = FdRegion.Offset + break + + VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj.SkuIds) + VariableInfo.SetVpdRegionMaxSize(VpdRegionSize) + VariableInfo.SetVpdRegionOffset(VpdRegionBase) + Index = 0 + for Pcd in sorted(DynamicPcdSet): + pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName)) + for SkuName in Pcd.SkuInfoList: + Sku = Pcd.SkuInfoList[SkuName] + SkuId = Sku.SkuId + if SkuId is None or SkuId == '': + continue + if len(Sku.VariableName) > 0: + if Sku.VariableAttribute and 'NV' not in Sku.VariableAttribute: + continue + VariableGuidStructure = Sku.VariableGuidValue + VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure) + for StorageName in Sku.DefaultStoreDict: + 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))) + Index += 1 + return VariableInfo + + def UpdateNVStoreMaxSize(self, OrgVpdFile): + if self.VariableInfo: + VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid) + PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"] + + if PcdNvStoreDfBuffer: + try: + OrgVpdFile.Read(VpdMapFilePath) + PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0]) + NvStoreOffset = list(PcdItems.values())[0].strip() if PcdItems else '0' + except: + EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath) + + NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset) + default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT) + maxsize = self.VariableInfo.VpdRegionSize - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(",")) + var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize) + + if var_data and default_skuobj: + default_skuobj.DefaultValue = var_data + PcdNvStoreDfBuffer[0].DefaultValue = var_data + PcdNvStoreDfBuffer[0].SkuInfoList.clear() + PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj + PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(","))) + + return OrgVpdFile + + ## Collect dynamic PCDs + # + # Gather dynamic PCDs list from each module and their settings from platform + # This interface should be invoked explicitly when platform action is created. + # + def CollectPlatformDynamicPcds(self): + self.CategoryPcds() + self.SortDynamicPcd() + + def CategoryPcds(self): + # Category Pcds into DynamicPcds and NonDynamicPcds + # for gathering error information + NoDatumTypePcdList = set() + FdfModuleList = [] + for InfName in self._AsBuildInfList: + InfName = mws.join(self.WorkspaceDir, InfName) + FdfModuleList.append(os.path.normpath(InfName)) + for M in self._MbList: +# F is the Module for which M is the module autogen + ModPcdList = self.ApplyPcdSetting(M, M.ModulePcdList) + LibPcdList = [] + for lib in M.LibraryPcdList: + LibPcdList.extend(self.ApplyPcdSetting(M, M.LibraryPcdList[lib], lib)) + for PcdFromModule in ModPcdList + LibPcdList: + + # make sure that the "VOID*" kind of datum has MaxDatumSize set + if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize: + NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, M.MetaFile)) + + # Check the PCD from Binary INF or Source INF + if M.IsBinaryModule == True: + PcdFromModule.IsFromBinaryInf = True + + # Check the PCD from DSC or not + PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds + + if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET: + if M.MetaFile.Path not in FdfModuleList: + # If one of the Source built modules listed in the DSC is not listed + # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic + # access method (it is only listed in the DEC file that declares the + # PCD as PcdsDynamic), then build tool will report warning message + # notify the PI that they are attempting to build a module that must + # be included in a flash image in order to be functional. These Dynamic + # PCD will not be added into the Database unless it is used by other + # modules that are included in the FDF file. + if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \ + PcdFromModule.IsFromBinaryInf == False: + # Print warning message to let the developer make a determine. + continue + # If one of the Source built modules listed in the DSC is not listed in + # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx + # access method (it is only listed in the DEC file that declares the + # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the + # PCD to the Platform's PCD Database. + if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET: + continue + # + # If a dynamic PCD used by a PEM module/PEI module & DXE module, + # it should be stored in Pcd PEI database, If a dynamic only + # used by DXE module, it should be stored in DXE PCD database. + # The default Phase is DXE + # + if M.ModuleType in SUP_MODULE_SET_PEI: + PcdFromModule.Phase = "PEI" + if PcdFromModule not in self._DynaPcdList_: + self._DynaPcdList_.append(PcdFromModule) + elif PcdFromModule.Phase == 'PEI': + # overwrite any the same PCD existing, if Phase is PEI + Index = self._DynaPcdList_.index(PcdFromModule) + self._DynaPcdList_[Index] = PcdFromModule + elif PcdFromModule not in self._NonDynaPcdList_: + self._NonDynaPcdList_.append(PcdFromModule) + elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True: + Index = self._NonDynaPcdList_.index(PcdFromModule) + if self._NonDynaPcdList_[Index].IsFromBinaryInf == False: + #The PCD from Binary INF will override the same one from source INF + self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index]) + PcdFromModule.Pending = False + self._NonDynaPcdList_.append (PcdFromModule) + DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules} + # add the PCD from modules that listed in FDF but not in DSC to Database + for InfName in FdfModuleList: + if InfName not in DscModuleSet: + InfClass = PathClass(InfName) + M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain] + # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source) + # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here. + # For binary module, if in current arch, we need to list the PCDs into database. + if not M.IsBinaryModule: + continue + # Override the module PCD setting by platform setting + ModulePcdList = self.ApplyPcdSetting(M, M.Pcds) + for PcdFromModule in ModulePcdList: + PcdFromModule.IsFromBinaryInf = True + PcdFromModule.IsFromDsc = False + # Only allow the DynamicEx and Patchable PCD in AsBuild INF + if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE: + EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error", + File=self.MetaFile, + ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n" + % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName)) + # make sure that the "VOID*" kind of datum has MaxDatumSize set + if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize: + NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName)) + if M.ModuleType in SUP_MODULE_SET_PEI: + PcdFromModule.Phase = "PEI" + if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET: + self._DynaPcdList_.append(PcdFromModule) + elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE: + self._NonDynaPcdList_.append(PcdFromModule) + if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET: + # Overwrite the phase of any the same PCD existing, if Phase is PEI. + # It is to solve the case that a dynamic PCD used by a PEM module/PEI + # module & DXE module at a same time. + # Overwrite the type of the PCDs in source INF by the type of AsBuild + # INF file as DynamicEx. + Index = self._DynaPcdList_.index(PcdFromModule) + self._DynaPcdList_[Index].Phase = PcdFromModule.Phase + self._DynaPcdList_[Index].Type = PcdFromModule.Type + for PcdFromModule in self._NonDynaPcdList_: + # If a PCD is not listed in the DSC file, but binary INF files used by + # this platform all (that use this PCD) list the PCD in a [PatchPcds] + # section, AND all source INF files used by this platform the build + # that use the PCD list the PCD in either a [Pcds] or [PatchPcds] + # section, then the tools must NOT add the PCD to the Platform's PCD + # Database; the build must assign the access method for this PCD as + # PcdsPatchableInModule. + if PcdFromModule not in self._DynaPcdList_: + continue + Index = self._DynaPcdList_.index(PcdFromModule) + if PcdFromModule.IsFromDsc == False and \ + PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \ + PcdFromModule.IsFromBinaryInf == True and \ + self._DynaPcdList_[Index].IsFromBinaryInf == False: + Index = self._DynaPcdList_.index(PcdFromModule) + self._DynaPcdList_.remove (self._DynaPcdList_[Index]) + + # print out error information and break the build, if error found + if len(NoDatumTypePcdList) > 0: + NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList) + EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error", + File=self.MetaFile, + ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n" + % NoDatumTypePcdListString) + self._NonDynamicPcdList = sorted(self._NonDynaPcdList_) + self._DynamicPcdList = self._DynaPcdList_ + + def SortDynamicPcd(self): + # + # Sort dynamic PCD list to: + # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should + # try to be put header of dynamicd List + # 2) If PCD is HII type, the PCD item should be put after unicode type PCD + # + # The reason of sorting is make sure the unicode string is in double-byte alignment in string table. + # + UnicodePcdArray = set() + HiiPcdArray = set() + OtherPcdArray = set() + VpdPcdDict = {} + VpdFile = VpdInfoFile.VpdInfoFile() + NeedProcessVpdMapFile = False + + for pcd in self.Platform.Pcds: + if pcd not in self._PlatformPcds: + self._PlatformPcds[pcd] = self.Platform.Pcds[pcd] + + for item in self._PlatformPcds: + if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]: + self._PlatformPcds[item].DatumType = TAB_VOID + + if (self.Workspace.ArchList[-1] == self.Arch): + for Pcd in self._DynamicPcdList: + # just pick the a value to determine whether is unicode string type + Sku = Pcd.SkuInfoList.get(TAB_DEFAULT) + Sku.VpdOffset = Sku.VpdOffset.strip() + + if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]: + Pcd.DatumType = TAB_VOID + + # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex + # if found HII type PCD then insert to right of UnicodeIndex + if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]: + VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd + + #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer + PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid")) + if PcdNvStoreDfBuffer: + self.VariableInfo = self.CollectVariables(self._DynamicPcdList) + vardump = self.VariableInfo.dump() + if vardump: + # + #According to PCD_DATABASE_INIT in edk2\MdeModulePkg\Include\Guid\PcdDataBaseSignatureGuid.h, + #the max size for string PCD should not exceed USHRT_MAX 65535(0xffff). + #typedef UINT16 SIZE_INFO; + #//SIZE_INFO SizeTable[]; + if len(vardump.split(",")) > 0xffff: + 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(",")))) + PcdNvStoreDfBuffer.DefaultValue = vardump + for skuname in PcdNvStoreDfBuffer.SkuInfoList: + PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump + PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(","))) + else: + #If the end user define [DefaultStores] and [XXX.Menufacturing] in DSC, but forget to configure PcdNvStoreDefaultValueBuffer to PcdsDynamicVpd + if [Pcd for Pcd in self._DynamicPcdList if Pcd.UserDefinedDefaultStoresFlag]: + 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) + PlatformPcds = sorted(self._PlatformPcds.keys()) + # + # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up. + # + VpdSkuMap = {} + for PcdKey in PlatformPcds: + Pcd = self._PlatformPcds[PcdKey] + if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \ + PcdKey in VpdPcdDict: + Pcd = VpdPcdDict[PcdKey] + SkuValueMap = {} + DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT) + if DefaultSku: + PcdValue = DefaultSku.DefaultValue + if PcdValue not in SkuValueMap: + SkuValueMap[PcdValue] = [] + VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset) + SkuValueMap[PcdValue].append(DefaultSku) + + for (SkuName, Sku) in Pcd.SkuInfoList.items(): + Sku.VpdOffset = Sku.VpdOffset.strip() + PcdValue = Sku.DefaultValue + if PcdValue == "": + PcdValue = Pcd.DefaultValue + if Sku.VpdOffset != TAB_STAR: + if PcdValue.startswith("{"): + Alignment = 8 + elif PcdValue.startswith("L"): + Alignment = 2 + else: + Alignment = 1 + try: + VpdOffset = int(Sku.VpdOffset) + except: + try: + VpdOffset = int(Sku.VpdOffset, 16) + except: + EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, Pcd.TokenSpaceGuidCName, Pcd.TokenCName)) + if VpdOffset % Alignment != 0: + if PcdValue.startswith("{"): + EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName), File=self.MetaFile) + else: + EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment)) + if PcdValue not in SkuValueMap: + SkuValueMap[PcdValue] = [] + VpdFile.Add(Pcd, SkuName, Sku.VpdOffset) + SkuValueMap[PcdValue].append(Sku) + # if the offset of a VPD is *, then it need to be fixed up by third party tool. + if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR: + NeedProcessVpdMapFile = True + if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '': + 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.") + + VpdSkuMap[PcdKey] = SkuValueMap + # + # Fix the PCDs define in VPD PCD section that never referenced by module. + # An example is PCD for signature usage. + # + for DscPcd in PlatformPcds: + DscPcdEntry = self._PlatformPcds[DscPcd] + if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]: + if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''): + FoundFlag = False + for VpdPcd in VpdFile._VpdArray: + # This PCD has been referenced by module + if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \ + (VpdPcd.TokenCName == DscPcdEntry.TokenCName): + FoundFlag = True + + # Not found, it should be signature + if not FoundFlag : + # just pick the a value to determine whether is unicode string type + SkuValueMap = {} + SkuObjList = list(DscPcdEntry.SkuInfoList.items()) + DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT) + if DefaultSku: + defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku)) + SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0] + for (SkuName, Sku) in SkuObjList: + Sku.VpdOffset = Sku.VpdOffset.strip() + + # Need to iterate DEC pcd information to get the value & datumtype + for eachDec in self.PackageList: + for DecPcd in eachDec.Pcds: + DecPcdEntry = eachDec.Pcds[DecPcd] + if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \ + (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName): + # Print warning message to let the developer make a determine. + EdkLogger.warn("build", "Unreferenced vpd pcd used!", + File=self.MetaFile, \ + ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \ + %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path)) + + DscPcdEntry.DatumType = DecPcdEntry.DatumType + DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue + DscPcdEntry.TokenValue = DecPcdEntry.TokenValue + DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName] + # Only fix the value while no value provided in DSC file. + if not Sku.DefaultValue: + DscPcdEntry.SkuInfoList[list(DscPcdEntry.SkuInfoList.keys())[0]].DefaultValue = DecPcdEntry.DefaultValue + + if DscPcdEntry not in self._DynamicPcdList: + self._DynamicPcdList.append(DscPcdEntry) + Sku.VpdOffset = Sku.VpdOffset.strip() + PcdValue = Sku.DefaultValue + if PcdValue == "": + PcdValue = DscPcdEntry.DefaultValue + if Sku.VpdOffset != TAB_STAR: + if PcdValue.startswith("{"): + Alignment = 8 + elif PcdValue.startswith("L"): + Alignment = 2 + else: + Alignment = 1 + try: + VpdOffset = int(Sku.VpdOffset) + except: + try: + VpdOffset = int(Sku.VpdOffset, 16) + except: + EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName)) + if VpdOffset % Alignment != 0: + if PcdValue.startswith("{"): + EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName), File=self.MetaFile) + else: + EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment)) + if PcdValue not in SkuValueMap: + SkuValueMap[PcdValue] = [] + VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset) + SkuValueMap[PcdValue].append(Sku) + if not NeedProcessVpdMapFile and Sku.VpdOffset == TAB_STAR: + NeedProcessVpdMapFile = True + if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"): + UnicodePcdArray.add(DscPcdEntry) + elif len(Sku.VariableName) > 0: + HiiPcdArray.add(DscPcdEntry) + else: + OtherPcdArray.add(DscPcdEntry) + + # if the offset of a VPD is *, then it need to be fixed up by third party tool. + VpdSkuMap[DscPcd] = SkuValueMap + if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \ + VpdFile.GetCount() != 0: + EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, + "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile)) + + if VpdFile.GetCount() != 0: + + self.FixVpdOffset(VpdFile) + + self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile)) + PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"] + if PcdNvStoreDfBuffer: + PcdName,PcdGuid = PcdNvStoreDfBuffer[0].TokenCName, PcdNvStoreDfBuffer[0].TokenSpaceGuidCName + if (PcdName,PcdGuid) in VpdSkuMap: + DefaultSku = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT) + VpdSkuMap[(PcdName,PcdGuid)] = {DefaultSku.DefaultValue:[SkuObj for SkuObj in PcdNvStoreDfBuffer[0].SkuInfoList.values() ]} + + # Process VPD map file generated by third party BPDG tool + if NeedProcessVpdMapFile: + VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid) + try: + VpdFile.Read(VpdMapFilePath) + + # Fixup TAB_STAR offset + for pcd in VpdSkuMap: + vpdinfo = VpdFile.GetVpdInfo(pcd) + if vpdinfo is None: + # just pick the a value to determine whether is unicode string type + continue + for pcdvalue in VpdSkuMap[pcd]: + for sku in VpdSkuMap[pcd][pcdvalue]: + for item in vpdinfo: + if item[2] == pcdvalue: + sku.VpdOffset = item[1] + except: + EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath) + + # Delete the DynamicPcdList At the last time enter into this function + for Pcd in self._DynamicPcdList: + # just pick the a value to determine whether is unicode string type + Sku = Pcd.SkuInfoList.get(TAB_DEFAULT) + Sku.VpdOffset = Sku.VpdOffset.strip() + + if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]: + Pcd.DatumType = TAB_VOID + + PcdValue = Sku.DefaultValue + if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"): + # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex + UnicodePcdArray.add(Pcd) + elif len(Sku.VariableName) > 0: + # if found HII type PCD then insert to right of UnicodeIndex + HiiPcdArray.add(Pcd) + else: + OtherPcdArray.add(Pcd) + del self._DynamicPcdList[:] + self._DynamicPcdList.extend(list(UnicodePcdArray)) + self._DynamicPcdList.extend(list(HiiPcdArray)) + self._DynamicPcdList.extend(list(OtherPcdArray)) + self._DynamicPcdList.sort() + allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()] + for pcd in self._DynamicPcdList: + if len(pcd.SkuInfoList) == 1: + for (SkuName, SkuId) in allskuset: + if isinstance(SkuId, str) and eval(SkuId) == 0 or SkuId == 0: + continue + pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT]) + pcd.SkuInfoList[SkuName].SkuId = SkuId + pcd.SkuInfoList[SkuName].SkuIdName = SkuName + + def FixVpdOffset(self, VpdFile ): + FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY) + if not os.path.exists(FvPath): + try: + os.makedirs(FvPath) + except: + EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir) + + VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid) + + if VpdFile.Write(VpdFilePath): + # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file. + BPDGToolName = None + for ToolDef in self.ToolDefinition.values(): + if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid: + if "PATH" not in ToolDef: + EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid) + BPDGToolName = ToolDef["PATH"] + break + # Call third party GUID BPDG tool. + if BPDGToolName is not None: + VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath) + else: + 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.") + + ## Return the platform build data object + @cached_property + def Platform(self): + return self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain] + + ## Return platform name + @cached_property + def Name(self): + return self.Platform.PlatformName + + ## Return the meta file GUID + @cached_property + def Guid(self): + return self.Platform.Guid + + ## Return the platform version + @cached_property + def Version(self): + return self.Platform.Version + + ## Return the FDF file name + @cached_property + def FdfFile(self): + if self.Workspace.FdfFile: + RetVal= mws.join(self.WorkspaceDir, self.Workspace.FdfFile) + else: + RetVal = '' + return RetVal + + ## Return the build output directory platform specifies + @cached_property + def OutputDir(self): + return self.Platform.OutputDirectory + + ## Return the directory to store all intermediate and final files built + @cached_property + def BuildDir(self): + if os.path.isabs(self.OutputDir): + GlobalData.gBuildDirectory = RetVal = path.join( + path.abspath(self.OutputDir), + self.BuildTarget + "_" + self.ToolChain, + ) + else: + GlobalData.gBuildDirectory = RetVal = path.join( + self.WorkspaceDir, + self.OutputDir, + self.BuildTarget + "_" + self.ToolChain, + ) + return RetVal + + ## Return directory of platform makefile + # + # @retval string Makefile directory + # + @cached_property + def MakeFileDir(self): + return path.join(self.BuildDir, self.Arch) + + ## Return build command string + # + # @retval string Build command string + # + @cached_property + def BuildCommand(self): + if "MAKE" in self.EdkIIBuildOption and "PATH" in self.EdkIIBuildOption["MAKE"]: + # MAKE_PATH in DSC [BuildOptions] section is higher priority + Path = self.EdkIIBuildOption["MAKE"]["PATH"] + if Path.startswith('='): + Path = Path[1:].strip() + RetVal = _SplitOption(Path) + elif "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]: + RetVal = _SplitOption(self.ToolDefinition["MAKE"]["PATH"]) + else: + return [] + if "MAKE" in self.ToolDefinition and "FLAGS" in self.ToolDefinition["MAKE"]: + NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip() + if NewOption != '': + RetVal += _SplitOption(NewOption) + if "MAKE" in self.EdkIIBuildOption and "FLAGS" in self.EdkIIBuildOption["MAKE"]: + Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"] + if Flags.startswith('='): + RetVal = [RetVal[0]] + _SplitOption(Flags[1:].strip()) + else: + RetVal = RetVal + _SplitOption(Flags.strip()) + return RetVal + + ## Compute a tool defintion key priority value in range 0..15 + # + # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE 15 + # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE 14 + # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE 13 + # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE 12 + # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE 11 + # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE 10 + # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE 9 + # ******_*********_****_COMMANDTYPE_ATTRIBUTE 8 + # TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE 7 + # ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE 6 + # TARGET_*********_ARCH_***********_ATTRIBUTE 5 + # ******_*********_ARCH_***********_ATTRIBUTE 4 + # TARGET_TOOLCHAIN_****_***********_ATTRIBUTE 3 + # ******_TOOLCHAIN_****_***********_ATTRIBUTE 2 + # TARGET_*********_****_***********_ATTRIBUTE 1 + # ******_*********_****_***********_ATTRIBUTE 0 + # + def ToolDefinitionPriority (self,Key): + KeyList = Key.split('_') + Priority = 0 + for Index in range (0, min(4, len(KeyList))): + if KeyList[Index] != '*': + Priority += (1 << Index) + return Priority + + ## Get tool chain definition + # + # Get each tool definition for given tool chain from tools_def.txt and platform + # + @cached_property + def ToolDefinition(self): + ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary + if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase: + EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration", + ExtraData="[%s]" % self.MetaFile) + RetVal = OrderedDict() + DllPathList = set() + + PrioritizedDefList = sorted(ToolDefinition.keys(), key=self.ToolDefinitionPriority, reverse=True) + for Def in PrioritizedDefList: + Target, Tag, Arch, Tool, Attr = Def.split("_") + if Target == TAB_STAR: + Target = self.BuildTarget + if Tag == TAB_STAR: + Tag = self.ToolChain + if Arch == TAB_STAR: + Arch = self.Arch + if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch: + continue + + Value = ToolDefinition[Def] + # don't record the DLL + if Attr == "DLL": + DllPathList.add(Value) + continue + + # + # ToolDefinition is sorted from highest priority to lowest priority. + # Only add the first(highest priority) match to RetVal + # + if Tool not in RetVal: + RetVal[Tool] = OrderedDict() + if Attr not in RetVal[Tool]: + RetVal[Tool][Attr] = Value + + ToolsDef = '' + if GlobalData.gOptions.SilentMode and "MAKE" in RetVal: + if "FLAGS" not in RetVal["MAKE"]: + RetVal["MAKE"]["FLAGS"] = "" + RetVal["MAKE"]["FLAGS"] += " -s" + MakeFlags = '' + + ToolList = list(RetVal.keys()) + ToolList.sort() + for Tool in ToolList: + if Tool == TAB_STAR: + continue + AttrList = list(RetVal[Tool].keys()) + if TAB_STAR in ToolList: + AttrList += list(RetVal[TAB_STAR]) + AttrList.sort() + for Attr in AttrList: + if Attr in RetVal[Tool]: + Value = RetVal[Tool][Attr] + else: + Value = RetVal[TAB_STAR][Attr] + if Tool in self._BuildOptionWithToolDef(RetVal) and Attr in self._BuildOptionWithToolDef(RetVal)[Tool]: + # check if override is indicated + if self._BuildOptionWithToolDef(RetVal)[Tool][Attr].startswith('='): + Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr][1:].strip() + else: + # Do not append PATH or GUID + if Attr != 'PATH' and Attr != 'GUID': + Value += " " + self._BuildOptionWithToolDef(RetVal)[Tool][Attr] + else: + Value = self._BuildOptionWithToolDef(RetVal)[Tool][Attr] + if Attr == "PATH": + # Don't put MAKE definition in the file + if Tool != "MAKE": + ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value) + elif Attr != "DLL": + # Don't put MAKE definition in the file + if Tool == "MAKE": + if Attr == "FLAGS": + MakeFlags = Value + else: + ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value) + ToolsDef += "\n" + + tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch) + SaveFileOnChange(tool_def_file, ToolsDef, False) + for DllPath in DllPathList: + os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"] + os.environ["MAKE_FLAGS"] = MakeFlags + + return RetVal + + ## Return the paths of tools + @cached_property + def ToolDefinitionFile(self): + tool_def_file = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch) + if not os.path.exists(tool_def_file): + self.ToolDefinition + return tool_def_file + + ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'. + @cached_property + def ToolChainFamily(self): + ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase + if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \ + or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \ + or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]: + EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \ + % self.ToolChain) + RetVal = TAB_COMPILER_MSFT + else: + RetVal = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain] + return RetVal + + @cached_property + def BuildRuleFamily(self): + ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase + if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \ + or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \ + or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]: + EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \ + % self.ToolChain) + return TAB_COMPILER_MSFT + + return ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain] + + ## Return the build options specific for all modules in this platform + @cached_property + def BuildOption(self): + return self._ExpandBuildOption(self.Platform.BuildOptions) + + def _BuildOptionWithToolDef(self, ToolDef): + return self._ExpandBuildOption(self.Platform.BuildOptions, ToolDef=ToolDef) + + ## Return the build options specific for EDK modules in this platform + @cached_property + def EdkBuildOption(self): + return self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME) + + ## Return the build options specific for EDKII modules in this platform + @cached_property + def EdkIIBuildOption(self): + return self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME) + + ## Parse build_rule.txt in Conf Directory. + # + # @retval BuildRule object + # + @cached_property + def BuildRule(self): + BuildRuleFile = None + if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary: + BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF] + if not BuildRuleFile: + BuildRuleFile = gDefaultBuildRuleFile + RetVal = BuildRule(BuildRuleFile) + if RetVal._FileVersion == "": + RetVal._FileVersion = AutoGenReqBuildRuleVerNum + else: + if RetVal._FileVersion < AutoGenReqBuildRuleVerNum : + # If Build Rule's version is less than the version number required by the tools, halting the build. + EdkLogger.error("build", AUTOGEN_ERROR, + 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])"\ + % (RetVal._FileVersion, AutoGenReqBuildRuleVerNum)) + return RetVal + + ## Summarize the packages used by modules in this platform + @cached_property + def PackageList(self): + RetVal = set() + for Mb in self._MbList: + RetVal.update(Mb.Packages) + for lb in Mb.LibInstances: + RetVal.update(lb.Packages) + #Collect package set information from INF of FDF + for ModuleFile in self._AsBuildModuleList: + if ModuleFile in self.Platform.Modules: + continue + ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain] + RetVal.update(ModuleData.Packages) + RetVal.update(self.Platform.Packages) + return list(RetVal) + + @cached_property + def NonDynamicPcdDict(self): + return {(Pcd.TokenCName, Pcd.TokenSpaceGuidCName):Pcd for Pcd in self.NonDynamicPcdList} + + ## Get list of non-dynamic PCDs + @property + def NonDynamicPcdList(self): + if not self._NonDynamicPcdList: + self.CollectPlatformDynamicPcds() + return self._NonDynamicPcdList + + ## Get list of dynamic PCDs + @property + def DynamicPcdList(self): + if not self._DynamicPcdList: + self.CollectPlatformDynamicPcds() + return self._DynamicPcdList + + ## Generate Token Number for all PCD + @cached_property + def PcdTokenNumber(self): + RetVal = OrderedDict() + TokenNumber = 1 + # + # Make the Dynamic and DynamicEx PCD use within different TokenNumber area. + # Such as: + # + # Dynamic PCD: + # TokenNumber 0 ~ 10 + # DynamicEx PCD: + # TokeNumber 11 ~ 20 + # + for Pcd in self.DynamicPcdList: + if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET: + EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) + RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber + TokenNumber += 1 + + for Pcd in self.DynamicPcdList: + if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET: + EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) + RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber + TokenNumber += 1 + + for Pcd in self.DynamicPcdList: + if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET: + EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) + RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber + TokenNumber += 1 + + for Pcd in self.DynamicPcdList: + if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET: + EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) + RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber + TokenNumber += 1 + + for Pcd in self.NonDynamicPcdList: + RetVal[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = 0 + return RetVal + + @cached_property + def _MbList(self): + ModuleList = [] + for m in self.Platform.Modules: + component = self.Platform.Modules[m] + module = self.BuildDatabase[m, self.Arch, self.BuildTarget, self.ToolChain] + module.Guid = component.Guid + ModuleList.append(module) + return ModuleList + + @cached_property + def _MaList(self): + for ModuleFile in self.Platform.Modules: + Ma = ModuleAutoGen( + self.Workspace, + ModuleFile, + self.BuildTarget, + self.ToolChain, + self.Arch, + self.MetaFile, + self.DataPipe + ) + self.Platform.Modules[ModuleFile].M = Ma + return [x.M for x in self.Platform.Modules.values()] + + ## Summarize ModuleAutoGen objects of all modules to be built for this platform + @cached_property + def ModuleAutoGenList(self): + RetVal = [] + for Ma in self._MaList: + if Ma not in RetVal: + RetVal.append(Ma) + return RetVal + + ## Summarize ModuleAutoGen objects of all libraries to be built for this platform + @cached_property + def LibraryAutoGenList(self): + RetVal = [] + for Ma in self._MaList: + for La in Ma.LibraryAutoGenList: + if La not in RetVal: + RetVal.append(La) + if Ma not in La.ReferenceModules: + La.ReferenceModules.append(Ma) + return RetVal + + ## Test if a module is supported by the platform + # + # An error will be raised directly if the module or its arch is not supported + # by the platform or current configuration + # + def ValidModule(self, Module): + return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \ + or Module in self._AsBuildModuleList + @cached_property + def GetAllModuleInfo(self,WithoutPcd=True): + ModuleLibs = set() + for m in self.Platform.Modules: + module_obj = self.BuildDatabase[m,self.Arch,self.BuildTarget,self.ToolChain] + if not bool(module_obj.LibraryClass): + Libs = GetModuleLibInstances(module_obj, self.Platform, self.BuildDatabase, self.Arch,self.BuildTarget,self.ToolChain,self.MetaFile,EdkLogger) + else: + Libs = [] + ModuleLibs.update( set([(l.MetaFile.File,l.MetaFile.Root,l.MetaFile.Path,l.MetaFile.BaseName,l.MetaFile.OriginalPath,l.Arch,True) for l in Libs])) + if WithoutPcd and module_obj.PcdIsDriver: + continue + ModuleLibs.add((m.File,m.Root,m.Path,m.BaseName,m.OriginalPath,module_obj.Arch,bool(module_obj.LibraryClass))) + + return ModuleLibs + + ## Resolve the library classes in a module to library instances + # + # This method will not only resolve library classes but also sort the library + # instances according to the dependency-ship. + # + # @param Module The module from which the library classes will be resolved + # + # @retval library_list List of library instances sorted + # + def ApplyLibraryInstance(self, Module): + # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly + if str(Module) not in self.Platform.Modules: + return [] + + return GetModuleLibInstances(Module, + self.Platform, + self.BuildDatabase, + self.Arch, + self.BuildTarget, + self.ToolChain, + self.MetaFile, + EdkLogger) + + ## Override PCD setting (type, value, ...) + # + # @param ToPcd The PCD to be overridden + # @param FromPcd The PCD overriding from + # + def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""): + # + # in case there's PCDs coming from FDF file, which have no type given. + # at this point, ToPcd.Type has the type found from dependent + # package + # + TokenCName = ToPcd.TokenCName + for PcdItem in GlobalData.MixedPcd: + if (ToPcd.TokenCName, ToPcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]: + TokenCName = PcdItem[0] + break + if FromPcd is not None: + if ToPcd.Pending and FromPcd.Type: + ToPcd.Type = FromPcd.Type + elif ToPcd.Type and FromPcd.Type\ + and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type: + if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX: + ToPcd.Type = FromPcd.Type + elif ToPcd.Type and FromPcd.Type \ + and ToPcd.Type != FromPcd.Type: + if Library: + Module = str(Module) + " 's library file (" + str(Library) + ")" + EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type", + ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\ + % (ToPcd.TokenSpaceGuidCName, TokenCName, + ToPcd.Type, Module, FromPcd.Type, Msg), + File=self.MetaFile) + + if FromPcd.MaxDatumSize: + ToPcd.MaxDatumSize = FromPcd.MaxDatumSize + ToPcd.MaxSizeUserSet = FromPcd.MaxDatumSize + if FromPcd.DefaultValue: + ToPcd.DefaultValue = FromPcd.DefaultValue + if FromPcd.TokenValue: + ToPcd.TokenValue = FromPcd.TokenValue + if FromPcd.DatumType: + ToPcd.DatumType = FromPcd.DatumType + if FromPcd.SkuInfoList: + ToPcd.SkuInfoList = FromPcd.SkuInfoList + if FromPcd.UserDefinedDefaultStoresFlag: + ToPcd.UserDefinedDefaultStoresFlag = FromPcd.UserDefinedDefaultStoresFlag + # Add Flexible PCD format parse + if ToPcd.DefaultValue: + try: + ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self.Platform._GuidDict)(True) + except BadExpression as Value: + EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value), + File=self.MetaFile) + + # check the validation of datum + IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue) + if not IsValid: + EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile, + ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, TokenCName)) + ToPcd.validateranges = FromPcd.validateranges + ToPcd.validlists = FromPcd.validlists + ToPcd.expressions = FromPcd.expressions + ToPcd.CustomAttribute = FromPcd.CustomAttribute + + if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize: + EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \ + % (ToPcd.TokenSpaceGuidCName, TokenCName)) + Value = ToPcd.DefaultValue + if not Value: + ToPcd.MaxDatumSize = '1' + elif Value[0] == 'L': + ToPcd.MaxDatumSize = str((len(Value) - 2) * 2) + elif Value[0] == '{': + ToPcd.MaxDatumSize = str(len(Value.split(','))) + else: + ToPcd.MaxDatumSize = str(len(Value) - 1) + + # apply default SKU for dynamic PCDS if specified one is not available + if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \ + and not ToPcd.SkuInfoList: + if self.Platform.SkuName in self.Platform.SkuIds: + SkuName = self.Platform.SkuName + else: + SkuName = TAB_DEFAULT + ToPcd.SkuInfoList = { + SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue) + } + + ## Apply PCD setting defined platform to a module + # + # @param Module The module from which the PCD setting will be overridden + # + # @retval PCD_list The list PCDs with settings from platform + # + def ApplyPcdSetting(self, Module, Pcds, Library=""): + # for each PCD in module + for Name, Guid in Pcds: + PcdInModule = Pcds[Name, Guid] + # find out the PCD setting in platform + if (Name, Guid) in self.Platform.Pcds: + PcdInPlatform = self.Platform.Pcds[Name, Guid] + else: + PcdInPlatform = None + # then override the settings if any + self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library) + # resolve the VariableGuid value + for SkuId in PcdInModule.SkuInfoList: + Sku = PcdInModule.SkuInfoList[SkuId] + if Sku.VariableGuid == '': continue + Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path) + if Sku.VariableGuidValue is None: + PackageList = "\n\t".join(str(P) for P in self.PackageList) + EdkLogger.error( + 'build', + RESOURCE_NOT_AVAILABLE, + "Value of GUID [%s] is not found in" % Sku.VariableGuid, + ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \ + % (Guid, Name, str(Module)), + File=self.MetaFile + ) + + # override PCD settings with module specific setting + if Module in self.Platform.Modules: + PlatformModule = self.Platform.Modules[str(Module)] + for Key in PlatformModule.Pcds: + if GlobalData.BuildOptionPcd: + for pcd in GlobalData.BuildOptionPcd: + (TokenSpaceGuidCName, TokenCName, FieldName, pcdvalue, _) = pcd + if (TokenCName, TokenSpaceGuidCName) == Key and FieldName =="": + PlatformModule.Pcds[Key].DefaultValue = pcdvalue + PlatformModule.Pcds[Key].PcdValueFromComm = pcdvalue + break + Flag = False + if Key in Pcds: + ToPcd = Pcds[Key] + Flag = True + elif Key in GlobalData.MixedPcd: + for PcdItem in GlobalData.MixedPcd[Key]: + if PcdItem in Pcds: + ToPcd = Pcds[PcdItem] + Flag = True + break + if Flag: + self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library) + # use PCD value to calculate the MaxDatumSize when it is not specified + for Name, Guid in Pcds: + Pcd = Pcds[Name, Guid] + if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize: + Pcd.MaxSizeUserSet = None + Value = Pcd.DefaultValue + if not Value: + Pcd.MaxDatumSize = '1' + elif Value[0] == 'L': + Pcd.MaxDatumSize = str((len(Value) - 2) * 2) + elif Value[0] == '{': + Pcd.MaxDatumSize = str(len(Value.split(','))) + else: + Pcd.MaxDatumSize = str(len(Value) - 1) + return list(Pcds.values()) + + ## Append build options in platform to a module + # + # @param Module The module to which the build options will be appended + # + # @retval options The options appended with build options in platform + # + def ApplyBuildOption(self, Module): + # Get the different options for the different style module + PlatformOptions = self.EdkIIBuildOption + ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType) + ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions) + ModuleOptions = self._ExpandBuildOption(Module.BuildOptions) + if Module in self.Platform.Modules: + PlatformModule = self.Platform.Modules[str(Module)] + PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions) + else: + PlatformModuleOptions = {} + + BuildRuleOrder = None + for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]: + for Tool in Options: + for Attr in Options[Tool]: + if Attr == TAB_TOD_DEFINES_BUILDRULEORDER: + BuildRuleOrder = Options[Tool][Attr] + + AllTools = set(list(ModuleOptions.keys()) + list(PlatformOptions.keys()) + + list(PlatformModuleOptions.keys()) + list(ModuleTypeOptions.keys()) + + list(self.ToolDefinition.keys())) + BuildOptions = defaultdict(lambda: defaultdict(str)) + for Tool in AllTools: + for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]: + if Tool not in Options: + continue + for Attr in Options[Tool]: + # + # Do not generate it in Makefile + # + if Attr == TAB_TOD_DEFINES_BUILDRULEORDER: + continue + Value = Options[Tool][Attr] + ToolList = [Tool] + if Tool == TAB_STAR: + ToolList = list(AllTools) + ToolList.remove(TAB_STAR) + for ExpandedTool in ToolList: + # check if override is indicated + if Value.startswith('='): + BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value[1:]) + else: + if Attr != 'PATH': + BuildOptions[ExpandedTool][Attr] += " " + mws.handleWsMacro(Value) + else: + BuildOptions[ExpandedTool][Attr] = mws.handleWsMacro(Value) + + return BuildOptions, BuildRuleOrder + + + def GetGlobalBuildOptions(self,Module): + ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType) + ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions) + + if Module in self.Platform.Modules: + PlatformModule = self.Platform.Modules[str(Module)] + PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions) + else: + PlatformModuleOptions = {} + + return ModuleTypeOptions,PlatformModuleOptions + def ModuleGuid(self,Module): + if os.path.basename(Module.MetaFile.File) != os.path.basename(Module.MetaFile.Path): + # + # Length of GUID is 36 + # + return os.path.basename(Module.MetaFile.Path)[:36] + return Module.Guid + @cached_property + def UniqueBaseName(self): + retVal ={} + ModuleNameDict = {} + UniqueName = {} + for Module in self._MbList: + unique_base_name = '%s_%s' % (Module.BaseName,self.ModuleGuid(Module)) + if unique_base_name not in ModuleNameDict: + ModuleNameDict[unique_base_name] = [] + ModuleNameDict[unique_base_name].append(Module.MetaFile) + if Module.BaseName not in UniqueName: + UniqueName[Module.BaseName] = set() + UniqueName[Module.BaseName].add((self.ModuleGuid(Module),Module.MetaFile)) + for module_paths in ModuleNameDict.values(): + if len(set(module_paths))>1: + samemodules = list(set(module_paths)) + EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n' + ' %s\n %s' % (samemodules[0], samemodules[1])) + for name in UniqueName: + Guid_Path = UniqueName[name] + if len(Guid_Path) > 1: + for guid,mpath in Guid_Path: + retVal[(name,mpath)] = '%s_%s' % (name,guid) + return retVal + ## Expand * in build option key + # + # @param Options Options to be expanded + # @param ToolDef Use specified ToolDef instead of full version. + # This is needed during initialization to prevent + # infinite recursion betweeh BuildOptions, + # ToolDefinition, and this function. + # + # @retval options Options expanded + # + def _ExpandBuildOption(self, Options, ModuleStyle=None, ToolDef=None): + if not ToolDef: + ToolDef = self.ToolDefinition + BuildOptions = {} + FamilyMatch = False + FamilyIsNull = True + + OverrideList = {} + # + # Construct a list contain the build options which need override. + # + for Key in Options: + # + # Key[0] -- tool family + # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE + # + if (Key[0] == self.BuildRuleFamily and + (ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))): + Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_') + if (Target == self.BuildTarget or Target == TAB_STAR) and\ + (ToolChain == self.ToolChain or ToolChain == TAB_STAR) and\ + (Arch == self.Arch or Arch == TAB_STAR) and\ + Options[Key].startswith("="): + + if OverrideList.get(Key[1]) is not None: + OverrideList.pop(Key[1]) + OverrideList[Key[1]] = Options[Key] + + # + # Use the highest priority value. + # + if (len(OverrideList) >= 2): + KeyList = list(OverrideList.keys()) + for Index in range(len(KeyList)): + NowKey = KeyList[Index] + Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_") + for Index1 in range(len(KeyList) - Index - 1): + NextKey = KeyList[Index1 + Index + 1] + # + # Compare two Key, if one is included by another, choose the higher priority one + # + Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_") + if (Target1 == Target2 or Target1 == TAB_STAR or Target2 == TAB_STAR) and\ + (ToolChain1 == ToolChain2 or ToolChain1 == TAB_STAR or ToolChain2 == TAB_STAR) and\ + (Arch1 == Arch2 or Arch1 == TAB_STAR or Arch2 == TAB_STAR) and\ + (CommandType1 == CommandType2 or CommandType1 == TAB_STAR or CommandType2 == TAB_STAR) and\ + (Attr1 == Attr2 or Attr1 == TAB_STAR or Attr2 == TAB_STAR): + + if CalculatePriorityValue(NowKey) > CalculatePriorityValue(NextKey): + if Options.get((self.BuildRuleFamily, NextKey)) is not None: + Options.pop((self.BuildRuleFamily, NextKey)) + else: + if Options.get((self.BuildRuleFamily, NowKey)) is not None: + Options.pop((self.BuildRuleFamily, NowKey)) + + for Key in Options: + if ModuleStyle is not None and len (Key) > 2: + # Check Module style is EDK or EDKII. + # Only append build option for the matched style module. + if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME: + continue + elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME: + continue + Family = Key[0] + Target, Tag, Arch, Tool, Attr = Key[1].split("_") + # if tool chain family doesn't match, skip it + if Family != "": + Found = False + if Tool in ToolDef: + FamilyIsNull = False + if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[Tool]: + if Family == ToolDef[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]: + FamilyMatch = True + Found = True + if TAB_STAR in ToolDef: + FamilyIsNull = False + if TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDef[TAB_STAR]: + if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_BUILDRULEFAMILY]: + FamilyMatch = True + Found = True + if not Found: + continue + + # expand any wildcard + if Target == TAB_STAR or Target == self.BuildTarget: + if Tag == TAB_STAR or Tag == self.ToolChain: + if Arch == TAB_STAR or Arch == self.Arch: + if Tool not in BuildOptions: + BuildOptions[Tool] = {} + if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='): + BuildOptions[Tool][Attr] = Options[Key] + else: + # append options for the same tool except PATH + if Attr != 'PATH': + BuildOptions[Tool][Attr] += " " + Options[Key] + else: + BuildOptions[Tool][Attr] = Options[Key] + # Build Option Family has been checked, which need't to be checked again for family. + if FamilyMatch or FamilyIsNull: + return BuildOptions + + for Key in Options: + if ModuleStyle is not None and len (Key) > 2: + # Check Module style is EDK or EDKII. + # Only append build option for the matched style module. + if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME: + continue + elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME: + continue + Family = Key[0] + Target, Tag, Arch, Tool, Attr = Key[1].split("_") + # if tool chain family doesn't match, skip it + if Family == "": + continue + # option has been added before + Found = False + if Tool in ToolDef: + if TAB_TOD_DEFINES_FAMILY in ToolDef[Tool]: + if Family == ToolDef[Tool][TAB_TOD_DEFINES_FAMILY]: + Found = True + if TAB_STAR in ToolDef: + if TAB_TOD_DEFINES_FAMILY in ToolDef[TAB_STAR]: + if Family == ToolDef[TAB_STAR][TAB_TOD_DEFINES_FAMILY]: + Found = True + if not Found: + continue + + # expand any wildcard + if Target == TAB_STAR or Target == self.BuildTarget: + if Tag == TAB_STAR or Tag == self.ToolChain: + if Arch == TAB_STAR or Arch == self.Arch: + if Tool not in BuildOptions: + BuildOptions[Tool] = {} + if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='): + BuildOptions[Tool][Attr] = Options[Key] + else: + # append options for the same tool except PATH + if Attr != 'PATH': + BuildOptions[Tool][Attr] += " " + Options[Key] + else: + BuildOptions[Tool][Attr] = Options[Key] + return BuildOptions |