[mirror_edk2.git] / BaseTools / Source / Python / GenFds / GenFds.py

## @file\r
# generate flash image\r
#\r
#  Copyright (c) 2007 - 2017, Intel Corporation. All rights reserved.<BR>\r
#\r
#  This program and the accompanying materials\r
#  are licensed and made available under the terms and conditions of the BSD License\r
#  which accompanies this distribution.  The full text of the license may be found at\r
#  http://opensource.org/licenses/bsd-license.php\r
#\r
#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
##\r
# Import Modules\r
#\r
from optparse import OptionParser\r
import sys\r
import Common.LongFilePathOs as os\r
import linecache\r
import FdfParser\r
import Common.BuildToolError as BuildToolError\r
from GenFdsGlobalVariable import GenFdsGlobalVariable\r
from Workspace.WorkspaceDatabase import WorkspaceDatabase\r
from Workspace.BuildClassObject import PcdClassObject\r
from Workspace.BuildClassObject import ModuleBuildClassObject\r
import RuleComplexFile\r
from EfiSection import EfiSection\r
import StringIO\r
import Common.TargetTxtClassObject as TargetTxtClassObject\r
import Common.ToolDefClassObject as ToolDefClassObject\r
from Common.DataType import *\r
import Common.GlobalData as GlobalData\r
from Common import EdkLogger\r
from Common.String import *\r
from Common.Misc import DirCache, PathClass\r
from Common.Misc import SaveFileOnChange\r
from Common.Misc import ClearDuplicatedInf\r
from Common.Misc import GuidStructureStringToGuidString\r
from Common.Misc import CheckPcdDatum\r
from Common.BuildVersion import gBUILD_VERSION\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
\r
## Version and Copyright\r
versionNumber = "1.0" + ' ' + gBUILD_VERSION\r
__version__ = "%prog Version " + versionNumber\r
__copyright__ = "Copyright (c) 2007 - 2017, Intel Corporation  All rights reserved."\r
\r
## Tool entrance method\r
#\r
# This method mainly dispatch specific methods per the command line options.\r
# If no error found, return zero value so the caller of this tool can know\r
# if it's executed successfully or not.\r
#\r
#   @retval 0     Tool was successful\r
#   @retval 1     Tool failed\r
#\r
def main():\r
    global Options\r
    Options = myOptionParser()\r
\r
    global Workspace\r
    Workspace = ""\r
    ArchList = None\r
    ReturnCode = 0\r
\r
    EdkLogger.Initialize()\r
    try:\r
        if Options.verbose != None:\r
            EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
            GenFdsGlobalVariable.VerboseMode = True\r
            \r
        if Options.FixedAddress != None:\r
            GenFdsGlobalVariable.FixedLoadAddress = True\r
            \r
        if Options.quiet != None:\r
            EdkLogger.SetLevel(EdkLogger.QUIET)\r
        if Options.debug != None:\r
            EdkLogger.SetLevel(Options.debug + 1)\r
            GenFdsGlobalVariable.DebugLevel = Options.debug\r
        else:\r
            EdkLogger.SetLevel(EdkLogger.INFO)\r
\r
        if (Options.Workspace == None):\r
            EdkLogger.error("GenFds", OPTION_MISSING, "WORKSPACE not defined",\r
                            ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")\r
        elif not os.path.exists(Options.Workspace):\r
            EdkLogger.error("GenFds", PARAMETER_INVALID, "WORKSPACE is invalid",\r
                            ExtraData="Please use '-w' switch to pass it or set the WORKSPACE environment variable.")\r
        else:\r
            Workspace = os.path.normcase(Options.Workspace)\r
            GenFdsGlobalVariable.WorkSpaceDir = Workspace\r
            if 'EDK_SOURCE' in os.environ.keys():\r
                GenFdsGlobalVariable.EdkSourceDir = os.path.normcase(os.environ['EDK_SOURCE'])\r
            if (Options.debug):\r
                GenFdsGlobalVariable.VerboseLogger("Using Workspace:" + Workspace)\r
        os.chdir(GenFdsGlobalVariable.WorkSpaceDir)\r
        \r
        # set multiple workspace\r
        PackagesPath = os.getenv("PACKAGES_PATH")\r
        mws.setWs(GenFdsGlobalVariable.WorkSpaceDir, PackagesPath)\r
\r
        if (Options.filename):\r
            FdfFilename = Options.filename\r
            FdfFilename = GenFdsGlobalVariable.ReplaceWorkspaceMacro(FdfFilename)\r
\r
            if FdfFilename[0:2] == '..':\r
                FdfFilename = os.path.realpath(FdfFilename)\r
            if not os.path.isabs(FdfFilename):\r
                FdfFilename = mws.join(GenFdsGlobalVariable.WorkSpaceDir, FdfFilename)\r
            if not os.path.exists(FdfFilename):\r
                EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=FdfFilename)\r
\r
            GenFdsGlobalVariable.FdfFile = FdfFilename\r
            GenFdsGlobalVariable.FdfFileTimeStamp = os.path.getmtime(FdfFilename)\r
        else:\r
            EdkLogger.error("GenFds", OPTION_MISSING, "Missing FDF filename")\r
\r
        if (Options.BuildTarget):\r
            GenFdsGlobalVariable.TargetName = Options.BuildTarget\r
