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

## @file\r
# Global variables for GenFds\r
#\r
#  Copyright (c) 2007 - 2014, 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
import Common.LongFilePathOs as os\r
import sys\r
import subprocess\r
import struct\r
import array\r
\r
from Common.BuildToolError import *\r
from Common import EdkLogger\r
from Common.Misc import SaveFileOnChange\r
\r
from Common.TargetTxtClassObject import TargetTxtClassObject\r
from Common.ToolDefClassObject import ToolDefClassObject\r
from AutoGen.BuildEngine import BuildRule\r
import Common.DataType as DataType\r
from Common.Misc import PathClass\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
\r
## Global variables\r
#\r
#\r
class GenFdsGlobalVariable:\r
    FvDir = ''\r
    OutputDirDict = {}\r
    BinDir = ''\r
    # will be FvDir + os.sep + 'Ffs'\r
    FfsDir = ''\r
    FdfParser = None\r
    LibDir = ''\r
    WorkSpace = None\r
    WorkSpaceDir = ''\r
    EdkSourceDir = ''\r
    OutputDirFromDscDict = {}\r
    TargetName = ''\r
    ToolChainTag = ''\r
    RuleDict = {}\r
    ArchList = None\r
    VtfDict = {}\r
    ActivePlatform = None\r
    FvAddressFileName = ''\r
    VerboseMode = False\r
    DebugLevel = -1\r
    SharpCounter = 0\r
    SharpNumberPerLine = 40\r
    FdfFile = ''\r
    FdfFileTimeStamp = 0\r
    FixedLoadAddress = False\r
    PlatformName = ''\r
    \r
    BuildRuleFamily = "MSFT"\r
    ToolChainFamily = "MSFT"\r
    __BuildRuleDatabase = None\r
    \r
    #\r
    # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.\r
    # At the beginning of each generation of FV, false flag is appended to the list,\r
    # after the call to GenerateSection returns, check the size of the output file,\r
    # if it is greater than 0xFFFFFF, the tail flag in list is set to true,\r
    # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.\r
    # At the end of generation of FV, pop the flag.\r
    # List is used as a stack to handle nested FV generation.\r
    #\r
    LargeFileInFvFlags = []\r
    EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'\r
    LARGE_FILE_SIZE = 0x1000000\r
\r
    SectionHeader = struct.Struct("3B 1B")\r
    \r
    ## LoadBuildRule\r
    #\r
    @staticmethod\r
    def __LoadBuildRule():\r
        if GenFdsGlobalVariable.__BuildRuleDatabase:\r
            return GenFdsGlobalVariable.__BuildRuleDatabase\r
        BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.WorkSpaceDir, "Conf/target.txt"))\r
        TargetTxt = TargetTxtClassObject()\r
        if os.path.isfile(BuildConfigurationFile) == True:\r
            TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
            if DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF in TargetTxt.TargetTxtDictionary:\r
                BuildRuleFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
            if BuildRuleFile in [None, '']:\r
                BuildRuleFile = 'Conf/build_rule.txt'\r
            GenFdsGlobalVariable.__BuildRuleDatabase = BuildRule(BuildRuleFile)\r
            ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
            if ToolDefinitionFile == '':\r
                ToolDefinitionFile = "Conf/tools_def.txt"\r
            if os.path.isfile(ToolDefinitionFile):\r
                ToolDef = ToolDefClassObject()\r
                ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
                ToolDefinition = ToolDef.ToolsDefTxtDatabase\r
                if DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDefinition \\r
                   and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
                   and ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]:\r
                    GenFdsGlobalVariable.BuildRuleFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]\r
                    \r
                if DataType.TAB_TOD_DEFINES_FAMILY in ToolDefinition \\r
                   and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY] \\r
                   and ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]:\r
                    GenFdsGlobalVariable.ToolChainFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]\r
        return GenFdsGlobalVariable.__BuildRuleDatabase\r
\r
    ## GetBuildRules\r
    #    @param Inf: object of InfBuildData\r
    #    @param Arch: current arch\r
    #\r
    @staticmethod\r
    def GetBuildRules(Inf, Arch):\r
        if not Arch:\r
            Arch = 'COMMON'\r
\r
        if not Arch in GenFdsGlobalVariable.OutputDirDict:\r
            return {}\r
\r
        BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule()\r
        if not BuildRuleDatabase:\r
            return {}\r
