| ## @file | |
| # This file is used to define each component of the build database | |
| # | |
| # Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR> | |
| # This program and the accompanying materials | |
| # are licensed and made available under the terms and conditions of the BSD License | |
| # which accompanies this distribution. The full text of the license may be found at | |
| # http://opensource.org/licenses/bsd-license.php | |
| # | |
| # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |
| # | |
| ## | |
| # Import Modules | |
| # | |
| import Common.LongFilePathOs as os, string, copy, pdb, copy | |
| import EdkLogger | |
| import DataType | |
| from InfClassObject import * | |
| from DecClassObject import * | |
| from DscClassObject import * | |
| from String import * | |
| from BuildToolError import * | |
| from Misc import sdict | |
| import Database as Database | |
| import time as time | |
| ## PcdClassObject | |
| # | |
| # This Class is used for PcdObject | |
| # | |
| # @param object: Inherited from object class | |
| # @param Name: Input value for Name of Pcd, default is None | |
| # @param Guid: Input value for Guid of Pcd, default is None | |
| # @param Type: Input value for Type of Pcd, default is None | |
| # @param DatumType: Input value for DatumType of Pcd, default is None | |
| # @param Value: Input value for Value of Pcd, default is None | |
| # @param Token: Input value for Token of Pcd, default is None | |
| # @param MaxDatumSize: Input value for MaxDatumSize of Pcd, default is None | |
| # @param SkuInfoList: Input value for SkuInfoList of Pcd, default is {} | |
| # @param IsOverrided: Input value for IsOverrided of Pcd, default is False | |
| # | |
| # @var TokenCName: To store value for TokenCName | |
| # @var TokenSpaceGuidCName: To store value for TokenSpaceGuidCName | |
| # @var Type: To store value for Type | |
| # @var DatumType: To store value for DatumType | |
| # @var TokenValue: To store value for TokenValue | |
| # @var MaxDatumSize: To store value for MaxDatumSize | |
| # @var SkuInfoList: To store value for SkuInfoList | |
| # @var IsOverrided: To store value for IsOverrided | |
| # @var Phase: To store value for Phase, default is "DXE" | |
| # | |
| class PcdClassObject(object): | |
| def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = {}, IsOverrided = False): | |
| self.TokenCName = Name | |
| self.TokenSpaceGuidCName = Guid | |
| self.Type = Type | |
| self.DatumType = DatumType | |
| self.DefaultValue = Value | |
| self.TokenValue = Token | |
| self.MaxDatumSize = MaxDatumSize | |
| self.SkuInfoList = SkuInfoList | |
| self.IsOverrided = IsOverrided | |
| self.Phase = "DXE" | |
| ## Convert the class to a string | |
| # | |
| # Convert each member of the class to string | |
| # Organize to a signle line format string | |
| # | |
| # @retval Rtn Formatted String | |
| # | |
| def __str__(self): | |
| Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \ | |
| 'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \ | |
| 'Type=' + str(self.Type) + ', ' + \ | |
| 'DatumType=' + str(self.DatumType) + ', ' + \ | |
| 'DefaultValue=' + str(self.DefaultValue) + ', ' + \ | |
| 'TokenValue=' + str(self.TokenValue) + ', ' + \ | |
| 'MaxDatumSize=' + str(self.MaxDatumSize) + ', ' | |
| for Item in self.SkuInfoList.values(): | |
| Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName | |
| Rtn = Rtn + str(self.IsOverrided) | |
| return Rtn | |
| ## Override __eq__ function | |
| # | |
| # Check whether pcds are the same | |
| # | |
| # @retval False The two pcds are different | |
| # @retval True The two pcds are the same | |
| # | |
| def __eq__(self, Other): | |
| return Other != None and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName | |
| ## Override __hash__ function | |
| # | |
| # Use (TokenCName, TokenSpaceGuidCName) as key in hash table | |
| # | |
| # @retval truple() Key for hash table | |
| # | |
| def __hash__(self): | |
| return hash((self.TokenCName, self.TokenSpaceGuidCName)) | |
| ## LibraryClassObject | |
| # | |
| # This Class defines LibraryClassObject used in BuildDatabase | |
| # | |
| # @param object: Inherited from object class | |
| # @param Name: Input value for LibraryClassName, default is None | |
| # @param SupModList: Input value for SupModList, default is [] | |
| # @param Type: Input value for Type, default is None | |
| # | |
| # @var LibraryClass: To store value for LibraryClass | |
| # @var SupModList: To store value for SupModList | |
| # @var Type: To store value for Type | |
| # | |
| class LibraryClassObject(object): | |
| def __init__(self, Name = None, SupModList = [], Type = None): | |
| self.LibraryClass = Name | |
| self.SupModList = SupModList | |
| if Type != None: | |
| self.SupModList = CleanString(Type).split(DataType.TAB_SPACE_SPLIT) | |
| ## ModuleBuildClassObject | |
| # | |
| # This Class defines ModuleBuildClass | |
| # | |
| # @param object: Inherited from object class | |
| # | |
| # @var DescFilePath: To store value for DescFilePath | |
| # @var BaseName: To store value for BaseName | |
| # @var ModuleType: To store value for ModuleType | |
| # @var Guid: To store value for Guid | |
| # @var Version: To store value for Version | |
| # @var PcdIsDriver: To store value for PcdIsDriver | |
| # @var BinaryModule: To store value for BinaryModule | |
| # @var CustomMakefile: To store value for CustomMakefile | |
| # @var Specification: To store value for Specification | |
| # @var Shadow To store value for Shadow | |
| # @var LibraryClass: To store value for LibraryClass, it is a list structure as | |
| # [ LibraryClassObject, ...] | |
| # @var ModuleEntryPointList: To store value for ModuleEntryPointList | |
| # @var ModuleUnloadImageList: To store value for ModuleUnloadImageList | |
| # @var ConstructorList: To store value for ConstructorList | |
| # @var DestructorList: To store value for DestructorList | |
| # @var Binaries: To store value for Binaries, it is a list structure as | |
| # [ ModuleBinaryClassObject, ...] | |
| # @var Sources: To store value for Sources, it is a list structure as | |
| # [ ModuleSourceFilesClassObject, ... ] | |
| # @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
| # { [LibraryClassName, ModuleType] : LibraryClassInfFile } | |
| # @var Protocols: To store value for Protocols, it is a list structure as | |
| # [ ProtocolName, ... ] | |
| # @var Ppis: To store value for Ppis, it is a list structure as | |
| # [ PpiName, ... ] | |
| # @var Guids: To store value for Guids, it is a list structure as | |
| # [ GuidName, ... ] | |
| # @var Includes: To store value for Includes, it is a list structure as | |
| # [ IncludePath, ... ] | |
| # @var Packages: To store value for Packages, it is a list structure as | |
| # [ DecFileName, ... ] | |
| # @var Pcds: To store value for Pcds, it is a set structure as | |
| # { [(PcdCName, PcdGuidCName)] : PcdClassObject} | |
| # @var BuildOptions: To store value for BuildOptions, it is a set structure as | |
| # { [BuildOptionKey] : BuildOptionValue} | |
| # @var Depex: To store value for Depex | |
| # | |
| class ModuleBuildClassObject(object): | |
| def __init__(self): | |
| self.AutoGenVersion = 0 | |
| self.DescFilePath = '' | |
| self.BaseName = '' | |
| self.ModuleType = '' | |
| self.Guid = '' | |
| self.Version = '' | |
| self.PcdIsDriver = '' | |
| self.BinaryModule = '' | |
| self.Shadow = '' | |
| self.CustomMakefile = {} | |
| self.Specification = {} | |
| self.LibraryClass = [] | |
| self.ModuleEntryPointList = [] | |
| self.ModuleUnloadImageList = [] | |
| self.ConstructorList = [] | |
| self.DestructorList = [] | |
| self.Binaries = [] | |
| self.Sources = [] | |
| self.LibraryClasses = sdict() | |
| self.Libraries = [] | |
| self.Protocols = [] | |
| self.Ppis = [] | |
| self.Guids = [] | |
| self.Includes = [] | |
| self.Packages = [] | |
| self.Pcds = {} | |
| self.BuildOptions = {} | |
| self.Depex = '' | |
| ## Convert the class to a string | |
| # | |
| # Convert member DescFilePath of the class to a string | |
| # | |
| # @retval string Formatted String | |
| # | |
| def __str__(self): | |
| return self.DescFilePath | |
| ## Override __eq__ function | |
| # | |
| # Check whether ModuleBuildClassObjects are the same | |
| # | |
| # @retval False The two ModuleBuildClassObjects are different | |
| # @retval True The two ModuleBuildClassObjects are the same | |
| # | |
| def __eq__(self, Other): | |
| return self.DescFilePath == str(Other) | |
| ## Override __hash__ function | |
| # | |
| # Use DescFilePath as key in hash table | |
| # | |
| # @retval string Key for hash table | |
| # | |
| def __hash__(self): | |
| return hash(self.DescFilePath) | |
| ## PackageBuildClassObject | |
| # | |
| # This Class defines PackageBuildClass | |
| # | |
| # @param object: Inherited from object class | |
| # | |
| # @var DescFilePath: To store value for DescFilePath | |
| # @var PackageName: To store value for PackageName | |
| # @var Guid: To store value for Guid | |
| # @var Version: To store value for Version | |
| # @var Protocols: To store value for Protocols, it is a set structure as | |
| # { [ProtocolName] : Protocol Guid, ... } | |
| # @var Ppis: To store value for Ppis, it is a set structure as | |
| # { [PpiName] : Ppi Guid, ... } | |
| # @var Guids: To store value for Guids, it is a set structure as | |
| # { [GuidName] : Guid, ... } | |
| # @var Includes: To store value for Includes, it is a list structure as | |
| # [ IncludePath, ... ] | |
| # @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
| # { [LibraryClassName] : LibraryClassInfFile } | |
| # @var Pcds: To store value for Pcds, it is a set structure as | |
| # { [(PcdCName, PcdGuidCName)] : PcdClassObject} | |
| # | |
| class PackageBuildClassObject(object): | |
| def __init__(self): | |
| self.DescFilePath = '' | |
| self.PackageName = '' | |
| self.Guid = '' | |
| self.Version = '' | |
| self.Protocols = {} | |
| self.Ppis = {} | |
| self.Guids = {} | |
| self.Includes = [] | |
| self.LibraryClasses = {} | |
| self.Pcds = {} | |
| ## Convert the class to a string | |
| # | |
| # Convert member DescFilePath of the class to a string | |
| # | |
| # @retval string Formatted String | |
| # | |
| def __str__(self): | |
| return self.DescFilePath | |
| ## Override __eq__ function | |
| # | |
| # Check whether PackageBuildClassObjects are the same | |
| # | |
| # @retval False The two PackageBuildClassObjects are different | |
| # @retval True The two PackageBuildClassObjects are the same | |
| # | |
| def __eq__(self, Other): | |
| return self.DescFilePath == str(Other) | |
| ## Override __hash__ function | |
| # | |
| # Use DescFilePath as key in hash table | |
| # | |
| # @retval string Key for hash table | |
| # | |
| def __hash__(self): | |
| return hash(self.DescFilePath) | |
| ## PlatformBuildClassObject | |
| # | |
| # This Class defines PlatformBuildClass | |
| # | |
| # @param object: Inherited from object class | |
| # | |
| # @var DescFilePath: To store value for DescFilePath | |
| # @var PlatformName: To store value for PlatformName | |
| # @var Guid: To store value for Guid | |
| # @var Version: To store value for Version | |
| # @var DscSpecification: To store value for DscSpecification | |
| # @var OutputDirectory: To store value for OutputDirectory | |
| # @var FlashDefinition: To store value for FlashDefinition | |
| # @var BuildNumber: To store value for BuildNumber | |
| # @var MakefileName: To store value for MakefileName | |
| # @var SkuIds: To store value for SkuIds, it is a set structure as | |
| # { 'SkuName' : SkuId, '!include' : includefilename, ...} | |
| # @var Modules: To store value for Modules, it is a list structure as | |
| # [ InfFileName, ... ] | |
| # @var Libraries: To store value for Libraries, it is a list structure as | |
| # [ InfFileName, ... ] | |
| # @var LibraryClasses: To store value for LibraryClasses, it is a set structure as | |
| # { (LibraryClassName, ModuleType) : LibraryClassInfFile } | |
| # @var Pcds: To store value for Pcds, it is a set structure as | |
| # { [(PcdCName, PcdGuidCName)] : PcdClassObject } | |
| # @var BuildOptions: To store value for BuildOptions, it is a set structure as | |
| # { [BuildOptionKey] : BuildOptionValue } | |
| # | |
| class PlatformBuildClassObject(object): | |
| def __init__(self): | |
| self.DescFilePath = '' | |
| self.PlatformName = '' | |
| self.Guid = '' | |
| self.Version = '' | |
| self.DscSpecification = '' | |
| self.OutputDirectory = '' | |
| self.FlashDefinition = '' | |
| self.BuildNumber = '' | |
| self.MakefileName = '' | |
| self.SkuIds = {} | |
| self.Modules = [] | |
| self.LibraryInstances = [] | |
| self.LibraryClasses = {} | |
| self.Libraries = {} | |
| self.Pcds = {} | |
| self.BuildOptions = {} | |
| ## Convert the class to a string | |
| # | |
| # Convert member DescFilePath of the class to a string | |
| # | |
| # @retval string Formatted String | |
| # | |
| def __str__(self): | |
| return self.DescFilePath | |
| ## Override __eq__ function | |
| # | |
| # Check whether PlatformBuildClassObjects are the same | |
| # | |
| # @retval False The two PlatformBuildClassObjects are different | |
| # @retval True The two PlatformBuildClassObjects are the same | |
| # | |
| def __eq__(self, other): | |
| return self.DescFilePath == str(other) | |
| ## Override __hash__ function | |
| # | |
| # Use DescFilePath as key in hash table | |
| # | |
| # @retval string Key for hash table | |
| # | |
| def __hash__(self): | |
| return hash(self.DescFilePath) | |
| ## ItemBuild | |
| # | |
| # This Class defines Module/Platform/Package databases for build system | |
| # | |
| # @param object: Inherited from object class | |
| # @param Arch: Build arch | |
| # @param Platform: Build Platform | |
| # @param Package: Build Package | |
| # @param Module: Build Module | |
| # | |
| # @var Arch: To store value for Build Arch | |
| # @var PlatformDatabase: To store value for PlatformDatabase, it is a set structure as | |
| # { [DscFileName] : PlatformBuildClassObject, ...} | |
| # @var PackageDatabase: To store value for PackageDatabase, it is a set structure as | |
| # { [DecFileName] : PacakgeBuildClassObject, ...} | |
| # @var ModuleDatabase: To store value for ModuleDatabase, it is a list structure as | |
| # { [InfFileName] : ModuleBuildClassObject, ...} | |
| # | |
| class ItemBuild(object): | |
| def __init__(self, Arch, Platform = None, Package = None, Module = None): | |
| self.Arch = Arch | |
| self.PlatformDatabase = {} | |
| self.PackageDatabase = {} | |
| self.ModuleDatabase = {} | |
| ## WorkspaceBuild | |
| # | |
| # This class is used to parse active platform to init all inf/dec/dsc files | |
| # Generate module/package/platform databases for build | |
| # | |
| # @param object: Inherited from object class | |
| # @param ActivePlatform: Input value for current active platform | |
| # @param WorkspaceDir: Input value for current WorkspaceDir | |
| # | |
| # @var WorkspaceDir: To store value for WorkspaceDir | |
| # @var SupArchList: To store value for SupArchList, selection scope is in below list | |
| # EBC | IA32 | X64 | IPF | ARM | PPC | AARCH64 | |
| # @var BuildTarget: To store value for WorkspaceDir, selection scope is in below list | |
| # RELEASE | DEBUG | |
| # @var SkuId: To store value for SkuId | |
| # @var Fdf: To store value for Fdf | |
| # @var FdTargetList: To store value for FdTargetList | |
| # @var FvTargetList: To store value for FvTargetList | |
| # @var TargetTxt: To store value for TargetTxt, it is a set structure as | |
| # TargetTxtClassObject | |
| # @var ToolDef: To store value for ToolDef, it is a set structure as | |
| # ToolDefClassObject | |
| # @var InfDatabase: To store value for InfDatabase, it is a set structure as | |
| # { [InfFileName] : InfClassObject} | |
| # @var DecDatabase: To store value for DecDatabase, it is a set structure as | |
| # { [DecFileName] : DecClassObject} | |
| # @var DscDatabase: To store value for DscDatabase, it is a set structure as | |
| # { [DscFileName] : DscClassObject} | |
| # @var Build: To store value for DscDatabase, it is a set structure as | |
| # ItemBuild | |
| # @var DscFileName: To store value for Active Platform | |
| # @var UnFoundPcdInDsc: To store values for the pcds defined in INF/DEC but not found in DSC, it is a set structure as | |
| # { (PcdGuid, PcdCName, Arch) : DecFileName } | |
| # | |
| class WorkspaceBuild(object): | |
| def __init__(self, ActivePlatform, WorkspaceDir): | |
| self.WorkspaceDir = NormPath(WorkspaceDir) | |
| self.SupArchList = [] | |
| self.BuildTarget = [] | |
| self.SkuId = '' | |
| self.Fdf = '' | |
| self.FdTargetList = [] | |
| self.FvTargetList = [] | |
| self.TargetTxt = None | |
| self.ToolDef = None | |
| self.InfDatabase = {} | |
| self.DecDatabase = {} | |
| self.DscDatabase = {} | |
| self.UnFoundPcdInDsc = {} | |
| # | |
| # Init build for all arches | |
| # | |
| self.Build = {} | |
| for Arch in DataType.ARCH_LIST: | |
| self.Build[Arch] = ItemBuild(Arch) | |
| # | |
| # Init build database | |
| # | |
| self.Db = Database.Database(DATABASE_PATH) | |
| self.Db.InitDatabase() | |
| # | |
| # Get active platform | |
| # | |
| self.DscFileName = NormPath(ActivePlatform) | |
| File = self.WorkspaceFile(self.DscFileName) | |
| if os.path.exists(File) and os.path.isfile(File): | |
| self.DscDatabase[self.DscFileName] = Dsc(File, False, True, self.WorkspaceDir, self.Db) | |
| else: | |
| EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData = File) | |
| # | |
| # Parse platform to get module | |
| # | |
| for DscFile in self.DscDatabase.keys(): | |
| Platform = self.DscDatabase[DscFile].Platform | |
| # | |
| # Get global information | |
| # | |
| Tmp = set() | |
| for Arch in DataType.ARCH_LIST: | |
| for Item in Platform.Header[Arch].SupArchList: | |
| Tmp.add(Item) | |
| self.SupArchList = list(Tmp) | |
| Tmp = set() | |
| for Arch in DataType.ARCH_LIST: | |
| for Item in Platform.Header[Arch].BuildTargets: | |
| Tmp.add(Item) | |
| self.BuildTarget = list(Tmp) | |
| for Arch in self.SupArchList: | |
| self.SkuId = Platform.Header[Arch].SkuIdName | |
| self.Fdf = Platform.FlashDefinitionFile.FilePath | |
| # | |
| # Get all inf files | |
| # | |
| for Item in Platform.LibraryClasses.LibraryList: | |
| for Arch in Item.SupArchList: | |
| self.AddToInfDatabase(Item.FilePath) | |
| for Item in Platform.Libraries.LibraryList: | |
| for Arch in Item.SupArchList: | |
| self.AddToInfDatabase(Item.FilePath) | |
| for Item in Platform.Modules.ModuleList: | |
| for Arch in Item.SupArchList: | |
| # | |
| # Add modules | |
| # | |
| Module = Item.FilePath | |
| self.AddToInfDatabase(Module) | |
| # | |
| # Add library used in modules | |
| # | |
| for Lib in Item.LibraryClasses.LibraryList: | |
| self.AddToInfDatabase(Lib.FilePath) | |
| self.UpdateLibraryClassOfModule(Module, Lib.Name, Arch, Lib.FilePath) | |
| # | |
| # Parse module to get package | |
| # | |
| for InfFile in self.InfDatabase.keys(): | |
| Module = self.InfDatabase[InfFile].Module | |
| # | |
| # Get all dec | |
| # | |
| for Item in Module.PackageDependencies: | |
| for Arch in Item.SupArchList: | |
| self.AddToDecDatabase(Item.FilePath) | |
| # End of self.Init() | |
| ## Generate PlatformDatabase | |
| # | |
| # Go through each arch to get all items in DscDatabase to PlatformDatabase | |
| # | |
| def GenPlatformDatabase(self, PcdsSet={}): | |
| for Dsc in self.DscDatabase.keys(): | |
| Platform = self.DscDatabase[Dsc].Platform | |
| for Arch in self.SupArchList: | |
| Pb = PlatformBuildClassObject() | |
| # | |
| # Defines | |
| # | |
| Pb.DescFilePath = Dsc | |
| Pb.PlatformName = Platform.Header[Arch].Name | |
| if Pb.PlatformName == '': | |
| EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of platform %s is not defined for arch %s" % (Dsc, Arch)) | |
| Pb.Guid = Platform.Header[Arch].Guid | |
| Pb.Version = Platform.Header[Arch].Version | |
| Pb.DscSpecification = Platform.Header[Arch].DscSpecification | |
| Pb.OutputDirectory = Platform.Header[Arch].OutputDirectory | |
| Pb.FlashDefinition = Platform.FlashDefinitionFile.FilePath | |
| Pb.BuildNumber = Platform.Header[Arch].BuildNumber | |
| # | |
| # SkuId | |
| # | |
| for Key in Platform.SkuInfos.SkuInfoList.keys(): | |
| Pb.SkuIds[Key] = Platform.SkuInfos.SkuInfoList[Key] | |
| # | |
| # Module | |
| # | |
| for Item in Platform.Modules.ModuleList: | |
| if Arch in Item.SupArchList: | |
| Pb.Modules.append(Item.FilePath) | |
| # | |
| # BuildOptions | |
| # | |
| for Item in Platform.BuildOptions.BuildOptionList: | |
| if Arch in Item.SupArchList: | |
| Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option | |
| # | |
| # LibraryClass | |
| # | |
| for Item in Platform.LibraryClasses.LibraryList: | |
| SupModuleList = self.FindSupModuleListOfLibraryClass(Item, Platform.LibraryClasses.LibraryList, Arch) | |
| if Arch in Item.SupArchList: | |
| for ModuleType in SupModuleList: | |
| Pb.LibraryClasses[(Item.Name, ModuleType)] = Item.FilePath | |
| # | |
| # Libraries | |
| # | |
| for Item in Platform.Libraries.LibraryList: | |
| for ItemArch in Item.SupArchList: | |
| Library = self.InfDatabase[Item.FilePath] | |
| if ItemArch not in Library.Module.Header: | |
| continue | |
| Pb.Libraries[Library.Module.Header[ItemArch].Name] = Item.FilePath | |
| # | |
| # Pcds | |
| # | |
| for Item in Platform.DynamicPcdBuildDefinitions: | |
| if Arch in Item.SupArchList: | |
| Name = Item.CName | |
| Guid = Item.TokenSpaceGuidCName | |
| Type = Item.ItemType | |
| DatumType = Item.DatumType | |
| Value = Item.DefaultValue | |
| Token = Item.Token | |
| MaxDatumSize = Item.MaxDatumSize | |
| SkuInfoList = Item.SkuInfoList | |
| Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False) | |
| for (Name, Guid) in PcdsSet: | |
| Value = PcdsSet[Name, Guid] | |
| for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]: | |
| for Dec in self.Build[Arch].PackageDatabase: | |
| Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds | |
| if (Name, Guid, PcdType) in Pcds: | |
| Pcd = Pcds[(Name, Guid, PcdType)] | |
| Type = PcdType | |
| DatumType = Pcd.DatumType | |
| Token = Pcd.TokenValue | |
| MaxDatumSize = Pcd.MaxDatumSize | |
| SkuInfoList = Pcd.SkuInfoList | |
| Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False) | |
| break | |
| else: | |
| # nothing found | |
| continue | |
| # found in one package, find next PCD | |
| break | |
| else: | |
| EdkLogger.error("AutoGen", PARSER_ERROR, "PCD is not found in any package", ExtraData="%s.%s" % (Guid, Name)) | |
| # | |
| # Add to database | |
| # | |
| self.Build[Arch].PlatformDatabase[Dsc] = Pb | |
| Pb = None | |
| ## Generate PackageDatabase | |
| # | |
| # Go through each arch to get all items in DecDatabase to PackageDatabase | |
| # | |
| def GenPackageDatabase(self): | |
| for Dec in self.DecDatabase.keys(): | |
| Package = self.DecDatabase[Dec].Package | |
| for Arch in self.SupArchList: | |
| Pb = PackageBuildClassObject() | |
| # | |
| # Defines | |
| # | |
| Pb.DescFilePath = Dec | |
| Pb.PackageName = Package.Header[Arch].Name | |
| if Pb.PackageName == '': | |
| EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of package %s is not defined for arch %s" % (Dec, Arch)) | |
| Pb.Guid = Package.Header[Arch].Guid | |
| Pb.Version = Package.Header[Arch].Version | |
| # | |
| # Protocols | |
| # | |
| for Item in Package.ProtocolDeclarations: | |
| if Arch in Item.SupArchList: | |
| Pb.Protocols[Item.CName] = Item.Guid | |
| # | |
| # Ppis | |
| # | |
| for Item in Package.PpiDeclarations: | |
| if Arch in Item.SupArchList: | |
| Pb.Ppis[Item.CName] = Item.Guid | |
| # | |
| # Guids | |
| # | |
| for Item in Package.GuidDeclarations: | |
| if Arch in Item.SupArchList: | |
| Pb.Guids[Item.CName] = Item.Guid | |
| # | |
| # Includes | |
| # | |
| for Item in Package.Includes: | |
| if Arch in Item.SupArchList: | |
| Pb.Includes.append(Item.FilePath) | |
| # | |
| # LibraryClasses | |
| # | |
| for Item in Package.LibraryClassDeclarations: | |
| if Arch in Item.SupArchList: | |
| Pb.LibraryClasses[Item.LibraryClass] = Item.RecommendedInstance | |
| # | |
| # Pcds | |
| # | |
| for Item in Package.PcdDeclarations: | |
| if Arch in Item.SupArchList: | |
| Name = Item.CName | |
| Guid = Item.TokenSpaceGuidCName | |
| Type = Item.ItemType | |
| DatumType = Item.DatumType | |
| Value = Item.DefaultValue | |
| Token = Item.Token | |
| MaxDatumSize = Item.MaxDatumSize | |
| SkuInfoList = Item.SkuInfoList | |
| Pb.Pcds[(Name, Guid, Type)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False) | |
| # | |
| # Add to database | |
| # | |
| self.Build[Arch].PackageDatabase[Dec] = Pb | |
| Pb = None | |
| ## Generate ModuleDatabase | |
| # | |
| # Go through each arch to get all items in InfDatabase to ModuleDatabase | |
| # | |
| def GenModuleDatabase(self, InfList = []): | |
| for Inf in self.InfDatabase.keys(): | |
| Module = self.InfDatabase[Inf].Module | |
| for Arch in self.SupArchList: | |
| if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList) or Arch not in Module.Header: | |
| continue | |
| ModuleHeader = Module.Header[Arch] | |
| Pb = ModuleBuildClassObject() | |
| # | |
| # Defines | |
| # | |
| Pb.DescFilePath = Inf | |
| Pb.BaseName = ModuleHeader.Name | |
| if Pb.BaseName == '': | |
| EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of module %s is not defined for arch %s" % (Inf, Arch)) | |
| Pb.Guid = ModuleHeader.Guid | |
| Pb.Version = ModuleHeader.Version | |
| Pb.ModuleType = ModuleHeader.ModuleType | |
| Pb.PcdIsDriver = ModuleHeader.PcdIsDriver | |
| Pb.BinaryModule = ModuleHeader.BinaryModule | |
| Pb.CustomMakefile = ModuleHeader.CustomMakefile | |
| Pb.Shadow = ModuleHeader.Shadow | |
| # | |
| # Specs os Defines | |
| # | |
| Pb.Specification = ModuleHeader.Specification | |
| Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = ModuleHeader.EdkReleaseVersion | |
| Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion | |
| Pb.Specification[TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion | |
| Pb.AutoGenVersion = int(ModuleHeader.InfVersion, 0) | |
| # | |
| # LibraryClass of Defines | |
| # | |
| for Item in ModuleHeader.LibraryClass: | |
| Pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None)) | |
| # | |
| # Module image and library of Defines | |
| # | |
| for Item in Module.ExternImages: | |
| if Item.ModuleEntryPoint != '' and Item.ModuleEntryPoint not in Pb.ModuleEntryPointList: | |
| Pb.ModuleEntryPointList.append(Item.ModuleEntryPoint) | |
| if Item.ModuleUnloadImage != '' and Item.ModuleUnloadImage not in Pb.ModuleUnloadImageList: | |
| Pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage) | |
| for Item in Module.ExternLibraries: | |
| if Item.Constructor != '' and Item.Constructor not in Pb.ConstructorList: | |
| Pb.ConstructorList.append(Item.Constructor) | |
| if Item.Destructor != '' and Item.Destructor not in Pb.DestructorList: | |
| Pb.DestructorList.append(Item.Destructor) | |
| # | |
| # Binaries | |
| # | |
| for Item in Module.Binaries: | |
| if Arch in Item.SupArchList: | |
| FileName = Item.BinaryFile | |
| FileType = Item.FileType | |
| Target = Item.Target | |
| FeatureFlag = Item.FeatureFlag | |
| Pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag, Arch.split())) | |
| # | |
| # Sources | |
| # | |
| for Item in Module.Sources: | |
| if Arch in Item.SupArchList: | |
| SourceFile = Item.SourceFile | |
| TagName = Item.TagName | |
| ToolCode = Item.ToolCode | |
| ToolChainFamily = Item.ToolChainFamily | |
| FeatureFlag = Item.FeatureFlag | |
| Pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag)) | |
| # | |
| # Protocols | |
| # | |
| for Item in Module.Protocols: | |
| if Arch in Item.SupArchList: | |
| Pb.Protocols.append(Item.CName) | |
| # | |
| # Ppis | |
| # | |
| for Item in Module.Ppis: | |
| if Arch in Item.SupArchList: | |
| Pb.Ppis.append(Item.CName) | |
| # | |
| # Guids | |
| # | |
| for Item in Module.Guids: | |
| if Arch in Item.SupArchList: | |
| Pb.Ppis.append(Item.CName) | |
| # | |
| # Includes | |
| # | |
| for Item in Module.Includes: | |
| if Arch in Item.SupArchList: | |
| Pb.Includes.append(Item.FilePath) | |
| # | |
| # Packages | |
| # | |
| for Item in Module.PackageDependencies: | |
| if Arch in Item.SupArchList: | |
| Pb.Packages.append(Item.FilePath) | |
| # | |
| # BuildOptions | |
| # | |
| for Item in Module.BuildOptions: | |
| if Arch in Item.SupArchList: | |
| if (Item.ToolChainFamily, Item.ToolChain) not in Pb.BuildOptions: | |
| Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option | |
| else: | |
| OptionString = Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] | |
| Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = OptionString + " " + Item.Option | |
| self.FindBuildOptions(Arch, Inf, Pb.BuildOptions) | |
| # | |
| # Depex | |
| # | |
| for Item in Module.Depex: | |
| if Arch in Item.SupArchList: | |
| Pb.Depex = Pb.Depex + Item.Depex + ' ' | |
| Pb.Depex = Pb.Depex.strip() | |
| # | |
| # LibraryClasses | |
| # | |
| for Item in Module.LibraryClasses: | |
| if Arch in Item.SupArchList: | |
| Lib = Item.LibraryClass | |
| RecommendedInstance = Item.RecommendedInstance | |
| if Pb.LibraryClass != []: | |
| # | |
| # For Library | |
| # | |
| for Libs in Pb.LibraryClass: | |
| for Type in Libs.SupModList: | |
| Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type) | |
| if Instance == None: | |
| Instance = RecommendedInstance | |
| Pb.LibraryClasses[(Lib, Type)] = Instance | |
| else: | |
| # | |
| # For Module | |
| # | |
| Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, Pb.ModuleType, Inf) | |
| if Instance == None: | |
| Instance = RecommendedInstance | |
| Pb.LibraryClasses[(Lib, Pb.ModuleType)] = Instance | |
| # | |
| # Libraries | |
| # | |
| for Item in Module.Libraries: | |
| if Arch in Item.SupArchList: | |
| Pb.Libraries.append(Item.Library) | |
| # | |
| # Pcds | |
| # | |
| for Item in Module.PcdCodes: | |
| if Arch in Item.SupArchList: | |
| Name = Item.CName | |
| Guid = Item.TokenSpaceGuidCName | |
| Type = Item.ItemType | |
| Pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type) | |
| # | |
| # Add to database | |
| # | |
| self.Build[Arch].ModuleDatabase[Inf] = Pb | |
| Pb = None | |
| ## Update Libraries Of Platform Database | |
| # | |
| # @param InfList: A list for all inf files | |
| # | |
| def UpdateLibrariesOfPlatform(self, InfList = []): | |
| for Arch in self.SupArchList: | |
| PlatformDatabase = self.Build[Arch].PlatformDatabase | |
| for Dsc in PlatformDatabase: | |
| Platform = PlatformDatabase[Dsc] | |
| for Inf in Platform.Modules: | |
| if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList): | |
| continue | |
| Module = self.Build[Arch].ModuleDatabase[Inf] | |
| if Module.LibraryClass == None or Module.LibraryClass == []: | |
| self.UpdateLibrariesOfModule(Platform, Module, Arch) | |
| for Key in Module.LibraryClasses: | |
| Lib = Module.LibraryClasses[Key] | |
| if Lib not in Platform.LibraryInstances: | |
| Platform.LibraryInstances.append(Lib) | |
| ## Update Libraries Of Module Database | |
| # | |
| # @param Module: The module need to be updated libraries | |
| # @param Arch: The supportted arch of the module | |
| # | |
| def UpdateLibrariesOfModule(self, Platform, Module, Arch): | |
| ModuleDatabase = self.Build[Arch].ModuleDatabase | |
| ModuleType = Module.ModuleType | |
| # check Edk module | |
| if Module.AutoGenVersion < 0x00010005: | |
| EdkLogger.verbose("") | |
| EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch)) | |
| LibraryConsumerList = [Module] | |
| # "CompilerStub" is a must for Edk modules | |
| Module.Libraries.append("CompilerStub") | |
| while len(LibraryConsumerList) > 0: | |
| M = LibraryConsumerList.pop() | |
| for LibraryName in M.Libraries: | |
| if LibraryName not in Platform.Libraries: | |
| EdkLogger.warn("AutoGen", "Library [%s] is not found" % LibraryName, | |
| ExtraData="\t%s [%s]" % (str(Module), Arch)) | |
| continue | |
| LibraryFile = Platform.Libraries[LibraryName] | |
| if (LibraryName, ModuleType) not in Module.LibraryClasses: | |
| Module.LibraryClasses[LibraryName, ModuleType] = LibraryFile | |
| LibraryConsumerList.append(ModuleDatabase[LibraryFile]) | |
| EdkLogger.verbose("\t" + LibraryName + " : " + LibraryFile) | |
| return | |
| # EdkII module | |
| LibraryConsumerList = [Module] | |
| Constructor = [] | |
| ConsumedByList = sdict() | |
| LibraryInstance = sdict() | |
| EdkLogger.verbose("") | |
| EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch)) | |
| while len(LibraryConsumerList) > 0: | |
| M = LibraryConsumerList.pop() | |
| for Key, LibraryPath in M.LibraryClasses.iteritems(): | |
| # The "Key" is in format of (library_class_name, supported_module_type) | |
| if ModuleType != "USER_DEFINED" and ModuleType not in Key: | |
| EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,))) | |
| continue | |
| LibraryClassName = Key[0] | |
| if LibraryClassName not in LibraryInstance or LibraryInstance[LibraryClassName] == None: | |
| if LibraryPath == None or LibraryPath == "": | |
| LibraryInstance[LibraryClassName] = None | |
| continue | |
| LibraryModule = ModuleDatabase[LibraryPath] | |
| LibraryInstance[LibraryClassName] = LibraryModule | |
| LibraryConsumerList.append(LibraryModule) | |
| EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule)) | |
| elif LibraryPath == None or LibraryPath == "": | |
| continue | |
| else: | |
| LibraryModule = LibraryInstance[LibraryClassName] | |
| if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor: | |
| Constructor.append(LibraryModule) | |
| if LibraryModule not in ConsumedByList: | |
| ConsumedByList[LibraryModule] = [] | |
| if M != Module: | |
| if M in ConsumedByList[LibraryModule]: | |
| continue | |
| ConsumedByList[LibraryModule].append(M) | |
| # | |
| # Initialize the sorted output list to the empty set | |
| # | |
| SortedLibraryList = [] | |
| # | |
| # Q <- Set of all nodes with no incoming edges | |
| # | |
| LibraryList = [] #LibraryInstance.values() | |
| Q = [] | |
| for LibraryClassName in LibraryInstance: | |
| M = LibraryInstance[LibraryClassName] | |
| if M == None: | |
| EdkLogger.error("AutoGen", AUTOGEN_ERROR, | |
| "Library instance for library class [%s] is not found" % LibraryClassName, | |
| ExtraData="\t%s [%s]" % (str(Module), Arch)) | |
| LibraryList.append(M) | |
| # | |
| # check if there're duplicate library classes | |
| # | |
| for Lc in M.LibraryClass: | |
| if Lc.SupModList != None and ModuleType not in Lc.SupModList: | |
| EdkLogger.error("AutoGen", AUTOGEN_ERROR, | |
| "Module type [%s] is not supported by library instance [%s]" % (ModuleType, str(M)), | |
| ExtraData="\t%s" % str(Module)) | |
| if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]): | |
| EdkLogger.error("AutoGen", AUTOGEN_ERROR, | |
| "More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, Module), | |
| ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M)) | |
| ) | |
| if ConsumedByList[M] == []: | |
| Q.insert(0, M) | |
| # | |
| # while Q is not empty do | |
| # | |
| while Q != []: | |
| # | |
| # remove node from Q | |
| # | |
| Node = Q.pop() | |
| # | |
| # output Node | |
| # | |
| SortedLibraryList.append(Node) | |
| # | |
| # for each node Item with an edge e from Node to Item do | |
| # | |
| for Item in LibraryList: | |
| if Node not in ConsumedByList[Item]: | |
| continue | |
| # | |
| # remove edge e from the graph | |
| # | |
| ConsumedByList[Item].remove(Node) | |
| # | |
| # If Item has no other incoming edges then | |
| # | |
| if ConsumedByList[Item] == []: | |
| # | |
| # insert Item into Q | |
| # | |
| Q.insert(0, Item) | |
| EdgeRemoved = True | |
| while Q == [] and EdgeRemoved: | |
| EdgeRemoved = False | |
| # | |
| # for each node Item with a Constructor | |
| # | |
| for Item in LibraryList: | |
| if Item in Constructor: | |
| # | |
| # for each Node without a constructor with an edge e from Item to Node | |
| # | |
| for Node in ConsumedByList[Item]: | |
| if Node not in Constructor: | |
| # | |
| # remove edge e from the graph | |
| # | |
| ConsumedByList[Item].remove(Node) | |
| EdgeRemoved = True | |
| if ConsumedByList[Item] == []: | |
| # | |
| # insert Item into Q | |
| # | |
| Q.insert(0, Item) | |
| break | |
| if Q != []: | |
| break | |
| # | |
| # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle | |
| # | |
| for Item in LibraryList: | |
| if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1: | |
| ErrorMessage = 'Library [%s] with constructors has a cycle' % str(Item) | |
| EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage, | |
| "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])) | |
| if Item not in SortedLibraryList: | |
| SortedLibraryList.append(Item) | |
| # | |
| # Build the list of constructor and destructir names | |
| # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order | |
| # | |
| SortedLibraryList.reverse() | |
| Module.LibraryClasses = sdict() | |
| for L in SortedLibraryList: | |
| for Lc in L.LibraryClass: | |
| Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L) | |
| # | |
| # Merge PCDs from library instance | |
| # | |
| for Key in L.Pcds: | |
| if Key not in Module.Pcds: | |
| LibPcd = L.Pcds[Key] | |
| Module.Pcds[Key] = self.FindPcd(Arch, str(Module), LibPcd.TokenCName, LibPcd.TokenSpaceGuidCName, LibPcd.Type) | |
| # | |
| # Merge GUIDs from library instance | |
| # | |
| for CName in L.Guids: | |
| if CName not in Module.Guids: | |
| Module.Guids.append(CName) | |
| # | |
| # Merge Protocols from library instance | |
| # | |
| for CName in L.Protocols: | |
| if CName not in Module.Protocols: | |
| Module.Protocols.append(CName) | |
| # | |
| # Merge Ppis from library instance | |
| # | |
| for CName in L.Ppis: | |
| if CName not in Module.Ppis: | |
| Module.Ppis.append(CName) | |
| ## GenBuildDatabase | |
| # | |
| # Generate build database for all arches | |
| # | |
| # @param PcdsSet: Pcd list for override from Fdf parse result | |
| # @param InfList: Inf list for override from Fdf parse result | |
| # | |
| def GenBuildDatabase(self, PcdsSet = {}, InfList = []): | |
| # | |
| # Add additional inf file defined in Fdf file | |
| # | |
| for InfFile in InfList: | |
| self.AddToInfDatabase(NormPath(InfFile)) | |
| # | |
| # Generate PlatformDatabase, PackageDatabase and ModuleDatabase | |
| # | |
| self.GenPackageDatabase() | |
| self.GenPlatformDatabase(PcdsSet) | |
| self.GenModuleDatabase(InfList) | |
| self.Db.Close() | |
| # | |
| # Update Libraries Of Platform | |
| # | |
| self.UpdateLibrariesOfPlatform(InfList) | |
| # | |
| # Output used Pcds not found in DSC file | |
| # | |
| self.ShowUnFoundPcds() | |
| ## ShowUnFoundPcds() | |
| # | |
| # If there is any pcd used but not defined in DSC | |
| # Print warning message on screen and output a list of pcds | |
| # | |
| def ShowUnFoundPcds(self): | |
| if self.UnFoundPcdInDsc != {}: | |
| WrnMessage = '**** WARNING ****\n' | |
| WrnMessage += 'The following Pcds were not defined in the DSC file: %s\n' % self.DscFileName | |
| WrnMessage += 'The default values were obtained from the DEC file that declares the PCD and the PCD default value\n' | |
| for (Guid, Name, Type, Arch) in self.UnFoundPcdInDsc: | |
| Dec = self.UnFoundPcdInDsc[(Guid, Name, Type, Arch)] | |
| Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds | |
| if (Name, Guid, Type) in Pcds: | |
| Pcd = Pcds[(Name, Guid, Type)] | |
| PcdItemTypeUsed = Pcd.Type | |
| DefaultValue = Pcd.DefaultValue | |
| WrnMessage += '%s.%s: Defined in file %s, PcdItemType is Pcds%s, DefaultValue is %s\n' % (Guid, Name, Dec, PcdItemTypeUsed, DefaultValue) | |
| EdkLogger.verbose(WrnMessage) | |
| ## Create a full path with workspace dir | |
| # | |
| # Convert Filename with workspace dir to create a full path | |
| # | |
| # @param Filename: The filename need to be added workspace dir | |
| # | |
| # @retval string Full path | |
| # | |
| def WorkspaceFile(self, Filename): | |
| return WorkspaceFile(self.WorkspaceDir, Filename) | |
| ## Update LibraryClass of Module | |
| # | |
| # If a module of a platform has its own override libraryclass but the libraryclass not defined in the module | |
| # Add this libraryclass to the module | |
| # | |
| # @param InfFileName: InfFileName specificed in platform | |
| # @param LibraryClass: LibraryClass specificed in platform | |
| # @param Arch: Supportted Arch | |
| # @param InstanceFilePath: InstanceFilePath specificed in platform | |
| # | |
| def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath): | |
| # | |
| # Update the library instance itself to add this libraryclass name | |
| # | |
| LibraryModule = self.InfDatabase[InstanceFilePath].Module | |
| LibList = LibraryModule.Header[Arch].LibraryClass | |
| NotFound = True | |
| for Lib in LibList: | |
| # | |
| # Find this LibraryClass | |
| # | |
| if Lib.LibraryClass == LibraryClass: | |
| NotFound = False; | |
| break; | |
| if NotFound: | |
| NewLib = LibraryClassClass() | |
| NewLib.LibraryClass = LibraryClass | |
| NewLib.SupModuleList = DataType.SUP_MODULE_LIST # LibraryModule.Header[Arch].ModuleType.split() | |
| LibraryModule.Header[Arch].LibraryClass.append(NewLib) | |
| # | |
| # Add it to LibraryClasses Section for the module which is using the library | |
| # | |
| Module = self.InfDatabase[InfFileName].Module | |
| LibList = Module.LibraryClasses | |
| NotFound = True | |
| for Lib in LibList: | |
| # | |
| # Find this LibraryClass | |
| # | |
| if Lib.LibraryClass == LibraryClass: | |
| if Arch in Lib.SupArchList: | |
| return | |
| else: | |
| Lib.SupArchList.append(Arch) | |
| return | |
| if NotFound: | |
| Lib = LibraryClassClass() | |
| Lib.LibraryClass = LibraryClass | |
| Lib.SupArchList = [Arch] | |
| Module.LibraryClasses.append(Lib) | |
| ## Add Inf file to InfDatabase | |
| # | |
| # Create a Inf instance for input inf file and add it to InfDatabase | |
| # | |
| # @param InfFileName: The InfFileName need to be added to database | |
| # | |
| def AddToInfDatabase(self, InfFileName): | |
| File = self.WorkspaceFile(InfFileName) | |
| if os.path.exists(File) and os.path.isfile(File): | |
| if InfFileName not in self.InfDatabase: | |
| self.InfDatabase[InfFileName] = Inf(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList) | |
| else: | |
| EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File) | |
| ## Add Dec file to DecDatabase | |
| # | |
| # Create a Dec instance for input dec file and add it to DecDatabase | |
| # | |
| # @param DecFileName: The DecFileName need to be added to database | |
| # | |
| def AddToDecDatabase(self, DecFileName): | |
| File = self.WorkspaceFile(DecFileName) | |
| if os.path.exists(File) and os.path.isfile(File): | |
| if DecFileName not in self.DecDatabase: | |
| self.DecDatabase[DecFileName] = Dec(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList) | |
| else: | |
| EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File) | |
| ## Search LibraryClass Instance for Module | |
| # | |
| # Search PlatformBuildDatabase to find LibraryClass Instance for Module | |
| # Return the instance if found | |
| # | |
| # @param Lib: Input value for Library Class Name | |
| # @param Arch: Supportted Arch | |
| # @param ModuleType: Supportted ModuleType | |
| # @param ModuleName: Input value for Module Name | |
| # | |
| # @retval string Found LibraryClass Instance file path | |
| # | |
| def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName): | |
| # | |
| # First find if exist in <LibraryClass> of <Components> from dsc file | |
| # | |
| for Dsc in self.DscDatabase.keys(): | |
| Platform = self.DscDatabase[Dsc].Platform | |
| for Module in Platform.Modules.ModuleList: | |
| if Arch in Module.SupArchList: | |
| if Module.FilePath == ModuleName: | |
| for LibraryClass in Module.LibraryClasses.LibraryList: | |
| if LibraryClass.Name == Lib: | |
| return LibraryClass.FilePath | |
| # | |
| #Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file | |
| # | |
| return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType) | |
| ## Search LibraryClass Instance for Library | |
| # | |
| # Search PlatformBuildDatabase to find LibraryClass Instance for Library | |
| # Return the instance if found | |
| # | |
| # @param Lib: Input value for Library Class Name | |
| # @param Arch: Supportted Arch | |
| # @param Type: Supportted Library Usage Type | |
| # | |
| # @retval string Found LibraryClass Instance file path | |
| # @retval None Not Found | |
| # | |
| def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type): | |
| for Dsc in self.DscDatabase.keys(): | |
| Platform = self.DscDatabase[Dsc].Platform | |
| if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses: | |
| return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)] | |
| elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses: | |
| return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')] | |
| return None | |
| ## Find BuildOptions | |
| # | |
| # Search DscDatabase to find component definition of ModuleName | |
| # Override BuildOption if it is defined in component | |
| # | |
| # @param Arch: Supportted Arch | |
| # @param ModuleName: The module which has buildoption definition in component of platform | |
| # @param BuildOptions: The set of all buildopitons | |
| # | |
| def FindBuildOptions(self, Arch, ModuleName, BuildOptions): | |
| for Dsc in self.DscDatabase.keys(): | |
| # | |
| # First find if exist in <BuildOptions> of <Components> from dsc file | |
| # if find, use that override the one defined in inf file | |
| # | |
| Platform = self.DscDatabase[Dsc].Platform | |
| for Module in Platform.Modules.ModuleList: | |
| if Arch in Module.SupArchList: | |
| if Module.FilePath == ModuleName: | |
| for BuildOption in Module.ModuleSaBuildOption.BuildOptionList: | |
| # | |
| # Add to BuildOptions | |
| # | |
| BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option | |
| ## Find Pcd | |
| # | |
| # Search platform database, package database, module database and PcdsSet from Fdf | |
| # Return found Pcd | |
| # | |
| # @param Arch: Supportted Arch | |
| # @param ModuleName: The module which has pcd definition in component of platform | |
| # @param Name: Name of Pcd | |
| # @param Guid: Guid of Pcd | |
| # @param Type: Type of Pcd | |
| # | |
| # @retval PcdClassObject An instance for PcdClassObject with all members filled | |
| # | |
| def FindPcd(self, Arch, ModuleName, Name, Guid, Type): | |
| NewType = '' | |
| DatumType = '' | |
| Value = '' | |
| Token = '' | |
| MaxDatumSize = '' | |
| SkuInfoList = {} | |
| IsOverrided = False | |
| IsFoundInDsc = False | |
| IsFoundInDec = False | |
| FoundInDecFile = '' | |
| # | |
| # Second get information from platform database | |
| # | |
| OwnerPlatform = '' | |
| for Dsc in self.Build[Arch].PlatformDatabase.keys(): | |
| Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds | |
| if (Name, Guid) in Pcds: | |
| OwnerPlatform = Dsc | |
| Pcd = Pcds[(Name, Guid)] | |
| if Pcd.Type != '' and Pcd.Type != None: | |
| NewType = Pcd.Type | |
| if NewType in DataType.PCD_DYNAMIC_TYPE_LIST: | |
| NewType = DataType.TAB_PCDS_DYNAMIC | |
| elif NewType in DataType.PCD_DYNAMIC_EX_TYPE_LIST: | |
| NewType = DataType.TAB_PCDS_DYNAMIC_EX | |
| else: | |
| NewType = Type | |
| if Type != '' and Type != NewType: | |
| ErrorMsg = "PCD %s.%s is declared as [%s] in module\n\t%s\n\n"\ | |
| " But it's used as [%s] in platform\n\t%s"\ | |
| % (Guid, Name, Type, ModuleName, NewType, OwnerPlatform) | |
| EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg) | |
| if Pcd.DatumType != '' and Pcd.DatumType != None: | |
| DatumType = Pcd.DatumType | |
| if Pcd.TokenValue != '' and Pcd.TokenValue != None: | |
| Token = Pcd.TokenValue | |
| if Pcd.DefaultValue != '' and Pcd.DefaultValue != None: | |
| Value = Pcd.DefaultValue | |
| if Pcd.MaxDatumSize != '' and Pcd.MaxDatumSize != None: | |
| MaxDatumSize = Pcd.MaxDatumSize | |
| SkuInfoList = Pcd.SkuInfoList | |
| IsOverrided = True | |
| IsFoundInDsc = True | |
| break | |
| # | |
| # Third get information from <Pcd> of <Compontents> from module database | |
| # | |
| for Dsc in self.DscDatabase.keys(): | |
| for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList: | |
| if Arch in Module.SupArchList: | |
| if Module.FilePath == ModuleName: | |
| for Pcd in Module.PcdBuildDefinitions: | |
| if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName): | |
| if Pcd.DefaultValue != '': | |
| Value = Pcd.DefaultValue | |
| if Pcd.MaxDatumSize != '': | |
| MaxDatumSize = Pcd.MaxDatumSize | |
| IsFoundInDsc = True | |
| IsOverrided = True | |
| break | |
| # | |
| # First get information from package database | |
| # | |
| Pcd = None | |
| if NewType == '': | |
| if Type != '': | |
| PcdTypeList = [Type] | |
| else: | |
| PcdTypeList = ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"] | |
| for Dec in self.Build[Arch].PackageDatabase.keys(): | |
| Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds | |
| for PcdType in PcdTypeList: | |
| if (Name, Guid, PcdType) in Pcds: | |
| Pcd = Pcds[(Name, Guid, PcdType)] | |
| NewType = PcdType | |
| IsOverrided = True | |
| IsFoundInDec = True | |
| FoundInDecFile = Dec | |
| break | |
| else: | |
| continue | |
| break | |
| else: | |
| for Dec in self.Build[Arch].PackageDatabase.keys(): | |
| Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds | |
| if (Name, Guid, NewType) in Pcds: | |
| Pcd = Pcds[(Name, Guid, NewType)] | |
| IsOverrided = True | |
| IsFoundInDec = True | |
| FoundInDecFile = Dec | |
| break | |
| if not IsFoundInDec: | |
| ErrorMsg = "Pcd '%s.%s [%s]' defined in module '%s' is not found in any package for Arch '%s'" % (Guid, Name, NewType, ModuleName, Arch) | |
| EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg) | |
| # | |
| # Not found in any platform and fdf | |
| # | |
| if not IsFoundInDsc: | |
| Value = Pcd.DefaultValue | |
| if NewType.startswith("Dynamic") and SkuInfoList == {}: | |
| SkuIds = self.Build[Arch].PlatformDatabase.values()[0].SkuIds | |
| SkuInfoList['DEFAULT'] = SkuInfoClass(SkuIdName='DEFAULT', SkuId=SkuIds['DEFAULT'], DefaultValue=Value) | |
| self.UnFoundPcdInDsc[(Guid, Name, NewType, Arch)] = FoundInDecFile | |
| #elif Type != '' and NewType.startswith("Dynamic"): | |
| # NewType = Pcd.Type | |
| DatumType = Pcd.DatumType | |
| if Token in [None, '']: | |
| Token = Pcd.TokenValue | |
| if DatumType == "VOID*" and MaxDatumSize in ['', None]: | |
| EdkLogger.verbose("No MaxDatumSize specified for PCD %s.%s in module [%s]" % (Guid, Name, ModuleName)) | |
| if Value[0] == 'L': | |
| MaxDatumSize = str(len(Value) * 2) | |
| elif Value[0] == '{': | |
| MaxDatumSize = str(len(Value.split(','))) | |
| else: | |
| MaxDatumSize = str(len(Value)) | |
| return PcdClassObject(Name, Guid, NewType, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided) | |
| ## Find Supportted Module List Of LibraryClass | |
| # | |
| # Search in InfDatabase, find the supmodulelist of the libraryclass | |
| # | |
| # @param LibraryClass: LibraryClass name for search | |
| # @param OverridedLibraryClassList: A list of all LibraryClass | |
| # @param Arch: Supportted Arch | |
| # | |
| # @retval list SupModuleList | |
| # | |
| def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList, Arch): | |
| Name = LibraryClass.Name | |
| FilePath = LibraryClass.FilePath | |
| SupModuleList = copy.copy(LibraryClass.SupModuleList) | |
| # | |
| # If the SupModuleList means all, remove overrided module types of platform | |
| # | |
| if SupModuleList == DataType.SUP_MODULE_LIST: | |
| EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name) | |
| for Item in OverridedLibraryClassList: | |
| # | |
| # Find a library class (Item) with the same name | |
| # | |
| if Item.Name == Name: | |
| # | |
| # Do nothing if it is itself | |
| # | |
| if Item.SupModuleList == DataType.SUP_MODULE_LIST: | |
| continue | |
| # | |
| # If not itself, check arch first | |
| # | |
| if Arch in LibraryClass.SupArchList: | |
| # | |
| # If arch is supportted, remove all related module type | |
| # | |
| if Arch in Item.SupArchList: | |
| for ModuleType in Item.SupModuleList: | |
| EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name) | |
| if ModuleType in SupModuleList: | |
| SupModuleList.remove(ModuleType) | |
| return SupModuleList | |
| ## Find Module inf Platform | |
| # | |
| # Check if the module is defined in <Compentent> of <Platform> | |
| # | |
| # @param Inf: Inf file (Module) need to be searched | |
| # @param Arch: Supportted Arch | |
| # @param InfList: A list for all Inf file | |
| # | |
| # @retval True Mudule Found | |
| # @retval Flase Module Not Found | |
| # | |
| def IsModuleDefinedInPlatform(self, Inf, Arch, InfList): | |
| for Dsc in self.DscDatabase.values(): | |
| for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList: | |
| if Inf == LibraryClass.FilePath and Arch in LibraryClass.SupArchList: | |
| return True | |
| for Module in Dsc.Platform.Modules.ModuleList: | |
| if Inf == Module.FilePath and Arch in Module.SupArchList: | |
| return True | |
| for Item in Module.LibraryClasses.LibraryList: | |
| if Inf == Item.FilePath: | |
| return True | |
| for Library in Dsc.Platform.Libraries.LibraryList: | |
| if Inf == Library.FilePath and Arch in Library.SupArchList: | |
| return True | |
| return False | |
| ## Show all content of the workspacebuild | |
| # | |
| # Print each item of the workspacebuild with (Key = Value) pair | |
| # | |
| def ShowWorkspaceBuild(self): | |
| print self.DscDatabase | |
| print self.InfDatabase | |
| print self.DecDatabase | |
| print 'SupArchList', self.SupArchList | |
| print 'BuildTarget', self.BuildTarget | |
| print 'SkuId', self.SkuId | |
| for Arch in self.SupArchList: | |
| print Arch | |
| print 'Platform' | |
| for Platform in self.Build[Arch].PlatformDatabase.keys(): | |
| P = self.Build[Arch].PlatformDatabase[Platform] | |
| print 'DescFilePath = ', P.DescFilePath | |
| print 'PlatformName = ', P.PlatformName | |
| print 'Guid = ', P.Guid | |
| print 'Version = ', P.Version | |
| print 'OutputDirectory = ', P.OutputDirectory | |
| print 'FlashDefinition = ', P.FlashDefinition | |
| print 'SkuIds = ', P.SkuIds | |
| print 'Modules = ', P.Modules | |
| print 'LibraryClasses = ', P.LibraryClasses | |
| print 'Pcds = ', P.Pcds | |
| for item in P.Pcds.keys(): | |
| print P.Pcds[item] | |
| print 'BuildOptions = ', P.BuildOptions | |
| print '' | |
| # End of Platform | |
| print 'package' | |
| for Package in self.Build[Arch].PackageDatabase.keys(): | |
| P = self.Build[Arch].PackageDatabase[Package] | |
| print 'DescFilePath = ', P.DescFilePath | |
| print 'PackageName = ', P.PackageName | |
| print 'Guid = ', P.Guid | |
| print 'Version = ', P.Version | |
| print 'Protocols = ', P.Protocols | |
| print 'Ppis = ', P.Ppis | |
| print 'Guids = ', P.Guids | |
| print 'Includes = ', P.Includes | |
| print 'LibraryClasses = ', P.LibraryClasses | |
| print 'Pcds = ', P.Pcds | |
| for item in P.Pcds.keys(): | |
| print P.Pcds[item] | |
| print '' | |
| # End of Package | |
| print 'module' | |
| for Module in self.Build[Arch].ModuleDatabase.keys(): | |
| P = self.Build[Arch].ModuleDatabase[Module] | |
| print 'DescFilePath = ', P.DescFilePath | |
| print 'BaseName = ', P.BaseName | |
| print 'ModuleType = ', P.ModuleType | |
| print 'Guid = ', P.Guid | |
| print 'Version = ', P.Version | |
| print 'CustomMakefile = ', P.CustomMakefile | |
| print 'Specification = ', P.Specification | |
| print 'Shadow = ', P.Shadow | |
| print 'PcdIsDriver = ', P.PcdIsDriver | |
| for Lib in P.LibraryClass: | |
| print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList | |
| print 'ModuleEntryPointList = ', P.ModuleEntryPointList | |
| print 'ModuleUnloadImageList = ', P.ModuleUnloadImageList | |
| print 'ConstructorList = ', P.ConstructorList | |
| print 'DestructorList = ', P.DestructorList | |
| print 'Binaries = ' | |
| for item in P.Binaries: | |
| print item.BinaryFile, item.FeatureFlag, item.SupArchList | |
| print 'Sources = ' | |
| for item in P.Sources: | |
| print item.SourceFile | |
| print 'LibraryClasses = ', P.LibraryClasses | |
| print 'Protocols = ', P.Protocols | |
| print 'Ppis = ', P.Ppis | |
| print 'Guids = ', P.Guids | |
| print 'Includes = ', P.Includes | |
| print 'Packages = ', P.Packages | |
| print 'Pcds = ', P.Pcds | |
| for item in P.Pcds.keys(): | |
| print P.Pcds[item] | |
| print 'BuildOptions = ', P.BuildOptions | |
| print 'Depex = ', P.Depex | |
| print '' | |
| # End of Module | |
| ## | |
| # | |
| # This acts like the main() function for the script, unless it is 'import'ed into another | |
| # script. | |
| # | |
| if __name__ == '__main__': | |
| print 'Start!', time.strftime('%H:%M:%S', time.localtime()) | |
| EdkLogger.Initialize() | |
| EdkLogger.SetLevel(EdkLogger.QUIET) | |
| W = os.getenv('WORKSPACE') | |
| Ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', W) | |
| Ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText', 'gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf']) | |
| print 'Done!', time.strftime('%H:%M:%S', time.localtime()) | |
| Ewb.ShowWorkspaceBuild() |