\r
        if (Options.ToolChain):\r
            GenFdsGlobalVariable.ToolChainTag = Options.ToolChain\r
\r
        if (Options.activePlatform):\r
            ActivePlatform = Options.activePlatform\r
            ActivePlatform = GenFdsGlobalVariable.ReplaceWorkspaceMacro(ActivePlatform)\r
\r
            if ActivePlatform[0:2] == '..':\r
                ActivePlatform = os.path.realpath(ActivePlatform)\r
\r
            if not os.path.isabs (ActivePlatform):\r
                ActivePlatform = mws.join(GenFdsGlobalVariable.WorkSpaceDir, ActivePlatform)\r
\r
            if not os.path.exists(ActivePlatform)  :\r
                EdkLogger.error("GenFds", FILE_NOT_FOUND, "ActivePlatform doesn't exist!")\r
        else:\r
            EdkLogger.error("GenFds", OPTION_MISSING, "Missing active platform")\r
\r
        GenFdsGlobalVariable.ActivePlatform = PathClass(NormPath(ActivePlatform))\r
\r
        if (Options.ConfDirectory):\r
            # Get alternate Conf location, if it is absolute, then just use the absolute directory name\r
            ConfDirectoryPath = os.path.normpath(Options.ConfDirectory)\r
            if ConfDirectoryPath.startswith('"'):\r
                ConfDirectoryPath = ConfDirectoryPath[1:]\r
            if ConfDirectoryPath.endswith('"'):\r
                ConfDirectoryPath = ConfDirectoryPath[:-1]\r
            if not os.path.isabs(ConfDirectoryPath):\r
                # Since alternate directory name is not absolute, the alternate directory is located within the WORKSPACE\r
                # This also handles someone specifying the Conf directory in the workspace. Using --conf=Conf\r
                ConfDirectoryPath = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, ConfDirectoryPath)\r
        else:\r
            if "CONF_PATH" in os.environ.keys():\r
                ConfDirectoryPath = os.path.normcase(os.environ["CONF_PATH"])\r
            else:\r
                # Get standard WORKSPACE/Conf, use the absolute path to the WORKSPACE/Conf\r
                ConfDirectoryPath = mws.join(GenFdsGlobalVariable.WorkSpaceDir, 'Conf')\r
        GenFdsGlobalVariable.ConfDir = ConfDirectoryPath\r
        BuildConfigurationFile = os.path.normpath(os.path.join(ConfDirectoryPath, "target.txt"))\r
        if os.path.isfile(BuildConfigurationFile) == True:\r
            TargetTxt = TargetTxtClassObject.TargetTxtClassObject()\r
            TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
            # if no build target given in command line, get it from target.txt\r
            if not GenFdsGlobalVariable.TargetName:\r
                BuildTargetList = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TARGET]\r
                if len(BuildTargetList) != 1:\r
                    EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="Only allows one instance for Target.")\r
                GenFdsGlobalVariable.TargetName = BuildTargetList[0]\r
\r
            # if no tool chain given in command line, get it from target.txt\r
            if not GenFdsGlobalVariable.ToolChainTag:\r
                ToolChainList = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_TAG]\r
                if ToolChainList == None or len(ToolChainList) == 0:\r
                    EdkLogger.error("GenFds", RESOURCE_NOT_AVAILABLE, ExtraData="No toolchain given. Don't know how to build.")\r
                if len(ToolChainList) != 1:\r
                    EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="Only allows one instance for ToolChain.")\r
                GenFdsGlobalVariable.ToolChainTag = ToolChainList[0]\r
        else:\r
            EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=BuildConfigurationFile)\r
\r
        #Set global flag for build mode\r
        GlobalData.gIgnoreSource = Options.IgnoreSources\r
\r
        if Options.Macros:\r
            for Pair in Options.Macros:\r
                if Pair.startswith('"'):\r
                    Pair = Pair[1:]\r
                if Pair.endswith('"'):\r
                    Pair = Pair[:-1]\r
                List = Pair.split('=')\r
                if len(List) == 2:\r
                    if not List[1].strip():\r
                        EdkLogger.error("GenFds", OPTION_VALUE_INVALID, ExtraData="No Value given for Macro %s" %List[0])\r
                    if List[0].strip() == "EFI_SOURCE":\r
                        GlobalData.gEfiSource = List[1].strip()\r
                        GlobalData.gGlobalDefines["EFI_SOURCE"] = GlobalData.gEfiSource\r
                        continue\r
                    elif List[0].strip() == "EDK_SOURCE":\r
                        GlobalData.gEdkSource = List[1].strip()\r
                        GlobalData.gGlobalDefines["EDK_SOURCE"] = GlobalData.gEdkSource\r
                        continue\r
                    elif List[0].strip() in ["WORKSPACE", "TARGET", "TOOLCHAIN"]:\r
                        GlobalData.gGlobalDefines[List[0].strip()] = List[1].strip()\r
                    else:\r
                        GlobalData.gCommandLineDefines[List[0].strip()] = List[1].strip()\r
                else:\r
                    GlobalData.gCommandLineDefines[List[0].strip()] = "TRUE"\r
        os.environ["WORKSPACE"] = Workspace\r