\r
        PathClassObj = PathClass(Inf.MetaFile.File,\r
                                 GenFdsGlobalVariable.WorkSpaceDir)\r
        Macro = {}\r
        Macro["WORKSPACE"             ] = GenFdsGlobalVariable.WorkSpaceDir\r
        Macro["MODULE_NAME"           ] = Inf.BaseName\r
        Macro["MODULE_GUID"           ] = Inf.Guid\r
        Macro["MODULE_VERSION"        ] = Inf.Version\r
        Macro["MODULE_TYPE"           ] = Inf.ModuleType\r
        Macro["MODULE_FILE"           ] = str(PathClassObj)\r
        Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName\r
        Macro["MODULE_RELATIVE_DIR"   ] = PathClassObj.SubDir\r
        Macro["MODULE_DIR"            ] = PathClassObj.SubDir\r
\r
        Macro["BASE_NAME"             ] = Inf.BaseName\r
\r
        Macro["ARCH"                  ] = Arch\r
        Macro["TOOLCHAIN"             ] = GenFdsGlobalVariable.ToolChainTag\r
        Macro["TOOLCHAIN_TAG"         ] = GenFdsGlobalVariable.ToolChainTag\r
        Macro["TOOL_CHAIN_TAG"        ] = GenFdsGlobalVariable.ToolChainTag\r
        Macro["TARGET"                ] = GenFdsGlobalVariable.TargetName\r
\r
        Macro["BUILD_DIR"             ] = GenFdsGlobalVariable.OutputDirDict[Arch]\r
        Macro["BIN_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)\r
        Macro["LIB_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)\r
        BuildDir = os.path.join(\r
            GenFdsGlobalVariable.OutputDirDict[Arch],\r
            Arch,\r
            PathClassObj.SubDir,\r
            PathClassObj.BaseName\r
        )\r
        Macro["MODULE_BUILD_DIR"      ] = BuildDir\r
        Macro["OUTPUT_DIR"            ] = os.path.join(BuildDir, "OUTPUT")\r
        Macro["DEBUG_DIR"             ] = os.path.join(BuildDir, "DEBUG")\r
\r
        BuildRules = {}\r
        for Type in BuildRuleDatabase.FileTypeList:\r
            #first try getting build rule by BuildRuleFamily\r
            RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.BuildRuleFamily]\r
            if not RuleObject:\r
                # build type is always module type, but ...\r
                if Inf.ModuleType != Inf.BuildType:\r
                    RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.BuildRuleFamily]\r
            #second try getting build rule by ToolChainFamily\r
            if not RuleObject:\r
                RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.ToolChainFamily]\r
                if not RuleObject:\r
                    # build type is always module type, but ...\r
                    if Inf.ModuleType != Inf.BuildType:\r
                        RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.ToolChainFamily]\r
            if not RuleObject:\r
                continue\r
            RuleObject = RuleObject.Instantiate(Macro)\r
            BuildRules[Type] = RuleObject\r
            for Ext in RuleObject.SourceFileExtList:\r
                BuildRules[Ext] = RuleObject\r
        return BuildRules\r
\r
    ## GetModuleCodaTargetList\r
    #\r
    #    @param Inf: object of InfBuildData\r
    #    @param Arch: current arch\r
    #\r
    @staticmethod\r
    def GetModuleCodaTargetList(Inf, Arch):\r
        BuildRules = GenFdsGlobalVariable.GetBuildRules(Inf, Arch)\r
        if not BuildRules:\r
            return []\r
\r
        TargetList = set()\r
        FileList = []\r
        for File in Inf.Sources:\r
            if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \\r
                File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily):\r
                FileList.append((File, DataType.TAB_UNKNOWN_FILE))\r
        \r
        for File in Inf.Binaries:\r
            if File.Target in ['COMMON', '*', GenFdsGlobalVariable.TargetName]:\r
                FileList.append((File, File.Type))\r
