BaseTools/Source/Python/Common/EdkIIWorkspaceBuild.py
## @file
# This file is used to define each component of the build database
#
# Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution. The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#
##
# Import Modules
#
import os, string, copy, pdb, copy
import EdkLogger
import DataType
from InfClassObject import *
from DecClassObject import *
from DscClassObject import *
from String import *
from BuildToolError import *
from Misc import sdict
import Database as Database
import time as time
## PcdClassObject
#
# This Class is used for PcdObject
#
# @param object: Inherited from object class
# @param Name: Input value for Name of Pcd, default is None
# @param Guid: Input value for Guid of Pcd, default is None
# @param Type: Input value for Type of Pcd, default is None
# @param DatumType: Input value for DatumType of Pcd, default is None
# @param Value: Input value for Value of Pcd, default is None
# @param Token: Input value for Token of Pcd, default is None
# @param MaxDatumSize: Input value for MaxDatumSize of Pcd, default is None
# @param SkuInfoList: Input value for SkuInfoList of Pcd, default is {}
# @param IsOverrided: Input value for IsOverrided of Pcd, default is False
#
# @var TokenCName: To store value for TokenCName
# @var TokenSpaceGuidCName: To store value for TokenSpaceGuidCName
# @var Type: To store value for Type
# @var DatumType: To store value for DatumType
# @var TokenValue: To store value for TokenValue
# @var MaxDatumSize: To store value for MaxDatumSize
# @var SkuInfoList: To store value for SkuInfoList
# @var IsOverrided: To store value for IsOverrided
# @var Phase: To store value for Phase, default is "DXE"
#
class PcdClassObject(object):
def __init__(self, Name = None, Guid = None, Type = None, DatumType = None, Value = None, Token = None, MaxDatumSize = None, SkuInfoList = {}, IsOverrided = False):
self.TokenCName = Name
self.TokenSpaceGuidCName = Guid
self.Type = Type
self.DatumType = DatumType
self.DefaultValue = Value
self.TokenValue = Token
self.MaxDatumSize = MaxDatumSize
self.SkuInfoList = SkuInfoList
self.IsOverrided = IsOverrided
self.Phase = "DXE"
## Convert the class to a string
#
# Convert each member of the class to string
# Organize to a signle line format string
#
# @retval Rtn Formatted String
#
def __str__(self):
Rtn = '\tTokenCName=' + str(self.TokenCName) + ', ' + \
'TokenSpaceGuidCName=' + str(self.TokenSpaceGuidCName) + ', ' + \
'Type=' + str(self.Type) + ', ' + \
'DatumType=' + str(self.DatumType) + ', ' + \
'DefaultValue=' + str(self.DefaultValue) + ', ' + \
'TokenValue=' + str(self.TokenValue) + ', ' + \
'MaxDatumSize=' + str(self.MaxDatumSize) + ', '
for Item in self.SkuInfoList.values():
Rtn = Rtn + 'SkuId=' + Item.SkuId + ', ' + 'SkuIdName=' + Item.SkuIdName
Rtn = Rtn + str(self.IsOverrided)
return Rtn
## Override __eq__ function
#
# Check whether pcds are the same
#
# @retval False The two pcds are different
# @retval True The two pcds are the same
#
def __eq__(self, Other):
return Other != None and self.TokenCName == Other.TokenCName and self.TokenSpaceGuidCName == Other.TokenSpaceGuidCName
## Override __hash__ function
#
# Use (TokenCName, TokenSpaceGuidCName) as key in hash table
#
# @retval truple() Key for hash table
#
def __hash__(self):
return hash((self.TokenCName, self.TokenSpaceGuidCName))
## LibraryClassObject
#
# This Class defines LibraryClassObject used in BuildDatabase
#
# @param object: Inherited from object class
# @param Name: Input value for LibraryClassName, default is None
# @param SupModList: Input value for SupModList, default is []
# @param Type: Input value for Type, default is None
#
# @var LibraryClass: To store value for LibraryClass
# @var SupModList: To store value for SupModList
# @var Type: To store value for Type
#
class LibraryClassObject(object):
def __init__(self, Name = None, SupModList = [], Type = None):
self.LibraryClass = Name
self.SupModList = SupModList
if Type != None:
self.SupModList = CleanString(Type).split(DataType.TAB_SPACE_SPLIT)
## ModuleBuildClassObject
#
# This Class defines ModuleBuildClass
#
# @param object: Inherited from object class
#
# @var DescFilePath: To store value for DescFilePath
# @var BaseName: To store value for BaseName
# @var ModuleType: To store value for ModuleType
# @var Guid: To store value for Guid
# @var Version: To store value for Version
# @var PcdIsDriver: To store value for PcdIsDriver
# @var BinaryModule: To store value for BinaryModule
# @var CustomMakefile: To store value for CustomMakefile
# @var Specification: To store value for Specification
# @var Shadow To store value for Shadow
# @var LibraryClass: To store value for LibraryClass, it is a list structure as
# [ LibraryClassObject, ...]
# @var ModuleEntryPointList: To store value for ModuleEntryPointList
# @var ModuleUnloadImageList: To store value for ModuleUnloadImageList
# @var ConstructorList: To store value for ConstructorList
# @var DestructorList: To store value for DestructorList
# @var Binaries: To store value for Binaries, it is a list structure as
# [ ModuleBinaryClassObject, ...]
# @var Sources: To store value for Sources, it is a list structure as
# [ ModuleSourceFilesClassObject, ... ]
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as
# { [LibraryClassName, ModuleType] : LibraryClassInfFile }
# @var Protocols: To store value for Protocols, it is a list structure as
# [ ProtocolName, ... ]
# @var Ppis: To store value for Ppis, it is a list structure as
# [ PpiName, ... ]
# @var Guids: To store value for Guids, it is a list structure as
# [ GuidName, ... ]
# @var Includes: To store value for Includes, it is a list structure as
# [ IncludePath, ... ]
# @var Packages: To store value for Packages, it is a list structure as
# [ DecFileName, ... ]
# @var Pcds: To store value for Pcds, it is a set structure as
# { [(PcdCName, PcdGuidCName)] : PcdClassObject}
# @var BuildOptions: To store value for BuildOptions, it is a set structure as
# { [BuildOptionKey] : BuildOptionValue}
# @var Depex: To store value for Depex
#
class ModuleBuildClassObject(object):
def __init__(self):
self.AutoGenVersion = 0
self.DescFilePath = ''
self.BaseName = ''
self.ModuleType = ''
self.Guid = ''
self.Version = ''
self.PcdIsDriver = ''
self.BinaryModule = ''
self.Shadow = ''
self.CustomMakefile = {}
self.Specification = {}
self.LibraryClass = []
self.ModuleEntryPointList = []
self.ModuleUnloadImageList = []
self.ConstructorList = []
self.DestructorList = []
self.Binaries = []
self.Sources = []
self.LibraryClasses = sdict()
self.Libraries = []
self.Protocols = []
self.Ppis = []
self.Guids = []
self.Includes = []
self.Packages = []
self.Pcds = {}
self.BuildOptions = {}
self.Depex = ''
## Convert the class to a string
#
# Convert member DescFilePath of the class to a string
#
# @retval string Formatted String
#
def __str__(self):
return self.DescFilePath
## Override __eq__ function
#
# Check whether ModuleBuildClassObjects are the same
#
# @retval False The two ModuleBuildClassObjects are different
# @retval True The two ModuleBuildClassObjects are the same
#
def __eq__(self, Other):
return self.DescFilePath == str(Other)
## Override __hash__ function
#
# Use DescFilePath as key in hash table
#
# @retval string Key for hash table
#
def __hash__(self):
return hash(self.DescFilePath)
## PackageBuildClassObject
#
# This Class defines PackageBuildClass
#
# @param object: Inherited from object class
#
# @var DescFilePath: To store value for DescFilePath
# @var PackageName: To store value for PackageName
# @var Guid: To store value for Guid
# @var Version: To store value for Version
# @var Protocols: To store value for Protocols, it is a set structure as
# { [ProtocolName] : Protocol Guid, ... }
# @var Ppis: To store value for Ppis, it is a set structure as
# { [PpiName] : Ppi Guid, ... }
# @var Guids: To store value for Guids, it is a set structure as
# { [GuidName] : Guid, ... }
# @var Includes: To store value for Includes, it is a list structure as
# [ IncludePath, ... ]
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as
# { [LibraryClassName] : LibraryClassInfFile }
# @var Pcds: To store value for Pcds, it is a set structure as
# { [(PcdCName, PcdGuidCName)] : PcdClassObject}
#
class PackageBuildClassObject(object):
def __init__(self):
self.DescFilePath = ''
self.PackageName = ''
self.Guid = ''
self.Version = ''
self.Protocols = {}
self.Ppis = {}
self.Guids = {}
self.Includes = []
self.LibraryClasses = {}
self.Pcds = {}
## Convert the class to a string
#
# Convert member DescFilePath of the class to a string
#
# @retval string Formatted String
#
def __str__(self):
return self.DescFilePath
## Override __eq__ function
#
# Check whether PackageBuildClassObjects are the same
#
# @retval False The two PackageBuildClassObjects are different
# @retval True The two PackageBuildClassObjects are the same
#
def __eq__(self, Other):
return self.DescFilePath == str(Other)
## Override __hash__ function
#
# Use DescFilePath as key in hash table
#
# @retval string Key for hash table
#
def __hash__(self):
return hash(self.DescFilePath)
## PlatformBuildClassObject
#
# This Class defines PlatformBuildClass
#
# @param object: Inherited from object class
#
# @var DescFilePath: To store value for DescFilePath
# @var PlatformName: To store value for PlatformName
# @var Guid: To store value for Guid
# @var Version: To store value for Version
# @var DscSpecification: To store value for DscSpecification
# @var OutputDirectory: To store value for OutputDirectory
# @var FlashDefinition: To store value for FlashDefinition
# @var BuildNumber: To store value for BuildNumber
# @var MakefileName: To store value for MakefileName
# @var SkuIds: To store value for SkuIds, it is a set structure as
# { 'SkuName' : SkuId, '!include' : includefilename, ...}
# @var Modules: To store value for Modules, it is a list structure as
# [ InfFileName, ... ]
# @var Libraries: To store value for Libraries, it is a list structure as
# [ InfFileName, ... ]
# @var LibraryClasses: To store value for LibraryClasses, it is a set structure as
# { (LibraryClassName, ModuleType) : LibraryClassInfFile }
# @var Pcds: To store value for Pcds, it is a set structure as
# { [(PcdCName, PcdGuidCName)] : PcdClassObject }
# @var BuildOptions: To store value for BuildOptions, it is a set structure as
# { [BuildOptionKey] : BuildOptionValue }
#
class PlatformBuildClassObject(object):
def __init__(self):
self.DescFilePath = ''
self.PlatformName = ''
self.Guid = ''
self.Version = ''
self.DscSpecification = ''
self.OutputDirectory = ''
self.FlashDefinition = ''
self.BuildNumber = ''
self.MakefileName = ''
self.SkuIds = {}
self.Modules = []
self.LibraryInstances = []
self.LibraryClasses = {}
self.Libraries = {}
self.Pcds = {}
self.BuildOptions = {}
## Convert the class to a string
#
# Convert member DescFilePath of the class to a string
#
# @retval string Formatted String
#
def __str__(self):
return self.DescFilePath
## Override __eq__ function
#
# Check whether PlatformBuildClassObjects are the same
#
# @retval False The two PlatformBuildClassObjects are different
# @retval True The two PlatformBuildClassObjects are the same
#
def __eq__(self, other):
return self.DescFilePath == str(other)
## Override __hash__ function
#
# Use DescFilePath as key in hash table
#
# @retval string Key for hash table
#
def __hash__(self):
return hash(self.DescFilePath)
## ItemBuild
#
# This Class defines Module/Platform/Package databases for build system
#
# @param object: Inherited from object class
# @param Arch: Build arch
# @param Platform: Build Platform
# @param Package: Build Package
# @param Module: Build Module
#
# @var Arch: To store value for Build Arch
# @var PlatformDatabase: To store value for PlatformDatabase, it is a set structure as
# { [DscFileName] : PlatformBuildClassObject, ...}
# @var PackageDatabase: To store value for PackageDatabase, it is a set structure as
# { [DecFileName] : PacakgeBuildClassObject, ...}
# @var ModuleDatabase: To store value for ModuleDatabase, it is a list structure as
# { [InfFileName] : ModuleBuildClassObject, ...}
#
class ItemBuild(object):
def __init__(self, Arch, Platform = None, Package = None, Module = None):
self.Arch = Arch
self.PlatformDatabase = {}
self.PackageDatabase = {}
self.ModuleDatabase = {}
## WorkspaceBuild
#
# This class is used to parse active platform to init all inf/dec/dsc files
# Generate module/package/platform databases for build
#
# @param object: Inherited from object class
# @param ActivePlatform: Input value for current active platform
# @param WorkspaceDir: Input value for current WorkspaceDir
#
# @var WorkspaceDir: To store value for WorkspaceDir
# @var SupArchList: To store value for SupArchList, selection scope is in below list
# EBC | IA32 | X64 | IPF | ARM | PPC | AARCH64
# @var BuildTarget: To store value for WorkspaceDir, selection scope is in below list
# RELEASE | DEBUG
# @var SkuId: To store value for SkuId
# @var Fdf: To store value for Fdf
# @var FdTargetList: To store value for FdTargetList
# @var FvTargetList: To store value for FvTargetList
# @var TargetTxt: To store value for TargetTxt, it is a set structure as
# TargetTxtClassObject
# @var ToolDef: To store value for ToolDef, it is a set structure as
# ToolDefClassObject
# @var InfDatabase: To store value for InfDatabase, it is a set structure as
# { [InfFileName] : InfClassObject}
# @var DecDatabase: To store value for DecDatabase, it is a set structure as
# { [DecFileName] : DecClassObject}
# @var DscDatabase: To store value for DscDatabase, it is a set structure as
# { [DscFileName] : DscClassObject}
# @var Build: To store value for DscDatabase, it is a set structure as
# ItemBuild
# @var DscFileName: To store value for Active Platform
# @var UnFoundPcdInDsc: To store values for the pcds defined in INF/DEC but not found in DSC, it is a set structure as
# { (PcdGuid, PcdCName, Arch) : DecFileName }
#
class WorkspaceBuild(object):
def __init__(self, ActivePlatform, WorkspaceDir):
self.WorkspaceDir = NormPath(WorkspaceDir)
self.SupArchList = []
self.BuildTarget = []
self.SkuId = ''
self.Fdf = ''
self.FdTargetList = []
self.FvTargetList = []
self.TargetTxt = None
self.ToolDef = None
self.InfDatabase = {}
self.DecDatabase = {}
self.DscDatabase = {}
self.UnFoundPcdInDsc = {}
#
# Init build for all arches
#
self.Build = {}
for Arch in DataType.ARCH_LIST:
self.Build[Arch] = ItemBuild(Arch)
#
# Init build database
#
self.Db = Database.Database(DATABASE_PATH)
self.Db.InitDatabase()
#
# Get active platform
#
self.DscFileName = NormPath(ActivePlatform)
File = self.WorkspaceFile(self.DscFileName)
if os.path.exists(File) and os.path.isfile(File):
self.DscDatabase[self.DscFileName] = Dsc(File, False, True, self.WorkspaceDir, self.Db)
else:
EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData = File)
#
# Parse platform to get module
#
for DscFile in self.DscDatabase.keys():
Platform = self.DscDatabase[DscFile].Platform
#
# Get global information
#
Tmp = set()
for Arch in DataType.ARCH_LIST:
for Item in Platform.Header[Arch].SupArchList:
Tmp.add(Item)
self.SupArchList = list(Tmp)
Tmp = set()
for Arch in DataType.ARCH_LIST:
for Item in Platform.Header[Arch].BuildTargets:
Tmp.add(Item)
self.BuildTarget = list(Tmp)
for Arch in self.SupArchList:
self.SkuId = Platform.Header[Arch].SkuIdName
self.Fdf = Platform.FlashDefinitionFile.FilePath
#
# Get all inf files
#
for Item in Platform.LibraryClasses.LibraryList:
for Arch in Item.SupArchList:
self.AddToInfDatabase(Item.FilePath)
for Item in Platform.Libraries.LibraryList:
for Arch in Item.SupArchList:
self.AddToInfDatabase(Item.FilePath)
for Item in Platform.Modules.ModuleList:
for Arch in Item.SupArchList:
#
# Add modules
#
Module = Item.FilePath
self.AddToInfDatabase(Module)
#
# Add library used in modules
#
for Lib in Item.LibraryClasses.LibraryList:
self.AddToInfDatabase(Lib.FilePath)
self.UpdateLibraryClassOfModule(Module, Lib.Name, Arch, Lib.FilePath)
#
# Parse module to get package
#
for InfFile in self.InfDatabase.keys():
Module = self.InfDatabase[InfFile].Module
#
# Get all dec
#
for Item in Module.PackageDependencies:
for Arch in Item.SupArchList:
self.AddToDecDatabase(Item.FilePath)
# End of self.Init()
## Generate PlatformDatabase
#
# Go through each arch to get all items in DscDatabase to PlatformDatabase
#
def GenPlatformDatabase(self, PcdsSet={}):
for Dsc in self.DscDatabase.keys():
Platform = self.DscDatabase[Dsc].Platform
for Arch in self.SupArchList:
Pb = PlatformBuildClassObject()
#
# Defines
#
Pb.DescFilePath = Dsc
Pb.PlatformName = Platform.Header[Arch].Name
if Pb.PlatformName == '':
EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of platform %s is not defined for arch %s" % (Dsc, Arch))
Pb.Guid = Platform.Header[Arch].Guid
Pb.Version = Platform.Header[Arch].Version
Pb.DscSpecification = Platform.Header[Arch].DscSpecification
Pb.OutputDirectory = Platform.Header[Arch].OutputDirectory
Pb.FlashDefinition = Platform.FlashDefinitionFile.FilePath
Pb.BuildNumber = Platform.Header[Arch].BuildNumber
#
# SkuId
#
for Key in Platform.SkuInfos.SkuInfoList.keys():
Pb.SkuIds[Key] = Platform.SkuInfos.SkuInfoList[Key]
#
# Module
#
for Item in Platform.Modules.ModuleList:
if Arch in Item.SupArchList:
Pb.Modules.append(Item.FilePath)
#
# BuildOptions
#
for Item in Platform.BuildOptions.BuildOptionList:
if Arch in Item.SupArchList:
Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option
#
# LibraryClass
#
for Item in Platform.LibraryClasses.LibraryList:
SupModuleList = self.FindSupModuleListOfLibraryClass(Item, Platform.LibraryClasses.LibraryList, Arch)
if Arch in Item.SupArchList:
for ModuleType in SupModuleList:
Pb.LibraryClasses[(Item.Name, ModuleType)] = Item.FilePath
#
# Libraries
#
for Item in Platform.Libraries.LibraryList:
for ItemArch in Item.SupArchList:
Library = self.InfDatabase[Item.FilePath]
if ItemArch not in Library.Module.Header:
continue
Pb.Libraries[Library.Module.Header[ItemArch].Name] = Item.FilePath
#
# Pcds
#
for Item in Platform.DynamicPcdBuildDefinitions:
if Arch in Item.SupArchList:
Name = Item.CName
Guid = Item.TokenSpaceGuidCName
Type = Item.ItemType
DatumType = Item.DatumType
Value = Item.DefaultValue
Token = Item.Token
MaxDatumSize = Item.MaxDatumSize
SkuInfoList = Item.SkuInfoList
Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
for (Name, Guid) in PcdsSet:
Value = PcdsSet[Name, Guid]
for PcdType in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
for Dec in self.Build[Arch].PackageDatabase:
Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
if (Name, Guid, PcdType) in Pcds:
Pcd = Pcds[(Name, Guid, PcdType)]
Type = PcdType
DatumType = Pcd.DatumType
Token = Pcd.TokenValue
MaxDatumSize = Pcd.MaxDatumSize
SkuInfoList = Pcd.SkuInfoList
Pb.Pcds[(Name, Guid)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
break
else:
# nothing found
continue
# found in one package, find next PCD
break
else:
EdkLogger.error("AutoGen", PARSER_ERROR, "PCD is not found in any package", ExtraData="%s.%s" % (Guid, Name))
#
# Add to database
#
self.Build[Arch].PlatformDatabase[Dsc] = Pb
Pb = None
## Generate PackageDatabase
#
# Go through each arch to get all items in DecDatabase to PackageDatabase
#
def GenPackageDatabase(self):
for Dec in self.DecDatabase.keys():
Package = self.DecDatabase[Dec].Package
for Arch in self.SupArchList:
Pb = PackageBuildClassObject()
#
# Defines
#
Pb.DescFilePath = Dec
Pb.PackageName = Package.Header[Arch].Name
if Pb.PackageName == '':
EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of package %s is not defined for arch %s" % (Dec, Arch))
Pb.Guid = Package.Header[Arch].Guid
Pb.Version = Package.Header[Arch].Version
#
# Protocols
#
for Item in Package.ProtocolDeclarations:
if Arch in Item.SupArchList:
Pb.Protocols[Item.CName] = Item.Guid
#
# Ppis
#
for Item in Package.PpiDeclarations:
if Arch in Item.SupArchList:
Pb.Ppis[Item.CName] = Item.Guid
#
# Guids
#
for Item in Package.GuidDeclarations:
if Arch in Item.SupArchList:
Pb.Guids[Item.CName] = Item.Guid
#
# Includes
#
for Item in Package.Includes:
if Arch in Item.SupArchList:
Pb.Includes.append(Item.FilePath)
#
# LibraryClasses
#
for Item in Package.LibraryClassDeclarations:
if Arch in Item.SupArchList:
Pb.LibraryClasses[Item.LibraryClass] = Item.RecommendedInstance
#
# Pcds
#
for Item in Package.PcdDeclarations:
if Arch in Item.SupArchList:
Name = Item.CName
Guid = Item.TokenSpaceGuidCName
Type = Item.ItemType
DatumType = Item.DatumType
Value = Item.DefaultValue
Token = Item.Token
MaxDatumSize = Item.MaxDatumSize
SkuInfoList = Item.SkuInfoList
Pb.Pcds[(Name, Guid, Type)] = PcdClassObject(Name, Guid, Type, DatumType, Value, Token, MaxDatumSize, SkuInfoList, False)
#
# Add to database
#
self.Build[Arch].PackageDatabase[Dec] = Pb
Pb = None
## Generate ModuleDatabase
#
# Go through each arch to get all items in InfDatabase to ModuleDatabase
#
def GenModuleDatabase(self, InfList = []):
for Inf in self.InfDatabase.keys():
Module = self.InfDatabase[Inf].Module
for Arch in self.SupArchList:
if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList) or Arch not in Module.Header:
continue
ModuleHeader = Module.Header[Arch]
Pb = ModuleBuildClassObject()
#
# Defines
#
Pb.DescFilePath = Inf
Pb.BaseName = ModuleHeader.Name
if Pb.BaseName == '':
EdkLogger.error("AutoGen", PARSER_ERROR, "The BaseName of module %s is not defined for arch %s" % (Inf, Arch))
Pb.Guid = ModuleHeader.Guid
Pb.Version = ModuleHeader.Version
Pb.ModuleType = ModuleHeader.ModuleType
Pb.PcdIsDriver = ModuleHeader.PcdIsDriver
Pb.BinaryModule = ModuleHeader.BinaryModule
Pb.CustomMakefile = ModuleHeader.CustomMakefile
Pb.Shadow = ModuleHeader.Shadow
#
# Specs os Defines
#
Pb.Specification = ModuleHeader.Specification
Pb.Specification[TAB_INF_DEFINES_EDK_RELEASE_VERSION] = ModuleHeader.EdkReleaseVersion
Pb.Specification[TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion
Pb.Specification[TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION] = ModuleHeader.UefiSpecificationVersion
Pb.AutoGenVersion = int(ModuleHeader.InfVersion, 0)
#
# LibraryClass of Defines
#
for Item in ModuleHeader.LibraryClass:
Pb.LibraryClass.append(LibraryClassObject(Item.LibraryClass, Item.SupModuleList, None))
#
# Module image and library of Defines
#
for Item in Module.ExternImages:
if Item.ModuleEntryPoint != '' and Item.ModuleEntryPoint not in Pb.ModuleEntryPointList:
Pb.ModuleEntryPointList.append(Item.ModuleEntryPoint)
if Item.ModuleUnloadImage != '' and Item.ModuleUnloadImage not in Pb.ModuleUnloadImageList:
Pb.ModuleUnloadImageList.append(Item.ModuleUnloadImage)
for Item in Module.ExternLibraries:
if Item.Constructor != '' and Item.Constructor not in Pb.ConstructorList:
Pb.ConstructorList.append(Item.Constructor)
if Item.Destructor != '' and Item.Destructor not in Pb.DestructorList:
Pb.DestructorList.append(Item.Destructor)
#
# Binaries
#
for Item in Module.Binaries:
if Arch in Item.SupArchList:
FileName = Item.BinaryFile
FileType = Item.FileType
Target = Item.Target
FeatureFlag = Item.FeatureFlag
Pb.Binaries.append(ModuleBinaryFileClass(FileName, FileType, Target, FeatureFlag, Arch.split()))
#
# Sources
#
for Item in Module.Sources:
if Arch in Item.SupArchList:
SourceFile = Item.SourceFile
TagName = Item.TagName
ToolCode = Item.ToolCode
ToolChainFamily = Item.ToolChainFamily
FeatureFlag = Item.FeatureFlag
Pb.Sources.append(ModuleSourceFileClass(SourceFile, TagName, ToolCode, ToolChainFamily, FeatureFlag))
#
# Protocols
#
for Item in Module.Protocols:
if Arch in Item.SupArchList:
Pb.Protocols.append(Item.CName)
#
# Ppis
#
for Item in Module.Ppis:
if Arch in Item.SupArchList:
Pb.Ppis.append(Item.CName)
#
# Guids
#
for Item in Module.Guids:
if Arch in Item.SupArchList:
Pb.Ppis.append(Item.CName)
#
# Includes
#
for Item in Module.Includes:
if Arch in Item.SupArchList:
Pb.Includes.append(Item.FilePath)
#
# Packages
#
for Item in Module.PackageDependencies:
if Arch in Item.SupArchList:
Pb.Packages.append(Item.FilePath)
#
# BuildOptions
#
for Item in Module.BuildOptions:
if Arch in Item.SupArchList:
if (Item.ToolChainFamily, Item.ToolChain) not in Pb.BuildOptions:
Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = Item.Option
else:
OptionString = Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)]
Pb.BuildOptions[(Item.ToolChainFamily, Item.ToolChain)] = OptionString + " " + Item.Option
self.FindBuildOptions(Arch, Inf, Pb.BuildOptions)
#
# Depex
#
for Item in Module.Depex:
if Arch in Item.SupArchList:
Pb.Depex = Pb.Depex + Item.Depex + ' '
Pb.Depex = Pb.Depex.strip()
#
# LibraryClasses
#
for Item in Module.LibraryClasses:
if Arch in Item.SupArchList:
Lib = Item.LibraryClass
RecommendedInstance = Item.RecommendedInstance
if Pb.LibraryClass != []:
#
# For Library
#
for Libs in Pb.LibraryClass:
for Type in Libs.SupModList:
Instance = self.FindLibraryClassInstanceOfLibrary(Lib, Arch, Type)
if Instance == None:
Instance = RecommendedInstance
Pb.LibraryClasses[(Lib, Type)] = Instance
else:
#
# For Module
#
Instance = self.FindLibraryClassInstanceOfModule(Lib, Arch, Pb.ModuleType, Inf)
if Instance == None:
Instance = RecommendedInstance
Pb.LibraryClasses[(Lib, Pb.ModuleType)] = Instance
#
# Libraries
#
for Item in Module.Libraries:
if Arch in Item.SupArchList:
Pb.Libraries.append(Item.Library)
#
# Pcds
#
for Item in Module.PcdCodes:
if Arch in Item.SupArchList:
Name = Item.CName
Guid = Item.TokenSpaceGuidCName
Type = Item.ItemType
Pb.Pcds[(Name, Guid)] = self.FindPcd(Arch, Inf, Name, Guid, Type)
#
# Add to database
#
self.Build[Arch].ModuleDatabase[Inf] = Pb
Pb = None
## Update Libraries Of Platform Database
#
# @param InfList: A list for all inf files
#
def UpdateLibrariesOfPlatform(self, InfList = []):
for Arch in self.SupArchList:
PlatformDatabase = self.Build[Arch].PlatformDatabase
for Dsc in PlatformDatabase:
Platform = PlatformDatabase[Dsc]
for Inf in Platform.Modules:
if not self.IsModuleDefinedInPlatform(Inf, Arch, InfList):
continue
Module = self.Build[Arch].ModuleDatabase[Inf]
if Module.LibraryClass == None or Module.LibraryClass == []:
self.UpdateLibrariesOfModule(Platform, Module, Arch)
for Key in Module.LibraryClasses:
Lib = Module.LibraryClasses[Key]
if Lib not in Platform.LibraryInstances:
Platform.LibraryInstances.append(Lib)
## Update Libraries Of Module Database
#
# @param Module: The module need to be updated libraries
# @param Arch: The supportted arch of the module
#
def UpdateLibrariesOfModule(self, Platform, Module, Arch):
ModuleDatabase = self.Build[Arch].ModuleDatabase
ModuleType = Module.ModuleType
# check Edk module
if Module.AutoGenVersion < 0x00010005:
EdkLogger.verbose("")
EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))
LibraryConsumerList = [Module]
# "CompilerStub" is a must for Edk modules
Module.Libraries.append("CompilerStub")
while len(LibraryConsumerList) > 0:
M = LibraryConsumerList.pop()
for LibraryName in M.Libraries:
if LibraryName not in Platform.Libraries:
EdkLogger.warn("AutoGen", "Library [%s] is not found" % LibraryName,
ExtraData="\t%s [%s]" % (str(Module), Arch))
continue
LibraryFile = Platform.Libraries[LibraryName]
if (LibraryName, ModuleType) not in Module.LibraryClasses:
Module.LibraryClasses[LibraryName, ModuleType] = LibraryFile
LibraryConsumerList.append(ModuleDatabase[LibraryFile])
EdkLogger.verbose("\t" + LibraryName + " : " + LibraryFile)
return
# EdkII module
LibraryConsumerList = [Module]
Constructor = []
ConsumedByList = sdict()
LibraryInstance = sdict()
EdkLogger.verbose("")
EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), Arch))
while len(LibraryConsumerList) > 0:
M = LibraryConsumerList.pop()
for Key, LibraryPath in M.LibraryClasses.iteritems():
# The "Key" is in format of (library_class_name, supported_module_type)
if ModuleType != "USER_DEFINED" and ModuleType not in Key:
EdkLogger.debug(EdkLogger.DEBUG_3, "%s for module type %s is not supported (%s)" % (Key + (LibraryPath,)))
continue
LibraryClassName = Key[0]
if LibraryClassName not in LibraryInstance or LibraryInstance[LibraryClassName] == None:
if LibraryPath == None or LibraryPath == "":
LibraryInstance[LibraryClassName] = None
continue
LibraryModule = ModuleDatabase[LibraryPath]
LibraryInstance[LibraryClassName] = LibraryModule
LibraryConsumerList.append(LibraryModule)
EdkLogger.verbose("\t" + LibraryClassName + " : " + str(LibraryModule))
elif LibraryPath == None or LibraryPath == "":
continue
else:
LibraryModule = LibraryInstance[LibraryClassName]
if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:
Constructor.append(LibraryModule)
if LibraryModule not in ConsumedByList:
ConsumedByList[LibraryModule] = []
if M != Module:
if M in ConsumedByList[LibraryModule]:
continue
ConsumedByList[LibraryModule].append(M)
#
# Initialize the sorted output list to the empty set
#
SortedLibraryList = []
#
# Q <- Set of all nodes with no incoming edges
#
LibraryList = [] #LibraryInstance.values()
Q = []
for LibraryClassName in LibraryInstance:
M = LibraryInstance[LibraryClassName]
if M == None:
EdkLogger.error("AutoGen", AUTOGEN_ERROR,
"Library instance for library class [%s] is not found" % LibraryClassName,
ExtraData="\t%s [%s]" % (str(Module), Arch))
LibraryList.append(M)
#
# check if there're duplicate library classes
#
for Lc in M.LibraryClass:
if Lc.SupModList != None and ModuleType not in Lc.SupModList:
EdkLogger.error("AutoGen", AUTOGEN_ERROR,
"Module type [%s] is not supported by library instance [%s]" % (ModuleType, str(M)),
ExtraData="\t%s" % str(Module))
if Lc.LibraryClass in LibraryInstance and str(M) != str(LibraryInstance[Lc.LibraryClass]):
EdkLogger.error("AutoGen", AUTOGEN_ERROR,
"More than one library instance found for library class [%s] in module [%s]" % (Lc.LibraryClass, Module),
ExtraData="\t%s\n\t%s" % (LibraryInstance[Lc.LibraryClass], str(M))
)
if ConsumedByList[M] == []:
Q.insert(0, M)
#
# while Q is not empty do
#
while Q != []:
#
# remove node from Q
#
Node = Q.pop()
#
# output Node
#
SortedLibraryList.append(Node)
#
# for each node Item with an edge e from Node to Item do
#
for Item in LibraryList:
if Node not in ConsumedByList[Item]:
continue
#
# remove edge e from the graph
#
ConsumedByList[Item].remove(Node)
#
# If Item has no other incoming edges then
#
if ConsumedByList[Item] == []:
#
# insert Item into Q
#
Q.insert(0, Item)
EdgeRemoved = True
while Q == [] and EdgeRemoved:
EdgeRemoved = False
#
# for each node Item with a Constructor
#
for Item in LibraryList:
if Item in Constructor:
#
# for each Node without a constructor with an edge e from Item to Node
#
for Node in ConsumedByList[Item]:
if Node not in Constructor:
#
# remove edge e from the graph
#
ConsumedByList[Item].remove(Node)
EdgeRemoved = True
if ConsumedByList[Item] == []:
#
# insert Item into Q
#
Q.insert(0, Item)
break
if Q != []:
break
#
# if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle
#
for Item in LibraryList:
if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:
ErrorMessage = 'Library [%s] with constructors has a cycle' % str(Item)
EdkLogger.error("AutoGen", AUTOGEN_ERROR, ErrorMessage,
"\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]]))
if Item not in SortedLibraryList:
SortedLibraryList.append(Item)
#
# Build the list of constructor and destructir names
# The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order
#
SortedLibraryList.reverse()
Module.LibraryClasses = sdict()
for L in SortedLibraryList:
for Lc in L.LibraryClass:
Module.LibraryClasses[Lc.LibraryClass, ModuleType] = str(L)
#
# Merge PCDs from library instance
#
for Key in L.Pcds:
if Key not in Module.Pcds:
LibPcd = L.Pcds[Key]
Module.Pcds[Key] = self.FindPcd(Arch, str(Module), LibPcd.TokenCName, LibPcd.TokenSpaceGuidCName, LibPcd.Type)
#
# Merge GUIDs from library instance
#
for CName in L.Guids:
if CName not in Module.Guids:
Module.Guids.append(CName)
#
# Merge Protocols from library instance
#
for CName in L.Protocols:
if CName not in Module.Protocols:
Module.Protocols.append(CName)
#
# Merge Ppis from library instance
#
for CName in L.Ppis:
if CName not in Module.Ppis:
Module.Ppis.append(CName)
## GenBuildDatabase
#
# Generate build database for all arches
#
# @param PcdsSet: Pcd list for override from Fdf parse result
# @param InfList: Inf list for override from Fdf parse result
#
def GenBuildDatabase(self, PcdsSet = {}, InfList = []):
#
# Add additional inf file defined in Fdf file
#
for InfFile in InfList:
self.AddToInfDatabase(NormPath(InfFile))
#
# Generate PlatformDatabase, PackageDatabase and ModuleDatabase
#
self.GenPackageDatabase()
self.GenPlatformDatabase(PcdsSet)
self.GenModuleDatabase(InfList)
self.Db.Close()
#
# Update Libraries Of Platform
#
self.UpdateLibrariesOfPlatform(InfList)
#
# Output used Pcds not found in DSC file
#
self.ShowUnFoundPcds()
## ShowUnFoundPcds()
#
# If there is any pcd used but not defined in DSC
# Print warning message on screen and output a list of pcds
#
def ShowUnFoundPcds(self):
if self.UnFoundPcdInDsc != {}:
WrnMessage = '**** WARNING ****\n'
WrnMessage += 'The following Pcds were not defined in the DSC file: %s\n' % self.DscFileName
WrnMessage += 'The default values were obtained from the DEC file that declares the PCD and the PCD default value\n'
for (Guid, Name, Type, Arch) in self.UnFoundPcdInDsc:
Dec = self.UnFoundPcdInDsc[(Guid, Name, Type, Arch)]
Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
if (Name, Guid, Type) in Pcds:
Pcd = Pcds[(Name, Guid, Type)]
PcdItemTypeUsed = Pcd.Type
DefaultValue = Pcd.DefaultValue
WrnMessage += '%s.%s: Defined in file %s, PcdItemType is Pcds%s, DefaultValue is %s\n' % (Guid, Name, Dec, PcdItemTypeUsed, DefaultValue)
EdkLogger.verbose(WrnMessage)
## Create a full path with workspace dir
#
# Convert Filename with workspace dir to create a full path
#
# @param Filename: The filename need to be added workspace dir
#
# @retval string Full path
#
def WorkspaceFile(self, Filename):
return WorkspaceFile(self.WorkspaceDir, Filename)
## Update LibraryClass of Module
#
# If a module of a platform has its own override libraryclass but the libraryclass not defined in the module
# Add this libraryclass to the module
#
# @param InfFileName: InfFileName specificed in platform
# @param LibraryClass: LibraryClass specificed in platform
# @param Arch: Supportted Arch
# @param InstanceFilePath: InstanceFilePath specificed in platform
#
def UpdateLibraryClassOfModule(self, InfFileName, LibraryClass, Arch, InstanceFilePath):
#
# Update the library instance itself to add this libraryclass name
#
LibraryModule = self.InfDatabase[InstanceFilePath].Module
LibList = LibraryModule.Header[Arch].LibraryClass
NotFound = True
for Lib in LibList:
#
# Find this LibraryClass
#
if Lib.LibraryClass == LibraryClass:
NotFound = False;
break;
if NotFound:
NewLib = LibraryClassClass()
NewLib.LibraryClass = LibraryClass
NewLib.SupModuleList = DataType.SUP_MODULE_LIST # LibraryModule.Header[Arch].ModuleType.split()
LibraryModule.Header[Arch].LibraryClass.append(NewLib)
#
# Add it to LibraryClasses Section for the module which is using the library
#
Module = self.InfDatabase[InfFileName].Module
LibList = Module.LibraryClasses
NotFound = True
for Lib in LibList:
#
# Find this LibraryClass
#
if Lib.LibraryClass == LibraryClass:
if Arch in Lib.SupArchList:
return
else:
Lib.SupArchList.append(Arch)
return
if NotFound:
Lib = LibraryClassClass()
Lib.LibraryClass = LibraryClass
Lib.SupArchList = [Arch]
Module.LibraryClasses.append(Lib)
## Add Inf file to InfDatabase
#
# Create a Inf instance for input inf file and add it to InfDatabase
#
# @param InfFileName: The InfFileName need to be added to database
#
def AddToInfDatabase(self, InfFileName):
File = self.WorkspaceFile(InfFileName)
if os.path.exists(File) and os.path.isfile(File):
if InfFileName not in self.InfDatabase:
self.InfDatabase[InfFileName] = Inf(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList)
else:
EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)
## Add Dec file to DecDatabase
#
# Create a Dec instance for input dec file and add it to DecDatabase
#
# @param DecFileName: The DecFileName need to be added to database
#
def AddToDecDatabase(self, DecFileName):
File = self.WorkspaceFile(DecFileName)
if os.path.exists(File) and os.path.isfile(File):
if DecFileName not in self.DecDatabase:
self.DecDatabase[DecFileName] = Dec(File, False, True, self.WorkspaceDir, self.Db, self.SupArchList)
else:
EdkLogger.error("AutoGen", FILE_NOT_FOUND, ExtraData=File)
## Search LibraryClass Instance for Module
#
# Search PlatformBuildDatabase to find LibraryClass Instance for Module
# Return the instance if found
#
# @param Lib: Input value for Library Class Name
# @param Arch: Supportted Arch
# @param ModuleType: Supportted ModuleType
# @param ModuleName: Input value for Module Name
#
# @retval string Found LibraryClass Instance file path
#
def FindLibraryClassInstanceOfModule(self, Lib, Arch, ModuleType, ModuleName):
#
# First find if exist in <LibraryClass> of <Components> from dsc file
#
for Dsc in self.DscDatabase.keys():
Platform = self.DscDatabase[Dsc].Platform
for Module in Platform.Modules.ModuleList:
if Arch in Module.SupArchList:
if Module.FilePath == ModuleName:
for LibraryClass in Module.LibraryClasses.LibraryList:
if LibraryClass.Name == Lib:
return LibraryClass.FilePath
#
#Second find if exist in <LibraryClass> of <LibraryClasses> from dsc file
#
return self.FindLibraryClassInstanceOfLibrary(Lib, Arch, ModuleType)
## Search LibraryClass Instance for Library
#
# Search PlatformBuildDatabase to find LibraryClass Instance for Library
# Return the instance if found
#
# @param Lib: Input value for Library Class Name
# @param Arch: Supportted Arch
# @param Type: Supportted Library Usage Type
#
# @retval string Found LibraryClass Instance file path
# @retval None Not Found
#
def FindLibraryClassInstanceOfLibrary(self, Lib, Arch, Type):
for Dsc in self.DscDatabase.keys():
Platform = self.DscDatabase[Dsc].Platform
if (Lib, Type) in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:
return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, Type)]
elif (Lib, '') in self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses:
return self.Build[Arch].PlatformDatabase[Dsc].LibraryClasses[(Lib, '')]
return None
## Find BuildOptions
#
# Search DscDatabase to find component definition of ModuleName
# Override BuildOption if it is defined in component
#
# @param Arch: Supportted Arch
# @param ModuleName: The module which has buildoption definition in component of platform
# @param BuildOptions: The set of all buildopitons
#
def FindBuildOptions(self, Arch, ModuleName, BuildOptions):
for Dsc in self.DscDatabase.keys():
#
# First find if exist in <BuildOptions> of <Components> from dsc file
# if find, use that override the one defined in inf file
#
Platform = self.DscDatabase[Dsc].Platform
for Module in Platform.Modules.ModuleList:
if Arch in Module.SupArchList:
if Module.FilePath == ModuleName:
for BuildOption in Module.ModuleSaBuildOption.BuildOptionList:
#
# Add to BuildOptions
#
BuildOptions[(BuildOption.ToolChainFamily, BuildOption.ToolChain)] = BuildOption.Option
## Find Pcd
#
# Search platform database, package database, module database and PcdsSet from Fdf
# Return found Pcd
#
# @param Arch: Supportted Arch
# @param ModuleName: The module which has pcd definition in component of platform
# @param Name: Name of Pcd
# @param Guid: Guid of Pcd
# @param Type: Type of Pcd
#
# @retval PcdClassObject An instance for PcdClassObject with all members filled
#
def FindPcd(self, Arch, ModuleName, Name, Guid, Type):
NewType = ''
DatumType = ''
Value = ''
Token = ''
MaxDatumSize = ''
SkuInfoList = {}
IsOverrided = False
IsFoundInDsc = False
IsFoundInDec = False
FoundInDecFile = ''
#
# Second get information from platform database
#
OwnerPlatform = ''
for Dsc in self.Build[Arch].PlatformDatabase.keys():
Pcds = self.Build[Arch].PlatformDatabase[Dsc].Pcds
if (Name, Guid) in Pcds:
OwnerPlatform = Dsc
Pcd = Pcds[(Name, Guid)]
if Pcd.Type != '' and Pcd.Type != None:
NewType = Pcd.Type
if NewType in DataType.PCD_DYNAMIC_TYPE_LIST:
NewType = DataType.TAB_PCDS_DYNAMIC
elif NewType in DataType.PCD_DYNAMIC_EX_TYPE_LIST:
NewType = DataType.TAB_PCDS_DYNAMIC_EX
else:
NewType = Type
if Type != '' and Type != NewType:
ErrorMsg = "PCD %s.%s is declared as [%s] in module\n\t%s\n\n"\
" But it's used as [%s] in platform\n\t%s"\
% (Guid, Name, Type, ModuleName, NewType, OwnerPlatform)
EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)
if Pcd.DatumType != '' and Pcd.DatumType != None:
DatumType = Pcd.DatumType
if Pcd.TokenValue != '' and Pcd.TokenValue != None:
Token = Pcd.TokenValue
if Pcd.DefaultValue != '' and Pcd.DefaultValue != None:
Value = Pcd.DefaultValue
if Pcd.MaxDatumSize != '' and Pcd.MaxDatumSize != None:
MaxDatumSize = Pcd.MaxDatumSize
SkuInfoList = Pcd.SkuInfoList
IsOverrided = True
IsFoundInDsc = True
break
#
# Third get information from <Pcd> of <Compontents> from module database
#
for Dsc in self.DscDatabase.keys():
for Module in self.DscDatabase[Dsc].Platform.Modules.ModuleList:
if Arch in Module.SupArchList:
if Module.FilePath == ModuleName:
for Pcd in Module.PcdBuildDefinitions:
if (Name, Guid) == (Pcd.CName, Pcd.TokenSpaceGuidCName):
if Pcd.DefaultValue != '':
Value = Pcd.DefaultValue
if Pcd.MaxDatumSize != '':
MaxDatumSize = Pcd.MaxDatumSize
IsFoundInDsc = True
IsOverrided = True
break
#
# First get information from package database
#
Pcd = None
if NewType == '':
if Type != '':
PcdTypeList = [Type]
else:
PcdTypeList = ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]
for Dec in self.Build[Arch].PackageDatabase.keys():
Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
for PcdType in PcdTypeList:
if (Name, Guid, PcdType) in Pcds:
Pcd = Pcds[(Name, Guid, PcdType)]
NewType = PcdType
IsOverrided = True
IsFoundInDec = True
FoundInDecFile = Dec
break
else:
continue
break
else:
for Dec in self.Build[Arch].PackageDatabase.keys():
Pcds = self.Build[Arch].PackageDatabase[Dec].Pcds
if (Name, Guid, NewType) in Pcds:
Pcd = Pcds[(Name, Guid, NewType)]
IsOverrided = True
IsFoundInDec = True
FoundInDecFile = Dec
break
if not IsFoundInDec:
ErrorMsg = "Pcd '%s.%s [%s]' defined in module '%s' is not found in any package for Arch '%s'" % (Guid, Name, NewType, ModuleName, Arch)
EdkLogger.error("AutoGen", PARSER_ERROR, ErrorMsg)
#
# Not found in any platform and fdf
#
if not IsFoundInDsc:
Value = Pcd.DefaultValue
if NewType.startswith("Dynamic") and SkuInfoList == {}:
SkuIds = self.Build[Arch].PlatformDatabase.values()[0].SkuIds
SkuInfoList['DEFAULT'] = SkuInfoClass(SkuIdName='DEFAULT', SkuId=SkuIds['DEFAULT'], DefaultValue=Value)
self.UnFoundPcdInDsc[(Guid, Name, NewType, Arch)] = FoundInDecFile
#elif Type != '' and NewType.startswith("Dynamic"):
# NewType = Pcd.Type
DatumType = Pcd.DatumType
if Token in [None, '']:
Token = Pcd.TokenValue
if DatumType == "VOID*" and MaxDatumSize in ['', None]:
EdkLogger.verbose("No MaxDatumSize specified for PCD %s.%s in module [%s]" % (Guid, Name, ModuleName))
if Value[0] == 'L':
MaxDatumSize = str(len(Value) * 2)
elif Value[0] == '{':
MaxDatumSize = str(len(Value.split(',')))
else:
MaxDatumSize = str(len(Value))
return PcdClassObject(Name, Guid, NewType, DatumType, Value, Token, MaxDatumSize, SkuInfoList, IsOverrided)
## Find Supportted Module List Of LibraryClass
#
# Search in InfDatabase, find the supmodulelist of the libraryclass
#
# @param LibraryClass: LibraryClass name for search
# @param OverridedLibraryClassList: A list of all LibraryClass
# @param Arch: Supportted Arch
#
# @retval list SupModuleList
#
def FindSupModuleListOfLibraryClass(self, LibraryClass, OverridedLibraryClassList, Arch):
Name = LibraryClass.Name
FilePath = LibraryClass.FilePath
SupModuleList = copy.copy(LibraryClass.SupModuleList)
#
# If the SupModuleList means all, remove overrided module types of platform
#
if SupModuleList == DataType.SUP_MODULE_LIST:
EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s supports all module types" % Name)
for Item in OverridedLibraryClassList:
#
# Find a library class (Item) with the same name
#
if Item.Name == Name:
#
# Do nothing if it is itself
#
if Item.SupModuleList == DataType.SUP_MODULE_LIST:
continue
#
# If not itself, check arch first
#
if Arch in LibraryClass.SupArchList:
#
# If arch is supportted, remove all related module type
#
if Arch in Item.SupArchList:
for ModuleType in Item.SupModuleList:
EdkLogger.debug(EdkLogger.DEBUG_3, "\tLibraryClass %s has specific defined module types" % Name)
if ModuleType in SupModuleList:
SupModuleList.remove(ModuleType)
return SupModuleList
## Find Module inf Platform
#
# Check if the module is defined in <Compentent> of <Platform>
#
# @param Inf: Inf file (Module) need to be searched
# @param Arch: Supportted Arch
# @param InfList: A list for all Inf file
#
# @retval True Mudule Found
# @retval Flase Module Not Found
#
def IsModuleDefinedInPlatform(self, Inf, Arch, InfList):
for Dsc in self.DscDatabase.values():
for LibraryClass in Dsc.Platform.LibraryClasses.LibraryList:
if Inf == LibraryClass.FilePath and Arch in LibraryClass.SupArchList:
return True
for Module in Dsc.Platform.Modules.ModuleList:
if Inf == Module.FilePath and Arch in Module.SupArchList:
return True
for Item in Module.LibraryClasses.LibraryList:
if Inf == Item.FilePath:
return True
for Library in Dsc.Platform.Libraries.LibraryList:
if Inf == Library.FilePath and Arch in Library.SupArchList:
return True
return False
## Show all content of the workspacebuild
#
# Print each item of the workspacebuild with (Key = Value) pair
#
def ShowWorkspaceBuild(self):
print self.DscDatabase
print self.InfDatabase
print self.DecDatabase
print 'SupArchList', self.SupArchList
print 'BuildTarget', self.BuildTarget
print 'SkuId', self.SkuId
for Arch in self.SupArchList:
print Arch
print 'Platform'
for Platform in self.Build[Arch].PlatformDatabase.keys():
P = self.Build[Arch].PlatformDatabase[Platform]
print 'DescFilePath = ', P.DescFilePath
print 'PlatformName = ', P.PlatformName
print 'Guid = ', P.Guid
print 'Version = ', P.Version
print 'OutputDirectory = ', P.OutputDirectory
print 'FlashDefinition = ', P.FlashDefinition
print 'SkuIds = ', P.SkuIds
print 'Modules = ', P.Modules
print 'LibraryClasses = ', P.LibraryClasses
print 'Pcds = ', P.Pcds
for item in P.Pcds.keys():
print P.Pcds[item]
print 'BuildOptions = ', P.BuildOptions
print ''
# End of Platform
print 'package'
for Package in self.Build[Arch].PackageDatabase.keys():
P = self.Build[Arch].PackageDatabase[Package]
print 'DescFilePath = ', P.DescFilePath
print 'PackageName = ', P.PackageName
print 'Guid = ', P.Guid
print 'Version = ', P.Version
print 'Protocols = ', P.Protocols
print 'Ppis = ', P.Ppis
print 'Guids = ', P.Guids
print 'Includes = ', P.Includes
print 'LibraryClasses = ', P.LibraryClasses
print 'Pcds = ', P.Pcds
for item in P.Pcds.keys():
print P.Pcds[item]
print ''
# End of Package
print 'module'
for Module in self.Build[Arch].ModuleDatabase.keys():
P = self.Build[Arch].ModuleDatabase[Module]
print 'DescFilePath = ', P.DescFilePath
print 'BaseName = ', P.BaseName
print 'ModuleType = ', P.ModuleType
print 'Guid = ', P.Guid
print 'Version = ', P.Version
print 'CustomMakefile = ', P.CustomMakefile
print 'Specification = ', P.Specification
print 'Shadow = ', P.Shadow
print 'PcdIsDriver = ', P.PcdIsDriver
for Lib in P.LibraryClass:
print 'LibraryClassDefinition = ', Lib.LibraryClass, 'SupModList = ', Lib.SupModList
print 'ModuleEntryPointList = ', P.ModuleEntryPointList
print 'ModuleUnloadImageList = ', P.ModuleUnloadImageList
print 'ConstructorList = ', P.ConstructorList
print 'DestructorList = ', P.DestructorList
print 'Binaries = '
for item in P.Binaries:
print item.BinaryFile, item.FeatureFlag, item.SupArchList
print 'Sources = '
for item in P.Sources:
print item.SourceFile
print 'LibraryClasses = ', P.LibraryClasses
print 'Protocols = ', P.Protocols
print 'Ppis = ', P.Ppis
print 'Guids = ', P.Guids
print 'Includes = ', P.Includes
print 'Packages = ', P.Packages
print 'Pcds = ', P.Pcds
for item in P.Pcds.keys():
print P.Pcds[item]
print 'BuildOptions = ', P.BuildOptions
print 'Depex = ', P.Depex
print ''
# End of Module
##
#
# This acts like the main() function for the script, unless it is 'import'ed into another
# script.
#
if __name__ == '__main__':
print 'Start!', time.strftime('%H:%M:%S', time.localtime())
EdkLogger.Initialize()
EdkLogger.SetLevel(EdkLogger.QUIET)
W = os.getenv('WORKSPACE')
Ewb = WorkspaceBuild('Nt32Pkg/Nt32Pkg.dsc', W)
Ewb.GenBuildDatabase({('PcdDevicePathSupportDevicePathFromText', 'gEfiMdeModulePkgTokenSpaceGuid') : 'KKKKKKKKKKKKKKKKKKKKK'}, ['Test.Inf'])
print 'Done!', time.strftime('%H:%M:%S', time.localtime())
Ewb.ShowWorkspaceBuild()