\r
        # Use the -t and -b option as gGlobalDefines's TOOLCHAIN and TARGET if they are not defined\r
        if "TARGET" not in GlobalData.gGlobalDefines.keys():\r
            GlobalData.gGlobalDefines["TARGET"] = GenFdsGlobalVariable.TargetName\r
        if "TOOLCHAIN" not in GlobalData.gGlobalDefines.keys():\r
            GlobalData.gGlobalDefines["TOOLCHAIN"] = GenFdsGlobalVariable.ToolChainTag\r
        if "TOOL_CHAIN_TAG" not in GlobalData.gGlobalDefines.keys():\r
            GlobalData.gGlobalDefines['TOOL_CHAIN_TAG'] = GenFdsGlobalVariable.ToolChainTag\r
\r
        """call Workspace build create database"""\r
        GlobalData.gDatabasePath = os.path.normpath(os.path.join(ConfDirectoryPath, GlobalData.gDatabasePath))\r
        BuildWorkSpace = WorkspaceDatabase(GlobalData.gDatabasePath)\r
        BuildWorkSpace.InitDatabase()\r
        \r
        #\r
        # Get files real name in workspace dir\r
        #\r
        GlobalData.gAllFiles = DirCache(Workspace)\r
        GlobalData.gWorkspace = Workspace\r
\r
        if (Options.archList) :\r
            ArchList = Options.archList.split(',')\r
        else:\r
#            EdkLogger.error("GenFds", OPTION_MISSING, "Missing build ARCH")\r
            ArchList = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON', Options.BuildTarget, Options.ToolChain].SupArchList\r
\r
        TargetArchList = set(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON', Options.BuildTarget, Options.ToolChain].SupArchList) & set(ArchList)\r
        if len(TargetArchList) == 0:\r
            EdkLogger.error("GenFds", GENFDS_ERROR, "Target ARCH %s not in platform supported ARCH %s" % (str(ArchList), str(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, 'COMMON'].SupArchList)))\r
        \r
        for Arch in ArchList:\r
            GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = NormPath(BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].OutputDirectory)\r
            GenFdsGlobalVariable.PlatformName = BuildWorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, Options.BuildTarget, Options.ToolChain].PlatformName\r
\r
        if (Options.outputDir):\r
            OutputDirFromCommandLine = GenFdsGlobalVariable.ReplaceWorkspaceMacro(Options.outputDir)\r
            if not os.path.isabs (OutputDirFromCommandLine):\r
                OutputDirFromCommandLine = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, OutputDirFromCommandLine)\r
            for Arch in ArchList:\r
                GenFdsGlobalVariable.OutputDirDict[Arch] = OutputDirFromCommandLine\r
        else:\r
            for Arch in ArchList:\r
                GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.join(GenFdsGlobalVariable.OutputDirFromDscDict[Arch], GenFdsGlobalVariable.TargetName + '_' + GenFdsGlobalVariable.ToolChainTag)\r
\r
        for Key in GenFdsGlobalVariable.OutputDirDict:\r
            OutputDir = GenFdsGlobalVariable.OutputDirDict[Key]\r
            if OutputDir[0:2] == '..':\r
                OutputDir = os.path.realpath(OutputDir)\r
\r
            if OutputDir[1] != ':':\r
                OutputDir = os.path.join (GenFdsGlobalVariable.WorkSpaceDir, OutputDir)\r
\r
            if not os.path.exists(OutputDir):\r
                EdkLogger.error("GenFds", FILE_NOT_FOUND, ExtraData=OutputDir)\r
            GenFdsGlobalVariable.OutputDirDict[Key] = OutputDir\r
\r
        """ Parse Fdf file, has to place after build Workspace as FDF may contain macros from DSC file """\r
        FdfParserObj = FdfParser.FdfParser(FdfFilename)\r
        FdfParserObj.ParseFile()\r
\r
        if FdfParserObj.CycleReferenceCheck():\r
            EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Cycle Reference Detected in FDF file")\r
\r
        if (Options.uiFdName) :\r
            if Options.uiFdName.upper() in FdfParserObj.Profile.FdDict.keys():\r
                GenFds.OnlyGenerateThisFd = Options.uiFdName\r
            else:\r
                EdkLogger.error("GenFds", OPTION_VALUE_INVALID,\r
                                "No such an FD in FDF file: %s" % Options.uiFdName)\r
\r
        if (Options.uiFvName) :\r
            if Options.uiFvName.upper() in FdfParserObj.Profile.FvDict.keys():\r
                GenFds.OnlyGenerateThisFv = Options.uiFvName\r
            else:\r
                EdkLogger.error("GenFds", OPTION_VALUE_INVALID,\r
                                "No such an FV in FDF file: %s" % Options.uiFvName)\r
\r
        if (Options.uiCapName) :\r
            if Options.uiCapName.upper() in FdfParserObj.Profile.CapsuleDict.keys():\r
                GenFds.OnlyGenerateThisCap = Options.uiCapName\r
            else:\r
                EdkLogger.error("GenFds", OPTION_VALUE_INVALID,\r
                                "No such a Capsule in FDF file: %s" % Options.uiCapName)\r
\r
        GenFdsGlobalVariable.WorkSpace = BuildWorkSpace\r
        if ArchList != None:\r
            GenFdsGlobalVariable.ArchList = ArchList\r