\r
        for File, FileType in FileList:\r
            LastTarget = None\r
            RuleChain = []\r
            SourceList = [File]\r
            Index = 0\r
            while Index < len(SourceList):\r
                Source = SourceList[Index]\r
                Index = Index + 1\r
    \r
                if File.IsBinary and File == Source and Inf.Binaries != None and File in Inf.Binaries:\r
                    # Skip all files that are not binary libraries\r
                    if not Inf.LibraryClass:\r
                        continue            \r
                    RuleObject = BuildRules[DataType.TAB_DEFAULT_BINARY_FILE]\r
                elif FileType in BuildRules:\r
                    RuleObject = BuildRules[FileType]\r
                elif Source.Ext in BuildRules:\r
                    RuleObject = BuildRules[Source.Ext]\r
                else:\r
                    # stop at no more rules\r
                    if LastTarget:\r
                        TargetList.add(str(LastTarget))\r
                    break\r
    \r
                FileType = RuleObject.SourceFileType\r
    \r
                # stop at STATIC_LIBRARY for library\r
                if Inf.LibraryClass and FileType == DataType.TAB_STATIC_LIBRARY:\r
                    if LastTarget:\r
                        TargetList.add(str(LastTarget))\r
                    break\r
    \r
                Target = RuleObject.Apply(Source)\r
                if not Target:\r
                    if LastTarget:\r
                        TargetList.add(str(LastTarget))\r
                    break\r
                elif not Target.Outputs:\r
                    # Only do build for target with outputs\r
                    TargetList.add(str(Target))\r
    \r
                # to avoid cyclic rule\r
                if FileType in RuleChain:\r
                    break\r
    \r
                RuleChain.append(FileType)\r
                SourceList.extend(Target.Outputs)\r
                LastTarget = Target\r
                FileType = DataType.TAB_UNKNOWN_FILE\r
\r
        return list(TargetList)\r
\r
    ## SetDir()\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 SetDir (OutputDir, FdfParser, WorkSpace, ArchList):\r
        GenFdsGlobalVariable.VerboseLogger( "GenFdsGlobalVariable.OutputDir :%s" %OutputDir)\r
#        GenFdsGlobalVariable.OutputDirDict = OutputDir\r
        GenFdsGlobalVariable.FdfParser = FdfParser\r
        GenFdsGlobalVariable.WorkSpace = WorkSpace\r
        GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], 'FV')\r
        if not os.path.exists(GenFdsGlobalVariable.FvDir) :\r
            os.makedirs(GenFdsGlobalVariable.FvDir)\r
        GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')\r
        if not os.path.exists(GenFdsGlobalVariable.FfsDir) :\r
            os.makedirs(GenFdsGlobalVariable.FfsDir)\r
        if ArchList != None:\r
            GenFdsGlobalVariable.ArchList = ArchList\r
\r
        T_CHAR_LF = '\n'\r
        #\r
        # Create FV Address inf file\r
        #\r
        GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')\r
        FvAddressFile = open (GenFdsGlobalVariable.FvAddressFileName, 'w')\r
        #\r
        # Add [Options]\r
        #\r
        FvAddressFile.writelines("[options]" + T_CHAR_LF)\r
        BsAddress = '0'\r
        for Arch in ArchList:\r
            if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress:\r
                BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress\r
                break\r
\r
        FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \\r
                                       BsAddress          + \\r
                                       T_CHAR_LF)\r
\r
        RtAddress = '0'\r
        for Arch in ArchList:\r
            if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress:\r
                RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress\r
\r
        FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \\r
                                       RtAddress          + \\r
                                       T_CHAR_LF)\r
\r
        FvAddressFile.close()\r
\r
    ## ReplaceWorkspaceMacro()\r
    #\r
    #   @param  String           String that may contain macro\r
    #\r
    def ReplaceWorkspaceMacro(String):\r
        Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir)\r
        if os.path.exists(Str):\r
            if not os.path.isabs(Str):\r
                Str = os.path.abspath(Str)\r
        else:\r
            Str = os.path.join(GenFdsGlobalVariable.WorkSpaceDir, String)\r
        return os.path.normpath(Str)\r
\r
    ## Check if the input files are newer than output files\r
    #\r
    #   @param  Output          Path of output file\r
    #   @param  Input           Path list of input files\r
    #\r
    #   @retval True            if Output doesn't exist, or any Input is newer\r
    #   @retval False           if all Input is older than Output\r
    #\r
    @staticmethod\r
    def NeedsUpdate(Output, Input):\r
        if not os.path.exists(Output):\r
            return True\r
        # always update "Output" if no "Input" given\r
        if Input == None or len(Input) == 0:\r
            return True\r
