b36d134faf
Signed-off-by: lgao4 Reviewed-by: gikidy git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12372 6f19259b-4bc3-4df7-8a09-765794883524
1671 lines
70 KiB
Python
1671 lines
70 KiB
Python
## @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
|
|
# @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()
|