BaseTools/Source/Python/GenFds/GenFds.py

   1 ## @file
   2 # generate flash image
   3 #
   4 #  Copyright (c) 2007 - 2010, 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 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
  40 ## Version and Copyright
  41 versionNumber = "1.0"
  42 __version__ = "%prog Version " + versionNumber
  43 __copyright__ = "Copyright (c) 2007 - 2010, Intel Corporation  All rights reserved."
  44
  45 ## Tool entrance method
  46 #
  47 # This method mainly dispatch specific methods per the command line options.
  48 # If no error found, return zero value so the caller of this tool can know
  49 # if it's executed successfully or not.
  50 #
  51 #   @retval 0     Tool was successful
  52 #   @retval 1     Tool failed
  53 #
  54 def main():
  55     global Options
  56     Options = myOptionParser()
  57
  58     global Workspace
  59     Workspace = ""
  60     ArchList = None
  61     ReturnCode = 0
  62
  63     EdkLogger.Initialize()
  64     try:
  65         if Options.verbose != None:
  66             EdkLogger.SetLevel(EdkLogger.VERBOSE)
  67             GenFdsGlobalVariable.VerboseMode = True
  68
  69         if Options.FixedAddress != None:
  70             GenFdsGlobalVariable.FixedLoadAddress = True
  71
  72         if Options.quiet != None:
  73             EdkLogger.SetLevel(EdkLogger.QUIET)
  74         if Options.debug != None:
  75             EdkLogger.SetLevel(Options.debug + 1)
  76             GenFdsGlobalVariable.DebugLevel = Options.debug
  77         else:
  78             EdkLogger.SetLevel(EdkLogger.INFO)
  79
  80         if (Options.Workspace == None):
  81             EdkLogger.error("GenFds", OPTION_MISSING, "WORKSPACE not defined",
  82                             ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
  83         elif not os.path.exists(Options.Workspace):
  84             EdkLogger.error("GenFds", PARAMETER_INVALID, "WORKSPACE is invalid",
  85                             ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
  86         else:
  87             Workspace = os.path.normcase(Options.Workspace)
  88             GenFdsGlobalVariable.WorkSpaceDir = Workspace
  89             if 'EDK_SOURCE' in os.environ.keys():
  90                 GenFdsGlobalVariable.EdkSourceDir = os.path.normcase(os.environ['EDK_SOURCE'])
  91             if (Options.debug):
  92                 GenFdsGlobalVariable.VerboseLogger( "Using Workspace:" + Workspace)
  93         os.chdir(GenFdsGlobalVariable.WorkSpaceDir)
  94
  95         if (Options.filename):
  96             FdfFilename = Options.filename
  97             FdfFilename = GenFdsGlobalVariable.ReplaceWorkspaceMacro(FdfFilename)
  98
  99             if FdfFilename[0:2] == '..':
 100                 FdfFilename = os.path.realpath(FdfFilename)
 101             if not os.path.isabs (FdfFilename):
 102                 FdfFilename = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, FdfFilename)
 103             if not os.path.exists(FdfFilename):
 104                 EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=FdfFilename)
 105             if os.path.normcase (FdfFilename).find(Workspace) != 0:
 106                 EdkLogger.error("GenFds", FILE_NOT_FOUND, "FdfFile doesn't exist in Workspace!")
 107
 108             GenFdsGlobalVariable.FdfFile = FdfFilename
 109             GenFdsGlobalVariable.FdfFileTimeStamp = os.path.getmtime(FdfFilename)
 110         else:
 111             EdkLogger.error("GenFds", OPTION_MISSING, "Missing FDF filename")
 112
 113         if (Options.BuildTarget):
 114             GenFdsGlobalVariable.TargetName = Options.BuildTarget
 115         else:
 116             EdkLogger.error("GenFds", OPTION_MISSING, "Missing build target")
 117
 118         if (Options.ToolChain):
 119             GenFdsGlobalVariable.ToolChainTag = Options.ToolChain
 120         else:
 121             EdkLogger.error("GenFds", OPTION_MISSING, "Missing tool chain tag")
 122
 123         if (Options.activePlatform):
 124             ActivePlatform = Options.activePlatform
 125             ActivePlatform = GenFdsGlobalVariable.ReplaceWorkspaceMacro(ActivePlatform)
 126
 127             if ActivePlatform[0:2] == '..':
 128                 ActivePlatform = os.path.realpath(ActivePlatform)
 129
 130             if not os.path.isabs (ActivePlatform):
 131                 ActivePlatform = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, ActivePlatform)
 132
 133             if not os.path.exists(ActivePlatform)  :
 134                 EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist!")
 135
 136             if os.path.normcase (ActivePlatform).find(Workspace) != 0:
 137                 EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist in Workspace!")
 138
 139             ActivePlatform = ActivePlatform[len(Workspace):]
 140             if len(ActivePlatform) > 0 :
 141                 if ActivePlatform[0] == '\\' or ActivePlatform[0] == '/':
 142                     ActivePlatform = ActivePlatform[1:]
 143             else:
 144                 EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist!")
 145         else:
 146             EdkLogger.error("GenFds", OPTION_MISSING, "Missing active platform")
 147
 148         GenFdsGlobalVariable.ActivePlatform = PathClass(NormPath(ActivePlatform), Workspace)
 149
 150         BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.WorkSpaceDir, "Conf/target.txt"))
 151         if os.path.isfile(BuildConfigurationFile) == True:
 152             TargetTxtClassObject.TargetTxtClassObject(BuildConfigurationFile)
 153         else:
 154             EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)
 155
 156         if Options.Macros:
 157             for Pair in Options.Macros:
 158                 Pair.strip('"')
 159                 List = Pair.split('=')
 160                 if len(List) == 2:
 161                     if List[0].strip() == "EFI_SOURCE":
 162                         GlobalData.gEfiSource = List[1].strip()
 163                         continue
 164                     elif List[0].strip() == "EDK_SOURCE":
 165                         GlobalData.gEdkSource = List[1].strip()
 166                         continue
 167                     else:
 168                         GlobalData.gEdkGlobal[List[0].strip()] = List[1].strip()
 169                         FdfParser.InputMacroDict[List[0].strip()] = List[1].strip()
 170                 else:
 171                     FdfParser.InputMacroDict[List[0].strip()] = ""
 172
 173         """call Workspace build create database"""
 174         os.environ["WORKSPACE"] = Workspace
 175         FdfParser.InputMacroDict["WORKSPACE"] = Workspace
 176         BuildWorkSpace = WorkspaceDatabase(':memory:', FdfParser.InputMacroDict)
 177         BuildWorkSpace.InitDatabase()
 178
 179         #
 180         # Get files real name in workspace dir
 181         #
 182         GlobalData.gAllFiles = DirCache(Workspace)
 183         GlobalData.gWorkspace = Workspace
 184
 185         if (Options.archList) :
 186             ArchList = Options.archList.split(',')
 187         else:
 188 #            EdkLogger.error("GenFds", OPTION_MISSING, "Missing build ARCH")
 189             ArchList = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList
 190
 191         TargetArchList = set(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList) & set(ArchList)
 192         if len(TargetArchList) == 0:
 193             EdkLogger.error("GenFds", GENFDS_ERROR, "Target ARCH %s not in platform supported ARCH %s" % (str(ArchList), str(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList)))
 194
 195         for Arch in ArchList:
 196             GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = NormPath(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch].OutputDirectory)
 197             GenFdsGlobalVariable.PlatformName = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch].PlatformName
 198
 199         if (Options.outputDir):
 200             OutputDirFromCommandLine = GenFdsGlobalVariable.ReplaceWorkspaceMacro(Options.outputDir)
 201             if not os.path.isabs (OutputDirFromCommandLine):
 202                 OutputDirFromCommandLine = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, OutputDirFromCommandLine)
 203             for Arch in ArchList:
 204                 GenFdsGlobalVariable.OutputDirDict[Arch] = OutputDirFromCommandLine
 205         else:
 206             for Arch in ArchList:
 207                 GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.join(GenFdsGlobalVariable.OutputDirFromDscDict[Arch], GenFdsGlobalVariable.TargetName + '_' + GenFdsGlobalVariable.ToolChainTag)
 208
 209         for Key in GenFdsGlobalVariable.OutputDirDict:
 210             OutputDir = GenFdsGlobalVariable.OutputDirDict[Key]
 211             if OutputDir[0:2] == '..':
 212                 OutputDir = os.path.realpath(OutputDir)
 213
 214             if OutputDir[1] != ':':
 215                 OutputDir = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, OutputDir)
 216
 217             if not os.path.exists(OutputDir):
 218                 EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=OutputDir)
 219             GenFdsGlobalVariable.OutputDirDict[Key] = OutputDir
 220
 221         """ Parse Fdf file, has to place after build Workspace as FDF may contain macros from DSC file """
 222         FdfParserObj = FdfParser.FdfParser(FdfFilename)
 223         FdfParserObj.ParseFile()
 224
 225         if FdfParserObj.CycleReferenceCheck():
 226             EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Cycle Reference Detected in FDF file")
 227
 228         if (Options.uiFdName) :
 229             if Options.uiFdName.upper() in FdfParserObj.Profile.FdDict.keys():
 230                 GenFds.OnlyGenerateThisFd = Options.uiFdName
 231             else:
 232                 EdkLogger.error("GenFds", OPTION_VALUE_INVALID,
 233                                 "No such an FD in FDF file: %s" % Options.uiFdName)
 234
 235         if (Options.uiFvName) :
 236             if Options.uiFvName.upper() in FdfParserObj.Profile.FvDict.keys():
 237                 GenFds.OnlyGenerateThisFv = Options.uiFvName
 238             else:
 239                 EdkLogger.error("GenFds", OPTION_VALUE_INVALID,
 240                                 "No such an FV in FDF file: %s" % Options.uiFvName)
 241
 242         """Modify images from build output if the feature of loading driver at fixed address is on."""
 243         if GenFdsGlobalVariable.FixedLoadAddress:
 244             GenFds.PreprocessImage(BuildWorkSpace, GenFdsGlobalVariable.ActivePlatform)
 245         """Call GenFds"""
 246         GenFds.GenFd('', FdfParserObj, BuildWorkSpace, ArchList)
 247
 248         """Generate GUID cross reference file"""
 249         GenFds.GenerateGuidXRefFile(BuildWorkSpace, ArchList)
 250
 251         """Display FV space info."""
 252         GenFds.DisplayFvSpaceInfo(FdfParserObj)
 253
 254     except FdfParser.Warning, X:
 255         EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError = False)
 256         ReturnCode = FORMAT_INVALID
 257     except FatalError, X:
 258         if Options.debug != None:
 259             import traceback
 260             EdkLogger.quiet(traceback.format_exc())
 261         ReturnCode = X.args[0]
 262     except:
 263         import traceback
 264         EdkLogger.error(
 265                     "\nPython",
 266                     CODE_ERROR,
 267                     "Tools code failure",
 268                     ExtraData="Please send email to edk2-buildtools-devel@lists.sourceforge.net for help, attaching following call stack trace!\n",
 269                     RaiseError=False
 270                     )
 271         EdkLogger.quiet(traceback.format_exc())
 272         ReturnCode = CODE_ERROR
 273     return ReturnCode
 274
 275 gParamCheck = []
 276 def SingleCheckCallback(option, opt_str, value, parser):
 277     if option not in gParamCheck:
 278         setattr(parser.values, option.dest, value)
 279         gParamCheck.append(option)
 280     else:
 281         parser.error("Option %s only allows one instance in command line!" % option)
 282
 283 ## Parse command line options
 284 #
 285 # Using standard Python module optparse to parse command line option of this tool.
 286 #
 287 #   @retval Opt   A optparse.Values object containing the parsed options
 288 #   @retval Args  Target of build command
 289 #
 290 def myOptionParser():
 291     usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\""
 292     Parser = OptionParser(usage=usage,description=__copyright__,version="%prog " + str(versionNumber))
 293     Parser.add_option("-f", "--file", dest="filename", type="string", help="Name of FDF file to convert", action="callback", callback=SingleCheckCallback)
 294     Parser.add_option("-a", "--arch", dest="archList", help="comma separated list containing one or more of: IA32, X64, IPF, ARM or EBC which should be built, overrides target.txt?s TARGET_ARCH")
 295     Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
 296     Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed.")
 297     Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
 298     Parser.add_option("-p", "--platform", type="string", dest="activePlatform", help="Set the ACTIVE_PLATFORM, overrides target.txt ACTIVE_PLATFORM setting.",
 299                       action="callback", callback=SingleCheckCallback)
 300     Parser.add_option("-w", "--workspace", type="string", dest="Workspace", default=os.environ.get('WORKSPACE'), help="Set the WORKSPACE",
 301                       action="callback", callback=SingleCheckCallback)
 302     Parser.add_option("-o", "--outputDir", type="string", dest="outputDir", help="Name of Build Output directory",
 303                       action="callback", callback=SingleCheckCallback)
 304     Parser.add_option("-r", "--rom_image", dest="uiFdName", help="Build the image using the [FD] section named by FdUiName.")
 305     Parser.add_option("-i", "--FvImage", dest="uiFvName", help="Buld the FV image using the [FV] section named by UiFvName")
 306     Parser.add_option("-b", "--buildtarget", type="choice", choices=['DEBUG','RELEASE'], dest="BuildTarget", help="Build TARGET is one of list: DEBUG, RELEASE.",
 307                       action="callback", callback=SingleCheckCallback)
 308     Parser.add_option("-t", "--tagname", type="string", dest="ToolChain", help="Using the tools: TOOL_CHAIN_TAG name to build the platform.",
 309                       action="callback", callback=SingleCheckCallback)
 310     Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
 311     Parser.add_option("-s", "--specifyaddress", dest="FixedAddress", action="store_true", type=None, help="Specify driver load address.")
 312     (Options, args) = Parser.parse_args()
 313     return Options
 314
 315 ## The class implementing the EDK2 flash image generation process
 316 #
 317 #   This process includes:
 318 #       1. Collect workspace information, includes platform and module information
 319 #       2. Call methods of Fd class to generate FD
 320 #       3. Call methods of Fv class to generate FV that not belong to FD
 321 #
 322 class GenFds :
 323     FdfParsef = None
 324     # FvName, FdName, CapName in FDF, Image file name
 325     ImageBinDict = {}
 326     OnlyGenerateThisFd = None
 327     OnlyGenerateThisFv = None
 328
 329     ## GenFd()
 330     #
 331     #   @param  OutputDir           Output directory
 332     #   @param  FdfParser           FDF contents parser
 333     #   @param  Workspace           The directory of workspace
 334     #   @param  ArchList            The Arch list of platform
 335     #
 336     def GenFd (OutputDir, FdfParser, WorkSpace, ArchList):
 337         GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList)
 338
 339         GenFdsGlobalVariable.VerboseLogger(" Generate all Fd images and their required FV and Capsule images!")
 340         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 341             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(GenFds.OnlyGenerateThisFd.upper())
 342             if FdObj != None:
 343                 FdObj.GenFd()
 344         elif GenFds.OnlyGenerateThisFd == None:
 345             for FdName in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 346                 FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[FdName]
 347                 FdObj.GenFd()
 348
 349         GenFdsGlobalVariable.VerboseLogger("\n Generate other FV images! ")
 350         if GenFds.OnlyGenerateThisFv != None and GenFds.OnlyGenerateThisFv.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 351             FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(GenFds.OnlyGenerateThisFv.upper())
 352             if FvObj != None:
 353                 Buffer = StringIO.StringIO()
 354                 FvObj.AddToBuffer(Buffer)
 355                 Buffer.close()
 356                 return
 357         elif GenFds.OnlyGenerateThisFv == None:
 358             for FvName in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
 359                 Buffer = StringIO.StringIO('')
 360                 FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[FvName]
 361                 FvObj.AddToBuffer(Buffer)
 362                 Buffer.close()
 363
 364         if GenFds.OnlyGenerateThisFv == None and GenFds.OnlyGenerateThisFd == None:
 365             if GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict != {}:
 366                 GenFdsGlobalVariable.VerboseLogger("\n Generate other Capsule images!")
 367                 for CapsuleName in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():
 368                     CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[CapsuleName]
 369                     CapsuleObj.GenCapsule()
 370
 371             if GenFdsGlobalVariable.FdfParser.Profile.OptRomDict != {}:
 372                 GenFdsGlobalVariable.VerboseLogger("\n Generate all Option ROM!")
 373                 for DriverName in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.keys():
 374                     OptRomObj = GenFdsGlobalVariable.FdfParser.Profile.OptRomDict[DriverName]
 375                     OptRomObj.AddToBuffer(None)
 376
 377     ## GetFvBlockSize()
 378     #
 379     #   @param  FvObj           Whose block size to get
 380     #   @retval int             Block size value
 381     #
 382     def GetFvBlockSize(FvObj):
 383         DefaultBlockSize = 0x1
 384         FdObj = None
 385         if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
 386             FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[GenFds.OnlyGenerateThisFd.upper()]
 387         if FdObj == None:
 388             for ElementFd in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
 389                 for ElementRegion in ElementFd.RegionList:
 390                     if ElementRegion.RegionType == 'FV':
 391                         for ElementRegionData in ElementRegion.RegionDataList:
 392                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 393                                 if FvObj.BlockSizeList != []:
 394                                     return FvObj.BlockSizeList[0][0]
 395                                 else:
 396                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 397             if FvObj.BlockSizeList != []:
 398                 return FvObj.BlockSizeList[0][0]
 399             return DefaultBlockSize
 400         else:
 401             for ElementRegion in FdObj.RegionList:
 402                     if ElementRegion.RegionType == 'FV':
 403                         for ElementRegionData in ElementRegion.RegionDataList:
 404                             if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
 405                                 if FvObj.BlockSizeList != []:
 406                                     return FvObj.BlockSizeList[0][0]
 407                                 else:
 408                                     return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
 409             return DefaultBlockSize
 410
 411     ## DisplayFvSpaceInfo()
 412     #
 413     #   @param  FvObj           Whose block size to get
 414     #   @retval None
 415     #
 416     def DisplayFvSpaceInfo(FdfParser):
 417
 418         FvSpaceInfoList = []
 419         MaxFvNameLength = 0
 420         for FvName in FdfParser.Profile.FvDict:
 421             if len(FvName) > MaxFvNameLength:
 422                 MaxFvNameLength = len(FvName)
 423             FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map')
 424             if os.path.exists(FvSpaceInfoFileName):
 425                 FileLinesList = linecache.getlines(FvSpaceInfoFileName)
 426                 TotalFound = False
 427                 Total = ''
 428                 UsedFound = False
 429                 Used = ''
 430                 FreeFound = False
 431                 Free = ''
 432                 for Line in FileLinesList:
 433                     NameValue = Line.split('=')
 434                     if len(NameValue) == 2:
 435                         if NameValue[0].strip() == 'EFI_FV_TOTAL_SIZE':
 436                             TotalFound = True
 437                             Total = NameValue[1].strip()
 438                         if NameValue[0].strip() == 'EFI_FV_TAKEN_SIZE':
 439                             UsedFound = True
 440                             Used = NameValue[1].strip()
 441                         if NameValue[0].strip() == 'EFI_FV_SPACE_SIZE':
 442                             FreeFound = True
 443                             Free = NameValue[1].strip()
 444
 445                 if TotalFound and UsedFound and FreeFound:
 446                     FvSpaceInfoList.append((FvName, Total, Used, Free))
 447
 448         GenFdsGlobalVariable.InfLogger('\nFV Space Information')
 449         for FvSpaceInfo in FvSpaceInfoList:
 450             Name = FvSpaceInfo[0]
 451             TotalSizeValue = long(FvSpaceInfo[1], 0)
 452             UsedSizeValue = long(FvSpaceInfo[2], 0)
 453             FreeSizeValue = long(FvSpaceInfo[3], 0)
 454             if UsedSizeValue == TotalSizeValue:
 455                 Percentage = '100'
 456             else:
 457                 Percentage = str((UsedSizeValue+0.0)/TotalSizeValue)[0:4].lstrip('0.')
 458
 459             GenFdsGlobalVariable.InfLogger(Name + ' ' + '[' + Percentage + '%Full] ' + str(TotalSizeValue) + ' total, ' + str(UsedSizeValue) + ' used, ' + str(FreeSizeValue) + ' free')
 460
 461     ## PreprocessImage()
 462     #
 463     #   @param  BuildDb         Database from build meta data files
 464     #   @param  DscFile         modules from dsc file will be preprocessed
 465     #   @retval None
 466     #
 467     def PreprocessImage(BuildDb, DscFile):
 468         PcdDict = BuildDb.BuildObject[DscFile, 'COMMON'].Pcds
 469         PcdValue = ''
 470         for Key in PcdDict:
 471             PcdObj = PcdDict[Key]
 472             if PcdObj.TokenCName == 'PcdBsBaseAddress':
 473                 PcdValue = PcdObj.DefaultValue
 474                 break
 475
 476         if PcdValue == '':
 477             return
 478
 479         Int64PcdValue = long(PcdValue, 0)
 480         if Int64PcdValue == 0 or Int64PcdValue < -1:
 481             return
 482
 483         TopAddress = 0
 484         if Int64PcdValue > 0:
 485             TopAddress = Int64PcdValue
 486
 487         ModuleDict = BuildDb.BuildObject[DscFile, 'COMMON'].Modules
 488         for Key in ModuleDict:
 489             ModuleObj = BuildDb.BuildObject[Key, 'COMMON']
 490             print ModuleObj.BaseName + ' ' + ModuleObj.ModuleType
 491
 492     def GenerateGuidXRefFile(BuildDb, ArchList):
 493         GuidXRefFileName = os.path.join(GenFdsGlobalVariable.FvDir, "Guid.xref")
 494         GuidXRefFile = StringIO.StringIO('')
 495         for Arch in ArchList:
 496             PlatformDataBase = BuildDb.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch]
 497             for ModuleFile in PlatformDataBase.Modules:
 498                 Module = BuildDb.BuildObject[ModuleFile, Arch]
 499                 GuidXRefFile.write("%s %s\n" % (Module.Guid, Module.BaseName))
 500         SaveFileOnChange(GuidXRefFileName, GuidXRefFile.getvalue(), False)
 501         GuidXRefFile.close()
 502         GenFdsGlobalVariable.InfLogger("\nGUID cross reference file can be found at %s" % GuidXRefFileName)
 503
 504     ##Define GenFd as static function
 505     GenFd = staticmethod(GenFd)
 506     GetFvBlockSize = staticmethod(GetFvBlockSize)
 507     DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo)
 508     PreprocessImage = staticmethod(PreprocessImage)
 509     GenerateGuidXRefFile = staticmethod(GenerateGuidXRefFile)
 510
 511 if __name__ == '__main__':
 512     r = main()
 513     ## 0-127 is a safe return range, and 1 is a standard default error
 514     if r < 0 or r > 127: r = 1
 515     sys.exit(r)
 516