\r
        if Options.OptionPcd:\r
            GlobalData.BuildOptionPcd = Options.OptionPcd\r
            CheckBuildOptionPcd()\r
\r
        """Modify images from build output if the feature of loading driver at fixed address is on."""\r
        if GenFdsGlobalVariable.FixedLoadAddress:\r
            GenFds.PreprocessImage(BuildWorkSpace, GenFdsGlobalVariable.ActivePlatform)\r
\r
        # Record the FV Region info that may specific in the FD\r
        if FdfParserObj.Profile.FvDict and FdfParserObj.Profile.FdDict:\r
            for Fv in FdfParserObj.Profile.FvDict:\r
                FvObj = FdfParserObj.Profile.FvDict[Fv]\r
                for Fd in FdfParserObj.Profile.FdDict:\r
                    FdObj = FdfParserObj.Profile.FdDict[Fd]\r
                    for RegionObj in FdObj.RegionList:\r
                        if RegionObj.RegionType != 'FV':\r
                            continue\r
                        for RegionData in RegionObj.RegionDataList:\r
                            if FvObj.UiFvName.upper() == RegionData.upper():\r
                                if FvObj.FvRegionInFD:\r
                                    if FvObj.FvRegionInFD != RegionObj.Size:\r
                                        EdkLogger.error("GenFds", FORMAT_INVALID, "The FV %s's region is specified in multiple FD with different value." %FvObj.UiFvName)\r
                                else:\r
                                    FvObj.FvRegionInFD = RegionObj.Size\r
                                    RegionObj.BlockInfoOfRegion(FdObj.BlockSizeList, FvObj)\r
\r
        """Call GenFds"""\r
        GenFds.GenFd('', FdfParserObj, BuildWorkSpace, ArchList)\r
\r
        """Generate GUID cross reference file"""\r
        GenFds.GenerateGuidXRefFile(BuildWorkSpace, ArchList)\r
\r
        """Display FV space info."""\r
        GenFds.DisplayFvSpaceInfo(FdfParserObj)\r
\r
    except FdfParser.Warning, X:\r
        EdkLogger.error(X.ToolName, FORMAT_INVALID, File=X.FileName, Line=X.LineNumber, ExtraData=X.Message, RaiseError=False)\r
        ReturnCode = FORMAT_INVALID\r
    except FatalError, X:\r
        if Options.debug != None:\r
            import traceback\r
            EdkLogger.quiet(traceback.format_exc())\r
        ReturnCode = X.args[0]\r
    except:\r
        import traceback\r
        EdkLogger.error(\r
                    "\nPython",\r
                    CODE_ERROR,\r
                    "Tools code failure",\r
                    ExtraData="Please send email to edk2-devel@lists.01.org for help, attaching following call stack trace!\n",\r
                    RaiseError=False\r
                    )\r
        EdkLogger.quiet(traceback.format_exc())\r
        ReturnCode = CODE_ERROR\r
    finally:\r
        ClearDuplicatedInf()\r
    return ReturnCode\r
\r
gParamCheck = []\r
def SingleCheckCallback(option, opt_str, value, parser):\r
    if option not in gParamCheck:\r
        setattr(parser.values, option.dest, value)\r
        gParamCheck.append(option)\r
    else:\r
        parser.error("Option %s only allows one instance in command line!" % option)\r
\r
def CheckBuildOptionPcd():\r
    for Arch in GenFdsGlobalVariable.ArchList:\r
        PkgList  = GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag)\r
        for i, pcd in enumerate(GlobalData.BuildOptionPcd):\r
            if type(pcd) is tuple:\r
                continue\r
            (pcdname, pcdvalue) = pcd.split('=')\r
            if not pcdvalue:\r
                EdkLogger.error('GenFds', OPTION_MISSING, "No Value specified for the PCD %s." % (pcdname))\r
            if '.' in pcdname:\r
                (TokenSpaceGuidCName, TokenCName) = pcdname.split('.')\r
                HasTokenSpace = True\r
            else:\r
                TokenCName = pcdname\r
                TokenSpaceGuidCName = ''\r
                HasTokenSpace = False\r
            TokenSpaceGuidCNameList = []\r
            FoundFlag = False\r
            PcdDatumType = ''\r
            NewValue = ''\r
            for package in PkgList:\r
                for key in package.Pcds:\r
                    PcdItem = package.Pcds[key]\r
                    if HasTokenSpace:\r
                        if (PcdItem.TokenCName, PcdItem.TokenSpaceGuidCName) == (TokenCName, TokenSpaceGuidCName):\r
                            PcdDatumType = PcdItem.DatumType\r
                            NewValue = BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, pcdvalue)\r
                            FoundFlag = True\r
                    else:\r
                        if PcdItem.TokenCName == TokenCName:\r
                            if not PcdItem.TokenSpaceGuidCName in TokenSpaceGuidCNameList:\r
                                if len (TokenSpaceGuidCNameList) < 1:\r
                                    TokenSpaceGuidCNameList.append(PcdItem.TokenSpaceGuidCName)\r
                                    PcdDatumType = PcdItem.DatumType\r
                                    TokenSpaceGuidCName = PcdItem.TokenSpaceGuidCName\r
                                    NewValue = BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, pcdvalue)\r
                                    FoundFlag = True\r
                                else:\r
                                    EdkLogger.error(\r
                                            'GenFds',\r
                                            PCD_VALIDATION_INFO_ERROR,\r
                                            "The Pcd %s is found under multiple different TokenSpaceGuid: %s and %s." % (TokenCName, PcdItem.TokenSpaceGuidCName, TokenSpaceGuidCNameList[0])\r
                                            )\r
