BaseTools/Source/Python/GenFds/GenFds.py

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