| ## @file |
| # Generate AutoGen.h, AutoGen.c and *.depex files |
| # |
| # Copyright (c) 2007, Intel Corporation |
| # All rights reserved. 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 os |
| import re |
| import os.path as path |
| import copy |
| |
| import GenC |
| import GenMake |
| import GenDepex |
| |
| from StrGather import * |
| from BuildEngine import BuildRule |
| |
| from Common.BuildToolError import * |
| from Common.DataType import * |
| from Common.Misc import * |
| from Common.String import * |
| import Common.GlobalData as GlobalData |
| from GenFds.FdfParser import * |
| from CommonDataClass.CommonClass import SkuInfoClass |
| from Workspace.BuildClassObject import * |
| |
| ## Regular expression for splitting Dependency Expression stirng into tokens |
| gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)") |
| |
| ## Mapping Makefile type |
| gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"} |
| |
| |
| ## Build rule configuration file |
| gBuildRuleFile = 'Conf/build_rule.txt' |
| |
| ## default file name for AutoGen |
| gAutoGenCodeFileName = "AutoGen.c" |
| gAutoGenHeaderFileName = "AutoGen.h" |
| gAutoGenStringFileName = "%(module_name)sStrDefs.h" |
| gAutoGenDepexFileName = "%(module_name)s.depex" |
| gAutoGenSmmDepexFileName = "%(module_name)s.smm" |
| |
| ## Base class for AutoGen |
| # |
| # This class just implements the cache mechanism of AutoGen objects. |
| # |
| class AutoGen(object): |
| # database to maintain the objects of xxxAutoGen |
| _CACHE_ = {} # (BuildTarget, ToolChain) : {ARCH : {platform file: AutoGen object}}} |
| |
| ## Factory method |
| # |
| # @param Class class object of real AutoGen class |
| # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen) |
| # @param Workspace Workspace directory or WorkspaceAutoGen object |
| # @param MetaFile The path of meta file |
| # @param Target Build target |
| # @param Toolchain Tool chain name |
| # @param Arch Target arch |
| # @param *args The specific class related parameters |
| # @param **kwargs The specific class related dict parameters |
| # |
| def __new__(Class, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs): |
| # check if the object has been created |
| Key = (Target, Toolchain) |
| if Key not in Class._CACHE_ or Arch not in Class._CACHE_[Key] \ |
| or MetaFile not in Class._CACHE_[Key][Arch]: |
| AutoGenObject = super(AutoGen, Class).__new__(Class) |
| # call real constructor |
| if not AutoGenObject._Init(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs): |
| return None |
| if Key not in Class._CACHE_: |
| Class._CACHE_[Key] = {} |
| if Arch not in Class._CACHE_[Key]: |
| Class._CACHE_[Key][Arch] = {} |
| Class._CACHE_[Key][Arch][MetaFile] = AutoGenObject |
| else: |
| AutoGenObject = Class._CACHE_[Key][Arch][MetaFile] |
| |
| return AutoGenObject |
| |
| ## hash() operator |
| # |
| # The file path of platform file will be used to represent hash value of this object |
| # |
| # @retval int Hash value of the file path of platform file |
| # |
| def __hash__(self): |
| return hash(self.MetaFile) |
| |
| ## str() operator |
| # |
| # The file path of platform file will be used to represent this object |
| # |
| # @retval string String of platform file path |
| # |
| def __str__(self): |
| return str(self.MetaFile) |
| |
| ## "==" operator |
| def __eq__(self, Other): |
| return Other and self.MetaFile == Other |
| |
| ## Workspace AutoGen class |
| # |
| # This class is used mainly to control the whole platform build for different |
| # architecture. This class will generate top level makefile. |
| # |
| class WorkspaceAutoGen(AutoGen): |
| ## Real constructor of WorkspaceAutoGen |
| # |
| # This method behaves the same as __init__ except that it needs explict invoke |
| # (in super class's __new__ method) |
| # |
| # @param WorkspaceDir Root directory of workspace |
| # @param ActivePlatform Meta-file of active platform |
| # @param Target Build target |
| # @param Toolchain Tool chain name |
| # @param ArchList List of architecture of current build |
| # @param MetaFileDb Database containing meta-files |
| # @param BuildConfig Configuration of build |
| # @param ToolDefinition Tool chain definitions |
| # @param FlashDefinitionFile File of flash definition |
| # @param Fds FD list to be generated |
| # @param Fvs FV list to be generated |
| # @param SkuId SKU id from command line |
| # |
| def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb, |
| BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=[], Fvs=[], SkuId=''): |
| self.MetaFile = ActivePlatform.MetaFile |
| self.WorkspaceDir = WorkspaceDir |
| self.Platform = ActivePlatform |
| self.BuildTarget = Target |
| self.ToolChain = Toolchain |
| self.ArchList = ArchList |
| self.SkuId = SkuId |
| |
| self.BuildDatabase = MetaFileDb |
| self.TargetTxt = BuildConfig |
| self.ToolDef = ToolDefinition |
| self.FdfFile = FlashDefinitionFile |
| self.FdTargetList = Fds |
| self.FvTargetList = Fvs |
| self.AutoGenObjectList = [] |
| |
| # there's many relative directory operations, so ... |
| os.chdir(self.WorkspaceDir) |
| |
| # parse FDF file to get PCDs in it, if any |
| if self.FdfFile != None and self.FdfFile != '': |
| Fdf = FdfParser(self.FdfFile.Path) |
| Fdf.ParseFile() |
| PcdSet = Fdf.Profile.PcdDict |
| ModuleList = Fdf.Profile.InfList |
| else: |
| PcdSet = {} |
| ModuleList = [] |
| |
| # apply SKU and inject PCDs from Flash Definition file |
| for Arch in self.ArchList: |
| Platform = self.BuildDatabase[self.MetaFile, Arch] |
| Platform.SkuName = self.SkuId |
| for Name, Guid in PcdSet: |
| Platform.AddPcd(Name, Guid, PcdSet[Name, Guid]) |
| |
| Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch) |
| # |
| # Explicitly collect platform's dynamic PCDs |
| # |
| Pa.CollectPlatformDynamicPcds() |
| self.AutoGenObjectList.append(Pa) |
| |
| self._BuildDir = None |
| self._FvDir = None |
| self._MakeFileDir = None |
| self._BuildCommand = None |
| |
| return True |
| |
| def __repr__(self): |
| return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList)) |
| |
| ## Return the directory to store FV files |
| def _GetFvDir(self): |
| if self._FvDir == None: |
| self._FvDir = path.join(self.BuildDir, 'FV') |
| return self._FvDir |
| |
| ## Return the directory to store all intermediate and final files built |
| def _GetBuildDir(self): |
| return self.AutoGenObjectList[0].BuildDir |
| |
| ## Return the build output directory platform specifies |
| def _GetOutputDir(self): |
| return self.Platform.OutputDirectory |
| |
| ## Return platform name |
| def _GetName(self): |
| return self.Platform.PlatformName |
| |
| ## Return meta-file GUID |
| def _GetGuid(self): |
| return self.Platform.Guid |
| |
| ## Return platform version |
| def _GetVersion(self): |
| return self.Platform.Version |
| |
| ## Return paths of tools |
| def _GetToolDefinition(self): |
| return self.AutoGenObjectList[0].ToolDefinition |
| |
| ## Return directory of platform makefile |
| # |
| # @retval string Makefile directory |
| # |
| def _GetMakeFileDir(self): |
| if self._MakeFileDir == None: |
| self._MakeFileDir = self.BuildDir |
| return self._MakeFileDir |
| |
| ## Return build command string |
| # |
| # @retval string Build command string |
| # |
| def _GetBuildCommand(self): |
| if self._BuildCommand == None: |
| # BuildCommand should be all the same. So just get one from platform AutoGen |
| self._BuildCommand = self.AutoGenObjectList[0].BuildCommand |
| return self._BuildCommand |
| |
| ## Create makefile for the platform and mdoules in it |
| # |
| # @param CreateDepsMakeFile Flag indicating if the makefile for |
| # modules will be created as well |
| # |
| def CreateMakeFile(self, CreateDepsMakeFile=False): |
| # create makefile for platform |
| Makefile = GenMake.TopLevelMakefile(self) |
| if Makefile.Generate(): |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] %s\n" % |
| (self.MetaFile, self.ArchList)) |
| else: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] %s\n" % |
| (self.MetaFile, self.ArchList)) |
| |
| if CreateDepsMakeFile: |
| for Pa in self.AutoGenObjectList: |
| Pa.CreateMakeFile(CreateDepsMakeFile) |
| |
| ## 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 CreateDepsCodeFile Flag indicating if creating module's |
| # autogen code file or not |
| # |
| def CreateCodeFile(self, CreateDepsCodeFile=False): |
| if not CreateDepsCodeFile: |
| return |
| for Pa in self.AutoGenObjectList: |
| Pa.CreateCodeFile(CreateDepsCodeFile) |
| |
| Name = property(_GetName) |
| Guid = property(_GetGuid) |
| Version = property(_GetVersion) |
| OutputDir = property(_GetOutputDir) |
| |
| ToolDefinition = property(_GetToolDefinition) # toolcode : tool path |
| |
| BuildDir = property(_GetBuildDir) |
| FvDir = property(_GetFvDir) |
| MakeFileDir = property(_GetMakeFileDir) |
| BuildCommand = property(_GetBuildCommand) |
| |
| ## AutoGen class for platform |
| # |
| # PlatformAutoGen class will process the original information in platform |
| # file in order to generate makefile for platform. |
| # |
| class PlatformAutoGen(AutoGen): |
| # |
| # Used to store all PCDs for both PEI and DXE phase, in order to generate |
| # correct PCD database |
| # |
| _DynaPcdList_ = [] |
| _NonDynaPcdList_ = [] |
| |
| ## The real constructor of PlatformAutoGen |
| # |
| # This method is not supposed to be called by users of PlatformAutoGen. It's |
| # only used by factory method __new__() to do real initialization work for an |
| # object of 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 _Init(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.SourceOverrideDir = None |
| self.FdTargetList = self.Workspace.FdTargetList |
| self.FvTargetList = self.Workspace.FvTargetList |
| |
| # flag indicating if the makefile/C-code file has been created or not |
| self.IsMakeFileCreated = False |
| self.IsCodeFileCreated = False |
| |
| self._Platform = None |
| self._Name = None |
| self._Guid = None |
| self._Version = None |
| |
| self._BuildRule = None |
| self._SourceDir = None |
| self._BuildDir = None |
| self._OutputDir = None |
| self._FvDir = None |
| self._MakeFileDir = None |
| self._FdfFile = None |
| |
| self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber |
| self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] |
| self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] |
| |
| self._ToolDefinitions = None |
| self._ToolDefFile = None # toolcode : tool path |
| self._ToolChainFamily = None |
| self._BuildRuleFamily = None |
| self._BuildOption = None # toolcode : option |
| self._PackageList = None |
| self._ModuleAutoGenList = None |
| self._LibraryAutoGenList = None |
| self._BuildCommand = None |
| |
| # get the original module/package/platform objects |
| self.BuildDatabase = Workspace.BuildDatabase |
| return True |
| |
| 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 |
| # |
| def CreateCodeFile(self, CreateModuleCodeFile=False): |
| # only module has code to be greated, so do nothing if CreateModuleCodeFile is False |
| if self.IsCodeFileCreated or not CreateModuleCodeFile: |
| return |
| |
| for Ma in self.ModuleAutoGenList: |
| Ma.CreateCodeFile(True) |
| |
| # don't do this twice |
| self.IsCodeFileCreated = True |
| |
| ## Create makefile for the platform and mdoules in it |
| # |
| # @param CreateModuleMakeFile Flag indicating if the makefile for |
| # modules will be created as well |
| # |
| def CreateMakeFile(self, CreateModuleMakeFile=False): |
| if CreateModuleMakeFile: |
| for ModuleFile in self.Platform.Modules: |
| Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget, |
| self.ToolChain, self.Arch, self.MetaFile) |
| Ma.CreateMakeFile(True) |
| |
| # no need to create makefile for the platform more than once |
| if self.IsMakeFileCreated: |
| return |
| |
| # create makefile for platform |
| Makefile = GenMake.PlatformMakefile(self) |
| if Makefile.Generate(): |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] [%s]\n" % |
| (self.MetaFile, self.Arch)) |
| else: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] [%s]\n" % |
| (self.MetaFile, self.Arch)) |
| self.IsMakeFileCreated = True |
| |
| ## 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): |
| # for gathering error information |
| NoDatumTypePcdList = set() |
| |
| self._GuidValue = {} |
| for F in self.Platform.Modules.keys(): |
| M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile) |
| #GuidValue.update(M.Guids) |
| for PcdFromModule in M.ModulePcdList+M.LibraryPcdList: |
| # make sure that the "VOID*" kind of datum has MaxDatumSize set |
| if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize == None: |
| NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F)) |
| |
| if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd: |
| # |
| # 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 ["PEIM", "PEI_CORE"]: |
| 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) |
| |
| # 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 = self._NonDynaPcdList_ |
| self._DynamicPcdList = self._DynaPcdList_ |
| |
| # |
| # 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 = [] |
| HiiPcdArray = [] |
| OtherPcdArray = [] |
| for Pcd in self._DynamicPcdList: |
| # just pick the a value to determine whether is unicode string type |
| Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]] |
| PcdValue = Sku.DefaultValue |
| if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"): |
| # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex |
| UnicodePcdArray.append(Pcd) |
| elif len(Sku.VariableName) > 0: |
| # if found HII type PCD then insert to right of UnicodeIndex |
| HiiPcdArray.append(Pcd) |
| else: |
| OtherPcdArray.append(Pcd) |
| del self._DynamicPcdList[:] |
| self._DynamicPcdList.extend(UnicodePcdArray) |
| self._DynamicPcdList.extend(HiiPcdArray) |
| self._DynamicPcdList.extend(OtherPcdArray) |
| |
| |
| ## Return the platform build data object |
| def _GetPlatform(self): |
| if self._Platform == None: |
| self._Platform = self.BuildDatabase[self.MetaFile, self.Arch] |
| return self._Platform |
| |
| ## Return platform name |
| def _GetName(self): |
| return self.Platform.PlatformName |
| |
| ## Return the meta file GUID |
| def _GetGuid(self): |
| return self.Platform.Guid |
| |
| ## Return the platform version |
| def _GetVersion(self): |
| return self.Platform.Version |
| |
| ## Return the FDF file name |
| def _GetFdfFile(self): |
| if self._FdfFile == None: |
| if self.Workspace.FdfFile != "": |
| self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile) |
| else: |
| self._FdfFile = '' |
| return self._FdfFile |
| |
| ## Return the build output directory platform specifies |
| def _GetOutputDir(self): |
| return self.Platform.OutputDirectory |
| |
| ## Return the directory to store all intermediate and final files built |
| def _GetBuildDir(self): |
| if self._BuildDir == None: |
| if os.path.isabs(self.OutputDir): |
| self._BuildDir = path.join( |
| path.abspath(self.OutputDir), |
| self.BuildTarget + "_" + self.ToolChain, |
| ) |
| else: |
| self._BuildDir = path.join( |
| self.WorkspaceDir, |
| self.OutputDir, |
| self.BuildTarget + "_" + self.ToolChain, |
| ) |
| return self._BuildDir |
| |
| ## Return directory of platform makefile |
| # |
| # @retval string Makefile directory |
| # |
| def _GetMakeFileDir(self): |
| if self._MakeFileDir == None: |
| self._MakeFileDir = path.join(self.BuildDir, self.Arch) |
| return self._MakeFileDir |
| |
| ## Return build command string |
| # |
| # @retval string Build command string |
| # |
| def _GetBuildCommand(self): |
| if self._BuildCommand == None: |
| self._BuildCommand = [] |
| if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]: |
| self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"]) |
| if "FLAGS" in self.ToolDefinition["MAKE"]: |
| NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip() |
| if NewOption != '': |
| self._BuildCommand += SplitOption(NewOption) |
| return self._BuildCommand |
| |
| ## Get tool chain definition |
| # |
| # Get each tool defition for given tool chain from tools_def.txt and platform |
| # |
| def _GetToolDefinition(self): |
| if self._ToolDefinitions == None: |
| 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) |
| self._ToolDefinitions = {} |
| DllPathList = set() |
| for Def in ToolDefinition: |
| Target, Tag, Arch, Tool, Attr = Def.split("_") |
| 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 |
| |
| if Tool not in self._ToolDefinitions: |
| self._ToolDefinitions[Tool] = {} |
| self._ToolDefinitions[Tool][Attr] = Value |
| |
| ToolsDef = '' |
| MakePath = '' |
| if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions: |
| if "FLAGS" not in self._ToolDefinitions["MAKE"]: |
| self._ToolDefinitions["MAKE"]["FLAGS"] = "" |
| self._ToolDefinitions["MAKE"]["FLAGS"] += " -s" |
| MakeFlags = '' |
| for Tool in self._ToolDefinitions: |
| for Attr in self._ToolDefinitions[Tool]: |
| Value = self._ToolDefinitions[Tool][Attr] |
| if Tool in self.BuildOption and Attr in self.BuildOption[Tool]: |
| # check if override is indicated |
| if self.BuildOption[Tool][Attr].startswith('='): |
| Value = self.BuildOption[Tool][Attr][1:] |
| else: |
| Value += " " + self.BuildOption[Tool][Attr] |
| |
| if Attr == "PATH": |
| # Don't put MAKE definition in the file |
| if Tool == "MAKE": |
| MakePath = Value |
| else: |
| ToolsDef += "%s = %s\n" % (Tool, 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" |
| |
| SaveFileOnChange(self.ToolDefinitionFile, ToolsDef) |
| for DllPath in DllPathList: |
| os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"] |
| os.environ["MAKE_FLAGS"] = MakeFlags |
| |
| return self._ToolDefinitions |
| |
| ## Return the paths of tools |
| def _GetToolDefFile(self): |
| if self._ToolDefFile == None: |
| self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch) |
| return self._ToolDefFile |
| |
| ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'. |
| def _GetToolChainFamily(self): |
| if self._ToolChainFamily == None: |
| 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) |
| self._ToolChainFamily = "MSFT" |
| else: |
| self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain] |
| return self._ToolChainFamily |
| |
| def _GetBuildRuleFamily(self): |
| if self._BuildRuleFamily == None: |
| 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) |
| self._BuildRuleFamily = "MSFT" |
| else: |
| self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain] |
| return self._BuildRuleFamily |
| |
| ## Return the build options specific to this platform |
| def _GetBuildOptions(self): |
| if self._BuildOption == None: |
| self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions) |
| return self._BuildOption |
| |
| ## Parse build_rule.txt in $(WORKSPACE)/Conf/build_rule.txt |
| # |
| # @retval BuildRule object |
| # |
| def _GetBuildRule(self): |
| if self._BuildRule == None: |
| 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 BuildRuleFile in [None, '']: |
| BuildRuleFile = gBuildRuleFile |
| self._BuildRule = BuildRule(BuildRuleFile) |
| return self._BuildRule |
| |
| ## Summarize the packages used by modules in this platform |
| def _GetPackageList(self): |
| if self._PackageList == None: |
| self._PackageList = set() |
| for La in self.LibraryAutoGenList: |
| self._PackageList.update(La.DependentPackageList) |
| for Ma in self.ModuleAutoGenList: |
| self._PackageList.update(Ma.DependentPackageList) |
| self._PackageList = list(self._PackageList) |
| return self._PackageList |
| |
| ## Get list of non-dynamic PCDs |
| def _GetNonDynamicPcdList(self): |
| return self._NonDynamicPcdList |
| |
| ## Get list of dynamic PCDs |
| def _GetDynamicPcdList(self): |
| return self._DynamicPcdList |
| |
| ## Generate Token Number for all PCD |
| def _GetPcdTokenNumbers(self): |
| if self._PcdTokenNumber == None: |
| self._PcdTokenNumber = sdict() |
| TokenNumber = 1 |
| for Pcd in self.DynamicPcdList: |
| if Pcd.Phase == "PEI": |
| EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) |
| self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber |
| TokenNumber += 1 |
| |
| for Pcd in self.DynamicPcdList: |
| if Pcd.Phase == "DXE": |
| EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber)) |
| self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber |
| TokenNumber += 1 |
| |
| for Pcd in self.NonDynamicPcdList: |
| self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber |
| TokenNumber += 1 |
| return self._PcdTokenNumber |
| |
| ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform |
| def _GetAutoGenObjectList(self): |
| self._ModuleAutoGenList = [] |
| self._LibraryAutoGenList = [] |
| for ModuleFile in self.Platform.Modules: |
| Ma = ModuleAutoGen( |
| self.Workspace, |
| ModuleFile, |
| self.BuildTarget, |
| self.ToolChain, |
| self.Arch, |
| self.MetaFile |
| ) |
| if Ma not in self._ModuleAutoGenList: |
| self._ModuleAutoGenList.append(Ma) |
| for La in Ma.LibraryAutoGenList: |
| if La not in self._LibraryAutoGenList: |
| self._LibraryAutoGenList.append(La) |
| |
| ## Summarize ModuleAutoGen objects of all modules to be built for this platform |
| def _GetModuleAutoGenList(self): |
| if self._ModuleAutoGenList == None: |
| self._GetAutoGenObjectList() |
| return self._ModuleAutoGenList |
| |
| ## Summarize ModuleAutoGen objects of all libraries to be built for this platform |
| def _GetLibraryAutoGenList(self): |
| if self._LibraryAutoGenList == None: |
| self._GetAutoGenObjectList() |
| return self._LibraryAutoGenList |
| |
| ## 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 |
| |
| ## 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): |
| ModuleType = Module.ModuleType |
| |
| # for overridding library instances with module specific setting |
| PlatformModule = self.Platform.Modules[str(Module)] |
| |
| # add forced library instance |
| for LibraryClass in PlatformModule.LibraryClasses: |
| if LibraryClass.startswith("NULL"): |
| Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass] |
| |
| # R9 module |
| LibraryConsumerList = [Module] |
| Constructor = [] |
| ConsumedByList = sdict() |
| LibraryInstance = sdict() |
| |
| EdkLogger.verbose("") |
| EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch)) |
| while len(LibraryConsumerList) > 0: |
| M = LibraryConsumerList.pop() |
| for LibraryClassName in M.LibraryClasses: |
| if LibraryClassName not in LibraryInstance: |
| # override library instance for this module |
| if LibraryClassName in PlatformModule.LibraryClasses: |
| LibraryPath = PlatformModule.LibraryClasses[LibraryClassName] |
| else: |
| LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType] |
| if LibraryPath == None or LibraryPath == "": |
| LibraryPath = M.LibraryClasses[LibraryClassName] |
| if LibraryPath == None or LibraryPath == "": |
| EdkLogger.error("build", RESOURCE_NOT_AVAILABLE, |
| "Instance of library class [%s] is not found" % LibraryClassName, |
| File=self.MetaFile, |
| ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module))) |
| |
| LibraryModule = self.BuildDatabase[LibraryPath, self.Arch] |
| # for those forced library instance (NULL library), add a fake library class |
| if LibraryClassName.startswith("NULL"): |
| LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType])) |
| elif LibraryModule.LibraryClass == None \ |
| or len(LibraryModule.LibraryClass) == 0 \ |
| or (ModuleType != 'USER_DEFINED' |
| and ModuleType not in LibraryModule.LibraryClass[0].SupModList): |
| # only USER_DEFINED can link against any library instance despite of its SupModList |
| EdkLogger.error("build", OPTION_MISSING, |
| "Module type [%s] is not supported by library instance [%s]" \ |
| % (ModuleType, LibraryPath), File=self.MetaFile, |
| ExtraData="consumed by [%s]" % str(Module)) |
| |
| LibraryInstance[LibraryClassName] = LibraryModule |
| LibraryConsumerList.append(LibraryModule) |
| EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule)) |
| else: |
| LibraryModule = LibraryInstance[LibraryClassName] |
| |
| if LibraryModule == None: |
| continue |
| |
| if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor: |
| Constructor.append(LibraryModule) |
| |
| if LibraryModule not in ConsumedByList: |
| ConsumedByList[LibraryModule] = [] |
| # don't add current module itself to consumer list |
| 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] |
| LibraryList.append(M) |
| if ConsumedByList[M] == []: |
| Q.insert(0, M) |
| |
| # |
| # start the DAG algorithm |
| # |
| while True: |
| EdgeRemoved = True |
| while Q == [] and EdgeRemoved: |
| EdgeRemoved = False |
| # for each node Item with a Constructor |
| for Item in LibraryList: |
| if Item not in Constructor: |
| continue |
| # for each Node without a constructor with an edge e from Item to Node |
| for Node in ConsumedByList[Item]: |
| if Node in Constructor: |
| continue |
| # remove edge e from the graph if Node has no constructor |
| ConsumedByList[Item].remove(Node) |
| EdgeRemoved = True |
| if ConsumedByList[Item] == []: |
| # insert Item into Q |
| Q.insert(0, Item) |
| break |
| if Q != []: |
| break |
| # DAG is done if there's no more incoming edge for all nodes |
| if Q == []: |
| break |
| |
| # 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 ConsumedByList[Item] != []: |
| continue |
| # insert Item into Q, if Item has no other incoming edges |
| Q.insert(0, Item) |
| |
| # |
| # 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 = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]]) |
| EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item), |
| ExtraData=ErrorMessage, File=self.MetaFile) |
| 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() |
| return SortedLibraryList |
| |
| |
| ## Override PCD setting (type, value, ...) |
| # |
| # @param ToPcd The PCD to be overrided |
| # @param FromPcd The PCD overrideing from |
| # |
| def _OverridePcd(self, ToPcd, FromPcd, Module=""): |
| # |
| # 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 |
| # |
| if FromPcd != None: |
| if ToPcd.Pending and FromPcd.Type not in [None, '']: |
| ToPcd.Type = FromPcd.Type |
| elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \ |
| and ToPcd.Type != FromPcd.Type: |
| EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type", |
| ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\ |
| % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, |
| ToPcd.Type, Module, FromPcd.Type), |
| File=self.MetaFile) |
| |
| if FromPcd.MaxDatumSize not in [None, '']: |
| ToPcd.MaxDatumSize = FromPcd.MaxDatumSize |
| if FromPcd.DefaultValue not in [None, '']: |
| ToPcd.DefaultValue = FromPcd.DefaultValue |
| if FromPcd.TokenValue not in [None, '']: |
| ToPcd.TokenValue = FromPcd.TokenValue |
| if FromPcd.MaxDatumSize not in [None, '']: |
| ToPcd.MaxDatumSize = FromPcd.MaxDatumSize |
| if FromPcd.DatumType not in [None, '']: |
| ToPcd.DatumType = FromPcd.DatumType |
| if FromPcd.SkuInfoList not in [None, '', []]: |
| ToPcd.SkuInfoList = FromPcd.SkuInfoList |
| |
| # 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, ToPcd.TokenCName)) |
| |
| if ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \ |
| % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName)) |
| Value = ToPcd.DefaultValue |
| if Value in [None, '']: |
| ToPcd.MaxDatumSize = 1 |
| elif Value[0] == 'L': |
| ToPcd.MaxDatumSize = str(len(Value) * 2) |
| elif Value[0] == '{': |
| ToPcd.MaxDatumSize = str(len(Value.split(','))) |
| else: |
| ToPcd.MaxDatumSize = str(len(Value)) |
| |
| # apply default SKU for dynamic PCDS if specified one is not available |
| if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \ |
| and ToPcd.SkuInfoList in [None, {}, '']: |
| if self.Platform.SkuName in self.Platform.SkuIds: |
| SkuName = self.Platform.SkuName |
| else: |
| SkuName = 'DEFAULT' |
| ToPcd.SkuInfoList = { |
| SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName], '', '', '', '', '', ToPcd.DefaultValue) |
| } |
| |
| ## Apply PCD setting defined platform to a module |
| # |
| # @param Module The module from which the PCD setting will be overrided |
| # |
| # @retval PCD_list The list PCDs with settings from platform |
| # |
| def ApplyPcdSetting(self, Module, Pcds): |
| # 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) |
| # resolve the VariableGuid value |
| for SkuId in PcdInModule.SkuInfoList: |
| Sku = PcdInModule.SkuInfoList[SkuId] |
| if Sku.VariableGuid == '': continue |
| Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList) |
| if Sku.VariableGuidValue == 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 Key in Pcds: |
| self._OverridePcd(Pcds[Key], PlatformModule.Pcds[Key], Module) |
| return Pcds.values() |
| |
| ## Resolve library names to library modules |
| # |
| # (for R8.x modules) |
| # |
| # @param Module The module from which the library names will be resolved |
| # |
| # @retval library_list The list of library modules |
| # |
| def ResolveLibraryReference(self, Module): |
| EdkLogger.verbose("") |
| EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch)) |
| LibraryConsumerList = [Module] |
| |
| # "CompilerStub" is a must for R8 modules |
| if Module.Libraries: |
| Module.Libraries.append("CompilerStub") |
| LibraryList = [] |
| while len(LibraryConsumerList) > 0: |
| M = LibraryConsumerList.pop() |
| for LibraryName in M.Libraries: |
| Library = self.Platform.LibraryClasses[LibraryName, ':dummy:'] |
| if Library == None: |
| for Key in self.Platform.LibraryClasses.data.keys(): |
| if LibraryName.upper() == Key.upper(): |
| Library = self.Platform.LibraryClasses[Key, ':dummy:'] |
| break |
| if Library == None: |
| EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M), |
| ExtraData="\t%s [%s]" % (str(Module), self.Arch)) |
| continue |
| |
| if Library not in LibraryList: |
| LibraryList.append(Library) |
| LibraryConsumerList.append(Library) |
| EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library))) |
| return LibraryList |
| |
| ## Expand * in build option key |
| # |
| # @param Options Options to be expanded |
| # |
| # @retval options Options expanded |
| # |
| def _ExpandBuildOption(self, Options): |
| BuildOptions = {} |
| for Key in Options: |
| Family = Key[0] |
| Target, Tag, Arch, Tool, Attr = Key[1].split("_") |
| # if tool chain family doesn't match, skip it |
| if Family and Tool in self.ToolDefinition and Family != self.ToolDefinition[Tool]["FAMILY"]: |
| continue |
| # expand any wildcard |
| if Target == "*" or Target == self.BuildTarget: |
| if Tag == "*" or Tag == self.ToolChain: |
| if Arch == "*" or Arch == self.Arch: |
| if Tool not in BuildOptions: |
| BuildOptions[Tool] = {} |
| if Attr != "FLAGS" or Attr not in BuildOptions[Tool]: |
| BuildOptions[Tool][Attr] = Options[Key] |
| else: |
| # append options for the same tool |
| BuildOptions[Tool][Attr] += " " + Options[Key] |
| return BuildOptions |
| |
| ## Append build options in platform to a module |
| # |
| # @param Module The module to which the build options will be appened |
| # |
| # @retval options The options appended with build options in platform |
| # |
| def ApplyBuildOption(self, Module): |
| PlatformOptions = self.BuildOption |
| ModuleOptions = self._ExpandBuildOption(Module.BuildOptions) |
| if Module in self.Platform.Modules: |
| PlatformModule = self.Platform.Modules[str(Module)] |
| PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions) |
| else: |
| PlatformModuleOptions = {} |
| |
| AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() + PlatformModuleOptions.keys() + self.ToolDefinition.keys()) |
| BuildOptions = {} |
| for Tool in AllTools: |
| if Tool not in BuildOptions: |
| BuildOptions[Tool] = {} |
| |
| for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]: |
| if Tool not in Options: |
| continue |
| for Attr in Options[Tool]: |
| Value = Options[Tool][Attr] |
| if Attr not in BuildOptions[Tool]: |
| BuildOptions[Tool][Attr] = "" |
| # check if override is indicated |
| if Value.startswith('='): |
| BuildOptions[Tool][Attr] = Value[1:] |
| else: |
| BuildOptions[Tool][Attr] += " " + Value |
| return BuildOptions |
| |
| Platform = property(_GetPlatform) |
| Name = property(_GetName) |
| Guid = property(_GetGuid) |
| Version = property(_GetVersion) |
| |
| OutputDir = property(_GetOutputDir) |
| BuildDir = property(_GetBuildDir) |
| MakeFileDir = property(_GetMakeFileDir) |
| FdfFile = property(_GetFdfFile) |
| |
| PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber |
| DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] |
| NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...] |
| PackageList = property(_GetPackageList) |
| |
| ToolDefinition = property(_GetToolDefinition) # toolcode : tool path |
| ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path |
| ToolChainFamily = property(_GetToolChainFamily) |
| BuildRuleFamily = property(_GetBuildRuleFamily) |
| BuildOption = property(_GetBuildOptions) # toolcode : option |
| |
| BuildCommand = property(_GetBuildCommand) |
| BuildRule = property(_GetBuildRule) |
| ModuleAutoGenList = property(_GetModuleAutoGenList) |
| LibraryAutoGenList = property(_GetLibraryAutoGenList) |
| |
| ## ModuleAutoGen class |
| # |
| # This class encapsules the AutoGen behaviors for the build tools. In addition to |
| # the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according |
| # to the [depex] section in module's inf file. |
| # |
| class ModuleAutoGen(AutoGen): |
| ## The real constructor of ModuleAutoGen |
| # |
| # This method is not supposed to be called by users of ModuleAutoGen. It's |
| # only used by factory method __new__() to do real initialization work for an |
| # object of ModuleAutoGen |
| # |
| # @param Workspace EdkIIWorkspaceBuild object |
| # @param ModuleFile The path of module file |
| # @param Target Build target (DEBUG, RELEASE) |
| # @param Toolchain Name of tool chain |
| # @param Arch The arch the module supports |
| # @param PlatformFile Platform meta-file |
| # |
| def _Init(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile): |
| EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch)) |
| GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target) |
| |
| self.Workspace = Workspace |
| self.WorkspaceDir = Workspace.WorkspaceDir |
| |
| self.MetaFile = ModuleFile |
| self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch) |
| # check if this module is employed by active platform |
| if not self.PlatformInfo.ValidModule(self.MetaFile): |
| EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \ |
| % (self.MetaFile, Arch)) |
| return False |
| |
| self.SourceDir = self.MetaFile.SubDir |
| self.SourceOverrideDir = None |
| # use overrided path defined in DSC file |
| if self.MetaFile.Key in GlobalData.gOverrideDir: |
| self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key] |
| |
| self.ToolChain = Toolchain |
| self.BuildTarget = Target |
| self.Arch = Arch |
| self.ToolChainFamily = self.PlatformInfo.ToolChainFamily |
| self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily |
| |
| self.IsMakeFileCreated = False |
| self.IsCodeFileCreated = False |
| |
| self.BuildDatabase = self.Workspace.BuildDatabase |
| |
| self._Module = None |
| self._Name = None |
| self._Guid = None |
| self._Version = None |
| self._ModuleType = None |
| self._ComponentType = None |
| self._PcdIsDriver = None |
| self._AutoGenVersion = None |
| self._LibraryFlag = None |
| self._CustomMakefile = None |
| self._Macro = None |
| |
| self._BuildDir = None |
| self._OutputDir = None |
| self._DebugDir = None |
| self._MakeFileDir = None |
| |
| self._IncludePathList = None |
| self._AutoGenFileList = None |
| self._UnicodeFileList = None |
| self._SourceFileList = None |
| self._ObjectFileList = None |
| self._BinaryFileList = None |
| |
| self._DependentPackageList = None |
| self._DependentLibraryList = None |
| self._LibraryAutoGenList = None |
| self._DerivedPackageList = None |
| self._ModulePcdList = None |
| self._LibraryPcdList = None |
| self._GuidList = None |
| self._ProtocolList = None |
| self._PpiList = None |
| self._DepexList = None |
| self._BuildOption = None |
| self._BuildTargets = None |
| self._IntroBuildTargetList = None |
| self._FinalBuildTargetList = None |
| self._FileTypes = None |
| self._BuildRules = None |
| |
| return True |
| |
| def __repr__(self): |
| return "%s [%s]" % (self.MetaFile, self.Arch) |
| |
| # Macros could be used in build_rule.txt (also Makefile) |
| def _GetMacros(self): |
| if self._Macro == None: |
| self._Macro = sdict() |
| self._Macro["WORKSPACE" ] = self.WorkspaceDir |
| self._Macro["MODULE_NAME" ] = self.Name |
| self._Macro["MODULE_GUID" ] = self.Guid |
| self._Macro["MODULE_VERSION" ] = self.Version |
| self._Macro["MODULE_TYPE" ] = self.ModuleType |
| self._Macro["MODULE_FILE" ] = str(self.MetaFile) |
| self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName |
| self._Macro["MODULE_RELATIVE_DIR" ] = self.SourceDir |
| self._Macro["MODULE_DIR" ] = self.SourceDir |
| |
| self._Macro["BASE_NAME" ] = self.Name |
| |
| self._Macro["ARCH" ] = self.Arch |
| self._Macro["TOOLCHAIN" ] = self.ToolChain |
| self._Macro["TOOLCHAIN_TAG" ] = self.ToolChain |
| self._Macro["TARGET" ] = self.BuildTarget |
| |
| self._Macro["BUILD_DIR" ] = self.PlatformInfo.BuildDir |
| self._Macro["BIN_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch) |
| self._Macro["LIB_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch) |
| self._Macro["MODULE_BUILD_DIR" ] = self.BuildDir |
| self._Macro["OUTPUT_DIR" ] = self.OutputDir |
| self._Macro["DEBUG_DIR" ] = self.DebugDir |
| return self._Macro |
| |
| ## Return the module build data object |
| def _GetModule(self): |
| if self._Module == None: |
| self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch] |
| return self._Module |
| |
| ## Return the module name |
| def _GetBaseName(self): |
| return self.Module.BaseName |
| |
| ## Return the module SourceOverridePath |
| def _GetSourceOverridePath(self): |
| return self.Module.SourceOverridePath |
| |
| ## Return the module meta-file GUID |
| def _GetGuid(self): |
| return self.Module.Guid |
| |
| ## Return the module version |
| def _GetVersion(self): |
| return self.Module.Version |
| |
| ## Return the module type |
| def _GetModuleType(self): |
| return self.Module.ModuleType |
| |
| ## Return the component type (for R8.x style of module) |
| def _GetComponentType(self): |
| return self.Module.ComponentType |
| |
| ## Return the build type |
| def _GetBuildType(self): |
| return self.Module.BuildType |
| |
| ## Return the PCD_IS_DRIVER setting |
| def _GetPcdIsDriver(self): |
| return self.Module.PcdIsDriver |
| |
| ## Return the autogen version, i.e. module meta-file version |
| def _GetAutoGenVersion(self): |
| return self.Module.AutoGenVersion |
| |
| ## Check if the module is library or not |
| def _IsLibrary(self): |
| if self._LibraryFlag == None: |
| if self.Module.LibraryClass != None and self.Module.LibraryClass != []: |
| self._LibraryFlag = True |
| else: |
| self._LibraryFlag = False |
| return self._LibraryFlag |
| |
| ## Return the directory to store intermediate files of the module |
| def _GetBuildDir(self): |
| if self._BuildDir == None: |
| self._BuildDir = path.join( |
| self.PlatformInfo.BuildDir, |
| self.Arch, |
| self.SourceDir, |
| self.MetaFile.BaseName |
| ) |
| CreateDirectory(self._BuildDir) |
| return self._BuildDir |
| |
| ## Return the directory to store the intermediate object files of the mdoule |
| def _GetOutputDir(self): |
| if self._OutputDir == None: |
| self._OutputDir = path.join(self.BuildDir, "OUTPUT") |
| CreateDirectory(self._OutputDir) |
| return self._OutputDir |
| |
| ## Return the directory to store auto-gened source files of the mdoule |
| def _GetDebugDir(self): |
| if self._DebugDir == None: |
| self._DebugDir = path.join(self.BuildDir, "DEBUG") |
| CreateDirectory(self._DebugDir) |
| return self._DebugDir |
| |
| ## Return the path of custom file |
| def _GetCustomMakefile(self): |
| if self._CustomMakefile == None: |
| self._CustomMakefile = {} |
| for Type in self.Module.CustomMakefile: |
| if Type in gMakeTypeMap: |
| MakeType = gMakeTypeMap[Type] |
| else: |
| MakeType = 'nmake' |
| if self.SourceOverrideDir != None: |
| File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type]) |
| if not os.path.exists(File): |
| File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type]) |
| else: |
| File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type]) |
| self._CustomMakefile[MakeType] = File |
| return self._CustomMakefile |
| |
| ## Return the directory of the makefile |
| # |
| # @retval string The directory string of module's makefile |
| # |
| def _GetMakeFileDir(self): |
| return self.BuildDir |
| |
| ## Return build command string |
| # |
| # @retval string Build command string |
| # |
| def _GetBuildCommand(self): |
| return self.PlatformInfo.BuildCommand |
| |
| ## Get object list of all packages the module and its dependent libraries belong to |
| # |
| # @retval list The list of package object |
| # |
| def _GetDerivedPackageList(self): |
| PackageList = [] |
| for M in [self.Module] + self.DependentLibraryList: |
| for Package in M.Packages: |
| if Package in PackageList: |
| continue |
| PackageList.append(Package) |
| return PackageList |
| |
| ## Merge dependency expression |
| # |
| # @retval list The token list of the dependency expression after parsed |
| # |
| def _GetDepexTokenList(self): |
| if self._DepexList == None: |
| self._DepexList = {} |
| if self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes: |
| return self._DepexList |
| |
| if self.ModuleType == "DXE_SMM_DRIVER": |
| self._DepexList["DXE_DRIVER"] = [] |
| self._DepexList["SMM_DRIVER"] = [] |
| else: |
| self._DepexList[self.ModuleType] = [] |
| |
| for ModuleType in self._DepexList: |
| DepexList = self._DepexList[ModuleType] |
| # |
| # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion |
| # |
| for M in [self.Module] + self.DependentLibraryList: |
| Inherited = False |
| for D in M.Depex[self.Arch, ModuleType]: |
| if DepexList != []: |
| DepexList.append('AND') |
| DepexList.append('(') |
| DepexList.extend(D) |
| if DepexList[-1] == 'END': # no need of a END at this time |
| DepexList.pop() |
| DepexList.append(')') |
| Inherited = True |
| if Inherited: |
| EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList)) |
| if 'BEFORE' in DepexList or 'AFTER' in DepexList: |
| break |
| if len(DepexList) > 0: |
| EdkLogger.verbose('') |
| return self._DepexList |
| |
| ## Return the list of specification version required for the module |
| # |
| # @retval list The list of specification defined in module file |
| # |
| def _GetSpecification(self): |
| return self.Module.Specification |
| |
| ## Tool option for the module build |
| # |
| # @param PlatformInfo The object of PlatformBuildInfo |
| # @retval dict The dict containing valid options |
| # |
| def _GetModuleBuildOption(self): |
| if self._BuildOption == None: |
| self._BuildOption = self.PlatformInfo.ApplyBuildOption(self.Module) |
| return self._BuildOption |
| |
| ## Return a list of files which can be built from source |
| # |
| # What kind of files can be built is determined by build rules in |
| # $(WORKSPACE)/Conf/build_rule.txt and toolchain family. |
| # |
| def _GetSourceFileList(self): |
| if self._SourceFileList == None: |
| self._SourceFileList = [] |
| for F in self.Module.Sources: |
| # match tool chain |
| if F.TagName != "" and F.TagName != self.ToolChain: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, " |
| "but [%s] is needed" % (F.TagName, str(F), self.ToolChain)) |
| continue |
| # match tool chain family |
| if F.ToolChainFamily != "" and F.ToolChainFamily != self.ToolChainFamily: |
| EdkLogger.debug( |
| EdkLogger.DEBUG_0, |
| "The file [%s] must be built by tools of [%s], " \ |
| "but current toolchain family is [%s]" \ |
| % (str(F), F.ToolChainFamily, self.ToolChainFamily)) |
| continue |
| |
| # add the file path into search path list for file including |
| if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005: |
| self.IncludePathList.insert(0, F.Dir) |
| self._SourceFileList.append(F) |
| self._ApplyBuildRule(F, TAB_UNKNOWN_FILE) |
| return self._SourceFileList |
| |
| ## Return the list of unicode files |
| def _GetUnicodeFileList(self): |
| if self._UnicodeFileList == None: |
| if TAB_UNICODE_FILE in self.FileTypes: |
| self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE] |
| else: |
| self._UnicodeFileList = [] |
| return self._UnicodeFileList |
| |
| ## Return a list of files which can be built from binary |
| # |
| # "Build" binary files are just to copy them to build directory. |
| # |
| # @retval list The list of files which can be built later |
| # |
| def _GetBinaryFiles(self): |
| if self._BinaryFileList == None: |
| self._BinaryFileList = [] |
| for F in self.Module.Binaries: |
| if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget: |
| continue |
| self._BinaryFileList.append(F) |
| self._ApplyBuildRule(F, F.Type) |
| return self._BinaryFileList |
| |
| def _GetBuildRules(self): |
| if self._BuildRules == None: |
| BuildRules = {} |
| BuildRuleDatabase = self.PlatformInfo.BuildRule |
| for Type in BuildRuleDatabase.FileTypeList: |
| #first try getting build rule by BuildRuleFamily |
| RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily] |
| if not RuleObject: |
| # build type is always module type, but ... |
| if self.ModuleType != self.BuildType: |
| RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily] |
| #second try getting build rule by ToolChainFamily |
| if not RuleObject: |
| RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily] |
| if not RuleObject: |
| # build type is always module type, but ... |
| if self.ModuleType != self.BuildType: |
| RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily] |
| if not RuleObject: |
| continue |
| RuleObject = RuleObject.Instantiate(self.Macros) |
| BuildRules[Type] = RuleObject |
| for Ext in RuleObject.SourceFileExtList: |
| BuildRules[Ext] = RuleObject |
| self._BuildRules = BuildRules |
| return self._BuildRules |
| |
| def _ApplyBuildRule(self, File, FileType): |
| if self._BuildTargets == None: |
| self._IntroBuildTargetList = set() |
| self._FinalBuildTargetList = set() |
| self._BuildTargets = {} |
| self._FileTypes = {} |
| |
| LastTarget = None |
| RuleChain = [] |
| SourceList = [File] |
| Index = 0 |
| while Index < len(SourceList): |
| Source = SourceList[Index] |
| Index = Index + 1 |
| |
| if Source != File: |
| CreateDirectory(Source.Dir) |
| |
| if FileType in self.BuildRules: |
| RuleObject = self.BuildRules[FileType] |
| elif Source.Ext in self.BuildRules: |
| RuleObject = self.BuildRules[Source.Ext] |
| elif File.IsBinary and File == Source: |
| RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE] |
| else: |
| # stop at no more rules |
| if LastTarget: |
| self._FinalBuildTargetList.add(LastTarget) |
| break |
| |
| FileType = RuleObject.SourceFileType |
| if FileType not in self._FileTypes: |
| self._FileTypes[FileType] = set() |
| self._FileTypes[FileType].add(Source) |
| |
| # stop at STATIC_LIBRARY for library |
| if self.IsLibrary and FileType == TAB_STATIC_LIBRARY: |
| self._FinalBuildTargetList.add(LastTarget) |
| break |
| |
| Target = RuleObject.Apply(Source) |
| if not Target: |
| if LastTarget: |
| self._FinalBuildTargetList.add(LastTarget) |
| break |
| elif not Target.Outputs: |
| # Only do build for target with outputs |
| self._FinalBuildTargetList.add(Target) |
| |
| if FileType not in self._BuildTargets: |
| self._BuildTargets[FileType] = set() |
| self._BuildTargets[FileType].add(Target) |
| |
| if not Source.IsBinary and Source == File: |
| self._IntroBuildTargetList.add(Target) |
| |
| # to avoid cyclic rule |
| if FileType in RuleChain: |
| break |
| |
| RuleChain.append(FileType) |
| SourceList.extend(Target.Outputs) |
| LastTarget = Target |
| FileType = TAB_UNKNOWN_FILE |
| |
| def _GetTargets(self): |
| if self._BuildTargets == None: |
| self._IntroBuildTargetList = set() |
| self._FinalBuildTargetList = set() |
| self._BuildTargets = {} |
| self._FileTypes = {} |
| |
| #TRICK: call _GetSourceFileList to apply build rule for binary files |
| if self.SourceFileList: |
| pass |
| |
| #TRICK: call _GetBinaryFileList to apply build rule for binary files |
| if self.BinaryFileList: |
| pass |
| |
| return self._BuildTargets |
| |
| def _GetIntroTargetList(self): |
| self._GetTargets() |
| return self._IntroBuildTargetList |
| |
| def _GetFinalTargetList(self): |
| self._GetTargets() |
| return self._FinalBuildTargetList |
| |
| def _GetFileTypes(self): |
| self._GetTargets() |
| return self._FileTypes |
| |
| ## Get the list of package object the module depends on |
| # |
| # @retval list The package object list |
| # |
| def _GetDependentPackageList(self): |
| return self.Module.Packages |
| |
| ## Return the list of auto-generated code file |
| # |
| # @retval list The list of auto-generated file |
| # |
| def _GetAutoGenFileList(self): |
| if self._AutoGenFileList == None: |
| self._AutoGenFileList = {} |
| AutoGenC = TemplateString() |
| AutoGenH = TemplateString() |
| StringH = TemplateString() |
| GenC.CreateCode(self, AutoGenC, AutoGenH, StringH) |
| if str(AutoGenC) != "" and TAB_C_CODE_FILE in self.FileTypes: |
| AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir) |
| self._AutoGenFileList[AutoFile] = str(AutoGenC) |
| self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE) |
| if str(AutoGenH) != "": |
| AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir) |
| self._AutoGenFileList[AutoFile] = str(AutoGenH) |
| self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE) |
| if str(StringH) != "": |
| AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir) |
| self._AutoGenFileList[AutoFile] = str(StringH) |
| self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE) |
| return self._AutoGenFileList |
| |
| ## Return the list of library modules explicitly or implicityly used by this module |
| def _GetLibraryList(self): |
| if self._DependentLibraryList == None: |
| # only merge library classes and PCD for non-library module |
| if self.IsLibrary: |
| self._DependentLibraryList = [] |
| else: |
| if self.AutoGenVersion < 0x00010005: |
| self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module) |
| else: |
| self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module) |
| return self._DependentLibraryList |
| |
| ## Get the list of PCDs from current module |
| # |
| # @retval list The list of PCD |
| # |
| def _GetModulePcdList(self): |
| if self._ModulePcdList == None: |
| # apply PCD settings from platform |
| self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds) |
| return self._ModulePcdList |
| |
| ## Get the list of PCDs from dependent libraries |
| # |
| # @retval list The list of PCD |
| # |
| def _GetLibraryPcdList(self): |
| if self._LibraryPcdList == None: |
| Pcds = {} |
| if not self.IsLibrary: |
| # get PCDs from dependent libraries |
| for Library in self.DependentLibraryList: |
| for Key in Library.Pcds: |
| # skip duplicated PCDs |
| if Key in self.Module.Pcds or Key in Pcds: |
| continue |
| Pcds[Key] = copy.copy(Library.Pcds[Key]) |
| # apply PCD settings from platform |
| self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds) |
| else: |
| self._LibraryPcdList = [] |
| return self._LibraryPcdList |
| |
| ## Get the GUID value mapping |
| # |
| # @retval dict The mapping between GUID cname and its value |
| # |
| def _GetGuidList(self): |
| if self._GuidList == None: |
| self._GuidList = self.Module.Guids |
| for Library in self.DependentLibraryList: |
| self._GuidList.update(Library.Guids) |
| return self._GuidList |
| |
| ## Get the protocol value mapping |
| # |
| # @retval dict The mapping between protocol cname and its value |
| # |
| def _GetProtocolList(self): |
| if self._ProtocolList == None: |
| self._ProtocolList = self.Module.Protocols |
| for Library in self.DependentLibraryList: |
| self._ProtocolList.update(Library.Protocols) |
| return self._ProtocolList |
| |
| ## Get the PPI value mapping |
| # |
| # @retval dict The mapping between PPI cname and its value |
| # |
| def _GetPpiList(self): |
| if self._PpiList == None: |
| self._PpiList = self.Module.Ppis |
| for Library in self.DependentLibraryList: |
| self._PpiList.update(Library.Ppis) |
| return self._PpiList |
| |
| ## Get the list of include search path |
| # |
| # @retval list The list path |
| # |
| def _GetIncludePathList(self): |
| if self._IncludePathList == None: |
| self._IncludePathList = [] |
| if self.AutoGenVersion < 0x00010005: |
| for Inc in self.Module.Includes: |
| if Inc not in self._IncludePathList: |
| self._IncludePathList.append(Inc) |
| # for r8 modules |
| Inc = path.join(Inc, self.Arch.capitalize()) |
| if os.path.exists(Inc) and Inc not in self._IncludePathList: |
| self._IncludePathList.append(Inc) |
| # r8 module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time |
| self._IncludePathList.append(self.DebugDir) |
| else: |
| self._IncludePathList.append(self.MetaFile.Dir) |
| self._IncludePathList.append(self.DebugDir) |
| |
| for Package in self.Module.Packages: |
| PackageDir = path.join(self.WorkspaceDir, Package.MetaFile.Dir) |
| if PackageDir not in self._IncludePathList: |
| self._IncludePathList.append(PackageDir) |
| for Inc in Package.Includes: |
| if Inc not in self._IncludePathList: |
| self._IncludePathList.append(str(Inc)) |
| return self._IncludePathList |
| |
| ## Create makefile for the module and its dependent libraries |
| # |
| # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of |
| # dependent libraries will be created |
| # |
| def CreateMakeFile(self, CreateLibraryMakeFile=True): |
| if self.IsMakeFileCreated: |
| return |
| |
| if not self.IsLibrary and CreateLibraryMakeFile: |
| for LibraryAutoGen in self.LibraryAutoGenList: |
| LibraryAutoGen.CreateMakeFile() |
| |
| if len(self.CustomMakefile) == 0: |
| Makefile = GenMake.ModuleMakefile(self) |
| else: |
| Makefile = GenMake.CustomMakefile(self) |
| if Makefile.Generate(): |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" % |
| (self.Name, self.Arch)) |
| else: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" % |
| (self.Name, self.Arch)) |
| |
| self.IsMakeFileCreated = True |
| |
| ## Create autogen code for the module and its dependent libraries |
| # |
| # @param CreateLibraryCodeFile Flag indicating if or not the code of |
| # dependent libraries will be created |
| # |
| def CreateCodeFile(self, CreateLibraryCodeFile=True): |
| if self.IsCodeFileCreated: |
| return |
| |
| if not self.IsLibrary and CreateLibraryCodeFile: |
| for LibraryAutoGen in self.LibraryAutoGenList: |
| LibraryAutoGen.CreateCodeFile() |
| |
| AutoGenList = [] |
| IgoredAutoGenList = [] |
| |
| for File in self.AutoGenFileList: |
| if GenC.Generate(File.Path, self.AutoGenFileList[File]): |
| #Ignore R8 AutoGen.c |
| if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c': |
| continue |
| |
| AutoGenList.append(str(File)) |
| else: |
| IgoredAutoGenList.append(str(File)) |
| |
| for ModuleType in self.DepexList: |
| if len(self.DepexList[ModuleType]) == 0: |
| continue |
| Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True) |
| if ModuleType == 'SMM_DRIVER': |
| DpxFile = gAutoGenSmmDepexFileName % {"module_name" : self.Name} |
| else: |
| DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name} |
| |
| if Dpx.Generate(path.join(self.OutputDir, DpxFile)): |
| AutoGenList.append(str(DpxFile)) |
| else: |
| IgoredAutoGenList.append(str(DpxFile)) |
| |
| if IgoredAutoGenList == []: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" % |
| (" ".join(AutoGenList), self.Name, self.Arch)) |
| elif AutoGenList == []: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" % |
| (" ".join(IgoredAutoGenList), self.Name, self.Arch)) |
| else: |
| EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" % |
| (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch)) |
| |
| self.IsCodeFileCreated = True |
| return AutoGenList |
| |
| ## Summarize the ModuleAutoGen objects of all libraries used by this module |
| def _GetLibraryAutoGenList(self): |
| if self._LibraryAutoGenList == None: |
| self._LibraryAutoGenList = [] |
| for Library in self.DependentLibraryList: |
| La = ModuleAutoGen( |
| self.Workspace, |
| Library.MetaFile, |
| self.BuildTarget, |
| self.ToolChain, |
| self.Arch, |
| self.PlatformInfo.MetaFile |
| ) |
| if La not in self._LibraryAutoGenList: |
| self._LibraryAutoGenList.append(La) |
| for Lib in La.CodaTargetList: |
| self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE) |
| return self._LibraryAutoGenList |
| |
| ## Return build command string |
| # |
| # @retval string Build command string |
| # |
| def _GetBuildCommand(self): |
| return self.PlatformInfo.BuildCommand |
| |
| |
| Module = property(_GetModule) |
| Name = property(_GetBaseName) |
| Guid = property(_GetGuid) |
| Version = property(_GetVersion) |
| ModuleType = property(_GetModuleType) |
| ComponentType = property(_GetComponentType) |
| BuildType = property(_GetBuildType) |
| PcdIsDriver = property(_GetPcdIsDriver) |
| AutoGenVersion = property(_GetAutoGenVersion) |
| Macros = property(_GetMacros) |
| Specification = property(_GetSpecification) |
| |
| IsLibrary = property(_IsLibrary) |
| |
| BuildDir = property(_GetBuildDir) |
| OutputDir = property(_GetOutputDir) |
| DebugDir = property(_GetDebugDir) |
| MakeFileDir = property(_GetMakeFileDir) |
| CustomMakefile = property(_GetCustomMakefile) |
| |
| IncludePathList = property(_GetIncludePathList) |
| AutoGenFileList = property(_GetAutoGenFileList) |
| UnicodeFileList = property(_GetUnicodeFileList) |
| SourceFileList = property(_GetSourceFileList) |
| BinaryFileList = property(_GetBinaryFiles) # FileType : [File List] |
| Targets = property(_GetTargets) |
| IntroTargetList = property(_GetIntroTargetList) |
| CodaTargetList = property(_GetFinalTargetList) |
| FileTypes = property(_GetFileTypes) |
| BuildRules = property(_GetBuildRules) |
| |
| DependentPackageList = property(_GetDependentPackageList) |
| DependentLibraryList = property(_GetLibraryList) |
| LibraryAutoGenList = property(_GetLibraryAutoGenList) |
| DerivedPackageList = property(_GetDerivedPackageList) |
| |
| ModulePcdList = property(_GetModulePcdList) |
| LibraryPcdList = property(_GetLibraryPcdList) |
| GuidList = property(_GetGuidList) |
| ProtocolList = property(_GetProtocolList) |
| PpiList = property(_GetPpiList) |
| DepexList = property(_GetDepexTokenList) |
| BuildOption = property(_GetModuleBuildOption) |
| BuildCommand = property(_GetBuildCommand) |
| |
| # This acts like the main() function for the script, unless it is 'import'ed into another script. |
| if __name__ == '__main__': |
| pass |
| |