\r
            GlobalData.BuildOptionPcd[i] = (TokenSpaceGuidCName, TokenCName, NewValue)\r
\r
def BuildOptionPcdValueFormat(TokenSpaceGuidCName, TokenCName, PcdDatumType, Value):\r
    if PcdDatumType == 'VOID*':\r
        if Value.startswith('L'):\r
            if not Value[1]:\r
                EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')\r
            Value = Value[0] + '"' + Value[1:] + '"'\r
        elif Value.startswith('B'):\r
            if not Value[1]:\r
                EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')\r
            Value = Value[1:]\r
        else:\r
            if not Value[0]:\r
                EdkLogger.error('GenFds', OPTION_VALUE_INVALID, 'For Void* type PCD, when specify the Value in the command line, please use the following format: "string", L"string", B"{...}"')\r
            Value = '"' + Value + '"'\r
\r
    IsValid, Cause = CheckPcdDatum(PcdDatumType, Value)\r
    if not IsValid:\r
        EdkLogger.error('build', FORMAT_INVALID, Cause, ExtraData="%s.%s" % (TokenSpaceGuidCName, TokenCName))\r
    if PcdDatumType == 'BOOLEAN':\r
        Value = Value.upper()\r
        if Value == 'TRUE' or Value == '1':\r
            Value = '1'\r
        elif Value == 'FALSE' or Value == '0':\r
            Value = '0'\r
    return  Value\r
\r
## FindExtendTool()\r
#\r
#  Find location of tools to process data\r
#\r
#  @param  KeyStringList    Filter for inputs of section generation\r
#  @param  CurrentArchList  Arch list\r
#  @param  NameGuid         The Guid name\r
#\r
def FindExtendTool(KeyStringList, CurrentArchList, NameGuid):\r
    ToolDb = ToolDefClassObject.ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDatabase\r
    # if user not specify filter, try to deduce it from global data.\r
    if KeyStringList == None or KeyStringList == []:\r
        Target = GenFdsGlobalVariable.TargetName\r
        ToolChain = GenFdsGlobalVariable.ToolChainTag\r
        if ToolChain not in ToolDb['TOOL_CHAIN_TAG']:\r
            EdkLogger.error("GenFds", GENFDS_ERROR, "Can not find external tool because tool tag %s is not defined in tools_def.txt!" % ToolChain)\r
        KeyStringList = [Target + '_' + ToolChain + '_' + CurrentArchList[0]]\r
        for Arch in CurrentArchList:\r
            if Target + '_' + ToolChain + '_' + Arch not in KeyStringList:\r
                KeyStringList.append(Target + '_' + ToolChain + '_' + Arch)\r
\r
    if GenFdsGlobalVariable.GuidToolDefinition:\r
        if NameGuid in GenFdsGlobalVariable.GuidToolDefinition.keys():\r
            return GenFdsGlobalVariable.GuidToolDefinition[NameGuid]\r
\r
    ToolDefinition = ToolDefClassObject.ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDictionary\r
    ToolPathTmp = None\r
    ToolOption = None\r
    ToolPathKey = None\r
    ToolOptionKey = None\r
    KeyList = None\r
    for ToolDef in ToolDefinition.items():\r
        if NameGuid == ToolDef[1]:\r
            KeyList = ToolDef[0].split('_')\r
            Key = KeyList[0] + \\r
                  '_' + \\r
                  KeyList[1] + \\r
                  '_' + \\r
                  KeyList[2]\r
            if Key in KeyStringList and KeyList[4] == 'GUID':\r
                ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'\r
                ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'\r
                ToolPath = ToolDefinition.get(ToolPathKey)\r
                ToolOption = ToolDefinition.get(ToolOptionKey)\r
                if ToolPathTmp == None:\r
                    ToolPathTmp = ToolPath\r
                else:\r
                    if ToolPathTmp != ToolPath:\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "Don't know which tool to use, %s or %s ?" % (ToolPathTmp, ToolPath))\r
