BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py

   1 ## @file
   2 # Global variables for GenFds
   3 #
   4 #  Copyright (c) 2007 - 2016, 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 import Common.LongFilePathOs as os
  19 import sys
  20 import subprocess
  21 import struct
  22 import array
  23
  24 from Common.BuildToolError import *
  25 from Common import EdkLogger
  26 from Common.Misc import SaveFileOnChange
  27
  28 from Common.TargetTxtClassObject import TargetTxtClassObject
  29 from Common.ToolDefClassObject import ToolDefClassObject
  30 from AutoGen.BuildEngine import BuildRule
  31 import Common.DataType as DataType
  32 from Common.Misc import PathClass
  33 from Common.LongFilePathSupport import OpenLongFilePath as open
  34 from Common.MultipleWorkspace import MultipleWorkspace as mws
  35
  36 ## Global variables
  37 #
  38 #
  39 class GenFdsGlobalVariable:
  40     FvDir = ''
  41     OutputDirDict = {}
  42     BinDir = ''
  43     # will be FvDir + os.sep + 'Ffs'
  44     FfsDir = ''
  45     FdfParser = None
  46     LibDir = ''
  47     WorkSpace = None
  48     WorkSpaceDir = ''
  49     ConfDir = ''
  50     EdkSourceDir = ''
  51     OutputDirFromDscDict = {}
  52     TargetName = ''
  53     ToolChainTag = ''
  54     RuleDict = {}
  55     ArchList = None
  56     VtfDict = {}
  57     ActivePlatform = None
  58     FvAddressFileName = ''
  59     VerboseMode = False
  60     DebugLevel = -1
  61     SharpCounter = 0
  62     SharpNumberPerLine = 40
  63     FdfFile = ''
  64     FdfFileTimeStamp = 0
  65     FixedLoadAddress = False
  66     PlatformName = ''
  67
  68     BuildRuleFamily = "MSFT"
  69     ToolChainFamily = "MSFT"
  70     __BuildRuleDatabase = None
  71     GuidToolDefinition = {}
  72
  73     #
  74     # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.
  75     # At the beginning of each generation of FV, false flag is appended to the list,
  76     # after the call to GenerateSection returns, check the size of the output file,
  77     # if it is greater than 0xFFFFFF, the tail flag in list is set to true,
  78     # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.
  79     # At the end of generation of FV, pop the flag.
  80     # List is used as a stack to handle nested FV generation.
  81     #
  82     LargeFileInFvFlags = []
  83     EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'
  84     LARGE_FILE_SIZE = 0x1000000
  85
  86     SectionHeader = struct.Struct("3B 1B")
  87
  88     ## LoadBuildRule
  89     #
  90     @staticmethod
  91     def __LoadBuildRule():
  92         if GenFdsGlobalVariable.__BuildRuleDatabase:
  93             return GenFdsGlobalVariable.__BuildRuleDatabase
  94         BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.ConfDir, "target.txt"))
  95         TargetTxt = TargetTxtClassObject()
  96         if os.path.isfile(BuildConfigurationFile) == True:
  97             TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)
  98             if DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF in TargetTxt.TargetTxtDictionary:
  99                 BuildRuleFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]
 100             if BuildRuleFile in [None, '']:
 101                 BuildRuleFile = 'Conf/build_rule.txt'
 102             GenFdsGlobalVariable.__BuildRuleDatabase = BuildRule(BuildRuleFile)
 103             ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]
 104             if ToolDefinitionFile == '':
 105                 ToolDefinitionFile = "Conf/tools_def.txt"
 106             if os.path.isfile(ToolDefinitionFile):
 107                 ToolDef = ToolDefClassObject()
 108                 ToolDef.LoadToolDefFile(ToolDefinitionFile)
 109                 ToolDefinition = ToolDef.ToolsDefTxtDatabase
 110                 if DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDefinition \
 111                    and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY] \
 112                    and ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]:
 113                     GenFdsGlobalVariable.BuildRuleFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]
 114
 115                 if DataType.TAB_TOD_DEFINES_FAMILY in ToolDefinition \
 116                    and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY] \
 117                    and ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]:
 118                     GenFdsGlobalVariable.ToolChainFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]
 119         return GenFdsGlobalVariable.__BuildRuleDatabase
 120
 121     ## GetBuildRules
 122     #    @param Inf: object of InfBuildData
 123     #    @param Arch: current arch
 124     #
 125     @staticmethod
 126     def GetBuildRules(Inf, Arch):
 127         if not Arch:
 128             Arch = 'COMMON'
 129
 130         if not Arch in GenFdsGlobalVariable.OutputDirDict:
 131             return {}
 132
 133         BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule()
 134         if not BuildRuleDatabase:
 135             return {}
 136
 137         PathClassObj = PathClass(Inf.MetaFile.File,
 138                                  GenFdsGlobalVariable.WorkSpaceDir)
 139         Macro = {}
 140         Macro["WORKSPACE"             ] = GenFdsGlobalVariable.WorkSpaceDir
 141         Macro["MODULE_NAME"           ] = Inf.BaseName
 142         Macro["MODULE_GUID"           ] = Inf.Guid
 143         Macro["MODULE_VERSION"        ] = Inf.Version
 144         Macro["MODULE_TYPE"           ] = Inf.ModuleType
 145         Macro["MODULE_FILE"           ] = str(PathClassObj)
 146         Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName
 147         Macro["MODULE_RELATIVE_DIR"   ] = PathClassObj.SubDir
 148         Macro["MODULE_DIR"            ] = PathClassObj.SubDir
 149
 150         Macro["BASE_NAME"             ] = Inf.BaseName
 151
 152         Macro["ARCH"                  ] = Arch
 153         Macro["TOOLCHAIN"             ] = GenFdsGlobalVariable.ToolChainTag
 154         Macro["TOOLCHAIN_TAG"         ] = GenFdsGlobalVariable.ToolChainTag
 155         Macro["TOOL_CHAIN_TAG"        ] = GenFdsGlobalVariable.ToolChainTag
 156         Macro["TARGET"                ] = GenFdsGlobalVariable.TargetName
 157
 158         Macro["BUILD_DIR"             ] = GenFdsGlobalVariable.OutputDirDict[Arch]
 159         Macro["BIN_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
 160         Macro["LIB_DIR"               ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)
 161         BuildDir = os.path.join(
 162             GenFdsGlobalVariable.OutputDirDict[Arch],
 163             Arch,
 164             PathClassObj.SubDir,
 165             PathClassObj.BaseName
 166         )
 167         Macro["MODULE_BUILD_DIR"      ] = BuildDir
 168         Macro["OUTPUT_DIR"            ] = os.path.join(BuildDir, "OUTPUT")
 169         Macro["DEBUG_DIR"             ] = os.path.join(BuildDir, "DEBUG")
 170
 171         BuildRules = {}
 172         for Type in BuildRuleDatabase.FileTypeList:
 173             #first try getting build rule by BuildRuleFamily
 174             RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
 175             if not RuleObject:
 176                 # build type is always module type, but ...
 177                 if Inf.ModuleType != Inf.BuildType:
 178                     RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.BuildRuleFamily]
 179             #second try getting build rule by ToolChainFamily
 180             if not RuleObject:
 181                 RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.ToolChainFamily]
 182                 if not RuleObject:
 183                     # build type is always module type, but ...
 184                     if Inf.ModuleType != Inf.BuildType:
 185                         RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.ToolChainFamily]
 186             if not RuleObject:
 187                 continue
 188             RuleObject = RuleObject.Instantiate(Macro)
 189             BuildRules[Type] = RuleObject
 190             for Ext in RuleObject.SourceFileExtList:
 191                 BuildRules[Ext] = RuleObject
 192         return BuildRules
 193
 194     ## GetModuleCodaTargetList
 195     #
 196     #    @param Inf: object of InfBuildData
 197     #    @param Arch: current arch
 198     #
 199     @staticmethod
 200     def GetModuleCodaTargetList(Inf, Arch):
 201         BuildRules = GenFdsGlobalVariable.GetBuildRules(Inf, Arch)
 202         if not BuildRules:
 203             return []
 204
 205         TargetList = set()
 206         FileList = []
 207
 208         if not Inf.IsBinaryModule:
 209             for File in Inf.Sources:
 210                 if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \
 211                     File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily):
 212                     FileList.append((File, DataType.TAB_UNKNOWN_FILE))
 213
 214         for File in Inf.Binaries:
 215             if File.Target in ['COMMON', '*', GenFdsGlobalVariable.TargetName]:
 216                 FileList.append((File, File.Type))
 217
 218         for File, FileType in FileList:
 219             LastTarget = None
 220             RuleChain = []
 221             SourceList = [File]
 222             Index = 0
 223             while Index < len(SourceList):
 224                 Source = SourceList[Index]
 225                 Index = Index + 1
 226
 227                 if File.IsBinary and File == Source and Inf.Binaries != None and File in Inf.Binaries:
 228                     # Skip all files that are not binary libraries
 229                     if not Inf.LibraryClass:
 230                         continue
 231                     RuleObject = BuildRules[DataType.TAB_DEFAULT_BINARY_FILE]
 232                 elif FileType in BuildRules:
 233                     RuleObject = BuildRules[FileType]
 234                 elif Source.Ext in BuildRules:
 235                     RuleObject = BuildRules[Source.Ext]
 236                 else:
 237                     # stop at no more rules
 238                     if LastTarget:
 239                         TargetList.add(str(LastTarget))
 240                     break
 241
 242                 FileType = RuleObject.SourceFileType
 243
 244                 # stop at STATIC_LIBRARY for library
 245                 if Inf.LibraryClass and FileType == DataType.TAB_STATIC_LIBRARY:
 246                     if LastTarget:
 247                         TargetList.add(str(LastTarget))
 248                     break
 249
 250                 Target = RuleObject.Apply(Source)
 251                 if not Target:
 252                     if LastTarget:
 253                         TargetList.add(str(LastTarget))
 254                     break
 255                 elif not Target.Outputs:
 256                     # Only do build for target with outputs
 257                     TargetList.add(str(Target))
 258
 259                 # to avoid cyclic rule
 260                 if FileType in RuleChain:
 261                     break
 262
 263                 RuleChain.append(FileType)
 264                 SourceList.extend(Target.Outputs)
 265                 LastTarget = Target
 266                 FileType = DataType.TAB_UNKNOWN_FILE
 267
 268         return list(TargetList)
 269
 270     ## SetDir()
 271     #
 272     #   @param  OutputDir           Output directory
 273     #   @param  FdfParser           FDF contents parser
 274     #   @param  Workspace           The directory of workspace
 275     #   @param  ArchList            The Arch list of platform
 276     #
 277     def SetDir (OutputDir, FdfParser, WorkSpace, ArchList):
 278         GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir :%s" % OutputDir)
 279 #        GenFdsGlobalVariable.OutputDirDict = OutputDir
 280         GenFdsGlobalVariable.FdfParser = FdfParser
 281         GenFdsGlobalVariable.WorkSpace = WorkSpace
 282         GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], 'FV')
 283         if not os.path.exists(GenFdsGlobalVariable.FvDir) :
 284             os.makedirs(GenFdsGlobalVariable.FvDir)
 285         GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')
 286         if not os.path.exists(GenFdsGlobalVariable.FfsDir) :
 287             os.makedirs(GenFdsGlobalVariable.FfsDir)
 288
 289         T_CHAR_LF = '\n'
 290         #
 291         # Create FV Address inf file
 292         #
 293         GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')
 294         FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')
 295         #
 296         # Add [Options]
 297         #
 298         FvAddressFile.writelines("[options]" + T_CHAR_LF)
 299         BsAddress = '0'
 300         for Arch in ArchList:
 301             if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress:
 302                 BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress
 303                 break
 304
 305         FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \
 306                                        BsAddress + \
 307                                        T_CHAR_LF)
 308
 309         RtAddress = '0'
 310         for Arch in ArchList:
 311             if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress:
 312                 RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress
 313
 314         FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \
 315                                        RtAddress + \
 316                                        T_CHAR_LF)
 317
 318         FvAddressFile.close()
 319
 320     ## ReplaceWorkspaceMacro()
 321     #
 322     #   @param  String           String that may contain macro
 323     #
 324     def ReplaceWorkspaceMacro(String):
 325         String = mws.handleWsMacro(String)
 326         Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir)
 327         if os.path.exists(Str):
 328             if not os.path.isabs(Str):
 329                 Str = os.path.abspath(Str)
 330         else:
 331             Str = mws.join(GenFdsGlobalVariable.WorkSpaceDir, String)
 332         return os.path.normpath(Str)
 333
 334     ## Check if the input files are newer than output files
 335     #
 336     #   @param  Output          Path of output file
 337     #   @param  Input           Path list of input files
 338     #
 339     #   @retval True            if Output doesn't exist, or any Input is newer
 340     #   @retval False           if all Input is older than Output
 341     #
 342     @staticmethod
 343     def NeedsUpdate(Output, Input):
 344         if not os.path.exists(Output):
 345             return True
 346         # always update "Output" if no "Input" given
 347         if Input == None or len(Input) == 0:
 348             return True
 349
 350         # if fdf file is changed after the 'Output" is generated, update the 'Output'
 351         OutputTime = os.path.getmtime(Output)
 352         if GenFdsGlobalVariable.FdfFileTimeStamp > OutputTime:
 353             return True
 354
 355         for F in Input:
 356             # always update "Output" if any "Input" doesn't exist
 357             if not os.path.exists(F):
 358                 return True
 359             # always update "Output" if any "Input" is newer than "Output"
 360             if os.path.getmtime(F) > OutputTime:
 361                 return True
 362         return False
 363
 364     @staticmethod
 365     def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,
 366                         GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=None, BuildNumber=None):
 367         Cmd = ["GenSec"]
 368         if Type not in [None, '']:
 369             Cmd += ["-s", Type]
 370         if CompressionType not in [None, '']:
 371             Cmd += ["-c", CompressionType]
 372         if Guid != None:
 373             Cmd += ["-g", Guid]
 374         if GuidHdrLen not in [None, '']:
 375             Cmd += ["-l", GuidHdrLen]
 376         if len(GuidAttr) != 0:
 377             #Add each guided attribute
 378             for Attr in GuidAttr:
 379                 Cmd += ["-r", Attr]
 380         if InputAlign != None:
 381             #Section Align is only for dummy section without section type
 382             for SecAlign in InputAlign:
 383                 Cmd += ["--sectionalign", SecAlign]
 384
 385         CommandFile = Output + '.txt'
 386         if Ui not in [None, '']:
 387             #Cmd += ["-n", '"' + Ui + '"']
 388             SectionData = array.array('B', [0, 0, 0, 0])
 389             SectionData.fromstring(Ui.encode("utf_16_le"))
 390             SectionData.append(0)
 391             SectionData.append(0)
 392             Len = len(SectionData)
 393             GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)
 394             SaveFileOnChange(Output, SectionData.tostring())
 395         elif Ver not in [None, '']:
 396             Cmd += ["-n", Ver]
 397             if BuildNumber:
 398                 Cmd += ["-j", BuildNumber]
 399             Cmd += ["-o", Output]
 400
 401             SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 402             if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 403                 return
 404
 405             GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
 406         else:
 407             Cmd += ["-o", Output]
 408             Cmd += Input
 409
 410             SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 411             if GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 412                 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 413                 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")
 414
 415             if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and
 416                 GenFdsGlobalVariable.LargeFileInFvFlags):
 417                 GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True
 418
 419     @staticmethod
 420     def GetAlignment (AlignString):
 421         if AlignString == None:
 422             return 0
 423         if AlignString in ("1K", "2K", "4K", "8K", "16K", "32K", "64K"):
 424             return int (AlignString.rstrip('K')) * 1024
 425         else:
 426             return int (AlignString)
 427
 428     @staticmethod
 429     def GenerateFfs(Output, Input, Type, Guid, Fixed=False, CheckSum=False, Align=None,
 430                     SectionAlign=None):
 431         Cmd = ["GenFfs", "-t", Type, "-g", Guid]
 432         if Fixed == True:
 433             Cmd += ["-x"]
 434         if CheckSum:
 435             Cmd += ["-s"]
 436         if Align not in [None, '']:
 437             Cmd += ["-a", Align]
 438
 439         Cmd += ["-o", Output]
 440         for I in range(0, len(Input)):
 441             Cmd += ("-i", Input[I])
 442             if SectionAlign not in [None, '', []] and SectionAlign[I] not in [None, '']:
 443                 Cmd += ("-n", SectionAlign[I])
 444
 445         CommandFile = Output + '.txt'
 446         SaveFileOnChange(CommandFile, ' '.join(Cmd), False)
 447         if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):
 448             return
 449         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 450
 451         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FFS")
 452
 453     @staticmethod
 454     def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,
 455                                AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):
 456         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):
 457             return
 458         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 459
 460         Cmd = ["GenFv"]
 461         if BaseAddress not in [None, '']:
 462             Cmd += ["-r", BaseAddress]
 463
 464         if ForceRebase == False:
 465             Cmd += ["-F", "FALSE"]
 466         elif ForceRebase == True:
 467             Cmd += ["-F", "TRUE"]
 468
 469         if Capsule:
 470             Cmd += ["-c"]
 471         if Dump:
 472             Cmd += ["-p"]
 473         if AddressFile not in [None, '']:
 474             Cmd += ["-a", AddressFile]
 475         if MapFile not in [None, '']:
 476             Cmd += ["-m", MapFile]
 477         if FileSystemGuid:
 478             Cmd += ["-g", FileSystemGuid]
 479         Cmd += ["-o", Output]
 480         for I in Input:
 481             Cmd += ["-i", I]
 482
 483         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FV")
 484
 485     @staticmethod
 486     def GenerateVtf(Output, Input, BaseAddress=None, FvSize=None):
 487         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
 488             return
 489         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 490
 491         Cmd = ["GenVtf"]
 492         if BaseAddress not in [None, ''] and FvSize not in [None, ''] \
 493             and len(BaseAddress) == len(FvSize):
 494             for I in range(0, len(BaseAddress)):
 495                 Cmd += ["-r", BaseAddress[I], "-s", FvSize[I]]
 496         Cmd += ["-o", Output]
 497         for F in Input:
 498             Cmd += ["-f", F]
 499
 500         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate VTF")
 501
 502     @staticmethod
 503     def GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,
 504                               Strip=False, Replace=False, TimeStamp=None, Join=False,
 505                               Align=None, Padding=None, Convert=False):
 506         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
 507             return
 508         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 509
 510         Cmd = ["GenFw"]
 511         if Type.lower() == "te":
 512             Cmd += ["-t"]
 513         if SubType not in [None, '']:
 514             Cmd += ["-e", SubType]
 515         if TimeStamp not in [None, '']:
 516             Cmd += ["-s", TimeStamp]
 517         if Align not in [None, '']:
 518             Cmd += ["-a", Align]
 519         if Padding not in [None, '']:
 520             Cmd += ["-p", Padding]
 521         if Zero:
 522             Cmd += ["-z"]
 523         if Strip:
 524             Cmd += ["-l"]
 525         if Replace:
 526             Cmd += ["-r"]
 527         if Join:
 528             Cmd += ["-j"]
 529         if Convert:
 530             Cmd += ["-m"]
 531         Cmd += ["-o", Output]
 532         Cmd += Input
 533
 534         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")
 535
 536     @staticmethod
 537     def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,
 538                         Revision=None, DeviceId=None, VendorId=None):
 539         InputList = []
 540         Cmd = ["EfiRom"]
 541         if len(EfiInput) > 0:
 542
 543             if Compress:
 544                 Cmd += ["-ec"]
 545             else:
 546                 Cmd += ["-e"]
 547
 548             for EfiFile in EfiInput:
 549                 Cmd += [EfiFile]
 550                 InputList.append (EfiFile)
 551
 552         if len(BinaryInput) > 0:
 553             Cmd += ["-b"]
 554             for BinFile in BinaryInput:
 555                 Cmd += [BinFile]
 556                 InputList.append (BinFile)
 557
 558         # Check List
 559         if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList):
 560             return
 561         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))
 562
 563         if ClassCode != None:
 564             Cmd += ["-l", ClassCode]
 565         if Revision != None:
 566             Cmd += ["-r", Revision]
 567         if DeviceId != None:
 568             Cmd += ["-i", DeviceId]
 569         if VendorId != None:
 570             Cmd += ["-f", VendorId]
 571
 572         Cmd += ["-o", Output]
 573         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")
 574
 575     @staticmethod
 576     def GuidTool(Output, Input, ToolPath, Options='', returnValue=[]):
 577         if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):
 578             return
 579         GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))
 580
 581         Cmd = [ToolPath, ]
 582         Cmd += Options.split(' ')
 583         Cmd += ["-o", Output]
 584         Cmd += Input
 585
 586         GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)
 587
 588     def CallExternalTool (cmd, errorMess, returnValue=[]):
 589
 590         if type(cmd) not in (tuple, list):
 591             GenFdsGlobalVariable.ErrorLogger("ToolError!  Invalid parameter type in call to CallExternalTool")
 592
 593         if GenFdsGlobalVariable.DebugLevel != -1:
 594             cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))
 595             GenFdsGlobalVariable.InfLogger (cmd)
 596
 597         if GenFdsGlobalVariable.VerboseMode:
 598             cmd += ('-v',)
 599             GenFdsGlobalVariable.InfLogger (cmd)
 600         else:
 601             sys.stdout.write ('#')
 602             sys.stdout.flush()
 603             GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1
 604             if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:
 605                 sys.stdout.write('\n')
 606
 607         try:
 608             PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
 609         except Exception, X:
 610             EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))
 611         (out, error) = PopenObject.communicate()
 612
 613         while PopenObject.returncode == None :
 614             PopenObject.wait()
 615         if returnValue != [] and returnValue[0] != 0:
 616             #get command return value
 617             returnValue[0] = PopenObject.returncode
 618             return
 619         if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:
 620             GenFdsGlobalVariable.InfLogger ("Return Value = %d" % PopenObject.returncode)
 621             GenFdsGlobalVariable.InfLogger (out)
 622             GenFdsGlobalVariable.InfLogger (error)
 623             if PopenObject.returncode != 0:
 624                 print "###", cmd
 625                 EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)
 626
 627     def VerboseLogger (msg):
 628         EdkLogger.verbose(msg)
 629
 630     def InfLogger (msg):
 631         EdkLogger.info(msg)
 632
 633     def ErrorLogger (msg, File=None, Line=None, ExtraData=None):
 634         EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)
 635
 636     def DebugLogger (Level, msg):
 637         EdkLogger.debug(Level, msg)
 638
 639     ## ReplaceWorkspaceMacro()
 640     #
 641     #   @param  Str           String that may contain macro
 642     #   @param  MacroDict     Dictionary that contains macro value pair
 643     #
 644     def MacroExtend (Str, MacroDict={}, Arch='COMMON'):
 645         if Str == None :
 646             return None
 647
 648         Dict = {'$(WORKSPACE)'   : GenFdsGlobalVariable.WorkSpaceDir,
 649                 '$(EDK_SOURCE)'  : GenFdsGlobalVariable.EdkSourceDir,
 650 #                '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,
 651                 '$(TARGET)' : GenFdsGlobalVariable.TargetName,
 652                 '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag,
 653                 '$(SPACE)' : ' '
 654                }
 655         OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]
 656         if Arch != 'COMMON' and Arch in GenFdsGlobalVariable.ArchList:
 657             OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]
 658
 659         Dict['$(OUTPUT_DIRECTORY)'] = OutputDir
 660
 661         if MacroDict != None  and len (MacroDict) != 0:
 662             Dict.update(MacroDict)
 663
 664         for key in Dict.keys():
 665             if Str.find(key) >= 0 :
 666                 Str = Str.replace (key, Dict[key])
 667
 668         if Str.find('$(ARCH)') >= 0:
 669             if len(GenFdsGlobalVariable.ArchList) == 1:
 670                 Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])
 671             else:
 672                 EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)
 673
 674         return Str
 675
 676     ## GetPcdValue()
 677     #
 678     #   @param  PcdPattern           pattern that labels a PCD.
 679     #
 680     def GetPcdValue (PcdPattern):
 681         if PcdPattern == None :
 682             return None
 683         PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')
 684         TokenSpace = PcdPair[0]
 685         TokenCName = PcdPair[1]
 686
 687         PcdValue = ''
 688         for Arch in GenFdsGlobalVariable.ArchList:
 689             Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]
 690             PcdDict = Platform.Pcds
 691             for Key in PcdDict:
 692                 PcdObj = PcdDict[Key]
 693                 if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 694                     if PcdObj.Type != 'FixedAtBuild':
 695                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 696                     if PcdObj.DatumType != 'VOID*':
 697                         EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 698
 699                     PcdValue = PcdObj.DefaultValue
 700                     return PcdValue
 701
 702             for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform,
 703                                                                          Arch,
 704                                                                          GenFdsGlobalVariable.TargetName,
 705                                                                          GenFdsGlobalVariable.ToolChainTag):
 706                 PcdDict = Package.Pcds
 707                 for Key in PcdDict:
 708                     PcdObj = PcdDict[Key]
 709                     if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):
 710                         if PcdObj.Type != 'FixedAtBuild':
 711                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)
 712                         if PcdObj.DatumType != 'VOID*':
 713                             EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)
 714
 715                         PcdValue = PcdObj.DefaultValue
 716                         return PcdValue
 717
 718         return PcdValue
 719
 720     SetDir = staticmethod(SetDir)
 721     ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)
 722     CallExternalTool = staticmethod(CallExternalTool)
 723     VerboseLogger = staticmethod(VerboseLogger)
 724     InfLogger = staticmethod(InfLogger)
 725     ErrorLogger = staticmethod(ErrorLogger)
 726     DebugLogger = staticmethod(DebugLogger)
 727     MacroExtend = staticmethod (MacroExtend)
 728     GetPcdValue = staticmethod(GetPcdValue)