Check In tool source code based on Build tool project revision r1655.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 486 insertions, 0 deletions

diff --git a/BaseTools/Source/Python/GenFds/GenFds.py b/BaseTools/Source/Python/GenFds/GenFds.py
new file mode 100644
index 0000000000..2bc416f828
--- /dev/null
+++ b/BaseTools/Source/Python/GenFds/GenFds.py
@@ -0,0 +1,486 @@
+## @file
+# generate flash image
+#
+#  Copyright (c) 2007, Intel Corporation
+#
+#  All rights reserved. This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution.  The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+
+##
+# Import Modules
+#
+from optparse import OptionParser
+import sys
+import os
+import linecache
+import FdfParser
+from Common.BuildToolError import *
+from GenFdsGlobalVariable import GenFdsGlobalVariable
+from Workspace.WorkspaceDatabase import WorkspaceDatabase
+from Workspace.BuildClassObject import PcdClassObject
+from Workspace.BuildClassObject import ModuleBuildClassObject
+import RuleComplexFile
+from EfiSection import EfiSection
+import StringIO
+import Common.TargetTxtClassObject as TargetTxtClassObject
+import Common.ToolDefClassObject as ToolDefClassObject
+import Common.DataType
+import Common.GlobalData as GlobalData
+from Common import EdkLogger
+from Common.String import *
+from Common.Misc import DirCache,PathClass
+
+## Version and Copyright
+versionNumber = "1.0"
+__version__ = "%prog Version " + versionNumber
+__copyright__ = "Copyright (c) 2007, Intel Corporation  All rights reserved."
+
+## Tool entrance method
+#
+# This method mainly dispatch specific methods per the command line options.
+# If no error found, return zero value so the caller of this tool can know
+# if it's executed successfully or not.
+#
+#   @retval 0     Tool was successful
+#   @retval 1     Tool failed
+#
+def main():
+    global Options
+    Options = myOptionParser()
+
+    global Workspace
+    Workspace = ""
+    ArchList = None
+    ReturnCode = 0
+
+    EdkLogger.Initialize()
+    try:
+        if Options.verbose != None:
+            EdkLogger.SetLevel(EdkLogger.VERBOSE)
+            GenFdsGlobalVariable.VerboseMode = True
+            
+        if Options.FixedAddress != None:
+            GenFdsGlobalVariable.FixedLoadAddress = True
+            
+        if Options.quiet != None:
+            EdkLogger.SetLevel(EdkLogger.QUIET)
+        if Options.debug != None:
+            EdkLogger.SetLevel(Options.debug + 1)
+            GenFdsGlobalVariable.DebugLevel = Options.debug
+        else:
+            EdkLogger.SetLevel(EdkLogger.INFO)
+
+        if (Options.Workspace == None):
+            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "WORKSPACE not defined",
+                            ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
+        elif not os.path.exists(Options.Workspace):
+            EdkLogger.error("GenFds", BuildToolError.PARAMETER_INVALID, "WORKSPACE is invalid",
+                            ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")
+        else:
+            Workspace = os.path.normcase(Options.Workspace)
+            GenFdsGlobalVariable.WorkSpaceDir = Workspace
+            if 'EDK_SOURCE' in os.environ.keys():
+                GenFdsGlobalVariable.EdkSourceDir = os.path.normcase(os.environ['EDK_SOURCE'])
+            if (Options.debug):
+                GenFdsGlobalVariable.VerboseLogger( "Using Workspace:" + Workspace)
+        os.chdir(GenFdsGlobalVariable.WorkSpaceDir)
+
+        if (Options.filename):
+            FdfFilename = Options.filename
+            FdfFilename = GenFdsGlobalVariable.ReplaceWorkspaceMacro(FdfFilename)
+        else:
+            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "Missing FDF filename")
+
+        if (Options.BuildTarget):
+            GenFdsGlobalVariable.TargetName = Options.BuildTarget
+        else:
+            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "Missing build target")
+
+        if (Options.ToolChain):
+            GenFdsGlobalVariable.ToolChainTag = Options.ToolChain
+        else:
+            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "Missing tool chain tag")
+
+        if FdfFilename[0:2] == '..':
+            FdfFilename = os.path.realpath(FdfFilename)
+        if FdfFilename[1] != ':':
+            FdfFilename = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, FdfFilename)
+
+        if not os.path.exists(FdfFilename):
+            EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, ExtraData=FdfFilename)
+        GenFdsGlobalVariable.FdfFile = FdfFilename
+        GenFdsGlobalVariable.FdfFileTimeStamp = os.path.getmtime(FdfFilename)
+
+        if (Options.activePlatform):
+            ActivePlatform = Options.activePlatform
+            ActivePlatform = GenFdsGlobalVariable.ReplaceWorkspaceMacro(ActivePlatform)
+
+            if ActivePlatform[0:2] == '..':
+                ActivePlatform = os.path.realpath(ActivePlatform)
+
+            if ActivePlatform[1] != ':':
+                ActivePlatform = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, ActivePlatform)
+
+            if not os.path.exists(ActivePlatform)  :
+                EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, "ActivePlatform doesn't exist!")
+
+            if ActivePlatform.find(Workspace) == -1:
+                EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, "ActivePlatform doesn't exist in Workspace!")
+
+            ActivePlatform = ActivePlatform.replace(Workspace, '')
+            if len(ActivePlatform) > 0 :
+                if ActivePlatform[0] == '\\' or ActivePlatform[0] == '/':
+                    ActivePlatform = ActivePlatform[1:]
+            else:
+                EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, "ActivePlatform doesn't exist!")
+        else :
+            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "Missing active platform")
+
+        GenFdsGlobalVariable.ActivePlatform = PathClass(NormPath(ActivePlatform), Workspace)
+
+        BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.WorkSpaceDir, "Conf/target.txt"))
+        if os.path.isfile(BuildConfigurationFile) == True:
+            TargetTxtClassObject.TargetTxtClassObject(BuildConfigurationFile)
+        else:
+            EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)
+
+        if Options.Macros:
+            for Pair in Options.Macros:
+                Pair.strip('"')
+                List = Pair.split('=')
+                if len(List) == 2:
+                    FdfParser.InputMacroDict[List[0].strip()] = List[1].strip()
+                    if List[0].strip() == "EFI_SOURCE":
+                        GlobalData.gEfiSource = List[1].strip()
+                    elif List[0].strip() == "EDK_SOURCE":
+                        GlobalData.gEdkSource = List[1].strip()
+                    else:
+                        GlobalData.gEdkGlobal[List[0].strip()] = List[1].strip()
+                else:
+                    FdfParser.InputMacroDict[List[0].strip()] = None
+
+        """call Workspace build create database"""
+        os.environ["WORKSPACE"] = Workspace
+        BuildWorkSpace = WorkspaceDatabase(':memory:', GlobalData.gGlobalDefines)
+        BuildWorkSpace.InitDatabase()
+        
+        #
+        # Get files real name in workspace dir
+        #
+        GlobalData.gAllFiles = DirCache(Workspace)
+        GlobalData.gWorkspace = Workspace
+
+        if (Options.archList) :
+            ArchList = Options.archList.split(',')
+        else:
+#            EdkLogger.error("GenFds", BuildToolError.OPTION_MISSING, "Missing build ARCH")
+            ArchList = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList
+
+        TargetArchList = set(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList) & set(ArchList)
+        if len(TargetArchList) == 0:
+            EdkLogger.error("GenFds", GENFDS_ERROR, "Target ARCH %s not in platform supported ARCH %s" % (str(ArchList), str(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList)))
+        
+        for Arch in ArchList:
+            GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = NormPath(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch].OutputDirectory)
+
+        if (Options.outputDir):
+            OutputDirFromCommandLine = GenFdsGlobalVariable.ReplaceWorkspaceMacro(Options.outputDir)
+            for Arch in ArchList:
+                GenFdsGlobalVariable.OutputDirDict[Arch] = OutputDirFromCommandLine
+        else:
+            for Arch in ArchList:
+                GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.join(GenFdsGlobalVariable.OutputDirFromDscDict[Arch], GenFdsGlobalVariable.TargetName + '_' + GenFdsGlobalVariable.ToolChainTag)
+
+        for Key in GenFdsGlobalVariable.OutputDirDict:
+            OutputDir = GenFdsGlobalVariable.OutputDirDict[Key]
+            if OutputDir[0:2] == '..':
+                OutputDir = os.path.realpath(OutputDir)
+
+            if OutputDir[1] != ':':
+                OutputDir = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, OutputDir)
+
+            if not os.path.exists(OutputDir):
+                EdkLogger.error("GenFds", BuildToolError.FILE_NOT_FOUND, ExtraData=OutputDir)
+            GenFdsGlobalVariable.OutputDirDict[Key] = OutputDir
+
+        """ Parse Fdf file, has to place after build Workspace as FDF may contain macros from DSC file """
+        FdfParserObj = FdfParser.FdfParser(FdfFilename)
+        FdfParserObj.ParseFile()
+
+        if FdfParserObj.CycleReferenceCheck():
+            EdkLogger.error("GenFds", BuildToolError.FORMAT_NOT_SUPPORTED, "Cycle Reference Detected in FDF file")
+
+        if (Options.uiFdName) :
+            if Options.uiFdName.upper() in FdfParserObj.Profile.FdDict.keys():
+                GenFds.OnlyGenerateThisFd = Options.uiFdName
+            else:
+                EdkLogger.error("GenFds", BuildToolError.OPTION_VALUE_INVALID,
+                                "No such an FD in FDF file: %s" % Options.uiFdName)
+
+        if (Options.uiFvName) :
+            if Options.uiFvName.upper() in FdfParserObj.Profile.FvDict.keys():
+                GenFds.OnlyGenerateThisFv = Options.uiFvName
+            else:
+                EdkLogger.error("GenFds", BuildToolError.OPTION_VALUE_INVALID,
+                                "No such an FV in FDF file: %s" % Options.uiFvName)
+
+        """Modify images from build output if the feature of loading driver at fixed address is on."""
+        if GenFdsGlobalVariable.FixedLoadAddress:
+            GenFds.PreprocessImage(BuildWorkSpace, GenFdsGlobalVariable.ActivePlatform)
+        """Call GenFds"""
+        GenFds.GenFd('', FdfParserObj, BuildWorkSpace, ArchList)
+        
+        """Display FV space info."""
+        GenFds.DisplayFvSpaceInfo(FdfParserObj)
+        
+    except FdfParser.Warning, X:
+        EdkLogger.error(X.ToolName, BuildToolError.FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError = False)
+        ReturnCode = BuildToolError.FORMAT_INVALID
+    except FatalError, X:
+        if Options.debug != None:
+            import traceback
+            EdkLogger.quiet(traceback.format_exc())
+        ReturnCode = X.args[0]
+    except:
+        import traceback
+        EdkLogger.error(
+                    "\nPython",
+                    CODE_ERROR,
+                    "Tools code failure",
+                    ExtraData="Please submit bug report in www.TianoCore.org, attaching following call stack trace!\n",
+                    RaiseError=False
+                    )
+        EdkLogger.quiet(traceback.format_exc())
+        ReturnCode = CODE_ERROR
+    return ReturnCode
+
+gParamCheck = []
+def SingleCheckCallback(option, opt_str, value, parser):
+    if option not in gParamCheck:
+        setattr(parser.values, option.dest, value)
+        gParamCheck.append(option)
+    else:
+        parser.error("Option %s only allows one instance in command line!" % option)
+        
+## Parse command line options
+#
+# Using standard Python module optparse to parse command line option of this tool.
+#
+#   @retval Opt   A optparse.Values object containing the parsed options
+#   @retval Args  Target of build command
+#
+def myOptionParser():
+    usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\""
+    Parser = OptionParser(usage=usage,description=__copyright__,version="%prog " + str(versionNumber))
+    Parser.add_option("-f", "--file", dest="filename", type="string", help="Name of FDF file to convert", action="callback", callback=SingleCheckCallback)
+    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")
+    Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")
+    Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed.")
+    Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")
+    Parser.add_option("-p", "--platform", type="string", dest="activePlatform", help="Set the ACTIVE_PLATFORM, overrides target.txt ACTIVE_PLATFORM setting.",
+                      action="callback", callback=SingleCheckCallback)
+    Parser.add_option("-w", "--workspace", type="string", dest="Workspace", default=os.environ.get('WORKSPACE'), help="Set the WORKSPACE",
+                      action="callback", callback=SingleCheckCallback)
+    Parser.add_option("-o", "--outputDir", type="string", dest="outputDir", help="Name of Build Output directory",
+                      action="callback", callback=SingleCheckCallback)
+    Parser.add_option("-r", "--rom_image", dest="uiFdName", help="Build the image using the [FD] section named by FdUiName.")
+    Parser.add_option("-i", "--FvImage", dest="uiFvName", help="Buld the FV image using the [FV] section named by UiFvName")
+    Parser.add_option("-b", "--buildtarget", type="choice", choices=['DEBUG','RELEASE'], dest="BuildTarget", help="Build TARGET is one of list: DEBUG, RELEASE.",
+                      action="callback", callback=SingleCheckCallback)
+    Parser.add_option("-t", "--tagname", type="string", dest="ToolChain", help="Using the tools: TOOL_CHAIN_TAG name to build the platform.",
+                      action="callback", callback=SingleCheckCallback)
+    Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")
+    Parser.add_option("-s", "--specifyaddress", dest="FixedAddress", action="store_true", type=None, help="Specify driver load address.")
+    (Options, args) = Parser.parse_args()
+    return Options
+
+## The class implementing the EDK2 flash image generation process
+#
+#   This process includes:
+#       1. Collect workspace information, includes platform and module information
+#       2. Call methods of Fd class to generate FD
+#       3. Call methods of Fv class to generate FV that not belong to FD
+#
+class GenFds :
+    FdfParsef = None
+    # FvName in FDF, FvBinFile name
+    FvBinDict = {}
+    OnlyGenerateThisFd = None
+    OnlyGenerateThisFv = None
+
+    ## GenFd()
+    #
+    #   @param  OutputDir           Output directory
+    #   @param  FdfParser           FDF contents parser
+    #   @param  Workspace           The directory of workspace
+    #   @param  ArchList            The Arch list of platform
+    #
+    def GenFd (OutputDir, FdfParser, WorkSpace, ArchList):
+        GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList)
+
+        GenFdsGlobalVariable.VerboseLogger("   Gen Fd  !")
+        if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
+            FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(GenFds.OnlyGenerateThisFd.upper())
+            if FdObj != None:
+                FdObj.GenFd(GenFds.FvBinDict)
+        elif GenFds.OnlyGenerateThisFv == None:
+            for FdName in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
+                FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[FdName]
+                FdObj.GenFd(GenFds.FvBinDict)
+
+        GenFdsGlobalVariable.VerboseLogger(" Gen FV ! ")
+        if GenFds.OnlyGenerateThisFv != None and GenFds.OnlyGenerateThisFv.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
+            FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(GenFds.OnlyGenerateThisFv.upper())
+            if FvObj != None:
+                Buffer = StringIO.StringIO()
+                # Get FV base Address
+                FvObj.AddToBuffer(Buffer, None, GenFds.GetFvBlockSize(FvObj))
+                Buffer.close()
+                return
+        elif GenFds.OnlyGenerateThisFd == None:
+            for FvName in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():
+                Buffer = StringIO.StringIO('')
+                FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[FvName]
+                # Get FV base Address
+                FvObj.AddToBuffer(Buffer, None, GenFds.GetFvBlockSize(FvObj))
+                Buffer.close()
+
+        if GenFds.OnlyGenerateThisFv == None and GenFds.OnlyGenerateThisFd == None:
+            GenFdsGlobalVariable.VerboseLogger(" Gen Capsule !")
+            for CapsuleObj in GenFdsGlobalVariable.FdfParser.Profile.CapsuleList:
+                CapsuleObj.GenCapsule()
+                
+            if GenFdsGlobalVariable.FdfParser.Profile.OptRomDict != {}:
+                GenFdsGlobalVariable.VerboseLogger(" Gen Option ROM !")
+                for DriverName in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.keys():
+                    OptRomObj = GenFdsGlobalVariable.FdfParser.Profile.OptRomDict[DriverName]
+                    OptRomObj.AddToBuffer(None)
+
+    ## GetFvBlockSize()
+    #
+    #   @param  FvObj           Whose block size to get
+    #   @retval int             Block size value
+    #
+    def GetFvBlockSize(FvObj):
+        DefaultBlockSize = 0x10000
+        FdObj = None
+        if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():
+            FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[GenFds.OnlyGenerateThisFd.upper()]
+        if FdObj == None:
+            for ElementFd in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():
+                for ElementRegion in ElementFd.RegionList:
+                    if ElementRegion.RegionType == 'FV':
+                        for ElementRegionData in ElementRegion.RegionDataList:
+                            if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
+                                if FvObj.BlockSizeList != []:
+                                    return FvObj.BlockSizeList[0][0]
+                                else:
+                                    return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
+            if FvObj.BlockSizeList != []:
+                return FvObj.BlockSizeList[0][0]
+            return DefaultBlockSize
+        else:
+            for ElementRegion in FdObj.RegionList:
+                    if ElementRegion.RegionType == 'FV':
+                        for ElementRegionData in ElementRegion.RegionDataList:
+                            if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:
+                                if FvObj.BlockSizeList != []:
+                                    return FvObj.BlockSizeList[0][0]
+                                else:
+                                    return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)
+            return DefaultBlockSize
+
+    ## DisplayFvSpaceInfo()
+    #
+    #   @param  FvObj           Whose block size to get
+    #   @retval None
+    #
+    def DisplayFvSpaceInfo(FdfParser):
+        
+        FvSpaceInfoList = []
+        MaxFvNameLength = 0
+        for FvName in FdfParser.Profile.FvDict:
+            if len(FvName) > MaxFvNameLength:
+                MaxFvNameLength = len(FvName)
+            FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map')
+            if os.path.exists(FvSpaceInfoFileName):
+                FileLinesList = linecache.getlines(FvSpaceInfoFileName)
+                TotalFound = False
+                Total = ''
+                UsedFound = False
+                Used = ''
+                FreeFound = False
+                Free = ''
+                for Line in FileLinesList:
+                    NameValue = Line.split('=')
+                    if len(NameValue) == 2:
+                        if NameValue[0].strip() == 'EFI_FV_TOTAL_SIZE':
+                            TotalFound = True
+                            Total = NameValue[1].strip()
+                        if NameValue[0].strip() == 'EFI_FV_TAKEN_SIZE':
+                            UsedFound = True
+                            Used = NameValue[1].strip()
+                        if NameValue[0].strip() == 'EFI_FV_SPACE_SIZE':
+                            FreeFound = True
+                            Free = NameValue[1].strip()
+                
+                if TotalFound and UsedFound and FreeFound:
+                    FvSpaceInfoList.append((FvName, Total, Used, Free))
+                
+        GenFdsGlobalVariable.InfLogger('\nFV Space Information')
+        for FvSpaceInfo in FvSpaceInfoList:
+            Name = FvSpaceInfo[0]
+            TotalSizeValue = long(FvSpaceInfo[1], 0)
+            UsedSizeValue = long(FvSpaceInfo[2], 0)
+            FreeSizeValue = long(FvSpaceInfo[3], 0)
+            GenFdsGlobalVariable.InfLogger(Name + ' ' + '[' + str((UsedSizeValue+0.0)/TotalSizeValue)[0:4].lstrip('0.') + '%Full] ' + str(TotalSizeValue) + ' total, ' + str(UsedSizeValue) + ' used, ' + str(FreeSizeValue) + ' free')
+
+    ## PreprocessImage()
+    #
+    #   @param  BuildDb         Database from build meta data files
+    #   @param  DscFile         modules from dsc file will be preprocessed
+    #   @retval None
+    #
+    def PreprocessImage(BuildDb, DscFile):
+        PcdDict = BuildDb.BuildObject[DscFile, 'COMMON'].Pcds
+        PcdValue = ''
+        for Key in PcdDict:
+            PcdObj = PcdDict[Key]
+            if PcdObj.TokenCName == 'PcdBsBaseAddress':
+                PcdValue = PcdObj.DefaultValue
+                break
+        
+        if PcdValue == '':
+            return
+        
+        Int64PcdValue = long(PcdValue, 0)
+        if Int64PcdValue == 0 or Int64PcdValue < -1:    
+            return
+                
+        TopAddress = 0
+        if Int64PcdValue > 0:
+            TopAddress = Int64PcdValue
+            
+        ModuleDict = BuildDb.BuildObject[DscFile, 'COMMON'].Modules
+        for Key in ModuleDict:
+            ModuleObj = BuildDb.BuildObject[Key, 'COMMON']
+            print ModuleObj.BaseName + ' ' + ModuleObj.ModuleType
+
+    ##Define GenFd as static function
+    GenFd = staticmethod(GenFd)
+    GetFvBlockSize = staticmethod(GetFvBlockSize)
+    DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo)
+    PreprocessImage = staticmethod(PreprocessImage)
+
+if __name__ == '__main__':
+    r = main()
+    ## 0-127 is a safe return range, and 1 is a standard default error
+    if r < 0 or r > 127: r = 1
+    sys.exit(r)
+