\r
    BuildOption = {}\r
    for Arch in CurrentArchList:\r
        Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
        # key is (ToolChainFamily, ToolChain, CodeBase)\r
        for item in Platform.BuildOptions:\r
            if '_PATH' in item[1] or '_FLAGS' in item[1] or '_GUID' in item[1]:\r
                if not item[0] or (item[0] and GenFdsGlobalVariable.ToolChainFamily== item[0]):\r
                    if item[1] not in BuildOption:\r
                        BuildOption[item[1]] = Platform.BuildOptions[item]\r
        if BuildOption:\r
            ToolList = [TAB_TOD_DEFINES_TARGET, TAB_TOD_DEFINES_TOOL_CHAIN_TAG, TAB_TOD_DEFINES_TARGET_ARCH]\r
            for Index in range(2, -1, -1):\r
                for Key in dict(BuildOption):\r
                    List = Key.split('_')\r
                    if List[Index] == '*':\r
                        for String in ToolDb[ToolList[Index]]:\r
                            if String in [Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]:\r
                                List[Index] = String\r
                                NewKey = '%s_%s_%s_%s_%s' % tuple(List)\r
                                if NewKey not in BuildOption:\r
                                    BuildOption[NewKey] = BuildOption[Key]\r
                                    continue\r
                                del BuildOption[Key]\r
                    elif List[Index] not in ToolDb[ToolList[Index]]:\r
                        del BuildOption[Key]\r
    if BuildOption:\r
        if not KeyList:\r
            for Op in BuildOption:\r
                if NameGuid == BuildOption[Op]:\r
                    KeyList = Op.split('_')\r
                    Key = KeyList[0] + '_' + KeyList[1] +'_' + KeyList[2]\r
                    if Key in KeyStringList and KeyList[4] == 'GUID':\r
                        ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'\r
                        ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'\r
        if ToolPathKey in BuildOption.keys():\r
            ToolPathTmp = BuildOption.get(ToolPathKey)\r
        if ToolOptionKey in BuildOption.keys():\r
            ToolOption = BuildOption.get(ToolOptionKey)\r
\r
    GenFdsGlobalVariable.GuidToolDefinition[NameGuid] = (ToolPathTmp, ToolOption)\r
    return ToolPathTmp, ToolOption\r
\r
## Parse command line options\r
#\r
# Using standard Python module optparse to parse command line option of this tool.\r
#\r
#   @retval Opt   A optparse.Values object containing the parsed options\r
#   @retval Args  Target of build command\r
#\r
def myOptionParser():\r
    usage = "%prog [options] -f input_file -a arch_list -b build_target -p active_platform -t tool_chain_tag -D \"MacroName [= MacroValue]\""\r
    Parser = OptionParser(usage=usage, description=__copyright__, version="%prog " + str(versionNumber))\r
    Parser.add_option("-f", "--file", dest="filename", type="string", help="Name of FDF file to convert", action="callback", callback=SingleCheckCallback)\r
    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")\r
    Parser.add_option("-q", "--quiet", action="store_true", type=None, help="Disable all messages except FATAL ERRORS.")\r
    Parser.add_option("-v", "--verbose", action="store_true", type=None, help="Turn on verbose output with informational messages printed.")\r
    Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
    Parser.add_option("-p", "--platform", type="string", dest="activePlatform", help="Set the ACTIVE_PLATFORM, overrides target.txt ACTIVE_PLATFORM setting.",\r
                      action="callback", callback=SingleCheckCallback)\r
    Parser.add_option("-w", "--workspace", type="string", dest="Workspace", default=os.environ.get('WORKSPACE'), help="Set the WORKSPACE",\r
                      action="callback", callback=SingleCheckCallback)\r
    Parser.add_option("-o", "--outputDir", type="string", dest="outputDir", help="Name of Build Output directory",\r
                      action="callback", callback=SingleCheckCallback)\r
    Parser.add_option("-r", "--rom_image", dest="uiFdName", help="Build the image using the [FD] section named by FdUiName.")\r
    Parser.add_option("-i", "--FvImage", dest="uiFvName", help="Build the FV image using the [FV] section named by UiFvName")\r
    Parser.add_option("-C", "--CapsuleImage", dest="uiCapName", help="Build the Capsule image using the [Capsule] section named by UiCapName")\r
    Parser.add_option("-b", "--buildtarget", type="string", dest="BuildTarget", help="Set the build TARGET, overrides target.txt TARGET setting.",\r
                      action="callback", callback=SingleCheckCallback)\r
    Parser.add_option("-t", "--tagname", type="string", dest="ToolChain", help="Using the tools: TOOL_CHAIN_TAG name to build the platform.",\r
                      action="callback", callback=SingleCheckCallback)\r
    Parser.add_option("-D", "--define", action="append", type="string", dest="Macros", help="Macro: \"Name [= Value]\".")\r
    Parser.add_option("-s", "--specifyaddress", dest="FixedAddress", action="store_true", type=None, help="Specify driver load address.")\r
    Parser.add_option("--conf", action="store", type="string", dest="ConfDirectory", help="Specify the customized Conf directory.")\r
    Parser.add_option("--ignore-sources", action="store_true", dest="IgnoreSources", default=False, help="Focus to a binary build and ignore all source files")\r
    Parser.add_option("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")\r
\r
    (Options, args) = Parser.parse_args()\r
    return Options\r
\r
## The class implementing the EDK2 flash image generation process\r
#\r
#   This process includes:\r
#       1. Collect workspace information, includes platform and module information\r
#       2. Call methods of Fd class to generate FD\r
#       3. Call methods of Fv class to generate FV that not belong to FD\r
#\r
class GenFds :\r
    FdfParsef = None\r
    # FvName, FdName, CapName in FDF, Image file name\r
    ImageBinDict = {}\r
    OnlyGenerateThisFd = None\r
    OnlyGenerateThisFv = None\r
    OnlyGenerateThisCap = None\r
\r
    ## GenFd()\r
    #\r
    #   @param  OutputDir           Output directory\r
    #   @param  FdfParser           FDF contents parser\r
    #   @param  Workspace           The directory of workspace\r
    #   @param  ArchList            The Arch list of platform\r
    #\r
    def GenFd (OutputDir, FdfParser, WorkSpace, ArchList):\r
        GenFdsGlobalVariable.SetDir ('', FdfParser, WorkSpace, ArchList)\r
