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 GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,
 597                               Strip=False, Replace=False, TimeStamp=None, Join=False,
 598                               Align=None, Padding=None, Convert=False, IsMakefile=False):
 599         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:
 600             return
 601         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 602
 603         Cmd = ["GenFw"]
 604         if Type.lower() == "te":
 605             Cmd.append("-t")
 606         if SubType:
 607             Cmd += ("-e", SubType)
 608         if TimeStamp:
 609             Cmd += ("-s", TimeStamp)
 610         if Align:
 611             Cmd += ("-a", Align)
 612         if Padding:
 613             Cmd += ("-p", Padding)
 614         if Zero:
 615             Cmd.append("-z")
 616         if Strip:
 617             Cmd.append("-l")
 618         if Replace:
 619             Cmd.append("-r")
 620         if Join:
 621             Cmd.append("-j")
 622         if Convert:
 623             Cmd.append("-m")
 624         Cmd += ("-o", Output)
 625         Cmd += Input
 626         if IsMakefile:
 627             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 628                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 629         else:
 630             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")
 631
 632     @staticmethod
 633     def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,
 634                         Revision=None, DeviceId=None, VendorId=None, IsMakefile=False):
 635         InputList = []
 636         Cmd = ["EfiRom"]
 637         if len(EfiInput) > 0:
 638
 639             if Compress:
 640                 Cmd.append("-ec")
 641             else:
 642                 Cmd.append("-e")
 643
 644             for EfiFile in EfiInput:
 645                 Cmd.append(EfiFile)
 646                 InputList.append (EfiFile)
 647
 648         if len(BinaryInput) > 0:
 649             Cmd.append("-b")
 650             for BinFile in BinaryInput:
 651                 Cmd.append(BinFile)
 652                 InputList.append (BinFile)
 653
 654         # Check List
 655         if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList) and not IsMakefile:
 656             return
 657         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))
 658
 659         if ClassCode is not None:
 660             Cmd += ("-l", ClassCode)
 661         if Revision is not None:
 662             Cmd += ("-r", Revision)
 663         if DeviceId is not None:
 664             Cmd += ("-i", DeviceId)
 665         if VendorId is not None:
 666             Cmd += ("-f", VendorId)
 667
 668         Cmd += ("-o", Output)
 669         if IsMakefile:
 670             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 671                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 672         else:
 673             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")
 674
 675     @staticmethod
 676     def GuidTool(Output, Input, ToolPath, Options='', returnValue=[], IsMakefile=False):
 677         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:
 678             return
 679         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 680
 681         Cmd = [ToolPath, ]
 682         Cmd += Options.split(' ')
 683         Cmd += ("-o", Output)
 684         Cmd += Input
 685         if IsMakefile:
 686             if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:
 687                 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())
 688         else:
 689             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)
 690
 691     def CallExternalTool (cmd, errorMess, returnValue=[]):
 692
 693         if type(cmd) not in (tuple, list):
 694             GenFdsGlobalVariable.ErrorLogger("ToolError!  Invalid parameter type in call to CallExternalTool")
 695
 696         if GenFdsGlobalVariable.DebugLevel != -1:
 697             cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))
 698             GenFdsGlobalVariable.InfLogger (cmd)
 699
 700         if GenFdsGlobalVariable.VerboseMode:
 701             cmd += ('-v',)
 702             GenFdsGlobalVariable.InfLogger (cmd)
 703         else:
 704             sys.stdout.write ('#')
 705             sys.stdout.flush()
 706             GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1
 707             if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:
 708                 sys.stdout.write('\n')
 709
 710         try:
 711             PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
 712         except Exception as X:
 713             EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))
 714         (out, error) = PopenObject.communicate()
 715
 716         while PopenObject.returncode is None :
 717             PopenObject.wait()
 718         if returnValue != [] and returnValue[0] != 0:
 719             #get command return value
 720             returnValue[0] = PopenObject.returncode
 721             return
 722         if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:
 723             GenFdsGlobalVariable.InfLogger ("Return Value = %d" % PopenObject.returncode)
 724             GenFdsGlobalVariable.InfLogger (out)
 725             GenFdsGlobalVariable.InfLogger (error)
 726             if PopenObject.returncode != 0:
 727                 print("###", cmd)
 728                 EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)
 729
 730     def VerboseLogger (msg):
 731         EdkLogger.verbose(msg)
 732
 733     def InfLogger (msg):
 734         EdkLogger.info(msg)
 735
 736     def ErrorLogger (msg, File=None, Line=None, ExtraData=None):
 737         EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)
 738
 739     def DebugLogger (Level, msg):
 740         EdkLogger.debug(Level, msg)
 741
 742     ## ReplaceWorkspaceMacro()
 743     #
 744     #   @param  Str           String that may contain macro
 745     #   @param  MacroDict     Dictionary that contains macro value pair
 746     #
 747     def MacroExtend (Str, MacroDict={}, Arch=DataType.TAB_COMMON):
 748         if Str is None :
 749             return None
 750
 751         Dict = {'$(WORKSPACE)'   : GenFdsGlobalVariable.WorkSpaceDir,
 752                 '$(EDK_SOURCE)'  : GenFdsGlobalVariable.EdkSourceDir,
 753 #                '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,
 754                 '$(TARGET)' : GenFdsGlobalVariable.TargetName,
 755                 '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag,
 756                 '$(SPACE)' : ' '
 757                }
 758         OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]
 759         if Arch != DataType.TAB_COMMON and Arch in GenFdsGlobalVariable.ArchList:
 760             OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]
 761
 762         Dict['$(OUTPUT_DIRECTORY)'] = OutputDir
 763
 764         if MacroDict is not None  and len (MacroDict) != 0:
 765             Dict.update(MacroDict)
 766
 767         for key in Dict:
 768             if Str.find(key) >= 0 :
 769                 Str = Str.replace (key, Dict[key])
 770
 771         if Str.find('$(ARCH)') >= 0:
 772             if len(GenFdsGlobalVariable.ArchList) == 1:
 773                 Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])
 774             else:
 775                 EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)
 776
 777         return Str
 778
 779     ## GetPcdValue()
 780     #
 781     #   @param  PcdPattern           pattern that labels a PCD.
 782     #
 783     def GetPcdValue (PcdPattern):
 784         if PcdPattern is None :
 785             return None
 786         PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')
 787         TokenSpace = PcdPair[0]
 788         TokenCName = PcdPair[1]
 789
 790         PcdValue = ''
 791         for Arch in GenFdsGlobalVariable.ArchList:
 792             Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 793             PcdDict = Platform.Pcds
 794             for Key in PcdDict:
 795                 PcdObj = PcdDict[Key]
 796                 if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 797                     if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:
 798                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 799                     if PcdObj.DatumType != DataType.TAB_VOID:
 800                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 801
 802                     PcdValue = PcdObj.DefaultValue
 803                     return PcdValue
 804
 805             for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform,
 806                                                                          Arch,
 807                                                                          GenFdsGlobalVariable.TargetName,
 808                                                                          GenFdsGlobalVariable.ToolChainTag):
 809                 PcdDict = Package.Pcds
 810                 for Key in PcdDict:
 811                     PcdObj = PcdDict[Key]
 812                     if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 813                         if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:
 814                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 815                         if PcdObj.DatumType != DataType.TAB_VOID:
 816                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 817
 818                         PcdValue = PcdObj.DefaultValue
 819                         return PcdValue
 820
 821         return PcdValue
 822
 823     SetDir = staticmethod(SetDir)
 824     SetEnv = staticmethod(SetEnv)
 825     ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)
 826     CallExternalTool = staticmethod(CallExternalTool)
 827     VerboseLogger = staticmethod(VerboseLogger)
 828     InfLogger = staticmethod(InfLogger)
 829     ErrorLogger = staticmethod(ErrorLogger)
 830     DebugLogger = staticmethod(DebugLogger)
 831     MacroExtend = staticmethod (MacroExtend)
 832     GetPcdValue = staticmethod(GetPcdValue)
 833
 834 ## FindExtendTool()
 835 #
 836 #  Find location of tools to process data
 837 #
 838 #  @param  KeyStringList    Filter for inputs of section generation
 839 #  @param  CurrentArchList  Arch list
 840 #  @param  NameGuid         The Guid name
 841 #
 842 def FindExtendTool(KeyStringList, CurrentArchList, NameGuid):
 843     ToolDb = ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDatabase
 844     # if user not specify filter, try to deduce it from global data.
 845     if KeyStringList is None or KeyStringList == []:
 846         Target = GenFdsGlobalVariable.TargetName
 847         ToolChain = GenFdsGlobalVariable.ToolChainTag
 848         if ToolChain not in ToolDb['TOOL_CHAIN_TAG']:
 849             EdkLogger.error("GenFds", GENFDS_ERROR, "Can not find external tool because tool tag %s is not defined in tools_def.txt!" % ToolChain)
 850         KeyStringList = [Target + '_' + ToolChain + '_' + CurrentArchList[0]]
 851         for Arch in CurrentArchList:
 852             if Target + '_' + ToolChain + '_' + Arch not in KeyStringList:
 853                 KeyStringList.append(Target + '_' + ToolChain + '_' + Arch)
 854
 855     if GenFdsGlobalVariable.GuidToolDefinition:
 856         if NameGuid in GenFdsGlobalVariable.GuidToolDefinition:
 857             return GenFdsGlobalVariable.GuidToolDefinition[NameGuid]
 858
 859     ToolDefinition = ToolDefDict(GenFdsGlobalVariable.ConfDir).ToolsDefTxtDictionary
 860     ToolPathTmp = None
 861     ToolOption = None
 862     ToolPathKey = None
 863     ToolOptionKey = None
 864     KeyList = None
 865     for ToolDef in ToolDefinition.items():
 866         if NameGuid.lower() == ToolDef[1].lower() :
 867             KeyList = ToolDef[0].split('_')
 868             Key = KeyList[0] + \
 869                   '_' + \
 870                   KeyList[1] + \
 871                   '_' + \
 872                   KeyList[2]
 873             if Key in KeyStringList and KeyList[4] == DataType.TAB_GUID:
 874                 ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 875                 ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 876                 ToolPath = ToolDefinition.get(ToolPathKey)
 877                 ToolOption = ToolDefinition.get(ToolOptionKey)
 878                 if ToolPathTmp is None:
 879                     ToolPathTmp = ToolPath
 880                 else:
 881                     if ToolPathTmp != ToolPath:
 882                         EdkLogger.error("GenFds", GENFDS_ERROR, "Don't know which tool to use, %s or %s ?" % (ToolPathTmp, ToolPath))
 883
 884     BuildOption = {}
 885     for Arch in CurrentArchList:
 886         Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 887         # key is (ToolChainFamily, ToolChain, CodeBase)
 888         for item in Platform.BuildOptions:
 889             if '_PATH' in item[1] or '_FLAGS' in item[1] or '_GUID' in item[1]:
 890                 if not item[0] or (item[0] and GenFdsGlobalVariable.ToolChainFamily== item[0]):
 891                     if item[1] not in BuildOption:
 892                         BuildOption[item[1]] = Platform.BuildOptions[item]
 893         if BuildOption:
 894             ToolList = [DataType.TAB_TOD_DEFINES_TARGET, DataType.TAB_TOD_DEFINES_TOOL_CHAIN_TAG, DataType.TAB_TOD_DEFINES_TARGET_ARCH]
 895             for Index in range(2, -1, -1):
 896                 for Key in list(BuildOption.keys()):
 897                     List = Key.split('_')
 898                     if List[Index] == '*':
 899                         for String in ToolDb[ToolList[Index]]:
 900                             if String in [Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]:
 901                                 List[Index] = String
 902                                 NewKey = '%s_%s_%s_%s_%s' % tuple(List)
 903                                 if NewKey not in BuildOption:
 904                                     BuildOption[NewKey] = BuildOption[Key]
 905                                     continue
 906                                 del BuildOption[Key]
 907                     elif List[Index] not in ToolDb[ToolList[Index]]:
 908                         del BuildOption[Key]
 909     if BuildOption:
 910         if not KeyList:
 911             for Op in BuildOption:
 912                 if NameGuid == BuildOption[Op]:
 913                     KeyList = Op.split('_')
 914                     Key = KeyList[0] + '_' + KeyList[1] +'_' + KeyList[2]
 915                     if Key in KeyStringList and KeyList[4] == DataType.TAB_GUID:
 916                         ToolPathKey   = Key + '_' + KeyList[3] + '_PATH'
 917                         ToolOptionKey = Key + '_' + KeyList[3] + '_FLAGS'
 918         if ToolPathKey in BuildOption:
 919             ToolPathTmp = BuildOption[ToolPathKey]
 920         if ToolOptionKey in BuildOption:
 921             ToolOption = BuildOption[ToolOptionKey]
 922
 923     GenFdsGlobalVariable.GuidToolDefinition[NameGuid] = (ToolPathTmp, ToolOption)
 924     return ToolPathTmp, ToolOption