BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py

   1 ## @file
   2 # Global variables for GenFds
   3 #
   4 #  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
   5 #
   6 #  This program and the accompanying materials
   7 #  are licensed and made available under the terms and conditions of the BSD License
   8 #  which accompanies this distribution.  The full text of the license may be found at
   9 #  http://opensource.org/licenses/bsd-license.php
  10 #
  11 #  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 #  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 #
  14
  15 ##
  16 # Import Modules
  17 #
  18 from __future__ import print_function
  19 import Common.LongFilePathOs as os
  20 import sys
  21 import subprocess
  22 import struct
  23 import array
  24
  25 from Common.BuildToolError import *
  26 from Common import EdkLogger
  27 from Common.Misc import SaveFileOnChange
  28
  29 from Common.TargetTxtClassObject import TargetTxtClassObject
  30 from Common.ToolDefClassObject import ToolDefClassObject, ToolDefDict
  31 from AutoGen.BuildEngine import BuildRule
  32 import Common.DataType as DataType
  33 from Common.Misc import PathClass
  34 from Common.LongFilePathSupport import OpenLongFilePath as open
  35 from Common.MultipleWorkspace import MultipleWorkspace as mws
  36
  37 ## Global variables
  38 #
  39 #
  40 class GenFdsGlobalVariable:
  41     FvDir = ''
  42     OutputDirDict = {}
  43     BinDir = ''
  44     # will be FvDir + os.sep + 'Ffs'
  45     FfsDir = ''
  46     FdfParser = None
  47     LibDir = ''
  48     WorkSpace = None
  49     WorkSpaceDir = ''
  50     ConfDir = ''
  51     EdkSourceDir = ''
  52     OutputDirFromDscDict = {}
  53     TargetName = ''
  54     ToolChainTag = ''
  55     RuleDict = {}
  56     ArchList = None
  57     VtfDict = {}
  58     ActivePlatform = None
  59     FvAddressFileName = ''
  60     VerboseMode = False
  61     DebugLevel = -1
  62     SharpCounter = 0
  63     SharpNumberPerLine = 40
  64     FdfFile = ''
  65     FdfFileTimeStamp = 0
  66     FixedLoadAddress = False
  67     PlatformName = ''
  68
  69     BuildRuleFamily = DataType.TAB_COMPILER_MSFT
  70     ToolChainFamily = DataType.TAB_COMPILER_MSFT
  71     __BuildRuleDatabase = None
  72     GuidToolDefinition = {}
  73     FfsCmdDict = {}
  74     SecCmdList = []
  75     CopyList   = []
  76     ModuleFile = ''
  77     EnableGenfdsMultiThread = False
  78
  79     #
  80     # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.
  81     # At the beginning of each generation of FV, false flag is appended to the list,
  82     # after the call to GenerateSection returns, check the size of the output file,
  83     # if it is greater than 0xFFFFFF, the tail flag in list is set to true,
  84     # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.
  85     # At the end of generation of FV, pop the flag.
  86     # List is used as a stack to handle nested FV generation.
  87     #
  88     LargeFileInFvFlags = []
  89     EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'
  90     LARGE_FILE_SIZE = 0x1000000
  91
  92     SectionHeader = struct.Struct("3B 1B")
  93
  94     # FvName, FdName, CapName in FDF, Image file name
  95     ImageBinDict = {}
  96
  97     ## LoadBuildRule
  98     #
  99     @staticmethod
 100     def __LoadBuildRule():
 101         if GenFdsGlobalVariable.__BuildRuleDatabase:
 102             return GenFdsGlobalVariable.__BuildRuleDatabase
 103         BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.ConfDir, "target.txt"))
 104         TargetTxt = TargetTxtClassObject()
 105         if os.path.isfile(BuildConfigurationFile) == True:
 106             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
 107             if DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF in TargetTxt.TargetTxtDictionary:
 108                 BuildRuleFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]
 109             if not BuildRuleFile:
 110                 BuildRuleFile = 'Conf/build_rule.txt'
 111             GenFdsGlobalVariable.__BuildRuleDatabase = BuildRule(BuildRuleFile)
 112             ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
 113             if ToolDefinitionFile == '':
 114                 ToolDefinitionFile = "Conf/tools_def.txt"
 115             if os.path.isfile(ToolDefinitionFile):
 116                 ToolDef = ToolDefClassObject()
 117                 ToolDef.LoadToolDefFile(ToolDefinitionFile)
 118                 ToolDefinition = ToolDef.ToolsDefTxtDatabase
 119                 if DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDefinition \
 120                    and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY] \
 121                    and ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]:
 122                     GenFdsGlobalVariable.BuildRuleFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]
 123
 124                 if DataType.TAB_TOD_DEFINES_FAMILY in ToolDefinition \
 125                    and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY] \
 126                    and ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]:
 127                     GenFdsGlobalVariable.ToolChainFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]
 128         return GenFdsGlobalVariable.__BuildRuleDatabase
 129
 130     ## GetBuildRules
 131     #    @param Inf: object of InfBuildData
 132     #    @param Arch: current arch
 133     #
 134     @staticmethod
 135     def GetBuildRules(Inf, Arch):
 136         if not Arch:
 137             Arch = DataType.TAB_COMMON
 138
 139         if not Arch in GenFdsGlobalVariable.OutputDirDict:
 140             return {}
 141
 142         BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule()
 143         if not BuildRuleDatabase:
 144             return {}
 145
 146         PathClassObj = PathClass(Inf.MetaFile.File,
 147                                  GenFdsGlobalVariable.WorkSpaceDir)
 148         Macro = {}
 149         Macro["WORKSPACE"             ] = GenFdsGlobalVariable.WorkSpaceDir
 150         Macro["MODULE_NAME"           ] = Inf.BaseName
 151         Macro["MODULE_GUID"           ] = Inf.Guid
 152         Macro["MODULE_VERSION"        ] = Inf.Version
 153         Macro["MODULE_TYPE"           ] = Inf.ModuleType
 154         Macro["MODULE_FILE"           ] = str(PathClassObj)
 155         Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName
 156         Macro["MODULE_RELATIVE_DIR"   ] = PathClassObj.SubDir
 157         Macro["MODULE_DIR"            ] = PathClassObj.SubDir
 158
 159         Macro["BASE_NAME"             ] = Inf.BaseName
 160
 161         Macro["ARCH"                  ] = Arch
 162         Macro["TOOLCHAIN"             ] = GenFdsGlobalVariable.ToolChainTag
 163         Macro["TOOLCHAIN_TAG"         ] = GenFdsGlobalVariable.ToolChainTag
 164         Macro["TOOL_CHAIN_TAG"        ] = GenFdsGlobalVariable.ToolChainTag
 165         Macro["TARGET"                ] = GenFdsGlobalVariable.TargetName
 166
 167         Macro["BUILD_DIR"             ] = GenFdsGlobalVariable.OutputDirDict[Arch]
 168         Macro["BIN_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
 169         Macro["LIB_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
 170         BuildDir = os.path.join(
 171             GenFdsGlobalVariable.OutputDirDict[Arch],
 172             Arch,
 173             PathClassObj.SubDir,
 174             PathClassObj.BaseName
 175         )
 176         Macro["MODULE_BUILD_DIR"      ] = BuildDir
 177         Macro["OUTPUT_DIR"            ] = os.path.join(BuildDir, "OUTPUT")
 178         Macro["DEBUG_DIR"             ] = os.path.join(BuildDir, "DEBUG")
 179
 180         BuildRules = {}
 181         for Type in BuildRuleDatabase.FileTypeList:
 182             #first try getting build rule by BuildRuleFamily
 183             RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
 184             if not RuleObject:
 185                 # build type is always module type, but ...
 186                 if Inf.ModuleType != Inf.BuildType:
 187                     RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
 188             #second try getting build rule by ToolChainFamily
 189             if not RuleObject:
 190                 RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.ToolChainFamily]
 191                 if not RuleObject:
 192                     # build type is always module type, but ...
 193                     if Inf.ModuleType != Inf.BuildType:
 194                         RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.ToolChainFamily]
 195             if not RuleObject:
 196                 continue
 197             RuleObject = RuleObject.Instantiate(Macro)
 198             BuildRules[Type] = RuleObject
 199             for Ext in RuleObject.SourceFileExtList:
 200                 BuildRules[Ext] = RuleObject
 201         return BuildRules
 202
 203     ## GetModuleCodaTargetList
 204     #
 205     #    @param Inf: object of InfBuildData
 206     #    @param Arch: current arch
 207     #
 208     @staticmethod
 209     def GetModuleCodaTargetList(Inf, Arch):
 210         BuildRules = GenFdsGlobalVariable.GetBuildRules(Inf, Arch)
 211         if not BuildRules:
 212             return []
 213
 214         TargetList = set()
 215         FileList = []
 216
 217         if not Inf.IsBinaryModule:
 218             for File in Inf.Sources:
 219                 if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \
 220                     File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily):
 221                     FileList.append((File, DataType.TAB_UNKNOWN_FILE))
 222
 223         for File in Inf.Binaries:
 224             if File.Target in [DataType.TAB_COMMON, '*', GenFdsGlobalVariable.TargetName]:
 225                 FileList.append((File, File.Type))
 226
 227         for File, FileType in FileList:
 228             LastTarget = None
 229             RuleChain = []
 230             SourceList = [File]
 231             Index = 0
 232             while Index < len(SourceList):
 233                 Source = SourceList[Index]
 234                 Index = Index + 1
 235
 236                 if File.IsBinary and File == Source and Inf.Binaries is not None and File in Inf.Binaries:
 237                     # Skip all files that are not binary libraries
 238                     if not Inf.LibraryClass:
 239                         continue
 240                     RuleObject = BuildRules[DataType.TAB_DEFAULT_BINARY_FILE]
 241                 elif FileType in BuildRules:
 242                     RuleObject = BuildRules[FileType]
 243                 elif Source.Ext in BuildRules:
 244                     RuleObject = BuildRules[Source.Ext]
 245                 else:
 246                     # stop at no more rules
 247                     if LastTarget:
 248                         TargetList.add(str(LastTarget))
 249                     break
 250
 251                 FileType = RuleObject.SourceFileType
 252
 253                 # stop at STATIC_LIBRARY for library
 254                 if Inf.LibraryClass and FileType == DataType.TAB_STATIC_LIBRARY:
 255                     if LastTarget:
 256                         TargetList.add(str(LastTarget))
 257                     break
 258
 259                 Target = RuleObject.Apply(Source)
 260                 if not Target:
 261                     if LastTarget:
 262                         TargetList.add(str(LastTarget))
 263                     break
 264                 elif not Target.Outputs:
 265                     # Only do build for target with outputs
 266                     TargetList.add(str(Target))
 267
 268                 # to avoid cyclic rule
 269                 if FileType in RuleChain:
 270                     break
 271
 272                 RuleChain.append(FileType)
 273                 SourceList.extend(Target.Outputs)
 274                 LastTarget = Target
 275                 FileType = DataType.TAB_UNKNOWN_FILE
 276                 for Cmd in Target.Commands:
 277                     if "$(CP)" == Cmd.split()[0]:
 278                         CpTarget = Cmd.split()[2]
 279                         TargetList.add(CpTarget)
 280
 281         return list(TargetList)
 282
 283     ## SetDir()
 284     #
 285     #   @param  OutputDir           Output directory
 286     #   @param  FdfParser           FDF contents parser
 287     #   @param  Workspace           The directory of workspace
 288     #   @param  ArchList            The Arch list of platform
 289     #
 290     def SetDir (OutputDir, FdfParser, WorkSpace, ArchList):
 291         GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir :%s" % OutputDir)
 292 #        GenFdsGlobalVariable.OutputDirDict = OutputDir
 293         GenFdsGlobalVariable.FdfParser = FdfParser
 294         GenFdsGlobalVariable.WorkSpace = WorkSpace
 295         GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], DataType.TAB_FV_DIRECTORY)
 296         if not os.path.exists(GenFdsGlobalVariable.FvDir) :
 297             os.makedirs(GenFdsGlobalVariable.FvDir)
 298         GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')
 299         if not os.path.exists(GenFdsGlobalVariable.FfsDir) :
 300             os.makedirs(GenFdsGlobalVariable.FfsDir)
 301
 302         T_CHAR_LF = '\n'
 303         #
 304         # Create FV Address inf file
 305         #
 306         GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')
 307         FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')
 308         #
 309         # Add [Options]
 310         #
 311         FvAddressFile.writelines("[options]" + T_CHAR_LF)
 312         BsAddress = '0'
 313         for Arch in ArchList:
 314             if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress:
 315                 BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress
 316                 break
 317
 318         FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \
 319                                        BsAddress + \
 320                                        T_CHAR_LF)
 321
 322         RtAddress = '0'
 323         for Arch in ArchList:
 324             if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress:
 325                 RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress
 326
 327         FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \
 328                                        RtAddress + \
 329                                        T_CHAR_LF)
 330
 331         FvAddressFile.close()
 332
 333     def SetEnv(FdfParser, WorkSpace, ArchList, GlobalData):
 334         GenFdsGlobalVariable.ModuleFile = WorkSpace.ModuleFile
 335         GenFdsGlobalVariable.FdfParser = FdfParser
 336         GenFdsGlobalVariable.WorkSpace = WorkSpace.Db
 337         GenFdsGlobalVariable.ArchList = ArchList
 338         GenFdsGlobalVariable.ToolChainTag = GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]
 339         GenFdsGlobalVariable.TargetName = GlobalData.gGlobalDefines["TARGET"]
 340         GenFdsGlobalVariable.ActivePlatform = GlobalData.gActivePlatform
 341         GenFdsGlobalVariable.EdkSourceDir = GlobalData.gGlobalDefines["EDK_SOURCE"]
 342         GenFdsGlobalVariable.ConfDir  = GlobalData.gConfDirectory
 343         GenFdsGlobalVariable.EnableGenfdsMultiThread = GlobalData.gEnableGenfdsMultiThread
 344         for Arch in ArchList:
 345             GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.normpath(
 346                 os.path.join(GlobalData.gWorkspace,
 347                              WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'],
 348                              GlobalData.gGlobalDefines['TOOLCHAIN']].OutputDirectory,
 349                              GlobalData.gGlobalDefines['TARGET'] +'_' + GlobalData.gGlobalDefines['TOOLCHAIN']))
 350             GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = os.path.normpath(
 351                              WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,
 352                              GlobalData.gGlobalDefines['TARGET'], GlobalData.gGlobalDefines['TOOLCHAIN']].OutputDirectory)
 353             GenFdsGlobalVariable.PlatformName = WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,
 354                                                                       GlobalData.gGlobalDefines['TARGET'],
 355                                                                       GlobalData.gGlobalDefines['TOOLCHAIN']].PlatformName
 356         GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], DataType.TAB_FV_DIRECTORY)
 357         if not os.path.exists(GenFdsGlobalVariable.FvDir):
 358             os.makedirs(GenFdsGlobalVariable.FvDir)
 359         GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')
 360         if not os.path.exists(GenFdsGlobalVariable.FfsDir):
 361             os.makedirs(GenFdsGlobalVariable.FfsDir)
 362
 363         T_CHAR_LF = '\n'
 364         #
 365         # Create FV Address inf file
 366         #
 367         GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')
 368         FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')
 369         #
 370         # Add [Options]
 371         #
 372         FvAddressFile.writelines("[options]" + T_CHAR_LF)
 373         BsAddress = '0'
 374         for Arch in ArchList:
 375             BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,
 376                                                                    GlobalData.gGlobalDefines['TARGET'],
 377                                                                    GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].BsBaseAddress
 378             if BsAddress:
 379                 break
 380
 381         FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \
 382                                  BsAddress + \
 383                                  T_CHAR_LF)
 384
 385         RtAddress = '0'
 386         for Arch in ArchList:
 387             if GenFdsGlobalVariable.WorkSpace.BuildObject[
 388                 GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'],
 389                 GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress:
 390                 RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[
 391                     GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'],
 392                     GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress
 393
 394         FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \
 395                                  RtAddress + \
 396                                  T_CHAR_LF)
 397
 398         FvAddressFile.close()
 399
 400     ## ReplaceWorkspaceMacro()
 401     #
 402     #   @param  String           String that may contain macro
 403     #
 404     def ReplaceWorkspaceMacro(String):
 405         String = mws.handleWsMacro(String)
 406         Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir)
 407         if os.path.exists(Str):
 408             if not os.path.isabs(Str):
 409                 Str = os.path.abspath(Str)
 410         else:
 411             Str = mws.join(GenFdsGlobalVariable.WorkSpaceDir, String)
 412         return os.path.normpath(Str)
 413
 414     ## Check if the input files are newer than output files
 415     #
 416     #   @param  Output          Path of output file
 417     #   @param  Input           Path list of input files
 418     #
 419     #   @retval True            if Output doesn't exist, or any Input is newer
 420     #   @retval False           if all Input is older than Output
 421     #
 422     @staticmethod
 423     def NeedsUpdate(Output, Input):
 424         if not os.path.exists(Output):
 425             return True
 426         # always update "Output" if no "Input" given
 427         if Input is None or len(Input) == 0:
 428             return True
 429
 430         # if fdf file is changed after the 'Output" is generated, update the 'Output'
 431         OutputTime = os.path.getmtime(Output)
 432         if GenFdsGlobalVariable.FdfFileTimeStamp > OutputTime:
 433             return True
 434
 435         for F in Input:
 436             # always update "Output" if any "Input" doesn't exist
 437             if not os.path.exists(F):
 438                 return True
 439             # always update "Output" if any "Input" is newer than "Output"
 440             if os.path.getmtime(F) > OutputTime:
 441                 return True
 442         return False
 443
 444     @staticmethod
 445     def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,
 446                         GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=[], BuildNumber=None, DummyFile=None, IsMakefile=False):
 447         Cmd = ["GenSec"]
 448         if Type:
 449             Cmd += ("-s", Type)
 450         if CompressionType:
 451             Cmd += ("-c", CompressionType)
 452         if Guid is not None:
 453             Cmd += ("-g", Guid)
 454         if DummyFile is not None:
 455             Cmd += ("--dummy", DummyFile)
 456         if GuidHdrLen:
 457             Cmd += ("-l", GuidHdrLen)
 458         #Add each guided attribute
 459         for Attr in GuidAttr:
 460             Cmd += ("-r", Attr)
 461         #Section Align is only for dummy section without section type
 462         for SecAlign in InputAlign:
 463             Cmd += ("--sectionalign", SecAlign)
 464
 465         CommandFile = Output + '.txt'
 466         if Ui:
 467             if IsMakefile:
 468                 if Ui == "$(MODULE_NAME)":
 469                     Cmd += ('-n', Ui)
 470                 else:
 471                     Cmd += ("-n", '"' + Ui + '"')
 472                 Cmd += ("-o", Output)
 473                 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 474                     GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())
 475             else:
 476                 SectionData = array.array('B', [0, 0, 0, 0])
 477                 SectionData.fromstring(Ui.encode("utf_16_le"))
 478                 SectionData.append(0)
 479                 SectionData.append(0)
 480                 Len = len(SectionData)
 481                 GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)
 482                 SaveFileOnChange(Output, SectionData.tostring())
 483
 484         elif Ver:
 485             Cmd += ("-n", Ver)
 486             if BuildNumber:
 487                 Cmd += ("-j", BuildNumber)
 488             Cmd += ("-o", Output)
 489
 490             SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 491             if IsMakefile:
 492                 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 493                     GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())
 494             else:
 495                 if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 496                     return
 497                 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
 498         else:
 499             Cmd += ("-o", Output)
 500             Cmd += Input
 501
 502             SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 503             if IsMakefile:
 504                 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 505                     GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())
 506             elif GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 507                 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 508                 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
 509                 if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and
 510                     GenFdsGlobalVariable.LargeFileInFvFlags):
 511                     GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True
 512
 513     @staticmethod
 514     def GetAlignment (AlignString):
 515         if not AlignString:
 516             return 0
 517         if AlignString.endswith('K'):
 518             return int (AlignString.rstrip('K')) * 1024
 519         if AlignString.endswith('M'):
 520             return int (AlignString.rstrip('M')) * 1024 * 1024
 521         if AlignString.endswith('G'):
 522             return int (AlignString.rstrip('G')) * 1024 * 1024 * 1024
 523         return int (AlignString)
 524
 525     @staticmethod
 526     def GenerateFfs(Output, Input, Type, Guid, Fixed=False, CheckSum=False, Align=None,
 527                     SectionAlign=None, MakefilePath=None):
 528         Cmd = ["GenFfs", "-t", Type, "-g", Guid]
 529         mFfsValidAlign = ["0", "8", "16", "128", "512", "1K", "4K", "32K", "64K", "128K", "256K", "512K", "1M", "2M", "4M", "8M", "16M"]
 530         if Fixed == True:
 531             Cmd.append("-x")
 532         if CheckSum:
 533             Cmd.append("-s")
 534         if Align:
 535             if Align not in mFfsValidAlign:
 536                 Align = GenFdsGlobalVariable.GetAlignment (Align)
 537                 for index in range(0, len(mFfsValidAlign) - 1):
 538                     if ((Align > GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index])) and (Align <= GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index + 1]))):
 539                         break
 540                 Align = mFfsValidAlign[index + 1]
 541             Cmd += ("-a", Align)
 542
 543         Cmd += ("-o", Output)
 544         for I in range(0, len(Input)):
 545             Cmd += ("-i", Input[I])
 546             if SectionAlign and SectionAlign[I]:
 547                 Cmd += ("-n", SectionAlign[I])
 548
 549         CommandFile = Output + '.txt'
 550         SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 551
 552         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 553         if MakefilePath:
 554             if (tuple(Cmd), tuple(GenFdsGlobalVariable.SecCmdList), tuple(GenFdsGlobalVariable.CopyList)) not in GenFdsGlobalVariable.FfsCmdDict:
 555                 GenFdsGlobalVariable.FfsCmdDict[tuple(Cmd), tuple(GenFdsGlobalVariable.SecCmdList), tuple(GenFdsGlobalVariable.CopyList)] = MakefilePath
 556             GenFdsGlobalVariable.SecCmdList = []
 557             GenFdsGlobalVariable.CopyList = []
 558         else:
 559             if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 560                 return
 561             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FFS")
 562
 563     @staticmethod
 564     def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,
 565                                AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):
 566         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):
 567             return
 568         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 569
 570         Cmd = ["GenFv"]
 571         if BaseAddress:
 572             Cmd += ("-r", BaseAddress)
 573
 574         if ForceRebase == False:
 575             Cmd += ("-F", "FALSE")
 576         elif ForceRebase == True:
 577             Cmd += ("-F", "TRUE")
 578
 579         if Capsule:
 580             Cmd.append("-c")
 581         if Dump:
 582             Cmd.append("-p")
 583         if AddressFile:
 584             Cmd += ("-a", AddressFile)
 585         if MapFile:
 586             Cmd += ("-m", MapFile)
 587         if FileSystemGuid:
 588             Cmd += ("-g", FileSystemGuid)
 589         Cmd += ("-o", Output)
 590         for I in Input:
 591             Cmd += ("-i", I)
 592
 593         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FV")
 594
 595     @staticmethod
 596     def GenerateVtf(Output, Input, BaseAddress=None, FvSize=None):
 597         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
 598             return
 599         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 600
 601         Cmd = ["GenVtf"]
 602         if BaseAddress and FvSize \
 603             and len(BaseAddress) == len(FvSize):
 604             for I in range(0, len(BaseAddress)):
 605                 Cmd += ("-r", BaseAddress[I], "-s", FvSize[I])
 606         Cmd += ("-o", Output)
 607         for F in Input:
 608             Cmd += ("-f", F)
 609
 610         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate VTF")
 611
 612     @staticmethod
 613     def GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,
 614                               Strip=False, Replace=False, TimeStamp=None, Join=False,
 615                               Align=None, Padding=None, Convert=False, IsMakefile=False):
 616         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:
 617             return
 618         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 619
 620         Cmd = ["GenFw"]
 621         if Type.lower() == "te":
 622             Cmd.append("-t")
 623         if SubType:
 624             Cmd += ("-e", SubType)
 625         if TimeStamp:
 626             Cmd += ("-s", TimeStamp)
 627         if Align:
 628             Cmd += ("-a", Align)
 629         if Padding:
 630             Cmd += ("-p", Padding)
 631         if Zero:
 632             Cmd.append("-z")
 633         if Strip:
 634             Cmd.append("-l")
 635         if Replace:
 636             Cmd.append("-r")
 637         if Join:
 638             Cmd.append("-j")
 639         if Convert:
 640             Cmd.append("-m")
 641         Cmd += ("-o", Output)
 642         Cmd += Input
 643         if IsMakefile:
 644             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 645                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 646         else:
 647             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")
 648
 649     @staticmethod
 650     def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,
 651                         Revision=None, DeviceId=None, VendorId=None, IsMakefile=False):
 652         InputList = []
 653         Cmd = ["EfiRom"]
 654         if len(EfiInput) > 0:
 655
 656             if Compress:
 657                 Cmd.append("-ec")
 658             else:
 659                 Cmd.append("-e")
 660
 661             for EfiFile in EfiInput:
 662                 Cmd.append(EfiFile)
 663                 InputList.append (EfiFile)
 664
 665         if len(BinaryInput) > 0:
 666             Cmd.append("-b")
 667             for BinFile in BinaryInput:
 668                 Cmd.append(BinFile)
 669                 InputList.append (BinFile)
 670
 671         # Check List
 672         if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList) and not IsMakefile:
 673             return
 674         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))
 675
 676         if ClassCode is not None:
 677             Cmd += ("-l", ClassCode)
 678         if Revision is not None:
 679             Cmd += ("-r", Revision)
 680         if DeviceId is not None:
 681             Cmd += ("-i", DeviceId)
 682         if VendorId is not None:
 683             Cmd += ("-f", VendorId)
 684
 685         Cmd += ("-o", Output)
 686         if IsMakefile:
 687             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 688                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 689         else:
 690             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")
 691
 692     @staticmethod
 693     def GuidTool(Output, Input, ToolPath, Options='', returnValue=[], IsMakefile=False):
 694         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:
 695             return
 696         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 697
 698         Cmd = [ToolPath, ]
 699         Cmd += Options.split(' ')
 700         Cmd += ("-o", Output)
 701         Cmd += Input
 702         if IsMakefile:
 703             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 704                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 705         else:
 706             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)
 707
 708     def CallExternalTool (cmd, errorMess, returnValue=[]):
 709
 710         if type(cmd) not in (tuple, list):
 711             GenFdsGlobalVariable.ErrorLogger("ToolError!  Invalid parameter type in call to CallExternalTool")
 712
 713         if GenFdsGlobalVariable.DebugLevel != -1:
 714             cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))
 715             GenFdsGlobalVariable.InfLogger (cmd)
 716
 717         if GenFdsGlobalVariable.VerboseMode:
 718             cmd += ('-v',)
 719             GenFdsGlobalVariable.InfLogger (cmd)
 720         else:
 721             sys.stdout.write ('#')
 722             sys.stdout.flush()
 723             GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1
 724             if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:
 725                 sys.stdout.write('\n')
 726
 727         try:
 728             PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
 729         except Exception as X:
 730             EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))
 731         (out, error) = PopenObject.communicate()
 732
 733         while PopenObject.returncode is None :
 734             PopenObject.wait()
 735         if returnValue != [] and returnValue[0] != 0:
 736             #get command return value
 737             returnValue[0] = PopenObject.returncode
 738             return
 739         if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:
 740             GenFdsGlobalVariable.InfLogger ("Return Value = %d" % PopenObject.returncode)
 741             GenFdsGlobalVariable.InfLogger (out)
 742             GenFdsGlobalVariable.InfLogger (error)
 743             if PopenObject.returncode != 0:
 744                 print("###", cmd)
 745                 EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)
 746
 747     def VerboseLogger (msg):
 748         EdkLogger.verbose(msg)
 749
 750     def InfLogger (msg):
 751         EdkLogger.info(msg)
 752
 753     def ErrorLogger (msg, File=None, Line=None, ExtraData=None):
 754         EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)
 755
 756     def DebugLogger (Level, msg):
 757         EdkLogger.debug(Level, msg)
 758
 759     ## ReplaceWorkspaceMacro()
 760     #
 761     #   @param  Str           String that may contain macro
 762     #   @param  MacroDict     Dictionary that contains macro value pair
 763     #
 764     def MacroExtend (Str, MacroDict={}, Arch=DataType.TAB_COMMON):
 765         if Str is None :
 766             return None
 767
 768         Dict = {'$(WORKSPACE)'   : GenFdsGlobalVariable.WorkSpaceDir,
 769                 '$(EDK_SOURCE)'  : GenFdsGlobalVariable.EdkSourceDir,
 770 #                '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,
 771                 '$(TARGET)' : GenFdsGlobalVariable.TargetName,
 772                 '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag,
 773                 '$(SPACE)' : ' '
 774                }
 775         OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]
 776         if Arch != DataType.TAB_COMMON and Arch in GenFdsGlobalVariable.ArchList:
 777             OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]
 778
 779         Dict['$(OUTPUT_DIRECTORY)'] = OutputDir
 780
 781         if MacroDict is not None  and len (MacroDict) != 0:
 782             Dict.update(MacroDict)
 783
 784         for key in Dict:
 785             if Str.find(key) >= 0 :
 786                 Str = Str.replace (key, Dict[key])
 787
 788         if Str.find('$(ARCH)') >= 0:
 789             if len(GenFdsGlobalVariable.ArchList) == 1:
 790                 Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])
 791             else:
 792                 EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)
 793
 794         return Str
 795
 796     ## GetPcdValue()
 797     #
 798     #   @param  PcdPattern           pattern that labels a PCD.
 799     #
 800     def GetPcdValue (PcdPattern):
 801         if PcdPattern is None :
 802             return None
 803         PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')
 804         TokenSpace = PcdPair[0]
 805         TokenCName = PcdPair[1]
 806
 807         PcdValue = ''
 808         for Arch in GenFdsGlobalVariable.ArchList:
 809             Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 810             PcdDict = Platform.Pcds
 811             for Key in PcdDict:
 812                 PcdObj = PcdDict[Key]
 813                 if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 814                     if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:
 815                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 816                     if PcdObj.DatumType != DataType.TAB_VOID:
 817                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 818
 819                     PcdValue = PcdObj.DefaultValue
 820                     return PcdValue
 821
 822             for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform,
 823                                                                          Arch,
 824                                                                          GenFdsGlobalVariable.TargetName,
 825                                                                          GenFdsGlobalVariable.ToolChainTag):
 826                 PcdDict = Package.Pcds
 827                 for Key in PcdDict:
 828                     PcdObj = PcdDict[Key]
 829                     if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 830                         if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:
 831                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 832                         if PcdObj.DatumType != DataType.TAB_VOID:
 833                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 834
 835                         PcdValue = PcdObj.DefaultValue
 836                         return PcdValue
 837
 838         return PcdValue
 839
 840     SetDir = staticmethod(SetDir)
 841     SetEnv = staticmethod(SetEnv)
 842     ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)
 843     CallExternalTool = staticmethod(CallExternalTool)
 844     VerboseLogger = staticmethod(VerboseLogger)
 845     InfLogger = staticmethod(InfLogger)
 846     ErrorLogger = staticmethod(ErrorLogger)
 847     DebugLogger = staticmethod(DebugLogger)
 848     MacroExtend = staticmethod (MacroExtend)
 849     GetPcdValue = staticmethod(GetPcdValue)
 850
 851 ## FindExtendTool()
 852 #
 853 #  Find location of tools to process data
 854 #
 855 #  @param  KeyStringList    Filter for inputs of section generation
 856 #  @param  CurrentArchList  Arch list
 857 #  @param  NameGuid         The Guid name
 858 #
 859 def FindExtendTool(KeyStringList, CurrentArchList, NameGuid):
 860     ToolDb = ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDatabase
 861     # if user not specify filter, try to deduce it from global data.
 862     if KeyStringList is None or KeyStringList == []:
 863         Target = GenFdsGlobalVariable.TargetName
 864         ToolChain = GenFdsGlobalVariable.ToolChainTag
 865         if ToolChain not in ToolDb['TOOL_CHAIN_TAG']:
 866             EdkLogger.error("GenFds", GENFDS_ERROR, "Can not find external tool because tool tag %s is not defined in tools_def.txt!" % ToolChain)
 867         KeyStringList = [Target + '_' + ToolChain + '_' + CurrentArchList[0]]
 868         for Arch in CurrentArchList:
 869             if Target + '_' + ToolChain + '_' + Arch not in KeyStringList:
 870                 KeyStringList.append(Target + '_' + ToolChain + '_' + Arch)
 871
 872     if GenFdsGlobalVariable.GuidToolDefinition:
 873         if NameGuid in GenFdsGlobalVariable.GuidToolDefinition:
 874             return GenFdsGlobalVariable.GuidToolDefinition[NameGuid]
 875
 876     ToolDefinition = ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDictionary
 877     ToolPathTmp = None
 878     ToolOption = None
 879     ToolPathKey = None
 880     ToolOptionKey = None
 881     KeyList = None
 882     for ToolDef in ToolDefinition.items():
 883         if NameGuid.lower() == ToolDef[1].lower() :
 884             KeyList = ToolDef[0].split('_')
 885             Key = KeyList[0] + \
 886                   '_' + \
 887                   KeyList[1] + \
 888                   '_' + \
 889                   KeyList[2]
 890             if Key in KeyStringList and KeyList[4] == DataType.TAB_GUID:
 891                 ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 892                 ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 893                 ToolPath = ToolDefinition.get(ToolPathKey)
 894                 ToolOption = ToolDefinition.get(ToolOptionKey)
 895                 if ToolPathTmp is None:
 896                     ToolPathTmp = ToolPath
 897                 else:
 898                     if ToolPathTmp != ToolPath:
 899                         EdkLogger.error("GenFds", GENFDS_ERROR, "Don't know which tool to use, %s or %s ?" % (ToolPathTmp, ToolPath))
 900
 901     BuildOption = {}
 902     for Arch in CurrentArchList:
 903         Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 904         # key is (ToolChainFamily, ToolChain, CodeBase)
 905         for item in Platform.BuildOptions:
 906             if '_PATH' in item[1] or '_FLAGS' in item[1] or '_GUID' in item[1]:
 907                 if not item[0] or (item[0] and GenFdsGlobalVariable.ToolChainFamily== item[0]):
 908                     if item[1] not in BuildOption:
 909                         BuildOption[item[1]] = Platform.BuildOptions[item]
 910         if BuildOption:
 911             ToolList = [DataType.TAB_TOD_DEFINES_TARGET, DataType.TAB_TOD_DEFINES_TOOL_CHAIN_TAG, DataType.TAB_TOD_DEFINES_TARGET_ARCH]
 912             for Index in range(2, -1, -1):
 913                 for Key in list(BuildOption.keys()):
 914                     List = Key.split('_')
 915                     if List[Index] == '*':
 916                         for String in ToolDb[ToolList[Index]]:
 917                             if String in [Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]:
 918                                 List[Index] = String
 919                                 NewKey = '%s_%s_%s_%s_%s' % tuple(List)
 920                                 if NewKey not in BuildOption:
 921                                     BuildOption[NewKey] = BuildOption[Key]
 922                                     continue
 923                                 del BuildOption[Key]
 924                     elif List[Index] not in ToolDb[ToolList[Index]]:
 925                         del BuildOption[Key]
 926     if BuildOption:
 927         if not KeyList:
 928             for Op in BuildOption:
 929                 if NameGuid == BuildOption[Op]:
 930                     KeyList = Op.split('_')
 931                     Key = KeyList[0] + '_' + KeyList[1] +'_' + KeyList[2]
 932                     if Key in KeyStringList and KeyList[4] == DataType.TAB_GUID:
 933                         ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 934                         ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 935         if ToolPathKey in BuildOption:
 936             ToolPathTmp = BuildOption[ToolPathKey]
 937         if ToolOptionKey in BuildOption:
 938             ToolOption = BuildOption[ToolOptionKey]
 939
 940     GenFdsGlobalVariable.GuidToolDefinition[NameGuid] = (ToolPathTmp, ToolOption)
 941     return ToolPathTmp, ToolOption