\r
        GenFdsGlobalVariable.VerboseLogger(" Generate all Fd images and their required FV and Capsule images!")\r
        if GenFds.OnlyGenerateThisCap != None and GenFds.OnlyGenerateThisCap.upper() in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():\r
            CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.get(GenFds.OnlyGenerateThisCap.upper())\r
            if CapsuleObj != None:\r
                CapsuleObj.GenCapsule()\r
                return\r
\r
        if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():\r
            FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict.get(GenFds.OnlyGenerateThisFd.upper())\r
            if FdObj != None:\r
                FdObj.GenFd()\r
                return\r
        elif GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisFv == None:\r
            for FdName in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():\r
                FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[FdName]\r
                FdObj.GenFd()\r
\r
        GenFdsGlobalVariable.VerboseLogger("\n Generate other FV images! ")\r
        if GenFds.OnlyGenerateThisFv != None and GenFds.OnlyGenerateThisFv.upper() in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():\r
            FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict.get(GenFds.OnlyGenerateThisFv.upper())\r
            if FvObj != None:\r
                Buffer = StringIO.StringIO()\r
                FvObj.AddToBuffer(Buffer)\r
                Buffer.close()\r
                return\r
        elif GenFds.OnlyGenerateThisFv == None:\r
            for FvName in GenFdsGlobalVariable.FdfParser.Profile.FvDict.keys():\r
                Buffer = StringIO.StringIO('')\r
                FvObj = GenFdsGlobalVariable.FdfParser.Profile.FvDict[FvName]\r
                FvObj.AddToBuffer(Buffer)\r
                Buffer.close()\r
        \r
        if GenFds.OnlyGenerateThisFv == None and GenFds.OnlyGenerateThisFd == None and GenFds.OnlyGenerateThisCap == None:\r
            if GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict != {}:\r
                GenFdsGlobalVariable.VerboseLogger("\n Generate other Capsule images!")\r
                for CapsuleName in GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict.keys():\r
                    CapsuleObj = GenFdsGlobalVariable.FdfParser.Profile.CapsuleDict[CapsuleName]\r
                    CapsuleObj.GenCapsule()\r
\r
            if GenFdsGlobalVariable.FdfParser.Profile.OptRomDict != {}:\r
                GenFdsGlobalVariable.VerboseLogger("\n Generate all Option ROM!")\r
                for DriverName in GenFdsGlobalVariable.FdfParser.Profile.OptRomDict.keys():\r
                    OptRomObj = GenFdsGlobalVariable.FdfParser.Profile.OptRomDict[DriverName]\r
                    OptRomObj.AddToBuffer(None)\r
\r
    ## GetFvBlockSize()\r
    #\r
    #   @param  FvObj           Whose block size to get\r
    #   @retval int             Block size value\r
    #\r
    def GetFvBlockSize(FvObj):\r
        DefaultBlockSize = 0x1\r
        FdObj = None\r
        if GenFds.OnlyGenerateThisFd != None and GenFds.OnlyGenerateThisFd.upper() in GenFdsGlobalVariable.FdfParser.Profile.FdDict.keys():\r
            FdObj = GenFdsGlobalVariable.FdfParser.Profile.FdDict[GenFds.OnlyGenerateThisFd.upper()]\r
        if FdObj == None:\r
            for ElementFd in GenFdsGlobalVariable.FdfParser.Profile.FdDict.values():\r
                for ElementRegion in ElementFd.RegionList:\r
                    if ElementRegion.RegionType == 'FV':\r
                        for ElementRegionData in ElementRegion.RegionDataList:\r
                            if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:\r
                                if FvObj.BlockSizeList != []:\r
                                    return FvObj.BlockSizeList[0][0]\r
                                else:\r
                                    return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)\r
            if FvObj.BlockSizeList != []:\r
                return FvObj.BlockSizeList[0][0]\r
            return DefaultBlockSize\r
        else:\r
            for ElementRegion in FdObj.RegionList:\r
                    if ElementRegion.RegionType == 'FV':\r
                        for ElementRegionData in ElementRegion.RegionDataList:\r
                            if ElementRegionData != None and ElementRegionData.upper() == FvObj.UiFvName:\r
                                if FvObj.BlockSizeList != []:\r
                                    return FvObj.BlockSizeList[0][0]\r
                                else:\r
                                    return ElementRegion.BlockSizeOfRegion(ElementFd.BlockSizeList)\r
            return DefaultBlockSize\r
