BaseTools/Source/Python/GenFds/GenFds.py

   1 ## @file
   2 # generate flash image
   3 #
   4 #  Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>
   5 #
   6 #  This program and the accompanying materials
   7 #  are licensed and made available under the terms and conditions of the BSD License
   8 #  which accompanies this distribution.  The full text of the license may be found at
   9 #  http://opensource.org/licenses/bsd-license.php
  10 #
  11 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 ##
  16 # Import Modules
  17 #
  18 from optparse import OptionParser
  19 import sys
  20 import Common.LongFilePathOs as os
  21 import linecache
  22 import FdfParser
  23 import Common.BuildToolError as BuildToolError
  24 from GenFdsGlobalVariable import GenFdsGlobalVariable
  25 from Workspace.WorkspaceDatabase import WorkspaceDatabase
  26 from Workspace.BuildClassObject import PcdClassObject
  27 from Workspace.BuildClassObject import ModuleBuildClassObject
  28 import RuleComplexFile
  29 from EfiSection import EfiSection
  30 import StringIO
  31 import Common.TargetTxtClassObject as TargetTxtClassObject
  32 import Common.ToolDefClassObject as ToolDefClassObject
  33 from Common.DataType import *
  34 import Common.GlobalData as GlobalData
  35 from Common import EdkLogger
  36 from Common.String import *
  37 from Common.Misc import DirCache, PathClass
  38 from Common.Misc import SaveFileOnChange
  39 from Common.Misc import ClearDuplicatedInf
  40 from Common.Misc import GuidStructureStringToGuidString
  41 from Common.Misc import CheckPcdDatum
  42 from Common.BuildVersion import gBUILD_VERSION
  43 from Common.MultipleWorkspace import MultipleWorkspace as mws
  44
  45 ## Version and Copyright
  46 versionNumber = "1.0" + ' ' + gBUILD_VERSION
  47 __version__ = "%prog Version " + versionNumber
  48 __copyright__ = "Copyright (c) 2007 - 2017, Intel Corporation  All rights reserved."
  49
  50 ## Tool entrance method
  51 #
  52 # This method mainly dispatch specific methods per the command line options.
  53 # If no error found, return zero value so the caller of this tool can know
  54 # if it's executed successfully or not.
  55 #
  56 #   @retval 0     Tool was successful
  57 #   @retval 1     Tool failed
  58 #
  59 def main():
  60     global Options
  61     Options = myOptionParser()
  62
  63     global Workspace
  64     Workspace = ""
  65     ArchList = None
  66     ReturnCode = 0
  67
  68     EdkLogger.Initialize()
  69     try:
  70         if Options.verbose != None:
  71             EdkLogger.SetLevel(EdkLogger.VERBOSE)
  72             GenFdsGlobalVariable.VerboseMode = True
  73
  74         if Options.FixedAddress != None:
  75             GenFdsGlobalVariable.FixedLoadAddress = True
  76
  77         if Options.quiet != None:
  78             EdkLogger.SetLevel(EdkLogger.QUIET)
  79         if Options.debug != None:
  80             EdkLogger.SetLevel(Options.debug + 1)
  81             GenFdsGlobalVariable.DebugLevel = Options.debug
  82         else:
  83             EdkLogger.SetLevel(EdkLogger.INFO)
  84
  85         if (Options.Workspace == None):
  86             EdkLogger.error("GenFds", OPTION_MISSING, "WORKSPACE not defined",
  87                             ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
  88         elif not os.path.exists(Options.Workspace):
  89             EdkLogger.error("GenFds", PARAMETER_INVALID, "WORKSPACE is invalid",
  90                             ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
  91         else:
  92             Workspace = os.path.normcase(Options.Workspace)
  93             GenFdsGlobalVariable.WorkSpaceDir = Workspace
  94             if 'EDK_SOURCE' in os.environ.keys():
  95                 GenFdsGlobalVariable.EdkSourceDir = os.path.normcase(os.environ['EDK_SOURCE'])
  96             if (Options.debug):
  97                 GenFdsGlobalVariable.VerboseLogger("Using Workspace:" + Workspace)
  98         os.chdir(GenFdsGlobalVariable.WorkSpaceDir)
  99
 100         # set multiple workspace
 101         PackagesPath = os.getenv("PACKAGES_PATH")
 102         mws.setWs(GenFdsGlobalVariable.WorkSpaceDir, PackagesPath)
 103
 104         if (Options.filename):
 105             FdfFilename = Options.filename
 106             FdfFilename = GenFdsGlobalVariable.ReplaceWorkspaceMacro(FdfFilename)
 107
 108             if FdfFilename[0:2] == '..':
 109                 FdfFilename = os.path.realpath(FdfFilename)
 110             if not os.path.isabs(FdfFilename):
 111                 FdfFilename = mws.join(GenFdsGlobalVariable.WorkSpaceDir, FdfFilename)
 112             if not os.path.exists(FdfFilename):
 113                 EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=FdfFilename)
 114
 115             GenFdsGlobalVariable.FdfFile = FdfFilename
 116             GenFdsGlobalVariable.FdfFileTimeStamp = os.path.getmtime(FdfFilename)
 117         else:
 118             EdkLogger.error("GenFds", OPTION_MISSING, "Missing FDF filename")
 119
 120         if (Options.BuildTarget):
 121             GenFdsGlobalVariable.TargetName = Options.BuildTarget
 122
 123         if (Options.ToolChain):
 124             GenFdsGlobalVariable.ToolChainTag = Options.ToolChain
 125
 126         if (Options.activePlatform):
 127             ActivePlatform = Options.activePlatform
 128             ActivePlatform = GenFdsGlobalVariable.ReplaceWorkspaceMacro(ActivePlatform)
 129
 130             if ActivePlatform[0:2] == '..':
 131                 ActivePlatform = os.path.realpath(ActivePlatform)
 132
 133             if not os.path.isabs (ActivePlatform):
 134                 ActivePlatform = mws.join(GenFdsGlobalVariable.WorkSpaceDir, ActivePlatform)
 135
 136             if not os.path.exists(ActivePlatform)  :
 137                 EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist!")
 138         else:
 139             EdkLogger.error("GenFds", OPTION_MISSING, "Missing active platform")
 140
 141         GenFdsGlobalVariable.ActivePlatform = PathClass(NormPath(ActivePlatform))
 142
 143         if (Options.ConfDirectory):
 144             # Get alternate Conf location, if it is absolute, then just use the absolute directory name
 145             ConfDirectoryPath = os.path.normpath(Options.ConfDirectory)
 146             if ConfDirectoryPath.startswith('"'):
 147                 ConfDirectoryPath = ConfDirectoryPath[1:]
 148             if ConfDirectoryPath.endswith('"'):
 149                 ConfDirectoryPath = ConfDirectoryPath[:-1]
 150             if not os.path.isabs(ConfDirectoryPath):
 151                 # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE
 152                 # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf
 153                 ConfDirectoryPath = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, ConfDirectoryPath)
 154         else:
 155             if "CONF_PATH" in os.environ.keys():
 156                 ConfDirectoryPath = os.path.normcase(os.environ["CONF_PATH"])
 157             else:
 158                 # Get standard WORKSPACE/Conf, use the absolute path to the WORKSPACE/Conf
 159                 ConfDirectoryPath = mws.join(GenFdsGlobalVariable.WorkSpaceDir, 'Conf')
 160         GenFdsGlobalVariable.ConfDir = ConfDirectoryPath
 161         BuildConfigurationFile = os.path.normpath(os.path.join(ConfDirectoryPath, "target.txt"))
 162         if os.path.isfile(BuildConfigurationFile) == True:
 163             TargetTxt = TargetTxtClassObject.TargetTxtClassObject()
 164             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
 165             # if no build target given in command line, get it from target.txt
 166             if not GenFdsGlobalVariable.TargetName:
 167                 BuildTargetList = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET]
 168                 if len(BuildTargetList) != 1:
 169                     EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="Only allows one instance for Target.")
 170                 GenFdsGlobalVariable.TargetName = BuildTargetList[0]
 171
 172             # if no tool chain given in command line, get it from target.txt
 173             if not GenFdsGlobalVariable.ToolChainTag:
 174                 ToolChainList = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG]
 175                 if ToolChainList == None or len(ToolChainList) == 0:
 176                     EdkLogger.error("GenFds", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.")
 177                 if len(ToolChainList) != 1:
 178                     EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="Only allows one instance for ToolChain.")
 179                 GenFdsGlobalVariable.ToolChainTag = ToolChainList[0]
 180         else:
 181             EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)
 182
 183         #Set global flag for build mode
 184         GlobalData.gIgnoreSource = Options.IgnoreSources
 185
 186         if Options.Macros:
 187             for Pair in Options.Macros:
 188                 if Pair.startswith('"'):
 189                     Pair = Pair[1:]
 190                 if Pair.endswith('"'):
 191                     Pair = Pair[:-1]
 192                 List = Pair.split('=')
 193                 if len(List) == 2:
 194                     if not List[1].strip():
 195                         EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="No Value given for Macro %s" %List[0])
 196                     if List[0].strip() == "EFI_SOURCE":
 197                         GlobalData.gEfiSource = List[1].strip()
 198                         GlobalData.gGlobalDefines["EFI_SOURCE"] = GlobalData.gEfiSource
 199                         continue
 200                     elif List[0].strip() == "EDK_SOURCE":
 201                         GlobalData.gEdkSource = List[1].strip()
 202                         GlobalData.gGlobalDefines["EDK_SOURCE"] = GlobalData.gEdkSource
 203                         continue
 204                     elif List[0].strip() in ["WORKSPACE", "TARGET", "TOOLCHAIN"]:
 205                         GlobalData.gGlobalDefines[List[0].strip()] = List[1].strip()
 206                     else:
 207                         GlobalData.gCommandLineDefines[List[0].strip()] = List[1].strip()
 208                 else:
 209                     GlobalData.gCommandLineDefines[List[0].strip()] = "TRUE"
 210         os.environ["WORKSPACE"] = Workspace
 211
 212         # Use the -t and -b option as gGlobalDefines's TOOLCHAIN and TARGET if they are not defined
 213         if "TARGET" not in GlobalData.gGlobalDefines.keys():
 214             GlobalData.gGlobalDefines["TARGET"] = GenFdsGlobalVariable.TargetName
 215         if "TOOLCHAIN" not in GlobalData.gGlobalDefines.keys():
 216             GlobalData.gGlobalDefines["TOOLCHAIN"] = GenFdsGlobalVariable.ToolChainTag
 217         if "TOOL_CHAIN_TAG" not in GlobalData.gGlobalDefines.keys():
 218             GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = GenFdsGlobalVariable.ToolChainTag
 219
 220         """call Workspace build create database"""
 221         GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))
 222         BuildWorkSpace = WorkspaceDatabase(GlobalData.gDatabasePath)
 223         BuildWorkSpace.InitDatabase()
 224
 225         #
 226         # Get files real name in workspace dir
 227         #
 228         GlobalData.gAllFiles = DirCache(Workspace)
 229         GlobalData.gWorkspace = Workspace
 230
 231         if (Options.archList) :
 232             ArchList = Options.archList.split(',')
 233         else:
 234 #            EdkLogger.error("GenFds", OPTION_MISSING, "Missing build ARCH")
 235             ArchList = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON', Options.BuildTarget, Options.ToolChain].SupArchList
 236
 237         TargetArchList = set(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON', Options.BuildTarget, Options.ToolChain].SupArchList) & set(ArchList)
 238         if len(TargetArchList) == 0:
 239             EdkLogger.error("GenFds", GENFDS_ERROR, "Target ARCH %s not in platform supported ARCH %s" % (str(ArchList), str(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList)))
 240
 241         for Arch in ArchList:
 242             GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = NormPath(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].OutputDirectory)
 243             GenFdsGlobalVariable.PlatformName = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].PlatformName
 244
 245         if (Options.outputDir):
 246             OutputDirFromCommandLine = GenFdsGlobalVariable.ReplaceWorkspaceMacro(Options.outputDir)
 247             if not os.path.isabs (OutputDirFromCommandLine):
 248                 OutputDirFromCommandLine = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, OutputDirFromCommandLine)
 249             for Arch in ArchList:
 250                 GenFdsGlobalVariable.OutputDirDict[Arch] = OutputDirFromCommandLine
 251         else:
 252             for Arch in ArchList:
 253                 GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.join(GenFdsGlobalVariable.OutputDirFromDscDict[Arch], GenFdsGlobalVariable.TargetName + '_' + GenFdsGlobalVariable.ToolChainTag)
 254
 255         for Key in GenFdsGlobalVariable.OutputDirDict:
 256             OutputDir = GenFdsGlobalVariable.OutputDirDict[Key]
 257             if OutputDir[0:2] == '..':
 258                 OutputDir = os.path.realpath(OutputDir)
 259
 260             if OutputDir[1] != ':':
 261                 OutputDir = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, OutputDir)
 262
 263             if not os.path.exists(OutputDir):
 264                 EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=OutputDir)
 265             GenFdsGlobalVariable.OutputDirDict[Key] = OutputDir
 266
 267         """ Parse Fdf file, has to place after build Workspace as FDF may contain macros from DSC file """
 268         FdfParserObj = FdfParser.FdfParser(FdfFilename)
 269         FdfParserObj.ParseFile()
 270
 271         if FdfParserObj.CycleReferenceCheck():
 272             EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Cycle Reference Detected in FDF file")
 273
 274         if (Options.uiFdName) :
 275             if Options.uiFdName.upper() in FdfParserObj.Profile.FdDict.keys():
 276                 GenFds.OnlyGenerateThisFd = Options.uiFdName
 277             else:
 278                 EdkLogger.error("GenFds", OPTION_VALUE_INVALID,
 279                                 "No such an FD in FDF file: %s" % Options.uiFdName)
 280
 281         if (Options.uiFvName) :
 282             if Options.uiFvName.upper() in FdfParserObj.Profile.FvDict.keys():
 283                 GenFds.OnlyGenerateThisFv = Options.uiFvName
 284             else:
 285                 EdkLogger.error("GenFds", OPTION_VALUE_INVALID,
 286                                 "No such an FV in FDF file: %s" % Options.uiFvName)
 287
 288         if (Options.uiCapName) :
 289             if Options.uiCapName.upper() in FdfParserObj.Profile.CapsuleDict.keys():
 290                 GenFds.OnlyGenerateThisCap = Options.uiCapName
 291             else:
 292                 EdkLogger.error("GenFds", OPTION_VALUE_INVALID,
 293                                 "No such a Capsule in FDF file: %s" % Options.uiCapName)
 294
 295         GenFdsGlobalVariable.WorkSpace = BuildWorkSpace
 296         if ArchList != None:
 297             GenFdsGlobalVariable.ArchList = ArchList
 298
 299         if Options.OptionPcd:
 300             GlobalData.BuildOptionPcd = Options.OptionPcd
 301             CheckBuildOptionPcd()
 302
 303         """Modify images from build output if the feature of loading driver at fixed address is on."""
 304         if GenFdsGlobalVariable.FixedLoadAddress:
 305             GenFds.PreprocessImage(BuildWorkSpace, GenFdsGlobalVariable.ActivePlatform)
 306         """Call GenFds"""
 307         GenFds.GenFd('', FdfParserObj, BuildWorkSpace, ArchList)
 308
 309         """Generate GUID cross reference file"""
 310         GenFds.GenerateGuidXRefFile(BuildWorkSpace, ArchList)
 311
 312         """Display FV space info."""
 313         GenFds.DisplayFvSpaceInfo(FdfParserObj)
 314
 315     except FdfParser.Warning, X:
 316         EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)
 317         ReturnCode = FORMAT_INVALID
 318     except FatalError, X:
 319         if Options.debug != None:
 320             import traceback
 321             EdkLogger.quiet(traceback.format_exc())
 322         ReturnCode = X.args[0]
 323     except:
 324         import traceback
 325         EdkLogger.error(
 326                     "\nPython",
 327                     CODE_ERROR,
 328                     "Tools code failure",
 329                     ExtraData="Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!\n",
 330                     RaiseError=False
 331                     )
 332         EdkLogger.quiet(traceback.format_exc())
 333         ReturnCode = CODE_ERROR
 334     finally:
 335         ClearDuplicatedInf()
 336     return ReturnCode
 337
 338 gParamCheck = []
 339 def SingleCheckCallback(option, opt_str, value, parser):
 340     if option not in gParamCheck:
 341         setattr(parser.values, option.dest, value)
 342         gParamCheck.append(option)
 343     else:
 344         parser.error("Option %s only allows one instance in command line!" % option)
 345
 346 def CheckBuildOptionPcd():
 347     for Arch in GenFdsGlobalVariable.ArchList:
 348         PkgList  = GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag)
 349         for i, pcd in enumerate(GlobalData.BuildOptionPcd):
 350             if type(pcd) is tuple:
 351                 continue
 352             (pcdname, pcdvalue) = pcd.split('=')
 353             if not pcdvalue:
 354                 EdkLogger.error('GenFds', OPTION_MISSING, "No Value specified for the PCD %s." % (pcdname))
 355             if '.' in pcdname:
 356                 (TokenSpaceGuidCName, TokenCName) = pcdname.split('.')
 357                 HasTokenSpace = True
 358             else:
 359                 TokenCName = pcdname
 360                 TokenSpaceGuidCName = ''
 361                 HasTokenSpace = False
 362             TokenSpaceGuidCNameList = []
 363             FoundFlag = False
 364             PcdDatumType = ''
 365             NewValue = ''
 366             for package in PkgList:
 367                 for key in package.Pcds:
 368                     PcdItem = package.Pcds[key]
 369                     if HasTokenSpace:
 370                         if (PcdItem.TokenCName, PcdItem.TokenSpaceGuidCName) == (TokenCName, TokenSpaceGuidCName):
 371                             PcdDatumType = PcdItem.DatumType
 372                             NewValue = BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, pcdvalue)
 373                             FoundFlag = True
 374                     else:
 375                         if PcdItem.TokenCName == TokenCName:
 376                             if not PcdItem.TokenSpaceGuidCName in TokenSpaceGuidCNameList:
 377                                 if len (TokenSpaceGuidCNameList) < 1:
 378                                     TokenSpaceGuidCNameList.append(PcdItem.TokenSpaceGuidCName)
 379                                     PcdDatumType = PcdItem.DatumType
 380                                     TokenSpaceGuidCName = PcdItem.TokenSpaceGuidCName
 381                                     NewValue = BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, pcdvalue)
 382                                     FoundFlag = True
 383                                 else:
 384                                     EdkLogger.error(
 385                                             'GenFds',
 386                                             PCD_VALIDATION_INFO_ERROR,
 387                                             "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (TokenCName, PcdItem.TokenSpaceGuidCName, TokenSpaceGuidCNameList[0])
 388                                             )
 389
 390             GlobalData.BuildOptionPcd[i] = (TokenSpaceGuidCName, TokenCName, NewValue)
 391
 392 def BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, Value):
 393     if PcdDatumType == 'VOID*':
 394         if Value.startswith('L'):
 395             if not Value[1]:
 396                 EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')
 397             Value = Value[0] + '"' + Value[1:] + '"'
 398         elif Value.startswith('B'):
 399             if not Value[1]:
 400                 EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')
 401             Value = Value[1:]
 402         else:
 403             if not Value[0]:
 404                 EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')
 405             Value = '"' + Value + '"'
 406
 407     IsValid, Cause = CheckPcdDatum(PcdDatumType, Value)
 408     if not IsValid:
 409         EdkLogger.error('build', FORMAT_INVALID, Cause, ExtraData="%s.%s" % (TokenSpaceGuidCName, TokenCName))
 410     if PcdDatumType == 'BOOLEAN':
 411         Value = Value.upper()
 412         if Value == 'TRUE' or Value == '1':
 413             Value = '1'
 414         elif Value == 'FALSE' or Value == '0':
 415             Value = '0'
 416     return  Value
 417
 418 ## FindExtendTool()
 419 #
 420 #  Find location of tools to process data
 421 #
 422 #  @param  KeyStringList    Filter for inputs of section generation
 423 #  @param  CurrentArchList  Arch list
 424 #  @param  NameGuid         The Guid name
 425 #
 426 def FindExtendTool(KeyStringList, CurrentArchList, NameGuid):
 427     ToolDb = ToolDefClassObject.ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDatabase
 428     # if user not specify filter, try to deduce it from global data.
 429     if KeyStringList == None or KeyStringList == []:
 430         Target = GenFdsGlobalVariable.TargetName
 431         ToolChain = GenFdsGlobalVariable.ToolChainTag
 432         if ToolChain not in ToolDb['TOOL_CHAIN_TAG']:
 433             EdkLogger.error("GenFds", GENFDS_ERROR, "Can not find external tool because tool tag %s is not defined in tools_def.txt!" % ToolChain)
 434         KeyStringList = [Target + '_' + ToolChain + '_' + CurrentArchList[0]]
 435         for Arch in CurrentArchList:
 436             if Target + '_' + ToolChain + '_' + Arch not in KeyStringList:
 437                 KeyStringList.append(Target + '_' + ToolChain + '_' + Arch)
 438
 439     if GenFdsGlobalVariable.GuidToolDefinition:
 440         if NameGuid in GenFdsGlobalVariable.GuidToolDefinition.keys():
 441             return GenFdsGlobalVariable.GuidToolDefinition[NameGuid]
 442
 443     ToolDefinition = ToolDefClassObject.ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDictionary
 444     ToolPathTmp = None
 445     ToolOption = None
 446     ToolPathKey = None
 447     ToolOptionKey = None
 448     KeyList = None
 449     for ToolDef in ToolDefinition.items():
 450         if NameGuid == ToolDef[1]:
 451             KeyList = ToolDef[0].split('_')
 452             Key = KeyList[0] + \
 453                   '_' + \
 454                   KeyList[1] + \
 455                   '_' + \
 456                   KeyList[2]
 457             if Key in KeyStringList and KeyList[4] == 'GUID':
 458                 ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 459                 ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 460                 ToolPath = ToolDefinition.get(ToolPathKey)
 461                 ToolOption = ToolDefinition.get(ToolOptionKey)
 462                 if ToolPathTmp == None:
 463                     ToolPathTmp = ToolPath
 464                 else:
 465                     if ToolPathTmp != ToolPath:
 466                         EdkLogger.error("GenFds", GENFDS_ERROR, "Don't know which tool to use, %s or %s ?" % (ToolPathTmp, ToolPath))
 467
 468     BuildOption = {}
 469     for Arch in CurrentArchList:
 470         Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 471         # key is (ToolChainFamily, ToolChain, CodeBase)
 472         for item in Platform.BuildOptions:
 473             if '_PATH' in item[1] or '_FLAGS' in item[1] or '_GUID' in item[1]:
 474                 if not item[0] or (item[0] and GenFdsGlobalVariable.ToolChainFamily== item[0]):
 475                     if item[1] not in BuildOption:
 476                         BuildOption[item[1]] = Platform.BuildOptions[item]
 477         if BuildOption:
 478             ToolList = [TAB_TOD_DEFINES_TARGET, TAB_TOD_DEFINES_TOOL_CHAIN_TAG, TAB_TOD_DEFINES_TARGET_ARCH]
 479             for Index in range(2, -1, -1):
 480                 for Key in dict(BuildOption):
 481                     List = Key.split('_')
 482                     if List[Index] == '*':
 483                         for String in ToolDb[ToolList[Index]]:
 484                             if String in [Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]:
 485                                 List[Index] = String
 486                                 NewKey = '%s_%s_%s_%s_%s' % tuple(List)
 487                                 if NewKey not in BuildOption:
 488                                     BuildOption[NewKey] = BuildOption[Key]
 489                                     continue
 490                                 del BuildOption[Key]
 491                     elif List[Index] not in ToolDb[ToolList[Index]]:
 492                         del BuildOption[Key]
 493     if BuildOption:
 494         if not KeyList:
 495             for Op in BuildOption:
 496                 if NameGuid == BuildOption[Op]:
 497                     KeyList = Op.split('_')
 498                     Key = KeyList[0] + '_' + KeyList[1] +'_' + KeyList[2]
 499                     if Key in KeyStringList and KeyList[4] == 'GUID':
 500                         ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 501                         ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 502         if ToolPathKey in BuildOption.keys():
 503             ToolPathTmp = BuildOption.get(ToolPathKey)
 504         if ToolOptionKey in BuildOption.keys():
 505             ToolOption = BuildOption.get(ToolOptionKey)
 506
 507     GenFdsGlobalVariable.GuidToolDefinition[NameGuid] = (ToolPathTmp, ToolOption)
 508     return ToolPathTmp, ToolOption
 509
 510 ## Parse command line options
 511 #
 512 # Using standard Python module optparse to parse command line option of this tool.
 513 #
 514 #   @retval Opt   A optparse.Values object containing the parsed options
 515 #   @retval Args  Target of build command
 516 #
 517 def myOptionParser():
 518     usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\""
 519     Parser = OptionParser(usage=usage, description=__copyright__, version="%prog " + str(versionNumber))
 520     Parser.add_option("-f", "--file", dest="filename", type="string", help="Name of FDF file to convert", action="callback", callback=SingleCheckCallback)
 521     Parser.add_option("-a", "--arch", dest="archList", help="comma separated list containing one or more of: IA32, X64, IPF, ARM, AARCH64 or EBC which should be built, overrides target.txt?s TARGET_ARCH")
 522     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
 523     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed.")
 524     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
 525     Parser.add_option("-p", "--platform", type="string", dest="activePlatform", help="Set the ACTIVE_PLATFORM, overrides target.txt ACTIVE_PLATFORM setting.",
 526                       action="callback", callback=SingleCheckCallback)
 527     Parser.add_option("-w", "--workspace", type="string", dest="Workspace", default=os.environ.get('WORKSPACE'), help="Set the WORKSPACE",
 528                       action="callback", callback=SingleCheckCallback)
 529     Parser.add_option("-o", "--outputDir", type="string", dest="outputDir", help="Name of Build Output directory",
 530                       action="callback", callback=SingleCheckCallback)
 531     Parser.add_option("-r", "--rom_image", dest="uiFdName", help="Build the image using the [FD] section named by FdUiName.")
 532     Parser.add_option("-i", "--FvImage", dest="uiFvName", help="Build the FV image using the [FV] section named by UiFvName")
 533     Parser.add_option("-C", "--CapsuleImage", dest="uiCapName", help="Build the Capsule image using the [Capsule] section named by UiCapName")
 534     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Set the build TARGET, overrides target.txt TARGET setting.",
 535                       action="callback", callback=SingleCheckCallback)
 536     Parser.add_option("-t", "--tagname", type="string", dest="ToolChain", help="Using the tools: TOOL_CHAIN_TAG name to build the platform.",
 537                       action="callback", callback=SingleCheckCallback)
 538     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
 539     Parser.add_option("-s", "--specifyaddress", dest="FixedAddress", action="store_true", type=None, help="Specify driver load address.")
 540     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
 541     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
 542     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
 543
 544     (Options, args) = Parser.parse_args()
 545     return Options
 546
 547 ## The class implementing the EDK2 flash image generation process
 548 #
 549 #   This process includes:
 550 #       1. Collect workspace information, includes platform and module information
 551 #       2. Call methods of Fd class to generate FD
 552 #       3. Call methods of Fv class to generate FV that not belong to FD
 553 #
 554 class GenFds :
 555     FdfParsef = None
 556     # FvName, FdName, CapName in FDF, Image file name
 557     ImageBinDict = {}
 558     OnlyGenerateThisFd = None
 559     OnlyGenerateThisFv = None
 560     OnlyGenerateThisCap = None
 561
 562     ## GenFd()
 563     #
 564     #   @param  OutputDir           Output directory
 565     #   @param  FdfParser           FDF contents parser
 566     #   @param  Workspace           The directory of workspace
 567     #   @param  ArchList            The Arch list of platform
 568     #
 569     def GenFd (OutputDir, FdfParser, WorkSpace, ArchList):
 570         GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList)
 571
 572         GenFdsGlobalVariable.VerboseLogger(" Generate all Fd images and their required FV and Capsule images!")
 573         if GenFds.OnlyGenerateThisCap != None and GenFds.OnlyGenerateThisCap.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 574             CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.get(GenFds.OnlyGenerateThisCap.upper())
 575             if CapsuleObj != None:
 576                 CapsuleObj.GenCapsule()
 577                 return
 578
 579         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 580             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(GenFds.OnlyGenerateThisFd.upper())
 581             if FdObj != None:
 582                 FdObj.GenFd()
 583                 return
 584         elif GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisFv == None:
 585             for FdName in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 586                 FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[FdName]
 587                 FdObj.GenFd()
 588
 589         GenFdsGlobalVariable.VerboseLogger("\n Generate other FV images! ")
 590         if GenFds.OnlyGenerateThisFv != None and GenFds.OnlyGenerateThisFv.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 591             FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(GenFds.OnlyGenerateThisFv.upper())
 592             if FvObj != None:
 593                 Buffer = StringIO.StringIO()
 594                 FvObj.AddToBuffer(Buffer)
 595                 Buffer.close()
 596                 return
 597         elif GenFds.OnlyGenerateThisFv == None:
 598             for FvName in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 599                 Buffer = StringIO.StringIO('')
 600                 FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[FvName]
 601                 FvObj.AddToBuffer(Buffer)
 602                 Buffer.close()
 603
 604         if GenFds.OnlyGenerateThisFv == None and GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisCap == None:
 605             if GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict != {}:
 606                 GenFdsGlobalVariable.VerboseLogger("\n Generate other Capsule images!")
 607                 for CapsuleName in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 608                     CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[CapsuleName]
 609                     CapsuleObj.GenCapsule()
 610
 611             if GenFdsGlobalVariable.FdfParser.Profile.OptRomDict != {}:
 612                 GenFdsGlobalVariable.VerboseLogger("\n Generate all Option ROM!")
 613                 for DriverName in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.keys():
 614                     OptRomObj = GenFdsGlobalVariable.FdfParser.Profile.OptRomDict[DriverName]
 615                     OptRomObj.AddToBuffer(None)
 616
 617     ## GetFvBlockSize()
 618     #
 619     #   @param  FvObj           Whose block size to get
 620     #   @retval int             Block size value
 621     #
 622     def GetFvBlockSize(FvObj):
 623         DefaultBlockSize = 0x1
 624         FdObj = None
 625         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 626             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[GenFds.OnlyGenerateThisFd.upper()]
 627         if FdObj == None:
 628             for ElementFd in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
 629                 for ElementRegion in ElementFd.RegionList:
 630                     if ElementRegion.RegionType == 'FV':
 631                         for ElementRegionData in ElementRegion.RegionDataList:
 632                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 633                                 if FvObj.BlockSizeList != []:
 634                                     return FvObj.BlockSizeList[0][0]
 635                                 else:
 636                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 637             if FvObj.BlockSizeList != []:
 638                 return FvObj.BlockSizeList[0][0]
 639             return DefaultBlockSize
 640         else:
 641             for ElementRegion in FdObj.RegionList:
 642                     if ElementRegion.RegionType == 'FV':
 643                         for ElementRegionData in ElementRegion.RegionDataList:
 644                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 645                                 if FvObj.BlockSizeList != []:
 646                                     return FvObj.BlockSizeList[0][0]
 647                                 else:
 648                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 649             return DefaultBlockSize
 650
 651     ## DisplayFvSpaceInfo()
 652     #
 653     #   @param  FvObj           Whose block size to get
 654     #   @retval None
 655     #
 656     def DisplayFvSpaceInfo(FdfParser):
 657
 658         FvSpaceInfoList = []
 659         MaxFvNameLength = 0
 660         for FvName in FdfParser.Profile.FvDict:
 661             if len(FvName) > MaxFvNameLength:
 662                 MaxFvNameLength = len(FvName)
 663             FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map')
 664             if os.path.exists(FvSpaceInfoFileName):
 665                 FileLinesList = linecache.getlines(FvSpaceInfoFileName)
 666                 TotalFound = False
 667                 Total = ''
 668                 UsedFound = False
 669                 Used = ''
 670                 FreeFound = False
 671                 Free = ''
 672                 for Line in FileLinesList:
 673                     NameValue = Line.split('=')
 674                     if len(NameValue) == 2:
 675                         if NameValue[0].strip() == 'EFI_FV_TOTAL_SIZE':
 676                             TotalFound = True
 677                             Total = NameValue[1].strip()
 678                         if NameValue[0].strip() == 'EFI_FV_TAKEN_SIZE':
 679                             UsedFound = True
 680                             Used = NameValue[1].strip()
 681                         if NameValue[0].strip() == 'EFI_FV_SPACE_SIZE':
 682                             FreeFound = True
 683                             Free = NameValue[1].strip()
 684
 685                 if TotalFound and UsedFound and FreeFound:
 686                     FvSpaceInfoList.append((FvName, Total, Used, Free))
 687
 688         GenFdsGlobalVariable.InfLogger('\nFV Space Information')
 689         for FvSpaceInfo in FvSpaceInfoList:
 690             Name = FvSpaceInfo[0]
 691             TotalSizeValue = long(FvSpaceInfo[1], 0)
 692             UsedSizeValue = long(FvSpaceInfo[2], 0)
 693             FreeSizeValue = long(FvSpaceInfo[3], 0)
 694             if UsedSizeValue == TotalSizeValue:
 695                 Percentage = '100'
 696             else:
 697                 Percentage = str((UsedSizeValue + 0.0) / TotalSizeValue)[0:4].lstrip('0.')
 698
 699             GenFdsGlobalVariable.InfLogger(Name + ' ' + '[' + Percentage + '%Full] ' + str(TotalSizeValue) + ' total, ' + str(UsedSizeValue) + ' used, ' + str(FreeSizeValue) + ' free')
 700
 701     ## PreprocessImage()
 702     #
 703     #   @param  BuildDb         Database from build meta data files
 704     #   @param  DscFile         modules from dsc file will be preprocessed
 705     #   @retval None
 706     #
 707     def PreprocessImage(BuildDb, DscFile):
 708         PcdDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Pcds
 709         PcdValue = ''
 710         for Key in PcdDict:
 711             PcdObj = PcdDict[Key]
 712             if PcdObj.TokenCName == 'PcdBsBaseAddress':
 713                 PcdValue = PcdObj.DefaultValue
 714                 break
 715
 716         if PcdValue == '':
 717             return
 718
 719         Int64PcdValue = long(PcdValue, 0)
 720         if Int64PcdValue == 0 or Int64PcdValue < -1:
 721             return
 722
 723         TopAddress = 0
 724         if Int64PcdValue > 0:
 725             TopAddress = Int64PcdValue
 726
 727         ModuleDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Modules
 728         for Key in ModuleDict:
 729             ModuleObj = BuildDb.BuildObject[Key, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 730             print ModuleObj.BaseName + ' ' + ModuleObj.ModuleType
 731
 732     def GenerateGuidXRefFile(BuildDb, ArchList):
 733         GuidXRefFileName = os.path.join(GenFdsGlobalVariable.FvDir, "Guid.xref")
 734         GuidXRefFile = StringIO.StringIO('')
 735         GuidDict = {}
 736         for Arch in ArchList:
 737             PlatformDataBase = BuildDb.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 738             for ModuleFile in PlatformDataBase.Modules:
 739                 Module = BuildDb.BuildObject[ModuleFile, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 740                 GuidXRefFile.write("%s %s\n" % (Module.Guid, Module.BaseName))
 741                 for key, item in Module.Protocols.items():
 742                     GuidDict[key] = item
 743                 for key, item in Module.Guids.items():
 744                     GuidDict[key] = item
 745                 for key, item in Module.Ppis.items():
 746                     GuidDict[key] = item
 747        # Append GUIDs, Protocols, and PPIs to the Xref file
 748         GuidXRefFile.write("\n")
 749         for key, item in GuidDict.items():
 750             GuidXRefFile.write("%s %s\n" % (GuidStructureStringToGuidString(item).upper(), key))
 751
 752         if GuidXRefFile.getvalue():
 753             SaveFileOnChange(GuidXRefFileName, GuidXRefFile.getvalue(), False)
 754             GenFdsGlobalVariable.InfLogger("\nGUID cross reference file can be found at %s" % GuidXRefFileName)
 755         elif os.path.exists(GuidXRefFileName):
 756             os.remove(GuidXRefFileName)
 757         GuidXRefFile.close()
 758
 759     ##Define GenFd as static function
 760     GenFd = staticmethod(GenFd)
 761     GetFvBlockSize = staticmethod(GetFvBlockSize)
 762     DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo)
 763     PreprocessImage = staticmethod(PreprocessImage)
 764     GenerateGuidXRefFile = staticmethod(GenerateGuidXRefFile)
 765
 766 if __name__ == '__main__':
 767     r = main()
 768     ## 0-127 is a safe return range, and 1 is a standard default error
 769     if r < 0 or r > 127: r = 1
 770     sys.exit(r)
 771