\r
        # if fdf file is changed after the 'Output" is generated, update the 'Output'\r
        OutputTime = os.path.getmtime(Output)\r
        if GenFdsGlobalVariable.FdfFileTimeStamp > OutputTime:\r
            return True\r
\r
        for F in Input:\r
            # always update "Output" if any "Input" doesn't exist\r
            if not os.path.exists(F):\r
                return True\r
            # always update "Output" if any "Input" is newer than "Output"\r
            if os.path.getmtime(F) > OutputTime:\r
                return True\r
        return False\r
\r
    @staticmethod\r
    def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,\r
                        GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=None, BuildNumber=None):\r
        Cmd = ["GenSec"]\r
        if Type not in [None, '']:\r
            Cmd += ["-s", Type]\r
        if CompressionType not in [None, '']:\r
            Cmd += ["-c", CompressionType]\r
        if Guid != None:\r
            Cmd += ["-g", Guid]\r
        if GuidHdrLen not in [None, '']:\r
            Cmd += ["-l", GuidHdrLen]\r
        if len(GuidAttr) != 0:\r
            #Add each guided attribute\r
            for Attr in GuidAttr:\r
                Cmd += ["-r", Attr]\r
        if InputAlign != None:\r
            #Section Align is only for dummy section without section type\r
            for SecAlign in InputAlign:\r
                Cmd += ["--sectionalign", SecAlign]\r
\r
        CommandFile = Output + '.txt'\r
        if Ui not in [None, '']:\r
            #Cmd += ["-n", '"' + Ui + '"']\r
            SectionData = array.array('B', [0,0,0,0])\r
            SectionData.fromstring(Ui.encode("utf_16_le"))\r
            SectionData.append(0)\r
            SectionData.append(0)\r
            Len = len(SectionData)\r
            GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)\r
            SaveFileOnChange(Output,  SectionData.tostring())\r
        elif Ver not in [None, '']:\r
            Cmd += ["-n", Ver]\r
            if BuildNumber:\r
                Cmd += ["-j", BuildNumber]\r
            Cmd += ["-o", Output]\r
\r
            SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
            if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
                return\r
\r
            GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")\r
        else:\r
            Cmd += ["-o", Output]\r
            Cmd += Input\r
\r
            SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
            if GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
                GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
                GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")\r
\r
            if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and\r
                GenFdsGlobalVariable.LargeFileInFvFlags):\r
                GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True \r
\r
    @staticmethod\r
    def GetAlignment (AlignString):\r
        if AlignString == None:\r
            return 0\r
        if AlignString in ("1K", "2K", "4K", "8K", "16K", "32K", "64K"):\r
            return int (AlignString.rstrip('K')) * 1024\r
        else:\r
            return int (AlignString)\r
\r
    @staticmethod\r
    def GenerateFfs(Output, Input, Type, Guid, Fixed=False, CheckSum=False, Align=None,\r
                    SectionAlign=None):\r
        Cmd = ["GenFfs", "-t", Type, "-g", Guid]\r
        if Fixed == True:\r
            Cmd += ["-x"]\r
        if CheckSum:\r
            Cmd += ["-s"]\r
        if Align not in [None, '']:\r
            Cmd += ["-a", Align]\r
\r
        Cmd += ["-o", Output]\r
        for I in range(0, len(Input)):\r
            Cmd += ("-i", Input[I])\r
            if SectionAlign not in [None, '', []] and SectionAlign[I] not in [None, '']:\r
                Cmd += ("-n", SectionAlign[I])\r
\r
        CommandFile = Output + '.txt'\r
        SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
\r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FFS")\r
\r
    @staticmethod\r
    def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,\r
                               AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
\r
        Cmd = ["GenFv"]\r
        if BaseAddress not in [None, '']:\r
            Cmd += ["-r", BaseAddress]\r
        \r
        if ForceRebase == False:\r
            Cmd +=["-F", "FALSE"]\r
        elif ForceRebase == True:\r
            Cmd +=["-F", "TRUE"]\r
            \r
        if Capsule:\r
            Cmd += ["-c"]\r
        if Dump:\r
            Cmd += ["-p"]\r
        if AddressFile not in [None, '']:\r
            Cmd += ["-a", AddressFile]\r
        if MapFile not in [None, '']:\r
            Cmd += ["-m", MapFile]\r
        if FileSystemGuid:\r
            Cmd += ["-g", FileSystemGuid]\r
        Cmd += ["-o", Output]\r
        for I in Input:\r
            Cmd += ["-i", I]\r
