diff options
Diffstat (limited to 'BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py')
| -rw-r--r-- | BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py | 735 |
1 files changed, 0 insertions, 735 deletions
diff --git a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py b/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py deleted file mode 100644 index d02befec11..0000000000 --- a/BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py +++ /dev/null @@ -1,735 +0,0 @@ -## @file
-# Global variables for GenFds
-#
-# Copyright (c) 2007 - 2016, 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
-import sys
-import subprocess
-import struct
-import array
-
-from Common.BuildToolError import *
-from Common import EdkLogger
-from Common.Misc import SaveFileOnChange
-
-from Common.TargetTxtClassObject import TargetTxtClassObject
-from Common.ToolDefClassObject import ToolDefClassObject
-from AutoGen.BuildEngine import BuildRule
-import Common.DataType as DataType
-from Common.Misc import PathClass
-from Common.LongFilePathSupport import OpenLongFilePath as open
-from Common.MultipleWorkspace import MultipleWorkspace as mws
-
-## Global variables
-#
-#
-class GenFdsGlobalVariable:
- FvDir = ''
- OutputDirDict = {}
- BinDir = ''
- # will be FvDir + os.sep + 'Ffs'
- FfsDir = ''
- FdfParser = None
- LibDir = ''
- WorkSpace = None
- WorkSpaceDir = ''
- ConfDir = ''
- EdkSourceDir = ''
- OutputDirFromDscDict = {}
- TargetName = ''
- ToolChainTag = ''
- RuleDict = {}
- ArchList = None
- VtfDict = {}
- ActivePlatform = None
- FvAddressFileName = ''
- VerboseMode = False
- DebugLevel = -1
- SharpCounter = 0
- SharpNumberPerLine = 40
- FdfFile = ''
- FdfFileTimeStamp = 0
- FixedLoadAddress = False
- PlatformName = ''
-
- BuildRuleFamily = "MSFT"
- ToolChainFamily = "MSFT"
- __BuildRuleDatabase = None
- GuidToolDefinition = {}
-
- #
- # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.
- # At the beginning of each generation of FV, false flag is appended to the list,
- # after the call to GenerateSection returns, check the size of the output file,
- # if it is greater than 0xFFFFFF, the tail flag in list is set to true,
- # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.
- # At the end of generation of FV, pop the flag.
- # List is used as a stack to handle nested FV generation.
- #
- LargeFileInFvFlags = []
- EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'
- LARGE_FILE_SIZE = 0x1000000
-
- SectionHeader = struct.Struct("3B 1B")
-
- ## LoadBuildRule
- #
- @staticmethod
- def __LoadBuildRule():
- if GenFdsGlobalVariable.__BuildRuleDatabase:
- return GenFdsGlobalVariable.__BuildRuleDatabase
- BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.ConfDir, "target.txt"))
- TargetTxt = TargetTxtClassObject()
- if os.path.isfile(BuildConfigurationFile) == True:
- TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
- if DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF in TargetTxt.TargetTxtDictionary:
- BuildRuleFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]
- if BuildRuleFile in [None, '']:
- BuildRuleFile = 'Conf/build_rule.txt'
- GenFdsGlobalVariable.__BuildRuleDatabase = BuildRule(BuildRuleFile)
- ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
- if ToolDefinitionFile == '':
- ToolDefinitionFile = "Conf/tools_def.txt"
- if os.path.isfile(ToolDefinitionFile):
- ToolDef = ToolDefClassObject()
- ToolDef.LoadToolDefFile(ToolDefinitionFile)
- ToolDefinition = ToolDef.ToolsDefTxtDatabase
- if DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDefinition \
- and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY] \
- and ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]:
- GenFdsGlobalVariable.BuildRuleFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]
-
- if DataType.TAB_TOD_DEFINES_FAMILY in ToolDefinition \
- and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY] \
- and ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]:
- GenFdsGlobalVariable.ToolChainFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]
- return GenFdsGlobalVariable.__BuildRuleDatabase
-
- ## GetBuildRules
- # @param Inf: object of InfBuildData
- # @param Arch: current arch
- #
- @staticmethod
- def GetBuildRules(Inf, Arch):
- if not Arch:
- Arch = 'COMMON'
-
- if not Arch in GenFdsGlobalVariable.OutputDirDict:
- return {}
-
- BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule()
- if not BuildRuleDatabase:
- return {}
-
- PathClassObj = PathClass(Inf.MetaFile.File,
- GenFdsGlobalVariable.WorkSpaceDir)
- Macro = {}
- Macro["WORKSPACE" ] = GenFdsGlobalVariable.WorkSpaceDir
- Macro["MODULE_NAME" ] = Inf.BaseName
- Macro["MODULE_GUID" ] = Inf.Guid
- Macro["MODULE_VERSION" ] = Inf.Version
- Macro["MODULE_TYPE" ] = Inf.ModuleType
- Macro["MODULE_FILE" ] = str(PathClassObj)
- Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName
- Macro["MODULE_RELATIVE_DIR" ] = PathClassObj.SubDir
- Macro["MODULE_DIR" ] = PathClassObj.SubDir
-
- Macro["BASE_NAME" ] = Inf.BaseName
-
- Macro["ARCH" ] = Arch
- Macro["TOOLCHAIN" ] = GenFdsGlobalVariable.ToolChainTag
- Macro["TOOLCHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag
- Macro["TOOL_CHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag
- Macro["TARGET" ] = GenFdsGlobalVariable.TargetName
-
- Macro["BUILD_DIR" ] = GenFdsGlobalVariable.OutputDirDict[Arch]
- Macro["BIN_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
- Macro["LIB_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
- BuildDir = os.path.join(
- GenFdsGlobalVariable.OutputDirDict[Arch],
- Arch,
- PathClassObj.SubDir,
- PathClassObj.BaseName
- )
- Macro["MODULE_BUILD_DIR" ] = BuildDir
- Macro["OUTPUT_DIR" ] = os.path.join(BuildDir, "OUTPUT")
- Macro["DEBUG_DIR" ] = os.path.join(BuildDir, "DEBUG")
-
- BuildRules = {}
- for Type in BuildRuleDatabase.FileTypeList:
- #first try getting build rule by BuildRuleFamily
- RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
- if not RuleObject:
- # build type is always module type, but ...
- if Inf.ModuleType != Inf.BuildType:
- RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
- #second try getting build rule by ToolChainFamily
- if not RuleObject:
- RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.ToolChainFamily]
- if not RuleObject:
- # build type is always module type, but ...
- if Inf.ModuleType != Inf.BuildType:
- RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.ToolChainFamily]
- if not RuleObject:
- continue
- RuleObject = RuleObject.Instantiate(Macro)
- BuildRules[Type] = RuleObject
- for Ext in RuleObject.SourceFileExtList:
- BuildRules[Ext] = RuleObject
- return BuildRules
-
- ## GetModuleCodaTargetList
- #
- # @param Inf: object of InfBuildData
- # @param Arch: current arch
- #
- @staticmethod
- def GetModuleCodaTargetList(Inf, Arch):
- BuildRules = GenFdsGlobalVariable.GetBuildRules(Inf, Arch)
- if not BuildRules:
- return []
-
- TargetList = set()
- FileList = []
-
- if not Inf.IsBinaryModule:
- for File in Inf.Sources:
- if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \
- File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily):
- FileList.append((File, DataType.TAB_UNKNOWN_FILE))
-
- for File in Inf.Binaries:
- if File.Target in ['COMMON', '*', GenFdsGlobalVariable.TargetName]:
- FileList.append((File, File.Type))
-
- for File, FileType in FileList:
- LastTarget = None
- RuleChain = []
- SourceList = [File]
- Index = 0
- while Index < len(SourceList):
- Source = SourceList[Index]
- Index = Index + 1
-
- if File.IsBinary and File == Source and Inf.Binaries != None and File in Inf.Binaries:
- # Skip all files that are not binary libraries
- if not Inf.LibraryClass:
- continue
- RuleObject = BuildRules[DataType.TAB_DEFAULT_BINARY_FILE]
- elif FileType in BuildRules:
- RuleObject = BuildRules[FileType]
- elif Source.Ext in BuildRules:
- RuleObject = BuildRules[Source.Ext]
- else:
- # stop at no more rules
- if LastTarget:
- TargetList.add(str(LastTarget))
- break
-
- FileType = RuleObject.SourceFileType
-
- # stop at STATIC_LIBRARY for library
- if Inf.LibraryClass and FileType == DataType.TAB_STATIC_LIBRARY:
- if LastTarget:
- TargetList.add(str(LastTarget))
- break
-
- Target = RuleObject.Apply(Source)
- if not Target:
- if LastTarget:
- TargetList.add(str(LastTarget))
- break
- elif not Target.Outputs:
- # Only do build for target with outputs
- TargetList.add(str(Target))
-
- # to avoid cyclic rule
- if FileType in RuleChain:
- break
-
- RuleChain.append(FileType)
- SourceList.extend(Target.Outputs)
- LastTarget = Target
- FileType = DataType.TAB_UNKNOWN_FILE
-
- return list(TargetList)
-
- ## SetDir()
- #
- # @param OutputDir Output directory
- # @param FdfParser FDF contents parser
- # @param Workspace The directory of workspace
- # @param ArchList The Arch list of platform
- #
- def SetDir (OutputDir, FdfParser, WorkSpace, ArchList):
- GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir :%s" % OutputDir)
-# GenFdsGlobalVariable.OutputDirDict = OutputDir
- GenFdsGlobalVariable.FdfParser = FdfParser
- GenFdsGlobalVariable.WorkSpace = WorkSpace
- GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], 'FV')
- if not os.path.exists(GenFdsGlobalVariable.FvDir) :
- os.makedirs(GenFdsGlobalVariable.FvDir)
- GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')
- if not os.path.exists(GenFdsGlobalVariable.FfsDir) :
- os.makedirs(GenFdsGlobalVariable.FfsDir)
-
- T_CHAR_LF = '\n'
- #
- # Create FV Address inf file
- #
- GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')
- FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')
- #
- # Add [Options]
- #
- FvAddressFile.writelines("[options]" + T_CHAR_LF)
- BsAddress = '0'
- for Arch in ArchList:
- if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress:
- BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress
- break
-
- FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \
- BsAddress + \
- T_CHAR_LF)
-
- RtAddress = '0'
- for Arch in ArchList:
- if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress:
- RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress
-
- FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \
- RtAddress + \
- T_CHAR_LF)
-
- FvAddressFile.close()
-
- ## ReplaceWorkspaceMacro()
- #
- # @param String String that may contain macro
- #
- def ReplaceWorkspaceMacro(String):
- String = mws.handleWsMacro(String)
- Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir)
- if os.path.exists(Str):
- if not os.path.isabs(Str):
- Str = os.path.abspath(Str)
- else:
- Str = mws.join(GenFdsGlobalVariable.WorkSpaceDir, String)
- return os.path.normpath(Str)
-
- ## Check if the input files are newer than output files
- #
- # @param Output Path of output file
- # @param Input Path list of input files
- #
- # @retval True if Output doesn't exist, or any Input is newer
- # @retval False if all Input is older than Output
- #
- @staticmethod
- def NeedsUpdate(Output, Input):
- if not os.path.exists(Output):
- return True
- # always update "Output" if no "Input" given
- if Input == None or len(Input) == 0:
- return True
-
- # if fdf file is changed after the 'Output" is generated, update the 'Output'
- OutputTime = os.path.getmtime(Output)
- if GenFdsGlobalVariable.FdfFileTimeStamp > OutputTime:
- return True
-
- for F in Input:
- # always update "Output" if any "Input" doesn't exist
- if not os.path.exists(F):
- return True
- # always update "Output" if any "Input" is newer than "Output"
- if os.path.getmtime(F) > OutputTime:
- return True
- return False
-
- @staticmethod
- def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,
- GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=None, BuildNumber=None):
- Cmd = ["GenSec"]
- if Type not in [None, '']:
- Cmd += ["-s", Type]
- if CompressionType not in [None, '']:
- Cmd += ["-c", CompressionType]
- if Guid != None:
- Cmd += ["-g", Guid]
- if GuidHdrLen not in [None, '']:
- Cmd += ["-l", GuidHdrLen]
- if len(GuidAttr) != 0:
- #Add each guided attribute
- for Attr in GuidAttr:
- Cmd += ["-r", Attr]
- if InputAlign != None:
- #Section Align is only for dummy section without section type
- for SecAlign in InputAlign:
- Cmd += ["--sectionalign", SecAlign]
-
- CommandFile = Output + '.txt'
- if Ui not in [None, '']:
- #Cmd += ["-n", '"' + Ui + '"']
- SectionData = array.array('B', [0, 0, 0, 0])
- SectionData.fromstring(Ui.encode("utf_16_le"))
- SectionData.append(0)
- SectionData.append(0)
- Len = len(SectionData)
- GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)
- SaveFileOnChange(Output, SectionData.tostring())
- elif Ver not in [None, '']:
- Cmd += ["-n", Ver]
- if BuildNumber:
- Cmd += ["-j", BuildNumber]
- Cmd += ["-o", Output]
-
- SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
- if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
- return
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
- else:
- Cmd += ["-o", Output]
- Cmd += Input
-
- SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
- if GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
-
- if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and
- GenFdsGlobalVariable.LargeFileInFvFlags):
- GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True
-
- @staticmethod
- def GetAlignment (AlignString):
- if AlignString == None:
- return 0
- if AlignString in ("1K", "2K", "4K", "8K", "16K", "32K", "64K"):
- return int (AlignString.rstrip('K')) * 1024
- else:
- return int (AlignString)
-
- @staticmethod
- def GenerateFfs(Output, Input, Type, Guid, Fixed=False, CheckSum=False, Align=None,
- SectionAlign=None):
- Cmd = ["GenFfs", "-t", Type, "-g", Guid]
- mFfsValidAlign = ["0", "8", "16", "128", "512", "1K", "4K", "32K", "64K"]
- if Fixed == True:
- Cmd += ["-x"]
- if CheckSum:
- Cmd += ["-s"]
- if Align not in [None, '']:
- if Align not in mFfsValidAlign:
- Align = GenFdsGlobalVariable.GetAlignment (Align)
- for index in range(0, len(mFfsValidAlign) - 1):
- if ((Align > GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index])) and (Align <= GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index + 1]))):
- break
- Align = mFfsValidAlign[index + 1]
- Cmd += ["-a", Align]
-
- Cmd += ["-o", Output]
- for I in range(0, len(Input)):
- Cmd += ("-i", Input[I])
- if SectionAlign not in [None, '', []] and SectionAlign[I] not in [None, '']:
- Cmd += ("-n", SectionAlign[I])
-
- CommandFile = Output + '.txt'
- SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
- if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FFS")
-
- @staticmethod
- def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,
- AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):
- if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
-
- Cmd = ["GenFv"]
- if BaseAddress not in [None, '']:
- Cmd += ["-r", BaseAddress]
-
- if ForceRebase == False:
- Cmd += ["-F", "FALSE"]
- elif ForceRebase == True:
- Cmd += ["-F", "TRUE"]
-
- if Capsule:
- Cmd += ["-c"]
- if Dump:
- Cmd += ["-p"]
- if AddressFile not in [None, '']:
- Cmd += ["-a", AddressFile]
- if MapFile not in [None, '']:
- Cmd += ["-m", MapFile]
- if FileSystemGuid:
- Cmd += ["-g", FileSystemGuid]
- Cmd += ["-o", Output]
- for I in Input:
- Cmd += ["-i", I]
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FV")
-
- @staticmethod
- def GenerateVtf(Output, Input, BaseAddress=None, FvSize=None):
- if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
-
- Cmd = ["GenVtf"]
- if BaseAddress not in [None, ''] and FvSize not in [None, ''] \
- and len(BaseAddress) == len(FvSize):
- for I in range(0, len(BaseAddress)):
- Cmd += ["-r", BaseAddress[I], "-s", FvSize[I]]
- Cmd += ["-o", Output]
- for F in Input:
- Cmd += ["-f", F]
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate VTF")
-
- @staticmethod
- def GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,
- Strip=False, Replace=False, TimeStamp=None, Join=False,
- Align=None, Padding=None, Convert=False):
- if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
-
- Cmd = ["GenFw"]
- if Type.lower() == "te":
- Cmd += ["-t"]
- if SubType not in [None, '']:
- Cmd += ["-e", SubType]
- if TimeStamp not in [None, '']:
- Cmd += ["-s", TimeStamp]
- if Align not in [None, '']:
- Cmd += ["-a", Align]
- if Padding not in [None, '']:
- Cmd += ["-p", Padding]
- if Zero:
- Cmd += ["-z"]
- if Strip:
- Cmd += ["-l"]
- if Replace:
- Cmd += ["-r"]
- if Join:
- Cmd += ["-j"]
- if Convert:
- Cmd += ["-m"]
- Cmd += ["-o", Output]
- Cmd += Input
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")
-
- @staticmethod
- def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,
- Revision=None, DeviceId=None, VendorId=None):
- InputList = []
- Cmd = ["EfiRom"]
- if len(EfiInput) > 0:
-
- if Compress:
- Cmd += ["-ec"]
- else:
- Cmd += ["-e"]
-
- for EfiFile in EfiInput:
- Cmd += [EfiFile]
- InputList.append (EfiFile)
-
- if len(BinaryInput) > 0:
- Cmd += ["-b"]
- for BinFile in BinaryInput:
- Cmd += [BinFile]
- InputList.append (BinFile)
-
- # Check List
- if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))
-
- if ClassCode != None:
- Cmd += ["-l", ClassCode]
- if Revision != None:
- Cmd += ["-r", Revision]
- if DeviceId != None:
- Cmd += ["-i", DeviceId]
- if VendorId != None:
- Cmd += ["-f", VendorId]
-
- Cmd += ["-o", Output]
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")
-
- @staticmethod
- def GuidTool(Output, Input, ToolPath, Options='', returnValue=[]):
- if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
- return
- GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
-
- Cmd = [ToolPath, ]
- Cmd += Options.split(' ')
- Cmd += ["-o", Output]
- Cmd += Input
-
- GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)
-
- def CallExternalTool (cmd, errorMess, returnValue=[]):
-
- if type(cmd) not in (tuple, list):
- GenFdsGlobalVariable.ErrorLogger("ToolError! Invalid parameter type in call to CallExternalTool")
-
- if GenFdsGlobalVariable.DebugLevel != -1:
- cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))
- GenFdsGlobalVariable.InfLogger (cmd)
-
- if GenFdsGlobalVariable.VerboseMode:
- cmd += ('-v',)
- GenFdsGlobalVariable.InfLogger (cmd)
- else:
- sys.stdout.write ('#')
- sys.stdout.flush()
- GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1
- if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:
- sys.stdout.write('\n')
-
- try:
- PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
- except Exception, X:
- EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))
- (out, error) = PopenObject.communicate()
-
- while PopenObject.returncode == None :
- PopenObject.wait()
- if returnValue != [] and returnValue[0] != 0:
- #get command return value
- returnValue[0] = PopenObject.returncode
- return
- if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:
- GenFdsGlobalVariable.InfLogger ("Return Value = %d" % PopenObject.returncode)
- GenFdsGlobalVariable.InfLogger (out)
- GenFdsGlobalVariable.InfLogger (error)
- if PopenObject.returncode != 0:
- print "###", cmd
- EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)
-
- def VerboseLogger (msg):
- EdkLogger.verbose(msg)
-
- def InfLogger (msg):
- EdkLogger.info(msg)
-
- def ErrorLogger (msg, File=None, Line=None, ExtraData=None):
- EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)
-
- def DebugLogger (Level, msg):
- EdkLogger.debug(Level, msg)
-
- ## ReplaceWorkspaceMacro()
- #
- # @param Str String that may contain macro
- # @param MacroDict Dictionary that contains macro value pair
- #
- def MacroExtend (Str, MacroDict={}, Arch='COMMON'):
- if Str == None :
- return None
-
- Dict = {'$(WORKSPACE)' : GenFdsGlobalVariable.WorkSpaceDir,
- '$(EDK_SOURCE)' : GenFdsGlobalVariable.EdkSourceDir,
-# '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,
- '$(TARGET)' : GenFdsGlobalVariable.TargetName,
- '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag,
- '$(SPACE)' : ' '
- }
- OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]
- if Arch != 'COMMON' and Arch in GenFdsGlobalVariable.ArchList:
- OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]
-
- Dict['$(OUTPUT_DIRECTORY)'] = OutputDir
-
- if MacroDict != None and len (MacroDict) != 0:
- Dict.update(MacroDict)
-
- for key in Dict.keys():
- if Str.find(key) >= 0 :
- Str = Str.replace (key, Dict[key])
-
- if Str.find('$(ARCH)') >= 0:
- if len(GenFdsGlobalVariable.ArchList) == 1:
- Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])
- else:
- EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)
-
- return Str
-
- ## GetPcdValue()
- #
- # @param PcdPattern pattern that labels a PCD.
- #
- def GetPcdValue (PcdPattern):
- if PcdPattern == None :
- return None
- PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')
- TokenSpace = PcdPair[0]
- TokenCName = PcdPair[1]
-
- PcdValue = ''
- for Arch in GenFdsGlobalVariable.ArchList:
- Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
- PcdDict = Platform.Pcds
- for Key in PcdDict:
- PcdObj = PcdDict[Key]
- if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
- if PcdObj.Type != 'FixedAtBuild':
- EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
- if PcdObj.DatumType != 'VOID*':
- EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
-
- PcdValue = PcdObj.DefaultValue
- return PcdValue
-
- for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform,
- Arch,
- GenFdsGlobalVariable.TargetName,
- GenFdsGlobalVariable.ToolChainTag):
- PcdDict = Package.Pcds
- for Key in PcdDict:
- PcdObj = PcdDict[Key]
- if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
- if PcdObj.Type != 'FixedAtBuild':
- EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
- if PcdObj.DatumType != 'VOID*':
- EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
-
- PcdValue = PcdObj.DefaultValue
- return PcdValue
-
- return PcdValue
-
- SetDir = staticmethod(SetDir)
- ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)
- CallExternalTool = staticmethod(CallExternalTool)
- VerboseLogger = staticmethod(VerboseLogger)
- InfLogger = staticmethod(InfLogger)
- ErrorLogger = staticmethod(ErrorLogger)
- DebugLogger = staticmethod(DebugLogger)
- MacroExtend = staticmethod (MacroExtend)
- GetPcdValue = staticmethod(GetPcdValue)
|