BaseTools/Source/Python/GenFds/GenFds.py

   1 ## @file
   2 # generate flash image
   3 #
   4 #  Copyright (c) 2007 - 2016, 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 import Common.DataType
  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 - 2016, 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     # if user not specify filter, try to deduce it from global data.
 428     if KeyStringList == None or KeyStringList == []:
 429         Target = GenFdsGlobalVariable.TargetName
 430         ToolChain = GenFdsGlobalVariable.ToolChainTag
 431         ToolDb = ToolDefClassObject.ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDatabase
 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     for ToolDef in ToolDefinition.items():
 447         if NameGuid == ToolDef[1]:
 448             KeyList = ToolDef[0].split('_')
 449             Key = KeyList[0] + \
 450                   '_' + \
 451                   KeyList[1] + \
 452                   '_' + \
 453                   KeyList[2]
 454             if Key in KeyStringList and KeyList[4] == 'GUID':
 455
 456                 ToolPath = ToolDefinition.get(Key + \
 457                                                '_' + \
 458                                                KeyList[3] + \
 459                                                '_' + \
 460                                                'PATH')
 461
 462                 ToolOption = ToolDefinition.get(Key + \
 463                                                 '_' + \
 464                                                 KeyList[3] + \
 465                                                 '_' + \
 466                                                 'FLAGS')
 467                 if ToolPathTmp == None:
 468                     ToolPathTmp = ToolPath
 469                 else:
 470                     if ToolPathTmp != ToolPath:
 471                         EdkLogger.error("GenFds", GENFDS_ERROR, "Don't know which tool to use, %s or %s ?" % (ToolPathTmp, ToolPath))
 472
 473     GenFdsGlobalVariable.GuidToolDefinition[NameGuid] = (ToolPathTmp, ToolOption)
 474     return ToolPathTmp, ToolOption
 475
 476 ## Parse command line options
 477 #
 478 # Using standard Python module optparse to parse command line option of this tool.
 479 #
 480 #   @retval Opt   A optparse.Values object containing the parsed options
 481 #   @retval Args  Target of build command
 482 #
 483 def myOptionParser():
 484     usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\""
 485     Parser = OptionParser(usage=usage, description=__copyright__, version="%prog " + str(versionNumber))
 486     Parser.add_option("-f", "--file", dest="filename", type="string", help="Name of FDF file to convert", action="callback", callback=SingleCheckCallback)
 487     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")
 488     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
 489     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed.")
 490     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
 491     Parser.add_option("-p", "--platform", type="string", dest="activePlatform", help="Set the ACTIVE_PLATFORM, overrides target.txt ACTIVE_PLATFORM setting.",
 492                       action="callback", callback=SingleCheckCallback)
 493     Parser.add_option("-w", "--workspace", type="string", dest="Workspace", default=os.environ.get('WORKSPACE'), help="Set the WORKSPACE",
 494                       action="callback", callback=SingleCheckCallback)
 495     Parser.add_option("-o", "--outputDir", type="string", dest="outputDir", help="Name of Build Output directory",
 496                       action="callback", callback=SingleCheckCallback)
 497     Parser.add_option("-r", "--rom_image", dest="uiFdName", help="Build the image using the [FD] section named by FdUiName.")
 498     Parser.add_option("-i", "--FvImage", dest="uiFvName", help="Build the FV image using the [FV] section named by UiFvName")
 499     Parser.add_option("-C", "--CapsuleImage", dest="uiCapName", help="Build the Capsule image using the [Capsule] section named by UiCapName")
 500     Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Set the build TARGET, overrides target.txt TARGET setting.",
 501                       action="callback", callback=SingleCheckCallback)
 502     Parser.add_option("-t", "--tagname", type="string", dest="ToolChain", help="Using the tools: TOOL_CHAIN_TAG name to build the platform.",
 503                       action="callback", callback=SingleCheckCallback)
 504     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
 505     Parser.add_option("-s", "--specifyaddress", dest="FixedAddress", action="store_true", type=None, help="Specify driver load address.")
 506     Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")
 507     Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")
 508     Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
 509
 510     (Options, args) = Parser.parse_args()
 511     return Options
 512
 513 ## The class implementing the EDK2 flash image generation process
 514 #
 515 #   This process includes:
 516 #       1. Collect workspace information, includes platform and module information
 517 #       2. Call methods of Fd class to generate FD
 518 #       3. Call methods of Fv class to generate FV that not belong to FD
 519 #
 520 class GenFds :
 521     FdfParsef = None
 522     # FvName, FdName, CapName in FDF, Image file name
 523     ImageBinDict = {}
 524     OnlyGenerateThisFd = None
 525     OnlyGenerateThisFv = None
 526     OnlyGenerateThisCap = None
 527
 528     ## GenFd()
 529     #
 530     #   @param  OutputDir           Output directory
 531     #   @param  FdfParser           FDF contents parser
 532     #   @param  Workspace           The directory of workspace
 533     #   @param  ArchList            The Arch list of platform
 534     #
 535     def GenFd (OutputDir, FdfParser, WorkSpace, ArchList):
 536         GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList)
 537
 538         GenFdsGlobalVariable.VerboseLogger(" Generate all Fd images and their required FV and Capsule images!")
 539         if GenFds.OnlyGenerateThisCap != None and GenFds.OnlyGenerateThisCap.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 540             CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.get(GenFds.OnlyGenerateThisCap.upper())
 541             if CapsuleObj != None:
 542                 CapsuleObj.GenCapsule()
 543                 return
 544
 545         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 546             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(GenFds.OnlyGenerateThisFd.upper())
 547             if FdObj != None:
 548                 FdObj.GenFd()
 549                 return
 550         elif GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisFv == None:
 551             for FdName in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 552                 FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[FdName]
 553                 FdObj.GenFd()
 554
 555         GenFdsGlobalVariable.VerboseLogger("\n Generate other FV images! ")
 556         if GenFds.OnlyGenerateThisFv != None and GenFds.OnlyGenerateThisFv.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 557             FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(GenFds.OnlyGenerateThisFv.upper())
 558             if FvObj != None:
 559                 Buffer = StringIO.StringIO()
 560                 FvObj.AddToBuffer(Buffer)
 561                 Buffer.close()
 562                 return
 563         elif GenFds.OnlyGenerateThisFv == None:
 564             for FvName in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 565                 Buffer = StringIO.StringIO('')
 566                 FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[FvName]
 567                 FvObj.AddToBuffer(Buffer)
 568                 Buffer.close()
 569
 570         if GenFds.OnlyGenerateThisFv == None and GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisCap == None:
 571             if GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict != {}:
 572                 GenFdsGlobalVariable.VerboseLogger("\n Generate other Capsule images!")
 573                 for CapsuleName in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 574                     CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[CapsuleName]
 575                     CapsuleObj.GenCapsule()
 576
 577             if GenFdsGlobalVariable.FdfParser.Profile.OptRomDict != {}:
 578                 GenFdsGlobalVariable.VerboseLogger("\n Generate all Option ROM!")
 579                 for DriverName in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.keys():
 580                     OptRomObj = GenFdsGlobalVariable.FdfParser.Profile.OptRomDict[DriverName]
 581                     OptRomObj.AddToBuffer(None)
 582
 583     ## GetFvBlockSize()
 584     #
 585     #   @param  FvObj           Whose block size to get
 586     #   @retval int             Block size value
 587     #
 588     def GetFvBlockSize(FvObj):
 589         DefaultBlockSize = 0x1
 590         FdObj = None
 591         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 592             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[GenFds.OnlyGenerateThisFd.upper()]
 593         if FdObj == None:
 594             for ElementFd in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
 595                 for ElementRegion in ElementFd.RegionList:
 596                     if ElementRegion.RegionType == 'FV':
 597                         for ElementRegionData in ElementRegion.RegionDataList:
 598                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 599                                 if FvObj.BlockSizeList != []:
 600                                     return FvObj.BlockSizeList[0][0]
 601                                 else:
 602                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 603             if FvObj.BlockSizeList != []:
 604                 return FvObj.BlockSizeList[0][0]
 605             return DefaultBlockSize
 606         else:
 607             for ElementRegion in FdObj.RegionList:
 608                     if ElementRegion.RegionType == 'FV':
 609                         for ElementRegionData in ElementRegion.RegionDataList:
 610                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 611                                 if FvObj.BlockSizeList != []:
 612                                     return FvObj.BlockSizeList[0][0]
 613                                 else:
 614                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 615             return DefaultBlockSize
 616
 617     ## DisplayFvSpaceInfo()
 618     #
 619     #   @param  FvObj           Whose block size to get
 620     #   @retval None
 621     #
 622     def DisplayFvSpaceInfo(FdfParser):
 623
 624         FvSpaceInfoList = []
 625         MaxFvNameLength = 0
 626         for FvName in FdfParser.Profile.FvDict:
 627             if len(FvName) > MaxFvNameLength:
 628                 MaxFvNameLength = len(FvName)
 629             FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map')
 630             if os.path.exists(FvSpaceInfoFileName):
 631                 FileLinesList = linecache.getlines(FvSpaceInfoFileName)
 632                 TotalFound = False
 633                 Total = ''
 634                 UsedFound = False
 635                 Used = ''
 636                 FreeFound = False
 637                 Free = ''
 638                 for Line in FileLinesList:
 639                     NameValue = Line.split('=')
 640                     if len(NameValue) == 2:
 641                         if NameValue[0].strip() == 'EFI_FV_TOTAL_SIZE':
 642                             TotalFound = True
 643                             Total = NameValue[1].strip()
 644                         if NameValue[0].strip() == 'EFI_FV_TAKEN_SIZE':
 645                             UsedFound = True
 646                             Used = NameValue[1].strip()
 647                         if NameValue[0].strip() == 'EFI_FV_SPACE_SIZE':
 648                             FreeFound = True
 649                             Free = NameValue[1].strip()
 650
 651                 if TotalFound and UsedFound and FreeFound:
 652                     FvSpaceInfoList.append((FvName, Total, Used, Free))
 653
 654         GenFdsGlobalVariable.InfLogger('\nFV Space Information')
 655         for FvSpaceInfo in FvSpaceInfoList:
 656             Name = FvSpaceInfo[0]
 657             TotalSizeValue = long(FvSpaceInfo[1], 0)
 658             UsedSizeValue = long(FvSpaceInfo[2], 0)
 659             FreeSizeValue = long(FvSpaceInfo[3], 0)
 660             if UsedSizeValue == TotalSizeValue:
 661                 Percentage = '100'
 662             else:
 663                 Percentage = str((UsedSizeValue + 0.0) / TotalSizeValue)[0:4].lstrip('0.')
 664
 665             GenFdsGlobalVariable.InfLogger(Name + ' ' + '[' + Percentage + '%Full] ' + str(TotalSizeValue) + ' total, ' + str(UsedSizeValue) + ' used, ' + str(FreeSizeValue) + ' free')
 666
 667     ## PreprocessImage()
 668     #
 669     #   @param  BuildDb         Database from build meta data files
 670     #   @param  DscFile         modules from dsc file will be preprocessed
 671     #   @retval None
 672     #
 673     def PreprocessImage(BuildDb, DscFile):
 674         PcdDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Pcds
 675         PcdValue = ''
 676         for Key in PcdDict:
 677             PcdObj = PcdDict[Key]
 678             if PcdObj.TokenCName == 'PcdBsBaseAddress':
 679                 PcdValue = PcdObj.DefaultValue
 680                 break
 681
 682         if PcdValue == '':
 683             return
 684
 685         Int64PcdValue = long(PcdValue, 0)
 686         if Int64PcdValue == 0 or Int64PcdValue < -1:
 687             return
 688
 689         TopAddress = 0
 690         if Int64PcdValue > 0:
 691             TopAddress = Int64PcdValue
 692
 693         ModuleDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Modules
 694         for Key in ModuleDict:
 695             ModuleObj = BuildDb.BuildObject[Key, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 696             print ModuleObj.BaseName + ' ' + ModuleObj.ModuleType
 697
 698     def GenerateGuidXRefFile(BuildDb, ArchList):
 699         GuidXRefFileName = os.path.join(GenFdsGlobalVariable.FvDir, "Guid.xref")
 700         GuidXRefFile = StringIO.StringIO('')
 701         GuidDict = {}
 702         for Arch in ArchList:
 703             PlatformDataBase = BuildDb.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 704             for ModuleFile in PlatformDataBase.Modules:
 705                 Module = BuildDb.BuildObject[ModuleFile, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 706                 GuidXRefFile.write("%s %s\n" % (Module.Guid, Module.BaseName))
 707                 for key, item in Module.Protocols.items():
 708                     GuidDict[key] = item
 709                 for key, item in Module.Guids.items():
 710                     GuidDict[key] = item
 711                 for key, item in Module.Ppis.items():
 712                     GuidDict[key] = item
 713        # Append GUIDs, Protocols, and PPIs to the Xref file
 714         GuidXRefFile.write("\n")
 715         for key, item in GuidDict.items():
 716             GuidXRefFile.write("%s %s\n" % (GuidStructureStringToGuidString(item).upper(), key))
 717
 718         if GuidXRefFile.getvalue():
 719             SaveFileOnChange(GuidXRefFileName, GuidXRefFile.getvalue(), False)
 720             GenFdsGlobalVariable.InfLogger("\nGUID cross reference file can be found at %s" % GuidXRefFileName)
 721         elif os.path.exists(GuidXRefFileName):
 722             os.remove(GuidXRefFileName)
 723         GuidXRefFile.close()
 724
 725     ##Define GenFd as static function
 726     GenFd = staticmethod(GenFd)
 727     GetFvBlockSize = staticmethod(GetFvBlockSize)
 728     DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo)
 729     PreprocessImage = staticmethod(PreprocessImage)
 730     GenerateGuidXRefFile = staticmethod(GenerateGuidXRefFile)
 731
 732 if __name__ == '__main__':
 733     r = main()
 734     ## 0-127 is a safe return range, and 1 is a standard default error
 735     if r < 0 or r > 127: r = 1
 736     sys.exit(r)
 737