\r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FV")\r
\r
    @staticmethod\r
    def GenerateVtf(Output, Input, BaseAddress=None, FvSize=None):\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
\r
        Cmd = ["GenVtf"]\r
        if BaseAddress not in [None, ''] and FvSize not in [None, ''] \\r
            and len(BaseAddress) == len(FvSize):\r
            for I in range(0, len(BaseAddress)):\r
                Cmd += ["-r", BaseAddress[I], "-s", FvSize[I]]\r
        Cmd += ["-o", Output]\r
        for F in Input:\r
            Cmd += ["-f", F]\r
\r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate VTF")\r
\r
    @staticmethod\r
    def GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,\r
                              Strip=False, Replace=False, TimeStamp=None, Join=False,\r
                              Align=None, Padding=None, Convert=False):\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
\r
        Cmd = ["GenFw"]\r
        if Type.lower() == "te":\r
            Cmd += ["-t"]\r
        if SubType not in [None, '']:\r
            Cmd += ["-e", SubType]\r
        if TimeStamp not in [None, '']:\r
            Cmd += ["-s", TimeStamp]\r
        if Align not in [None, '']:\r
            Cmd += ["-a", Align]\r
        if Padding not in [None, '']:\r
            Cmd += ["-p", Padding]\r
        if Zero:\r
            Cmd += ["-z"]\r
        if Strip:\r
            Cmd += ["-l"]\r
        if Replace:\r
            Cmd += ["-r"]\r
        if Join:\r
            Cmd += ["-j"]\r
        if Convert:\r
            Cmd += ["-m"]\r
        Cmd += ["-o", Output]\r
        Cmd += Input\r
\r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")\r
\r
    @staticmethod\r
    def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,\r
                        Revision=None, DeviceId=None, VendorId=None):\r
        InputList = []   \r
        Cmd = ["EfiRom"]\r
        if len(EfiInput) > 0:\r
            \r
            if Compress:\r
                Cmd += ["-ec"]\r
            else:\r
                Cmd += ["-e"]\r
                \r
            for EfiFile in EfiInput:\r
                Cmd += [EfiFile]\r
                InputList.append (EfiFile)\r
        \r
        if len(BinaryInput) > 0:\r
            Cmd += ["-b"]\r
            for BinFile in BinaryInput:\r
                Cmd += [BinFile]\r
                InputList.append (BinFile)\r
\r
        # Check List\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))\r
                        \r
        if ClassCode != None:\r
            Cmd += ["-l", ClassCode]\r
        if Revision != None:\r
            Cmd += ["-r", Revision]\r
        if DeviceId != None:\r
            Cmd += ["-i", DeviceId]\r
        if VendorId != None:\r
            Cmd += ["-f", VendorId]\r
\r
        Cmd += ["-o", Output]    \r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")\r
\r
    @staticmethod\r
    def GuidTool(Output, Input, ToolPath, Options='', returnValue=[]):\r
        if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):\r
            return\r
        GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
\r
        Cmd = [ToolPath, ]\r
        Cmd += Options.split(' ')\r
        Cmd += ["-o", Output]\r
        Cmd += Input\r
\r
        GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)\r
\r
    def CallExternalTool (cmd, errorMess, returnValue=[]):\r
\r
        if type(cmd) not in (tuple, list):\r
            GenFdsGlobalVariable.ErrorLogger("ToolError!  Invalid parameter type in call to CallExternalTool")\r
\r
        if GenFdsGlobalVariable.DebugLevel != -1:\r
            cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))\r
            GenFdsGlobalVariable.InfLogger (cmd)\r
\r
        if GenFdsGlobalVariable.VerboseMode:\r
            cmd += ('-v',)\r
            GenFdsGlobalVariable.InfLogger (cmd)\r
        else:\r
            sys.stdout.write ('#')\r
            sys.stdout.flush()\r
            GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1\r
            if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:\r
                sys.stdout.write('\n')\r
\r
        try:\r
            PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr= subprocess.PIPE, shell=True)\r
        except Exception, X:\r
            EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))\r
        (out, error) = PopenObject.communicate()\r