\r
    ## DisplayFvSpaceInfo()\r
    #\r
    #   @param  FvObj           Whose block size to get\r
    #   @retval None\r
    #\r
    def DisplayFvSpaceInfo(FdfParser):\r
        \r
        FvSpaceInfoList = []\r
        MaxFvNameLength = 0\r
        for FvName in FdfParser.Profile.FvDict:\r
            if len(FvName) > MaxFvNameLength:\r
                MaxFvNameLength = len(FvName)\r
            FvSpaceInfoFileName = os.path.join(GenFdsGlobalVariable.FvDir, FvName.upper() + '.Fv.map')\r
            if os.path.exists(FvSpaceInfoFileName):\r
                FileLinesList = linecache.getlines(FvSpaceInfoFileName)\r
                TotalFound = False\r
                Total = ''\r
                UsedFound = False\r
                Used = ''\r
                FreeFound = False\r
                Free = ''\r
                for Line in FileLinesList:\r
                    NameValue = Line.split('=')\r
                    if len(NameValue) == 2:\r
                        if NameValue[0].strip() == 'EFI_FV_TOTAL_SIZE':\r
                            TotalFound = True\r
                            Total = NameValue[1].strip()\r
                        if NameValue[0].strip() == 'EFI_FV_TAKEN_SIZE':\r
                            UsedFound = True\r
                            Used = NameValue[1].strip()\r
                        if NameValue[0].strip() == 'EFI_FV_SPACE_SIZE':\r
                            FreeFound = True\r
                            Free = NameValue[1].strip()\r
                \r
                if TotalFound and UsedFound and FreeFound:\r
                    FvSpaceInfoList.append((FvName, Total, Used, Free))\r
                \r
        GenFdsGlobalVariable.InfLogger('\nFV Space Information')\r
        for FvSpaceInfo in FvSpaceInfoList:\r
            Name = FvSpaceInfo[0]\r
            TotalSizeValue = long(FvSpaceInfo[1], 0)\r
            UsedSizeValue = long(FvSpaceInfo[2], 0)\r
            FreeSizeValue = long(FvSpaceInfo[3], 0)\r
            if UsedSizeValue == TotalSizeValue:\r
                Percentage = '100'\r
            else:\r
                Percentage = str((UsedSizeValue + 0.0) / TotalSizeValue)[0:4].lstrip('0.')\r
\r
            GenFdsGlobalVariable.InfLogger(Name + ' ' + '[' + Percentage + '%Full] ' + str(TotalSizeValue) + ' total, ' + str(UsedSizeValue) + ' used, ' + str(FreeSizeValue) + ' free')\r
\r
    ## PreprocessImage()\r
    #\r
    #   @param  BuildDb         Database from build meta data files\r
    #   @param  DscFile         modules from dsc file will be preprocessed\r
    #   @retval None\r
    #\r
    def PreprocessImage(BuildDb, DscFile):\r
        PcdDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Pcds\r
        PcdValue = ''\r
        for Key in PcdDict:\r
            PcdObj = PcdDict[Key]\r
            if PcdObj.TokenCName == 'PcdBsBaseAddress':\r
                PcdValue = PcdObj.DefaultValue\r
                break\r
        \r
        if PcdValue == '':\r
            return\r
        \r
        Int64PcdValue = long(PcdValue, 0)\r
        if Int64PcdValue == 0 or Int64PcdValue < -1:    \r
            return\r
                \r
        TopAddress = 0\r
        if Int64PcdValue > 0:\r
            TopAddress = Int64PcdValue\r
            \r
        ModuleDict = BuildDb.BuildObject[DscFile, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].Modules\r
        for Key in ModuleDict:\r
            ModuleObj = BuildDb.BuildObject[Key, 'COMMON', GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
            print ModuleObj.BaseName + ' ' + ModuleObj.ModuleType\r
\r
    def GenerateGuidXRefFile(BuildDb, ArchList):\r
        GuidXRefFileName = os.path.join(GenFdsGlobalVariable.FvDir, "Guid.xref")\r
        GuidXRefFile = StringIO.StringIO('')\r
        GuidDict = {}\r
        for Arch in ArchList:\r
            PlatformDataBase = BuildDb.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
            for ModuleFile in PlatformDataBase.Modules:\r
                Module = BuildDb.BuildObject[ModuleFile, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
                GuidXRefFile.write("%s %s\n" % (Module.Guid, Module.BaseName))\r
                for key, item in Module.Protocols.items():\r
                    GuidDict[key] = item\r
                for key, item in Module.Guids.items():\r
                    GuidDict[key] = item\r
                for key, item in Module.Ppis.items():\r
                    GuidDict[key] = item\r
       # Append GUIDs, Protocols, and PPIs to the Xref file\r
        GuidXRefFile.write("\n")\r
        for key, item in GuidDict.items():\r
            GuidXRefFile.write("%s %s\n" % (GuidStructureStringToGuidString(item).upper(), key))\r
\r
        if GuidXRefFile.getvalue():\r
            SaveFileOnChange(GuidXRefFileName, GuidXRefFile.getvalue(), False)\r
            GenFdsGlobalVariable.InfLogger("\nGUID cross reference file can be found at %s" % GuidXRefFileName)\r
        elif os.path.exists(GuidXRefFileName):\r
            os.remove(GuidXRefFileName)\r
        GuidXRefFile.close()\r
\r
    ##Define GenFd as static function\r
    GenFd = staticmethod(GenFd)\r
    GetFvBlockSize = staticmethod(GetFvBlockSize)\r
    DisplayFvSpaceInfo = staticmethod(DisplayFvSpaceInfo)\r
    PreprocessImage = staticmethod(PreprocessImage)\r
    GenerateGuidXRefFile = staticmethod(GenerateGuidXRefFile)\r
\r
if __name__ == '__main__':\r
    r = main()\r
    ## 0-127 is a safe return range, and 1 is a standard default error\r
    if r < 0 or r > 127: r = 1\r
    sys.exit(r)\r
\r