\r
        while PopenObject.returncode == None :\r
            PopenObject.wait()\r
        if returnValue != [] and returnValue[0] != 0:\r
            #get command return value\r
            returnValue[0] = PopenObject.returncode\r
            return\r
        if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:\r
            GenFdsGlobalVariable.InfLogger ("Return Value = %d" %PopenObject.returncode)\r
            GenFdsGlobalVariable.InfLogger (out)\r
            GenFdsGlobalVariable.InfLogger (error)\r
            if PopenObject.returncode != 0:\r
                print "###", cmd\r
                EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)\r
\r
    def VerboseLogger (msg):\r
        EdkLogger.verbose(msg)\r
\r
    def InfLogger (msg):\r
        EdkLogger.info(msg)\r
\r
    def ErrorLogger (msg, File = None, Line = None, ExtraData = None):\r
        EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)\r
\r
    def DebugLogger (Level, msg):\r
        EdkLogger.debug(Level, msg)\r
\r
    ## ReplaceWorkspaceMacro()\r
    #\r
    #   @param  Str           String that may contain macro\r
    #   @param  MacroDict     Dictionary that contains macro value pair\r
    #\r
    def MacroExtend (Str, MacroDict = {}, Arch = 'COMMON'):\r
        if Str == None :\r
            return None\r
\r
        Dict = {'$(WORKSPACE)'   : GenFdsGlobalVariable.WorkSpaceDir,\r
                '$(EDK_SOURCE)'  : GenFdsGlobalVariable.EdkSourceDir,\r
#                '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,\r
                '$(TARGET)' : GenFdsGlobalVariable.TargetName,\r
                '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag\r
               }\r
        OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]\r
        if Arch != 'COMMON' and Arch in GenFdsGlobalVariable.ArchList:\r
            OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]\r
\r
        Dict['$(OUTPUT_DIRECTORY)'] = OutputDir\r
\r
        if MacroDict != None  and len (MacroDict) != 0:\r
            Dict.update(MacroDict)\r
\r
        for key in Dict.keys():\r
            if Str.find(key) >= 0 :\r
                Str = Str.replace (key, Dict[key])\r
\r
        if Str.find('$(ARCH)') >= 0:\r
            if len(GenFdsGlobalVariable.ArchList) == 1:\r
                Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])\r
            else:\r
                EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)\r
\r
        return Str\r
\r
    ## GetPcdValue()\r
    #\r
    #   @param  PcdPattern           pattern that labels a PCD.\r
    #\r
    def GetPcdValue (PcdPattern):\r
        if PcdPattern == None :\r
            return None\r
        PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')\r
        TokenSpace = PcdPair[0]\r
        TokenCName = PcdPair[1]\r
\r
        PcdValue = ''\r
        for Arch in GenFdsGlobalVariable.ArchList:\r
            Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
            PcdDict = Platform.Pcds\r
            for Key in PcdDict:\r
                PcdObj = PcdDict[Key]\r
                if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):\r
                    if PcdObj.Type != 'FixedAtBuild':\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)\r
                    if PcdObj.DatumType != 'VOID*':\r
                        EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)\r
                        \r
                    PcdValue = PcdObj.DefaultValue\r
                    return PcdValue\r
                \r
            for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform, \r
                                                                         Arch, \r
                                                                         GenFdsGlobalVariable.TargetName, \r
                                                                         GenFdsGlobalVariable.ToolChainTag):\r
                PcdDict = Package.Pcds\r
                for Key in PcdDict:\r
                    PcdObj = PcdDict[Key]\r
                    if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):\r
                        if PcdObj.Type != 'FixedAtBuild':\r
                            EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)\r
                        if PcdObj.DatumType != 'VOID*':\r
                            EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)\r
                            \r
                        PcdValue = PcdObj.DefaultValue\r
                        return PcdValue\r
\r
        return PcdValue\r
\r
    SetDir = staticmethod(SetDir)\r
    ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)\r
    CallExternalTool = staticmethod(CallExternalTool)\r
    VerboseLogger = staticmethod(VerboseLogger)\r
    InfLogger = staticmethod(InfLogger)\r
    ErrorLogger = staticmethod(ErrorLogger)\r
    DebugLogger = staticmethod(DebugLogger)\r
    MacroExtend = staticmethod (MacroExtend)\r
    GetPcdValue = staticmethod(GetPcdValue)\r