mirror of https://github.com/acidanthera/audk.git
2376 lines
104 KiB
Python
2376 lines
104 KiB
Python
## @file
|
|
# This file is used to create a database used by build tool
|
|
#
|
|
# Copyright (c) 2008 - 2010, Intel Corporation
|
|
# All rights reserved. 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 sqlite3
|
|
import os
|
|
import os.path
|
|
import pickle
|
|
|
|
import Common.EdkLogger as EdkLogger
|
|
import Common.GlobalData as GlobalData
|
|
|
|
from Common.String import *
|
|
from Common.DataType import *
|
|
from Common.Misc import *
|
|
from types import *
|
|
|
|
from CommonDataClass.CommonClass import SkuInfoClass
|
|
|
|
from MetaDataTable import *
|
|
from MetaFileTable import *
|
|
from MetaFileParser import *
|
|
from BuildClassObject import *
|
|
|
|
## Platform build information from DSC file
|
|
#
|
|
# This class is used to retrieve information stored in database and convert them
|
|
# into PlatformBuildClassObject form for easier use for AutoGen.
|
|
#
|
|
class DscBuildData(PlatformBuildClassObject):
|
|
# dict used to convert PCD type in database to string used by build tool
|
|
_PCD_TYPE_STRING_ = {
|
|
MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",
|
|
MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",
|
|
MODEL_PCD_FEATURE_FLAG : "FeatureFlag",
|
|
MODEL_PCD_DYNAMIC : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_HII : "DynamicHii",
|
|
MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",
|
|
MODEL_PCD_DYNAMIC_EX : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",
|
|
MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",
|
|
}
|
|
|
|
# dict used to convert part of [Defines] to members of DscBuildData directly
|
|
_PROPERTY_ = {
|
|
#
|
|
# Required Fields
|
|
#
|
|
TAB_DSC_DEFINES_PLATFORM_NAME : "_PlatformName",
|
|
TAB_DSC_DEFINES_PLATFORM_GUID : "_Guid",
|
|
TAB_DSC_DEFINES_PLATFORM_VERSION : "_Version",
|
|
TAB_DSC_DEFINES_DSC_SPECIFICATION : "_DscSpecification",
|
|
#TAB_DSC_DEFINES_OUTPUT_DIRECTORY : "_OutputDirectory",
|
|
#TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES : "_SupArchList",
|
|
#TAB_DSC_DEFINES_BUILD_TARGETS : "_BuildTargets",
|
|
#TAB_DSC_DEFINES_SKUID_IDENTIFIER : "_SkuName",
|
|
#TAB_DSC_DEFINES_FLASH_DEFINITION : "_FlashDefinition",
|
|
TAB_DSC_DEFINES_BUILD_NUMBER : "_BuildNumber",
|
|
TAB_DSC_DEFINES_MAKEFILE_NAME : "_MakefileName",
|
|
TAB_DSC_DEFINES_BS_BASE_ADDRESS : "_BsBaseAddress",
|
|
TAB_DSC_DEFINES_RT_BASE_ADDRESS : "_RtBaseAddress",
|
|
}
|
|
|
|
# used to compose dummy library class name for those forced library instances
|
|
_NullLibraryNumber = 0
|
|
|
|
## Constructor of DscBuildData
|
|
#
|
|
# Initialize object of DscBuildData
|
|
#
|
|
# @param FilePath The path of platform description file
|
|
# @param RawData The raw data of DSC file
|
|
# @param BuildDataBase Database used to retrieve module/package information
|
|
# @param Arch The target architecture
|
|
# @param Platform (not used for DscBuildData)
|
|
# @param Macros Macros used for replacement in DSC file
|
|
#
|
|
def __init__(self, FilePath, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):
|
|
self.MetaFile = FilePath
|
|
self._RawData = RawData
|
|
self._Bdb = BuildDataBase
|
|
self._Arch = Arch
|
|
self._Macros = Macros
|
|
self._Clear()
|
|
RecordList = self._RawData[MODEL_META_DATA_DEFINE, self._Arch]
|
|
for Record in RecordList:
|
|
GlobalData.gEdkGlobal[Record[0]] = Record[1]
|
|
|
|
## XXX[key] = value
|
|
def __setitem__(self, key, value):
|
|
self.__dict__[self._PROPERTY_[key]] = value
|
|
|
|
## value = XXX[key]
|
|
def __getitem__(self, key):
|
|
return self.__dict__[self._PROPERTY_[key]]
|
|
|
|
## "in" test support
|
|
def __contains__(self, key):
|
|
return key in self._PROPERTY_
|
|
|
|
## Set all internal used members of DscBuildData to None
|
|
def _Clear(self):
|
|
self._Header = None
|
|
self._PlatformName = None
|
|
self._Guid = None
|
|
self._Version = None
|
|
self._DscSpecification = None
|
|
self._OutputDirectory = None
|
|
self._SupArchList = None
|
|
self._BuildTargets = None
|
|
self._SkuName = None
|
|
self._FlashDefinition = None
|
|
self._BuildNumber = None
|
|
self._MakefileName = None
|
|
self._BsBaseAddress = None
|
|
self._RtBaseAddress = None
|
|
self._SkuIds = None
|
|
self._Modules = None
|
|
self._LibraryInstances = None
|
|
self._LibraryClasses = None
|
|
self._Pcds = None
|
|
self._BuildOptions = None
|
|
self._LoadFixAddress = None
|
|
|
|
## Get architecture
|
|
def _GetArch(self):
|
|
return self._Arch
|
|
|
|
## Set architecture
|
|
#
|
|
# Changing the default ARCH to another may affect all other information
|
|
# because all information in a platform may be ARCH-related. That's
|
|
# why we need to clear all internal used members, in order to cause all
|
|
# information to be re-retrieved.
|
|
#
|
|
# @param Value The value of ARCH
|
|
#
|
|
def _SetArch(self, Value):
|
|
if self._Arch == Value:
|
|
return
|
|
self._Arch = Value
|
|
self._Clear()
|
|
|
|
## Retrieve all information in [Defines] section
|
|
#
|
|
# (Retriving all [Defines] information in one-shot is just to save time.)
|
|
#
|
|
def _GetHeaderInfo(self):
|
|
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch]
|
|
for Record in RecordList:
|
|
Name = Record[0]
|
|
# items defined _PROPERTY_ don't need additional processing
|
|
if Name in self:
|
|
self[Name] = Record[1]
|
|
# some special items in [Defines] section need special treatment
|
|
elif Name == TAB_DSC_DEFINES_OUTPUT_DIRECTORY:
|
|
self._OutputDirectory = NormPath(Record[1], self._Macros)
|
|
if ' ' in self._OutputDirectory:
|
|
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "No space is allowed in OUTPUT_DIRECTORY",
|
|
File=self.MetaFile, Line=Record[-1],
|
|
ExtraData=self._OutputDirectory)
|
|
elif Name == TAB_DSC_DEFINES_FLASH_DEFINITION:
|
|
self._FlashDefinition = PathClass(NormPath(Record[1], self._Macros), GlobalData.gWorkspace)
|
|
ErrorCode, ErrorInfo = self._FlashDefinition.Validate('.fdf')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=Record[-1],
|
|
ExtraData=ErrorInfo)
|
|
elif Name == TAB_DSC_DEFINES_SUPPORTED_ARCHITECTURES:
|
|
self._SupArchList = GetSplitValueList(Record[1], TAB_VALUE_SPLIT)
|
|
elif Name == TAB_DSC_DEFINES_BUILD_TARGETS:
|
|
self._BuildTargets = GetSplitValueList(Record[1])
|
|
elif Name == TAB_DSC_DEFINES_SKUID_IDENTIFIER:
|
|
if self._SkuName == None:
|
|
self._SkuName = Record[1]
|
|
elif Name == TAB_FIX_LOAD_TOP_MEMORY_ADDRESS:
|
|
self._LoadFixAddress = Record[1]
|
|
# set _Header to non-None in order to avoid database re-querying
|
|
self._Header = 'DUMMY'
|
|
|
|
## Retrieve platform name
|
|
def _GetPlatformName(self):
|
|
if self._PlatformName == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._PlatformName == None:
|
|
EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No PLATFORM_NAME", File=self.MetaFile)
|
|
return self._PlatformName
|
|
|
|
## Retrieve file guid
|
|
def _GetFileGuid(self):
|
|
if self._Guid == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._Guid == None:
|
|
EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No FILE_GUID", File=self.MetaFile)
|
|
return self._Guid
|
|
|
|
## Retrieve platform version
|
|
def _GetVersion(self):
|
|
if self._Version == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._Version == None:
|
|
self._Version = ''
|
|
return self._Version
|
|
|
|
## Retrieve platform description file version
|
|
def _GetDscSpec(self):
|
|
if self._DscSpecification == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._DscSpecification == None:
|
|
self._DscSpecification = ''
|
|
return self._DscSpecification
|
|
|
|
## Retrieve OUTPUT_DIRECTORY
|
|
def _GetOutpuDir(self):
|
|
if self._OutputDirectory == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._OutputDirectory == None:
|
|
self._OutputDirectory = os.path.join("Build", self._PlatformName)
|
|
return self._OutputDirectory
|
|
|
|
## Retrieve SUPPORTED_ARCHITECTURES
|
|
def _GetSupArch(self):
|
|
if self._SupArchList == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._SupArchList == None:
|
|
self._SupArchList = ARCH_LIST
|
|
return self._SupArchList
|
|
|
|
## Retrieve BUILD_TARGETS
|
|
def _GetBuildTarget(self):
|
|
if self._BuildTargets == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._BuildTargets == None:
|
|
self._BuildTargets = ['DEBUG', 'RELEASE']
|
|
return self._BuildTargets
|
|
|
|
## Retrieve SKUID_IDENTIFIER
|
|
def _GetSkuName(self):
|
|
if self._SkuName == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._SkuName == None or self._SkuName not in self.SkuIds:
|
|
self._SkuName = 'DEFAULT'
|
|
return self._SkuName
|
|
|
|
## Override SKUID_IDENTIFIER
|
|
def _SetSkuName(self, Value):
|
|
if Value in self.SkuIds:
|
|
self._SkuName = Value
|
|
|
|
def _GetFdfFile(self):
|
|
if self._FlashDefinition == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._FlashDefinition == None:
|
|
self._FlashDefinition = ''
|
|
return self._FlashDefinition
|
|
|
|
## Retrieve FLASH_DEFINITION
|
|
def _GetBuildNumber(self):
|
|
if self._BuildNumber == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._BuildNumber == None:
|
|
self._BuildNumber = ''
|
|
return self._BuildNumber
|
|
|
|
## Retrieve MAKEFILE_NAME
|
|
def _GetMakefileName(self):
|
|
if self._MakefileName == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._MakefileName == None:
|
|
self._MakefileName = ''
|
|
return self._MakefileName
|
|
|
|
## Retrieve BsBaseAddress
|
|
def _GetBsBaseAddress(self):
|
|
if self._BsBaseAddress == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._BsBaseAddress == None:
|
|
self._BsBaseAddress = ''
|
|
return self._BsBaseAddress
|
|
|
|
## Retrieve RtBaseAddress
|
|
def _GetRtBaseAddress(self):
|
|
if self._RtBaseAddress == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._RtBaseAddress == None:
|
|
self._RtBaseAddress = ''
|
|
return self._RtBaseAddress
|
|
|
|
## Retrieve the top address for the load fix address
|
|
def _GetLoadFixAddress(self):
|
|
if self._LoadFixAddress == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._LoadFixAddress == None:
|
|
self._LoadFixAddress = ''
|
|
return self._LoadFixAddress
|
|
|
|
## Retrieve [SkuIds] section information
|
|
def _GetSkuIds(self):
|
|
if self._SkuIds == None:
|
|
self._SkuIds = {}
|
|
RecordList = self._RawData[MODEL_EFI_SKU_ID]
|
|
for Record in RecordList:
|
|
if Record[0] in [None, '']:
|
|
EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID number',
|
|
File=self.MetaFile, Line=Record[-1])
|
|
if Record[1] in [None, '']:
|
|
EdkLogger.error('build', FORMAT_INVALID, 'No Sku ID name',
|
|
File=self.MetaFile, Line=Record[-1])
|
|
self._SkuIds[Record[1]] = Record[0]
|
|
if 'DEFAULT' not in self._SkuIds:
|
|
self._SkuIds['DEFAULT'] = 0
|
|
return self._SkuIds
|
|
|
|
## Retrieve [Components] section information
|
|
def _GetModules(self):
|
|
if self._Modules != None:
|
|
return self._Modules
|
|
|
|
self._Modules = sdict()
|
|
RecordList = self._RawData[MODEL_META_DATA_COMPONENT, self._Arch]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
ModuleFile = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
|
|
ModuleId = Record[5]
|
|
LineNo = Record[6]
|
|
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = ModuleFile.Validate('.inf')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
|
|
ExtraData=ErrorInfo)
|
|
# Check duplication
|
|
if ModuleFile in self._Modules:
|
|
EdkLogger.error('build', FILE_DUPLICATED, File=self.MetaFile, ExtraData=str(ModuleFile), Line=LineNo)
|
|
|
|
Module = ModuleBuildClassObject()
|
|
Module.MetaFile = ModuleFile
|
|
|
|
# get module override path
|
|
RecordList = self._RawData[MODEL_META_DATA_COMPONENT_SOURCE_OVERRIDE_PATH, self._Arch, None, ModuleId]
|
|
if RecordList != []:
|
|
Module.SourceOverridePath = os.path.join(GlobalData.gWorkspace, NormPath(RecordList[0][0], Macros))
|
|
|
|
# Check if the source override path exists
|
|
if not os.path.isdir(Module.SourceOverridePath):
|
|
EdkLogger.error('build', FILE_NOT_FOUND, Message = 'Source override path does not exist:', File=self.MetaFile, ExtraData=Module.SourceOverridePath, Line=LineNo)
|
|
|
|
#Add to GlobalData Variables
|
|
GlobalData.gOverrideDir[ModuleFile.Key] = Module.SourceOverridePath
|
|
|
|
# get module private library instance
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, None, ModuleId]
|
|
for Record in RecordList:
|
|
LibraryClass = Record[0]
|
|
LibraryPath = PathClass(NormPath(Record[1], Macros), GlobalData.gWorkspace, Arch=self._Arch)
|
|
LineNo = Record[-1]
|
|
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = LibraryPath.Validate('.inf')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
|
|
ExtraData=ErrorInfo)
|
|
|
|
if LibraryClass == '' or LibraryClass == 'NULL':
|
|
self._NullLibraryNumber += 1
|
|
LibraryClass = 'NULL%d' % self._NullLibraryNumber
|
|
EdkLogger.verbose("Found forced library for %s\n\t%s [%s]" % (ModuleFile, LibraryPath, LibraryClass))
|
|
Module.LibraryClasses[LibraryClass] = LibraryPath
|
|
if LibraryPath not in self.LibraryInstances:
|
|
self.LibraryInstances.append(LibraryPath)
|
|
|
|
# get module private PCD setting
|
|
for Type in [MODEL_PCD_FIXED_AT_BUILD, MODEL_PCD_PATCHABLE_IN_MODULE, \
|
|
MODEL_PCD_FEATURE_FLAG, MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
|
|
RecordList = self._RawData[Type, self._Arch, None, ModuleId]
|
|
for TokenSpaceGuid, PcdCName, Setting, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
|
|
TokenList = GetSplitValueList(Setting)
|
|
DefaultValue = TokenList[0]
|
|
if len(TokenList) > 1:
|
|
MaxDatumSize = TokenList[1]
|
|
else:
|
|
MaxDatumSize = ''
|
|
TypeString = self._PCD_TYPE_STRING_[Type]
|
|
Pcd = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
TypeString,
|
|
'',
|
|
DefaultValue,
|
|
'',
|
|
MaxDatumSize,
|
|
{},
|
|
None
|
|
)
|
|
Module.Pcds[PcdCName, TokenSpaceGuid] = Pcd
|
|
|
|
# get module private build options
|
|
RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, None, ModuleId]
|
|
for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
|
|
if (ToolChainFamily, ToolChain) not in Module.BuildOptions:
|
|
Module.BuildOptions[ToolChainFamily, ToolChain] = Option
|
|
else:
|
|
OptionString = Module.BuildOptions[ToolChainFamily, ToolChain]
|
|
Module.BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
|
|
|
|
self._Modules[ModuleFile] = Module
|
|
return self._Modules
|
|
|
|
## Retrieve all possible library instances used in this platform
|
|
def _GetLibraryInstances(self):
|
|
if self._LibraryInstances == None:
|
|
self._GetLibraryClasses()
|
|
return self._LibraryInstances
|
|
|
|
## Retrieve [LibraryClasses] information
|
|
def _GetLibraryClasses(self):
|
|
if self._LibraryClasses == None:
|
|
self._LibraryInstances = []
|
|
#
|
|
# tdict is a special dict kind of type, used for selecting correct
|
|
# library instance for given library class and module type
|
|
#
|
|
LibraryClassDict = tdict(True, 3)
|
|
# track all library class names
|
|
LibraryClassSet = set()
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
LibraryClass, LibraryInstance, Dummy, Arch, ModuleType, Dummy, LineNo = Record
|
|
if LibraryClass == '' or LibraryClass == 'NULL':
|
|
self._NullLibraryNumber += 1
|
|
LibraryClass = 'NULL%d' % self._NullLibraryNumber
|
|
EdkLogger.verbose("Found forced library for arch=%s\n\t%s [%s]" % (Arch, LibraryInstance, LibraryClass))
|
|
LibraryClassSet.add(LibraryClass)
|
|
LibraryInstance = PathClass(NormPath(LibraryInstance, Macros), GlobalData.gWorkspace, Arch=self._Arch)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = LibraryInstance.Validate('.inf')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
|
|
ExtraData=ErrorInfo)
|
|
|
|
if ModuleType != 'COMMON' and ModuleType not in SUP_MODULE_LIST:
|
|
EdkLogger.error('build', OPTION_UNKNOWN, "Unknown module type [%s]" % ModuleType,
|
|
File=self.MetaFile, ExtraData=LibraryInstance, Line=LineNo)
|
|
LibraryClassDict[Arch, ModuleType, LibraryClass] = LibraryInstance
|
|
if LibraryInstance not in self._LibraryInstances:
|
|
self._LibraryInstances.append(LibraryInstance)
|
|
|
|
# resolve the specific library instance for each class and each module type
|
|
self._LibraryClasses = tdict(True)
|
|
for LibraryClass in LibraryClassSet:
|
|
# try all possible module types
|
|
for ModuleType in SUP_MODULE_LIST:
|
|
LibraryInstance = LibraryClassDict[self._Arch, ModuleType, LibraryClass]
|
|
if LibraryInstance == None:
|
|
continue
|
|
self._LibraryClasses[LibraryClass, ModuleType] = LibraryInstance
|
|
|
|
# for R8 style library instances, which are listed in different section
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch]
|
|
for Record in RecordList:
|
|
File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
|
|
LineNo = Record[-1]
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate('.inf')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, File=self.MetaFile, Line=LineNo,
|
|
ExtraData=ErrorInfo)
|
|
if File not in self._LibraryInstances:
|
|
self._LibraryInstances.append(File)
|
|
#
|
|
# we need the module name as the library class name, so we have
|
|
# to parse it here. (self._Bdb[] will trigger a file parse if it
|
|
# hasn't been parsed)
|
|
#
|
|
Library = self._Bdb[File, self._Arch]
|
|
self._LibraryClasses[Library.BaseName, ':dummy:'] = Library
|
|
return self._LibraryClasses
|
|
|
|
## Retrieve all PCD settings in platform
|
|
def _GetPcds(self):
|
|
if self._Pcds == None:
|
|
self._Pcds = {}
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
|
|
self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_DEFAULT))
|
|
self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_HII))
|
|
self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_VPD))
|
|
self._Pcds.update(self._GetDynamicPcd(MODEL_PCD_DYNAMIC_EX_DEFAULT))
|
|
self._Pcds.update(self._GetDynamicHiiPcd(MODEL_PCD_DYNAMIC_EX_HII))
|
|
self._Pcds.update(self._GetDynamicVpdPcd(MODEL_PCD_DYNAMIC_EX_VPD))
|
|
return self._Pcds
|
|
|
|
## Retrieve [BuildOptions]
|
|
def _GetBuildOptions(self):
|
|
if self._BuildOptions == None:
|
|
self._BuildOptions = {}
|
|
#
|
|
# Retrieve build option for EDKII style module
|
|
#
|
|
RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDKII_NAME]
|
|
for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
|
|
self._BuildOptions[ToolChainFamily, ToolChain, EDKII_NAME] = Option
|
|
#
|
|
# Retrieve build option for EDK style module
|
|
#
|
|
RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, 'COMMON', EDK_NAME]
|
|
for ToolChainFamily, ToolChain, Option, Dummy1, Dummy2, Dummy3, Dummy4 in RecordList:
|
|
self._BuildOptions[ToolChainFamily, ToolChain, EDK_NAME] = Option
|
|
return self._BuildOptions
|
|
|
|
## Retrieve non-dynamic PCD settings
|
|
#
|
|
# @param Type PCD type
|
|
#
|
|
# @retval a dict object contains settings of given PCD type
|
|
#
|
|
def _GetPcd(self, Type):
|
|
Pcds = {}
|
|
#
|
|
# tdict is a special dict kind of type, used for selecting correct
|
|
# PCD settings for certain ARCH
|
|
#
|
|
PcdDict = tdict(True, 3)
|
|
PcdSet = set()
|
|
# Find out all possible PCD candidates for self._Arch
|
|
RecordList = self._RawData[Type, self._Arch]
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting
|
|
# Remove redundant PCD candidates
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '', '']
|
|
Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
PcdValue, DatumType, MaxDatumSize = ValueList
|
|
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
self._PCD_TYPE_STRING_[Type],
|
|
DatumType,
|
|
PcdValue,
|
|
'',
|
|
MaxDatumSize,
|
|
{},
|
|
None
|
|
)
|
|
return Pcds
|
|
|
|
## Retrieve dynamic PCD settings
|
|
#
|
|
# @param Type PCD type
|
|
#
|
|
# @retval a dict object contains settings of given PCD type
|
|
#
|
|
def _GetDynamicPcd(self, Type):
|
|
Pcds = {}
|
|
#
|
|
# tdict is a special dict kind of type, used for selecting correct
|
|
# PCD settings for certain ARCH and SKU
|
|
#
|
|
PcdDict = tdict(True, 4)
|
|
PcdSet = set()
|
|
# Find out all possible PCD candidates for self._Arch
|
|
RecordList = self._RawData[Type, self._Arch]
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
|
|
# Remove redundant PCD candidates, per the ARCH and SKU
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '', '']
|
|
Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
PcdValue, DatumType, MaxDatumSize = ValueList
|
|
|
|
SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', '', PcdValue)
|
|
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
self._PCD_TYPE_STRING_[Type],
|
|
DatumType,
|
|
PcdValue,
|
|
'',
|
|
MaxDatumSize,
|
|
{self.SkuName : SkuInfo},
|
|
None
|
|
)
|
|
return Pcds
|
|
|
|
## Retrieve dynamic HII PCD settings
|
|
#
|
|
# @param Type PCD type
|
|
#
|
|
# @retval a dict object contains settings of given PCD type
|
|
#
|
|
def _GetDynamicHiiPcd(self, Type):
|
|
Pcds = {}
|
|
#
|
|
# tdict is a special dict kind of type, used for selecting correct
|
|
# PCD settings for certain ARCH and SKU
|
|
#
|
|
PcdDict = tdict(True, 4)
|
|
PcdSet = set()
|
|
RecordList = self._RawData[Type, self._Arch]
|
|
# Find out all possible PCD candidates for self._Arch
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
|
|
# Remove redundant PCD candidates, per the ARCH and SKU
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '', '', '']
|
|
Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
VariableName, VariableGuid, VariableOffset, DefaultValue = ValueList
|
|
SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], VariableName, VariableGuid, VariableOffset, DefaultValue)
|
|
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
self._PCD_TYPE_STRING_[Type],
|
|
'',
|
|
DefaultValue,
|
|
'',
|
|
'',
|
|
{self.SkuName : SkuInfo},
|
|
None
|
|
)
|
|
return Pcds
|
|
|
|
## Retrieve dynamic VPD PCD settings
|
|
#
|
|
# @param Type PCD type
|
|
#
|
|
# @retval a dict object contains settings of given PCD type
|
|
#
|
|
def _GetDynamicVpdPcd(self, Type):
|
|
Pcds = {}
|
|
#
|
|
# tdict is a special dict kind of type, used for selecting correct
|
|
# PCD settings for certain ARCH and SKU
|
|
#
|
|
PcdDict = tdict(True, 4)
|
|
PcdSet = set()
|
|
# Find out all possible PCD candidates for self._Arch
|
|
RecordList = self._RawData[Type, self._Arch]
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, SkuName, Dummy3, Dummy4 in RecordList:
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
PcdDict[Arch, SkuName, PcdCName, TokenSpaceGuid] = Setting
|
|
# Remove redundant PCD candidates, per the ARCH and SKU
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '']
|
|
Setting = PcdDict[self._Arch, self.SkuName, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
VpdOffset, MaxDatumSize = ValueList
|
|
|
|
SkuInfo = SkuInfoClass(self.SkuName, self.SkuIds[self.SkuName], '', '', '', '', VpdOffset)
|
|
Pcds[PcdCName, TokenSpaceGuid] = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
self._PCD_TYPE_STRING_[Type],
|
|
'',
|
|
'',
|
|
'',
|
|
MaxDatumSize,
|
|
{self.SkuName : SkuInfo},
|
|
None
|
|
)
|
|
return Pcds
|
|
|
|
## Add external modules
|
|
#
|
|
# The external modules are mostly those listed in FDF file, which don't
|
|
# need "build".
|
|
#
|
|
# @param FilePath The path of module description file
|
|
#
|
|
def AddModule(self, FilePath):
|
|
FilePath = NormPath(FilePath)
|
|
if FilePath not in self.Modules:
|
|
Module = ModuleBuildClassObject()
|
|
Module.MetaFile = FilePath
|
|
self.Modules.append(Module)
|
|
|
|
## Add external PCDs
|
|
#
|
|
# The external PCDs are mostly those listed in FDF file to specify address
|
|
# or offset information.
|
|
#
|
|
# @param Name Name of the PCD
|
|
# @param Guid Token space guid of the PCD
|
|
# @param Value Value of the PCD
|
|
#
|
|
def AddPcd(self, Name, Guid, Value):
|
|
if (Name, Guid) not in self.Pcds:
|
|
self.Pcds[Name, Guid] = PcdClassObject(Name, Guid, '', '', '', '', '', {}, None)
|
|
self.Pcds[Name, Guid].DefaultValue = Value
|
|
|
|
Arch = property(_GetArch, _SetArch)
|
|
Platform = property(_GetPlatformName)
|
|
PlatformName = property(_GetPlatformName)
|
|
Guid = property(_GetFileGuid)
|
|
Version = property(_GetVersion)
|
|
DscSpecification = property(_GetDscSpec)
|
|
OutputDirectory = property(_GetOutpuDir)
|
|
SupArchList = property(_GetSupArch)
|
|
BuildTargets = property(_GetBuildTarget)
|
|
SkuName = property(_GetSkuName, _SetSkuName)
|
|
FlashDefinition = property(_GetFdfFile)
|
|
BuildNumber = property(_GetBuildNumber)
|
|
MakefileName = property(_GetMakefileName)
|
|
BsBaseAddress = property(_GetBsBaseAddress)
|
|
RtBaseAddress = property(_GetRtBaseAddress)
|
|
LoadFixAddress = property(_GetLoadFixAddress)
|
|
|
|
SkuIds = property(_GetSkuIds)
|
|
Modules = property(_GetModules)
|
|
LibraryInstances = property(_GetLibraryInstances)
|
|
LibraryClasses = property(_GetLibraryClasses)
|
|
Pcds = property(_GetPcds)
|
|
BuildOptions = property(_GetBuildOptions)
|
|
|
|
## Platform build information from DSC file
|
|
#
|
|
# This class is used to retrieve information stored in database and convert them
|
|
# into PackageBuildClassObject form for easier use for AutoGen.
|
|
#
|
|
class DecBuildData(PackageBuildClassObject):
|
|
# dict used to convert PCD type in database to string used by build tool
|
|
_PCD_TYPE_STRING_ = {
|
|
MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",
|
|
MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",
|
|
MODEL_PCD_FEATURE_FLAG : "FeatureFlag",
|
|
MODEL_PCD_DYNAMIC : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_HII : "DynamicHii",
|
|
MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",
|
|
MODEL_PCD_DYNAMIC_EX : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",
|
|
MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",
|
|
}
|
|
|
|
# dict used to convert part of [Defines] to members of DecBuildData directly
|
|
_PROPERTY_ = {
|
|
#
|
|
# Required Fields
|
|
#
|
|
TAB_DEC_DEFINES_PACKAGE_NAME : "_PackageName",
|
|
TAB_DEC_DEFINES_PACKAGE_GUID : "_Guid",
|
|
TAB_DEC_DEFINES_PACKAGE_VERSION : "_Version",
|
|
}
|
|
|
|
|
|
## Constructor of DecBuildData
|
|
#
|
|
# Initialize object of DecBuildData
|
|
#
|
|
# @param FilePath The path of package description file
|
|
# @param RawData The raw data of DEC file
|
|
# @param BuildDataBase Database used to retrieve module information
|
|
# @param Arch The target architecture
|
|
# @param Platform (not used for DecBuildData)
|
|
# @param Macros Macros used for replacement in DSC file
|
|
#
|
|
def __init__(self, File, RawData, BuildDataBase, Arch='COMMON', Platform='DUMMY', Macros={}):
|
|
self.MetaFile = File
|
|
self._PackageDir = File.Dir
|
|
self._RawData = RawData
|
|
self._Bdb = BuildDataBase
|
|
self._Arch = Arch
|
|
self._Macros = Macros
|
|
self._Clear()
|
|
|
|
## XXX[key] = value
|
|
def __setitem__(self, key, value):
|
|
self.__dict__[self._PROPERTY_[key]] = value
|
|
|
|
## value = XXX[key]
|
|
def __getitem__(self, key):
|
|
return self.__dict__[self._PROPERTY_[key]]
|
|
|
|
## "in" test support
|
|
def __contains__(self, key):
|
|
return key in self._PROPERTY_
|
|
|
|
## Set all internal used members of DecBuildData to None
|
|
def _Clear(self):
|
|
self._Header = None
|
|
self._PackageName = None
|
|
self._Guid = None
|
|
self._Version = None
|
|
self._Protocols = None
|
|
self._Ppis = None
|
|
self._Guids = None
|
|
self._Includes = None
|
|
self._LibraryClasses = None
|
|
self._Pcds = None
|
|
|
|
## Get architecture
|
|
def _GetArch(self):
|
|
return self._Arch
|
|
|
|
## Set architecture
|
|
#
|
|
# Changing the default ARCH to another may affect all other information
|
|
# because all information in a platform may be ARCH-related. That's
|
|
# why we need to clear all internal used members, in order to cause all
|
|
# information to be re-retrieved.
|
|
#
|
|
# @param Value The value of ARCH
|
|
#
|
|
def _SetArch(self, Value):
|
|
if self._Arch == Value:
|
|
return
|
|
self._Arch = Value
|
|
self._Clear()
|
|
|
|
## Retrieve all information in [Defines] section
|
|
#
|
|
# (Retriving all [Defines] information in one-shot is just to save time.)
|
|
#
|
|
def _GetHeaderInfo(self):
|
|
RecordList = self._RawData[MODEL_META_DATA_HEADER]
|
|
for Record in RecordList:
|
|
Name = Record[0]
|
|
if Name in self:
|
|
self[Name] = Record[1]
|
|
self._Header = 'DUMMY'
|
|
|
|
## Retrieve package name
|
|
def _GetPackageName(self):
|
|
if self._PackageName == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._PackageName == None:
|
|
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_NAME", File=self.MetaFile)
|
|
return self._PackageName
|
|
|
|
## Retrieve file guid
|
|
def _GetFileGuid(self):
|
|
if self._Guid == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._Guid == None:
|
|
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "No PACKAGE_GUID", File=self.MetaFile)
|
|
return self._Guid
|
|
|
|
## Retrieve package version
|
|
def _GetVersion(self):
|
|
if self._Version == None:
|
|
if self._Header == None:
|
|
self._GetHeaderInfo()
|
|
if self._Version == None:
|
|
self._Version = ''
|
|
return self._Version
|
|
|
|
## Retrieve protocol definitions (name/value pairs)
|
|
def _GetProtocol(self):
|
|
if self._Protocols == None:
|
|
#
|
|
# tdict is a special kind of dict, used for selecting correct
|
|
# protocol defition for given ARCH
|
|
#
|
|
ProtocolDict = tdict(True)
|
|
NameList = []
|
|
# find out all protocol definitions for specific and 'common' arch
|
|
RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch]
|
|
for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
|
|
if Name not in NameList:
|
|
NameList.append(Name)
|
|
ProtocolDict[Arch, Name] = Guid
|
|
# use sdict to keep the order
|
|
self._Protocols = sdict()
|
|
for Name in NameList:
|
|
#
|
|
# limit the ARCH to self._Arch, if no self._Arch found, tdict
|
|
# will automatically turn to 'common' ARCH for trying
|
|
#
|
|
self._Protocols[Name] = ProtocolDict[self._Arch, Name]
|
|
return self._Protocols
|
|
|
|
## Retrieve PPI definitions (name/value pairs)
|
|
def _GetPpi(self):
|
|
if self._Ppis == None:
|
|
#
|
|
# tdict is a special kind of dict, used for selecting correct
|
|
# PPI defition for given ARCH
|
|
#
|
|
PpiDict = tdict(True)
|
|
NameList = []
|
|
# find out all PPI definitions for specific arch and 'common' arch
|
|
RecordList = self._RawData[MODEL_EFI_PPI, self._Arch]
|
|
for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
|
|
if Name not in NameList:
|
|
NameList.append(Name)
|
|
PpiDict[Arch, Name] = Guid
|
|
# use sdict to keep the order
|
|
self._Ppis = sdict()
|
|
for Name in NameList:
|
|
#
|
|
# limit the ARCH to self._Arch, if no self._Arch found, tdict
|
|
# will automatically turn to 'common' ARCH for trying
|
|
#
|
|
self._Ppis[Name] = PpiDict[self._Arch, Name]
|
|
return self._Ppis
|
|
|
|
## Retrieve GUID definitions (name/value pairs)
|
|
def _GetGuid(self):
|
|
if self._Guids == None:
|
|
#
|
|
# tdict is a special kind of dict, used for selecting correct
|
|
# GUID defition for given ARCH
|
|
#
|
|
GuidDict = tdict(True)
|
|
NameList = []
|
|
# find out all protocol definitions for specific and 'common' arch
|
|
RecordList = self._RawData[MODEL_EFI_GUID, self._Arch]
|
|
for Name, Guid, Dummy, Arch, ID, LineNo in RecordList:
|
|
if Name not in NameList:
|
|
NameList.append(Name)
|
|
GuidDict[Arch, Name] = Guid
|
|
# use sdict to keep the order
|
|
self._Guids = sdict()
|
|
for Name in NameList:
|
|
#
|
|
# limit the ARCH to self._Arch, if no self._Arch found, tdict
|
|
# will automatically turn to 'common' ARCH for trying
|
|
#
|
|
self._Guids[Name] = GuidDict[self._Arch, Name]
|
|
return self._Guids
|
|
|
|
## Retrieve public include paths declared in this package
|
|
def _GetInclude(self):
|
|
if self._Includes == None:
|
|
self._Includes = []
|
|
RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
File = PathClass(NormPath(Record[0], Macros), self._PackageDir, Arch=self._Arch)
|
|
LineNo = Record[-1]
|
|
# validate the path
|
|
ErrorCode, ErrorInfo = File.Validate()
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
|
|
|
|
# avoid duplicate include path
|
|
if File not in self._Includes:
|
|
self._Includes.append(File)
|
|
return self._Includes
|
|
|
|
## Retrieve library class declarations (not used in build at present)
|
|
def _GetLibraryClass(self):
|
|
if self._LibraryClasses == None:
|
|
#
|
|
# tdict is a special kind of dict, used for selecting correct
|
|
# library class declaration for given ARCH
|
|
#
|
|
LibraryClassDict = tdict(True)
|
|
LibraryClassSet = set()
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
for LibraryClass, File, Dummy, Arch, ID, LineNo in RecordList:
|
|
File = PathClass(NormPath(File, Macros), self._PackageDir, Arch=self._Arch)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate()
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
|
|
LibraryClassSet.add(LibraryClass)
|
|
LibraryClassDict[Arch, LibraryClass] = File
|
|
self._LibraryClasses = sdict()
|
|
for LibraryClass in LibraryClassSet:
|
|
self._LibraryClasses[LibraryClass] = LibraryClassDict[self._Arch, LibraryClass]
|
|
return self._LibraryClasses
|
|
|
|
## Retrieve PCD declarations
|
|
def _GetPcds(self):
|
|
if self._Pcds == None:
|
|
self._Pcds = {}
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))
|
|
return self._Pcds
|
|
|
|
## Retrieve PCD declarations for given type
|
|
def _GetPcd(self, Type):
|
|
Pcds = {}
|
|
#
|
|
# tdict is a special kind of dict, used for selecting correct
|
|
# PCD declaration for given ARCH
|
|
#
|
|
PcdDict = tdict(True, 3)
|
|
# for summarizing PCD
|
|
PcdSet = set()
|
|
# find out all PCDs of the 'type'
|
|
RecordList = self._RawData[Type, self._Arch]
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, Dummy1, Dummy2 in RecordList:
|
|
PcdDict[Arch, PcdCName, TokenSpaceGuid] = Setting
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '', '']
|
|
#
|
|
# limit the ARCH to self._Arch, if no self._Arch found, tdict
|
|
# will automatically turn to 'common' ARCH and try again
|
|
#
|
|
Setting = PcdDict[self._Arch, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
DefaultValue, DatumType, TokenNumber = ValueList
|
|
Pcds[PcdCName, TokenSpaceGuid, self._PCD_TYPE_STRING_[Type]] = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
self._PCD_TYPE_STRING_[Type],
|
|
DatumType,
|
|
DefaultValue,
|
|
TokenNumber,
|
|
'',
|
|
{},
|
|
None
|
|
)
|
|
return Pcds
|
|
|
|
|
|
Arch = property(_GetArch, _SetArch)
|
|
PackageName = property(_GetPackageName)
|
|
Guid = property(_GetFileGuid)
|
|
Version = property(_GetVersion)
|
|
|
|
Protocols = property(_GetProtocol)
|
|
Ppis = property(_GetPpi)
|
|
Guids = property(_GetGuid)
|
|
Includes = property(_GetInclude)
|
|
LibraryClasses = property(_GetLibraryClass)
|
|
Pcds = property(_GetPcds)
|
|
|
|
## Module build information from INF file
|
|
#
|
|
# This class is used to retrieve information stored in database and convert them
|
|
# into ModuleBuildClassObject form for easier use for AutoGen.
|
|
#
|
|
class InfBuildData(ModuleBuildClassObject):
|
|
# dict used to convert PCD type in database to string used by build tool
|
|
_PCD_TYPE_STRING_ = {
|
|
MODEL_PCD_FIXED_AT_BUILD : "FixedAtBuild",
|
|
MODEL_PCD_PATCHABLE_IN_MODULE : "PatchableInModule",
|
|
MODEL_PCD_FEATURE_FLAG : "FeatureFlag",
|
|
MODEL_PCD_DYNAMIC : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_DEFAULT : "Dynamic",
|
|
MODEL_PCD_DYNAMIC_HII : "DynamicHii",
|
|
MODEL_PCD_DYNAMIC_VPD : "DynamicVpd",
|
|
MODEL_PCD_DYNAMIC_EX : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_DEFAULT : "DynamicEx",
|
|
MODEL_PCD_DYNAMIC_EX_HII : "DynamicExHii",
|
|
MODEL_PCD_DYNAMIC_EX_VPD : "DynamicExVpd",
|
|
}
|
|
|
|
# dict used to convert part of [Defines] to members of InfBuildData directly
|
|
_PROPERTY_ = {
|
|
#
|
|
# Required Fields
|
|
#
|
|
TAB_INF_DEFINES_BASE_NAME : "_BaseName",
|
|
TAB_INF_DEFINES_FILE_GUID : "_Guid",
|
|
TAB_INF_DEFINES_MODULE_TYPE : "_ModuleType",
|
|
#
|
|
# Optional Fields
|
|
#
|
|
TAB_INF_DEFINES_INF_VERSION : "_AutoGenVersion",
|
|
TAB_INF_DEFINES_COMPONENT_TYPE : "_ComponentType",
|
|
TAB_INF_DEFINES_MAKEFILE_NAME : "_MakefileName",
|
|
#TAB_INF_DEFINES_CUSTOM_MAKEFILE : "_CustomMakefile",
|
|
TAB_INF_DEFINES_VERSION_NUMBER : "_Version",
|
|
TAB_INF_DEFINES_VERSION_STRING : "_Version",
|
|
TAB_INF_DEFINES_VERSION : "_Version",
|
|
TAB_INF_DEFINES_PCD_IS_DRIVER : "_PcdIsDriver",
|
|
TAB_INF_DEFINES_SHADOW : "_Shadow",
|
|
|
|
TAB_COMPONENTS_SOURCE_OVERRIDE_PATH : "_SourceOverridePath",
|
|
}
|
|
|
|
# dict used to convert Component type to Module type
|
|
_MODULE_TYPE_ = {
|
|
"LIBRARY" : "BASE",
|
|
"SECURITY_CORE" : "SEC",
|
|
"PEI_CORE" : "PEI_CORE",
|
|
"COMBINED_PEIM_DRIVER" : "PEIM",
|
|
"PIC_PEIM" : "PEIM",
|
|
"RELOCATABLE_PEIM" : "PEIM",
|
|
"PE32_PEIM" : "PEIM",
|
|
"BS_DRIVER" : "DXE_DRIVER",
|
|
"RT_DRIVER" : "DXE_RUNTIME_DRIVER",
|
|
"SAL_RT_DRIVER" : "DXE_SAL_DRIVER",
|
|
"DXE_SMM_DRIVER" : "DXE_SMM_DRIVER",
|
|
# "SMM_DRIVER" : "DXE_SMM_DRIVER",
|
|
# "BS_DRIVER" : "DXE_SMM_DRIVER",
|
|
# "BS_DRIVER" : "UEFI_DRIVER",
|
|
"APPLICATION" : "UEFI_APPLICATION",
|
|
"LOGO" : "BASE",
|
|
}
|
|
|
|
# regular expression for converting XXX_FLAGS in [nmake] section to new type
|
|
_NMAKE_FLAG_PATTERN_ = re.compile("(?:EBC_)?([A-Z]+)_(?:STD_|PROJ_|ARCH_)?FLAGS(?:_DLL|_ASL|_EXE)?", re.UNICODE)
|
|
# dict used to convert old tool name used in [nmake] section to new ones
|
|
_TOOL_CODE_ = {
|
|
"C" : "CC",
|
|
"LIB" : "SLINK",
|
|
"LINK" : "DLINK",
|
|
}
|
|
|
|
|
|
## Constructor of DscBuildData
|
|
#
|
|
# Initialize object of DscBuildData
|
|
#
|
|
# @param FilePath The path of platform description file
|
|
# @param RawData The raw data of DSC file
|
|
# @param BuildDataBase Database used to retrieve module/package information
|
|
# @param Arch The target architecture
|
|
# @param Platform The name of platform employing this module
|
|
# @param Macros Macros used for replacement in DSC file
|
|
#
|
|
def __init__(self, FilePath, RawData, BuildDatabase, Arch='COMMON', Platform='COMMON', Macros={}):
|
|
self.MetaFile = FilePath
|
|
self._ModuleDir = FilePath.Dir
|
|
self._RawData = RawData
|
|
self._Bdb = BuildDatabase
|
|
self._Arch = Arch
|
|
self._Platform = 'COMMON'
|
|
self._Macros = Macros
|
|
self._SourceOverridePath = None
|
|
if FilePath.Key in GlobalData.gOverrideDir:
|
|
self._SourceOverridePath = GlobalData.gOverrideDir[FilePath.Key]
|
|
self._Clear()
|
|
|
|
## XXX[key] = value
|
|
def __setitem__(self, key, value):
|
|
self.__dict__[self._PROPERTY_[key]] = value
|
|
|
|
## value = XXX[key]
|
|
def __getitem__(self, key):
|
|
return self.__dict__[self._PROPERTY_[key]]
|
|
|
|
## "in" test support
|
|
def __contains__(self, key):
|
|
return key in self._PROPERTY_
|
|
|
|
## Set all internal used members of InfBuildData to None
|
|
def _Clear(self):
|
|
self._Header_ = None
|
|
self._AutoGenVersion = None
|
|
self._BaseName = None
|
|
self._ModuleType = None
|
|
self._ComponentType = None
|
|
self._BuildType = None
|
|
self._Guid = None
|
|
self._Version = None
|
|
self._PcdIsDriver = None
|
|
self._BinaryModule = None
|
|
self._Shadow = None
|
|
self._MakefileName = None
|
|
self._CustomMakefile = None
|
|
self._Specification = None
|
|
self._LibraryClass = None
|
|
self._ModuleEntryPointList = None
|
|
self._ModuleUnloadImageList = None
|
|
self._ConstructorList = None
|
|
self._DestructorList = None
|
|
self._Defs = None
|
|
self._Binaries = None
|
|
self._Sources = None
|
|
self._LibraryClasses = None
|
|
self._Libraries = None
|
|
self._Protocols = None
|
|
self._Ppis = None
|
|
self._Guids = None
|
|
self._Includes = None
|
|
self._Packages = None
|
|
self._Pcds = None
|
|
self._BuildOptions = None
|
|
self._Depex = None
|
|
self._DepexExpression = None
|
|
#self._SourceOverridePath = None
|
|
|
|
## Get architecture
|
|
def _GetArch(self):
|
|
return self._Arch
|
|
|
|
## Set architecture
|
|
#
|
|
# Changing the default ARCH to another may affect all other information
|
|
# because all information in a platform may be ARCH-related. That's
|
|
# why we need to clear all internal used members, in order to cause all
|
|
# information to be re-retrieved.
|
|
#
|
|
# @param Value The value of ARCH
|
|
#
|
|
def _SetArch(self, Value):
|
|
if self._Arch == Value:
|
|
return
|
|
self._Arch = Value
|
|
self._Clear()
|
|
|
|
## Return the name of platform employing this module
|
|
def _GetPlatform(self):
|
|
return self._Platform
|
|
|
|
## Change the name of platform employing this module
|
|
#
|
|
# Changing the default name of platform to another may affect some information
|
|
# because they may be PLATFORM-related. That's why we need to clear all internal
|
|
# used members, in order to cause all information to be re-retrieved.
|
|
#
|
|
def _SetPlatform(self, Value):
|
|
if self._Platform == Value:
|
|
return
|
|
self._Platform = Value
|
|
self._Clear()
|
|
|
|
## Retrieve all information in [Defines] section
|
|
#
|
|
# (Retriving all [Defines] information in one-shot is just to save time.)
|
|
#
|
|
def _GetHeaderInfo(self):
|
|
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
Name = Record[0]
|
|
# items defined _PROPERTY_ don't need additional processing
|
|
if Name in self:
|
|
self[Name] = Record[1]
|
|
# some special items in [Defines] section need special treatment
|
|
elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'):
|
|
if self._Specification == None:
|
|
self._Specification = sdict()
|
|
self._Specification['UEFI_SPECIFICATION_VERSION'] = Record[1]
|
|
elif Name == 'EDK_RELEASE_VERSION':
|
|
if self._Specification == None:
|
|
self._Specification = sdict()
|
|
self._Specification[Name] = Record[1]
|
|
elif Name == 'PI_SPECIFICATION_VERSION':
|
|
if self._Specification == None:
|
|
self._Specification = sdict()
|
|
self._Specification[Name] = Record[1]
|
|
elif Name == 'LIBRARY_CLASS':
|
|
if self._LibraryClass == None:
|
|
self._LibraryClass = []
|
|
ValueList = GetSplitValueList(Record[1])
|
|
LibraryClass = ValueList[0]
|
|
if len(ValueList) > 1:
|
|
SupModuleList = GetSplitValueList(ValueList[1], ' ')
|
|
else:
|
|
SupModuleList = SUP_MODULE_LIST
|
|
self._LibraryClass.append(LibraryClassObject(LibraryClass, SupModuleList))
|
|
elif Name == 'ENTRY_POINT':
|
|
if self._ModuleEntryPointList == None:
|
|
self._ModuleEntryPointList = []
|
|
self._ModuleEntryPointList.append(Record[1])
|
|
elif Name == 'UNLOAD_IMAGE':
|
|
if self._ModuleUnloadImageList == None:
|
|
self._ModuleUnloadImageList = []
|
|
if Record[1] == '':
|
|
continue
|
|
self._ModuleUnloadImageList.append(Record[1])
|
|
elif Name == 'CONSTRUCTOR':
|
|
if self._ConstructorList == None:
|
|
self._ConstructorList = []
|
|
if Record[1] == '':
|
|
continue
|
|
self._ConstructorList.append(Record[1])
|
|
elif Name == 'DESTRUCTOR':
|
|
if self._DestructorList == None:
|
|
self._DestructorList = []
|
|
if Record[1] == '':
|
|
continue
|
|
self._DestructorList.append(Record[1])
|
|
elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE:
|
|
TokenList = GetSplitValueList(Record[1])
|
|
if self._CustomMakefile == None:
|
|
self._CustomMakefile = {}
|
|
if len(TokenList) < 2:
|
|
self._CustomMakefile['MSFT'] = TokenList[0]
|
|
self._CustomMakefile['GCC'] = TokenList[0]
|
|
else:
|
|
if TokenList[0] not in ['MSFT', 'GCC']:
|
|
EdkLogger.error("build", FORMAT_NOT_SUPPORTED,
|
|
"No supported family [%s]" % TokenList[0],
|
|
File=self.MetaFile, Line=Record[-1])
|
|
self._CustomMakefile[TokenList[0]] = TokenList[1]
|
|
else:
|
|
if self._Defs == None:
|
|
self._Defs = sdict()
|
|
self._Defs[Name] = Record[1]
|
|
|
|
#
|
|
# Retrieve information in sections specific to R8.x modules
|
|
#
|
|
if self._AutoGenVersion >= 0x00010005: # _AutoGenVersion may be None, which is less than anything
|
|
if not self._ModuleType:
|
|
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
|
|
"MODULE_TYPE is not given", File=self.MetaFile)
|
|
if (self._Specification == None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (self._Specification['PI_SPECIFICATION_VERSION'] < 0x0001000A):
|
|
if self._ModuleType == SUP_MODULE_SMM_CORE:
|
|
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.MetaFile)
|
|
if self._Defs and 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \
|
|
and 'PCI_CLASS_CODE' in self._Defs:
|
|
self._BuildType = 'UEFI_OPTIONROM'
|
|
elif self._Defs and 'UEFI_HII_RESOURCE_SECTION' in self._Defs \
|
|
and self._Defs['UEFI_HII_RESOURCE_SECTION'] == 'TRUE':
|
|
self._BuildType = 'UEFI_HII'
|
|
else:
|
|
self._BuildType = self._ModuleType.upper()
|
|
else:
|
|
self._BuildType = self._ComponentType.upper()
|
|
if not self._ComponentType:
|
|
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
|
|
"COMPONENT_TYPE is not given", File=self.MetaFile)
|
|
if self._ComponentType in self._MODULE_TYPE_:
|
|
self._ModuleType = self._MODULE_TYPE_[self._ComponentType]
|
|
if self._ComponentType == 'LIBRARY':
|
|
self._LibraryClass = [LibraryClassObject(self._BaseName, SUP_MODULE_LIST)]
|
|
# make use some [nmake] section macros
|
|
RecordList = self._RawData[MODEL_META_DATA_NMAKE, self._Arch, self._Platform]
|
|
for Name,Value,Dummy,Arch,Platform,ID,LineNo in RecordList:
|
|
Value = Value.replace('$(PROCESSOR)', self._Arch)
|
|
Name = Name.replace('$(PROCESSOR)', self._Arch)
|
|
Name, Value = ReplaceMacros((Name, Value), GlobalData.gEdkGlobal, True)
|
|
if Name == "IMAGE_ENTRY_POINT":
|
|
if self._ModuleEntryPointList == None:
|
|
self._ModuleEntryPointList = []
|
|
self._ModuleEntryPointList.append(Value)
|
|
elif Name == "DPX_SOURCE":
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
File = PathClass(NormPath(Value, Macros), self._ModuleDir, Arch=self._Arch)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate(".dxs", CaseSensitive=False)
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo,
|
|
File=self.MetaFile, Line=LineNo)
|
|
if self.Sources == None:
|
|
self._Sources = []
|
|
self._Sources.append(File)
|
|
else:
|
|
ToolList = self._NMAKE_FLAG_PATTERN_.findall(Name)
|
|
if len(ToolList) == 0 or len(ToolList) != 1:
|
|
pass
|
|
# EdkLogger.warn("build", "Don't know how to do with macro [%s]" % Name,
|
|
# File=self.MetaFile, Line=LineNo)
|
|
else:
|
|
if self._BuildOptions == None:
|
|
self._BuildOptions = sdict()
|
|
|
|
if ToolList[0] in self._TOOL_CODE_:
|
|
Tool = self._TOOL_CODE_[ToolList[0]]
|
|
else:
|
|
Tool = ToolList[0]
|
|
ToolChain = "*_*_*_%s_FLAGS" % Tool
|
|
ToolChainFamily = 'MSFT' # R8.x only support MSFT tool chain
|
|
#ignore not replaced macros in value
|
|
ValueList = GetSplitValueList(' ' + Value, '/D')
|
|
Dummy = ValueList[0]
|
|
for Index in range(1, len(ValueList)):
|
|
if ValueList[Index][-1] == '=' or ValueList[Index] == '':
|
|
continue
|
|
Dummy = Dummy + ' /D ' + ValueList[Index]
|
|
Value = Dummy.strip()
|
|
if (ToolChainFamily, ToolChain) not in self._BuildOptions:
|
|
self._BuildOptions[ToolChainFamily, ToolChain] = Value
|
|
else:
|
|
OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
|
|
self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Value
|
|
# set _Header to non-None in order to avoid database re-querying
|
|
self._Header_ = 'DUMMY'
|
|
|
|
## Retrieve file version
|
|
def _GetInfVersion(self):
|
|
if self._AutoGenVersion == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._AutoGenVersion == None:
|
|
self._AutoGenVersion = 0x00010000
|
|
return self._AutoGenVersion
|
|
|
|
## Retrieve BASE_NAME
|
|
def _GetBaseName(self):
|
|
if self._BaseName == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._BaseName == None:
|
|
EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile)
|
|
return self._BaseName
|
|
|
|
## Retrieve MODULE_TYPE
|
|
def _GetModuleType(self):
|
|
if self._ModuleType == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._ModuleType == None:
|
|
self._ModuleType = 'BASE'
|
|
if self._ModuleType not in SUP_MODULE_LIST:
|
|
self._ModuleType = "USER_DEFINED"
|
|
return self._ModuleType
|
|
|
|
## Retrieve COMPONENT_TYPE
|
|
def _GetComponentType(self):
|
|
if self._ComponentType == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._ComponentType == None:
|
|
self._ComponentType = 'USER_DEFINED'
|
|
return self._ComponentType
|
|
|
|
## Retrieve "BUILD_TYPE"
|
|
def _GetBuildType(self):
|
|
if self._BuildType == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if not self._BuildType:
|
|
self._BuildType = "BASE"
|
|
return self._BuildType
|
|
|
|
## Retrieve file guid
|
|
def _GetFileGuid(self):
|
|
if self._Guid == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._Guid == None:
|
|
self._Guid = '00000000-0000-0000-000000000000'
|
|
return self._Guid
|
|
|
|
## Retrieve module version
|
|
def _GetVersion(self):
|
|
if self._Version == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._Version == None:
|
|
self._Version = '0.0'
|
|
return self._Version
|
|
|
|
## Retrieve PCD_IS_DRIVER
|
|
def _GetPcdIsDriver(self):
|
|
if self._PcdIsDriver == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._PcdIsDriver == None:
|
|
self._PcdIsDriver = ''
|
|
return self._PcdIsDriver
|
|
|
|
## Retrieve SHADOW
|
|
def _GetShadow(self):
|
|
if self._Shadow == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._Shadow != None and self._Shadow.upper() == 'TRUE':
|
|
self._Shadow = True
|
|
else:
|
|
self._Shadow = False
|
|
return self._Shadow
|
|
|
|
## Retrieve CUSTOM_MAKEFILE
|
|
def _GetMakefile(self):
|
|
if self._CustomMakefile == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._CustomMakefile == None:
|
|
self._CustomMakefile = {}
|
|
return self._CustomMakefile
|
|
|
|
## Retrieve EFI_SPECIFICATION_VERSION
|
|
def _GetSpec(self):
|
|
if self._Specification == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._Specification == None:
|
|
self._Specification = {}
|
|
return self._Specification
|
|
|
|
## Retrieve LIBRARY_CLASS
|
|
def _GetLibraryClass(self):
|
|
if self._LibraryClass == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._LibraryClass == None:
|
|
self._LibraryClass = []
|
|
return self._LibraryClass
|
|
|
|
## Retrieve ENTRY_POINT
|
|
def _GetEntryPoint(self):
|
|
if self._ModuleEntryPointList == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._ModuleEntryPointList == None:
|
|
self._ModuleEntryPointList = []
|
|
return self._ModuleEntryPointList
|
|
|
|
## Retrieve UNLOAD_IMAGE
|
|
def _GetUnloadImage(self):
|
|
if self._ModuleUnloadImageList == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._ModuleUnloadImageList == None:
|
|
self._ModuleUnloadImageList = []
|
|
return self._ModuleUnloadImageList
|
|
|
|
## Retrieve CONSTRUCTOR
|
|
def _GetConstructor(self):
|
|
if self._ConstructorList == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._ConstructorList == None:
|
|
self._ConstructorList = []
|
|
return self._ConstructorList
|
|
|
|
## Retrieve DESTRUCTOR
|
|
def _GetDestructor(self):
|
|
if self._DestructorList == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._DestructorList == None:
|
|
self._DestructorList = []
|
|
return self._DestructorList
|
|
|
|
## Retrieve definies other than above ones
|
|
def _GetDefines(self):
|
|
if self._Defs == None:
|
|
if self._Header_ == None:
|
|
self._GetHeaderInfo()
|
|
if self._Defs == None:
|
|
self._Defs = sdict()
|
|
return self._Defs
|
|
|
|
## Retrieve binary files
|
|
def _GetBinaryFiles(self):
|
|
if self._Binaries == None:
|
|
self._Binaries = []
|
|
RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
FileType = Record[0]
|
|
LineNo = Record[-1]
|
|
Target = 'COMMON'
|
|
FeatureFlag = []
|
|
if Record[2]:
|
|
TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT)
|
|
if TokenList:
|
|
Target = TokenList[0]
|
|
if len(TokenList) > 1:
|
|
FeatureFlag = Record[1:]
|
|
|
|
File = PathClass(NormPath(Record[1], Macros), self._ModuleDir, '', FileType, True, self._Arch, '', Target)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate()
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
|
|
self._Binaries.append(File)
|
|
return self._Binaries
|
|
|
|
## Retrieve source files
|
|
def _GetSourceFiles(self):
|
|
if self._Sources == None:
|
|
self._Sources = []
|
|
RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource, 'PROCESSOR':self._Arch}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
LineNo = Record[-1]
|
|
ToolChainFamily = Record[1]
|
|
TagName = Record[2]
|
|
ToolCode = Record[3]
|
|
FeatureFlag = Record[4]
|
|
if self._AutoGenVersion < 0x00010005:
|
|
# old module source files (R8)
|
|
File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, self._SourceOverridePath,
|
|
'', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate(CaseSensitive=False)
|
|
if ErrorCode != 0:
|
|
if File.Ext.lower() == '.h':
|
|
EdkLogger.warn('build', 'Include file not found', ExtraData=ErrorInfo,
|
|
File=self.MetaFile, Line=LineNo)
|
|
continue
|
|
else:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=File, File=self.MetaFile, Line=LineNo)
|
|
else:
|
|
File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '',
|
|
'', False, self._Arch, ToolChainFamily, '', TagName, ToolCode)
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate()
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
|
|
|
|
self._Sources.append(File)
|
|
return self._Sources
|
|
|
|
## Retrieve library classes employed by this module
|
|
def _GetLibraryClassUses(self):
|
|
if self._LibraryClasses == None:
|
|
self._LibraryClasses = sdict()
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
Lib = Record[0]
|
|
Instance = Record[1]
|
|
if Instance != None and Instance != '':
|
|
Instance = NormPath(Instance, self._Macros)
|
|
self._LibraryClasses[Lib] = Instance
|
|
return self._LibraryClasses
|
|
|
|
## Retrieve library names (for R8.x style of modules)
|
|
def _GetLibraryNames(self):
|
|
if self._Libraries == None:
|
|
self._Libraries = []
|
|
RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
# in case of name with '.lib' extension, which is unusual in R8.x inf
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
LibraryName = os.path.splitext(Record[0])[0]
|
|
if LibraryName not in self._Libraries:
|
|
self._Libraries.append(LibraryName)
|
|
return self._Libraries
|
|
|
|
## Retrieve protocols consumed/produced by this module
|
|
def _GetProtocols(self):
|
|
if self._Protocols == None:
|
|
self._Protocols = sdict()
|
|
RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
CName = Record[0]
|
|
Value = ProtocolValue(CName, self.Packages)
|
|
if Value == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.Packages])
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
|
|
"Value of Protocol [%s] is not found under [Protocols] section in" % CName,
|
|
ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
|
|
self._Protocols[CName] = Value
|
|
return self._Protocols
|
|
|
|
## Retrieve PPIs consumed/produced by this module
|
|
def _GetPpis(self):
|
|
if self._Ppis == None:
|
|
self._Ppis = sdict()
|
|
RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
CName = Record[0]
|
|
Value = PpiValue(CName, self.Packages)
|
|
if Value == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.Packages])
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
|
|
"Value of PPI [%s] is not found under [Ppis] section in " % CName,
|
|
ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
|
|
self._Ppis[CName] = Value
|
|
return self._Ppis
|
|
|
|
## Retrieve GUIDs consumed/produced by this module
|
|
def _GetGuids(self):
|
|
if self._Guids == None:
|
|
self._Guids = sdict()
|
|
RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
CName = Record[0]
|
|
Value = GuidValue(CName, self.Packages)
|
|
if Value == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.Packages])
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
|
|
"Value of Guid [%s] is not found under [Guids] section in" % CName,
|
|
ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
|
|
self._Guids[CName] = Value
|
|
return self._Guids
|
|
|
|
## Retrieve include paths necessary for this module (for R8.x style of modules)
|
|
def _GetIncludes(self):
|
|
if self._Includes == None:
|
|
self._Includes = []
|
|
if self._SourceOverridePath:
|
|
self._Includes.append(self._SourceOverridePath)
|
|
RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform]
|
|
# [includes] section must be used only in old (R8.x) inf file
|
|
if self.AutoGenVersion >= 0x00010005 and len(RecordList) > 0:
|
|
EdkLogger.error('build', FORMAT_NOT_SUPPORTED, "No [include] section allowed",
|
|
File=self.MetaFile, Line=RecordList[0][-1]-1)
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
Record[0] = Record[0].replace('$(PROCESSOR)', self._Arch)
|
|
Record[0] = ReplaceMacro(Record[0], {'EFI_SOURCE' : GlobalData.gEfiSource}, False)
|
|
if Record[0].find('EDK_SOURCE') > -1:
|
|
File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEcpSource}, False), self._Macros)
|
|
if File[0] == '.':
|
|
File = os.path.join(self._ModuleDir, File)
|
|
else:
|
|
File = os.path.join(GlobalData.gWorkspace, File)
|
|
File = RealPath(os.path.normpath(File))
|
|
if File:
|
|
self._Includes.append(File)
|
|
|
|
#TRICK: let compiler to choose correct header file
|
|
File = NormPath(ReplaceMacro(Record[0], {'EDK_SOURCE' : GlobalData.gEdkSource}, False), self._Macros)
|
|
if File[0] == '.':
|
|
File = os.path.join(self._ModuleDir, File)
|
|
else:
|
|
File = os.path.join(GlobalData.gWorkspace, File)
|
|
File = RealPath(os.path.normpath(File))
|
|
if File:
|
|
self._Includes.append(File)
|
|
else:
|
|
File = NormPath(Record[0], self._Macros)
|
|
if File[0] == '.':
|
|
File = os.path.join(self._ModuleDir, File)
|
|
else:
|
|
File = os.path.join(GlobalData.gWorkspace, File)
|
|
File = RealPath(os.path.normpath(File))
|
|
if File:
|
|
self._Includes.append(File)
|
|
return self._Includes
|
|
|
|
## Retrieve packages this module depends on
|
|
def _GetPackages(self):
|
|
if self._Packages == None:
|
|
self._Packages = []
|
|
RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform]
|
|
Macros = {"EDK_SOURCE":GlobalData.gEcpSource, "EFI_SOURCE":GlobalData.gEfiSource}
|
|
Macros.update(self._Macros)
|
|
for Record in RecordList:
|
|
File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch)
|
|
LineNo = Record[-1]
|
|
# check the file validation
|
|
ErrorCode, ErrorInfo = File.Validate('.dec')
|
|
if ErrorCode != 0:
|
|
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo)
|
|
# parse this package now. we need it to get protocol/ppi/guid value
|
|
Package = self._Bdb[File, self._Arch]
|
|
self._Packages.append(Package)
|
|
return self._Packages
|
|
|
|
## Retrieve PCDs used in this module
|
|
def _GetPcds(self):
|
|
if self._Pcds == None:
|
|
self._Pcds = {}
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC))
|
|
self._Pcds.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX))
|
|
return self._Pcds
|
|
|
|
## Retrieve build options specific to this module
|
|
def _GetBuildOptions(self):
|
|
if self._BuildOptions == None:
|
|
self._BuildOptions = sdict()
|
|
RecordList = self._RawData[MODEL_META_DATA_BUILD_OPTION, self._Arch, self._Platform]
|
|
for Record in RecordList:
|
|
ToolChainFamily = Record[0]
|
|
ToolChain = Record[1]
|
|
Option = Record[2]
|
|
if (ToolChainFamily, ToolChain) not in self._BuildOptions:
|
|
self._BuildOptions[ToolChainFamily, ToolChain] = Option
|
|
else:
|
|
# concatenate the option string if they're for the same tool
|
|
OptionString = self._BuildOptions[ToolChainFamily, ToolChain]
|
|
self._BuildOptions[ToolChainFamily, ToolChain] = OptionString + " " + Option
|
|
return self._BuildOptions
|
|
|
|
## Retrieve depedency expression
|
|
def _GetDepex(self):
|
|
if self._Depex == None:
|
|
self._Depex = tdict(False, 2)
|
|
RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
|
|
|
|
# PEIM and DXE drivers must have a valid [Depex] section
|
|
if len(self.LibraryClass) == 0 and len(RecordList) == 0:
|
|
if self.ModuleType == 'DXE_DRIVER' or self.ModuleType == 'PEIM' or self.ModuleType == 'DXE_SMM_DRIVER' or \
|
|
self.ModuleType == 'DXE_SAL_DRIVER' or self.ModuleType == 'DXE_RUNTIME_DRIVER':
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No [Depex] section or no valid expression in [Depex] section for [%s] module" \
|
|
% self.ModuleType, File=self.MetaFile)
|
|
|
|
Depex = {}
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
Arch = Record[3]
|
|
ModuleType = Record[4]
|
|
TokenList = Record[0].split()
|
|
if (Arch, ModuleType) not in Depex:
|
|
Depex[Arch, ModuleType] = []
|
|
DepexList = Depex[Arch, ModuleType]
|
|
for Token in TokenList:
|
|
if Token in DEPEX_SUPPORTED_OPCODE:
|
|
DepexList.append(Token)
|
|
elif Token.endswith(".inf"): # module file name
|
|
ModuleFile = os.path.normpath(Token)
|
|
Module = self.BuildDatabase[ModuleFile]
|
|
if Module == None:
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "Module is not found in active platform",
|
|
ExtraData=Token, File=self.MetaFile, Line=Record[-1])
|
|
DepexList.append(Module.Guid)
|
|
else:
|
|
# get the GUID value now
|
|
Value = ProtocolValue(Token, self.Packages)
|
|
if Value == None:
|
|
Value = PpiValue(Token, self.Packages)
|
|
if Value == None:
|
|
Value = GuidValue(Token, self.Packages)
|
|
if Value == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.Packages])
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
|
|
"Value of [%s] is not found in" % Token,
|
|
ExtraData=PackageList, File=self.MetaFile, Line=Record[-1])
|
|
DepexList.append(Value)
|
|
for Arch, ModuleType in Depex:
|
|
self._Depex[Arch, ModuleType] = Depex[Arch, ModuleType]
|
|
return self._Depex
|
|
|
|
## Retrieve depedency expression
|
|
def _GetDepexExpression(self):
|
|
if self._DepexExpression == None:
|
|
self._DepexExpression = tdict(False, 2)
|
|
RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch]
|
|
DepexExpression = {}
|
|
for Record in RecordList:
|
|
Record = ReplaceMacros(Record, GlobalData.gEdkGlobal, False)
|
|
Arch = Record[3]
|
|
ModuleType = Record[4]
|
|
TokenList = Record[0].split()
|
|
if (Arch, ModuleType) not in DepexExpression:
|
|
DepexExpression[Arch, ModuleType] = ''
|
|
for Token in TokenList:
|
|
DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType] + Token.strip() + ' '
|
|
for Arch, ModuleType in DepexExpression:
|
|
self._DepexExpression[Arch, ModuleType] = DepexExpression[Arch, ModuleType]
|
|
return self._DepexExpression
|
|
|
|
## Retrieve PCD for given type
|
|
def _GetPcd(self, Type):
|
|
Pcds = {}
|
|
PcdDict = tdict(True, 4)
|
|
PcdSet = set()
|
|
RecordList = self._RawData[Type, self._Arch, self._Platform]
|
|
for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Dummy1, LineNo in RecordList:
|
|
PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo)
|
|
PcdSet.add((PcdCName, TokenSpaceGuid))
|
|
# get the guid value
|
|
if TokenSpaceGuid not in self.Guids:
|
|
Value = GuidValue(TokenSpaceGuid, self.Packages)
|
|
if Value == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.Packages])
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE,
|
|
"Value of Guid [%s] is not found under [Guids] section in" % TokenSpaceGuid,
|
|
ExtraData=PackageList, File=self.MetaFile, Line=LineNo)
|
|
self.Guids[TokenSpaceGuid] = Value
|
|
|
|
# resolve PCD type, value, datum info, etc. by getting its definition from package
|
|
for PcdCName, TokenSpaceGuid in PcdSet:
|
|
ValueList = ['', '']
|
|
Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid]
|
|
if Setting == None:
|
|
continue
|
|
TokenList = Setting.split(TAB_VALUE_SPLIT)
|
|
ValueList[0:len(TokenList)] = TokenList
|
|
DefaultValue = ValueList[0]
|
|
Pcd = PcdClassObject(
|
|
PcdCName,
|
|
TokenSpaceGuid,
|
|
'',
|
|
'',
|
|
DefaultValue,
|
|
'',
|
|
'',
|
|
{},
|
|
self.Guids[TokenSpaceGuid]
|
|
)
|
|
|
|
# get necessary info from package declaring this PCD
|
|
for Package in self.Packages:
|
|
#
|
|
# 'dynamic' in INF means its type is determined by platform;
|
|
# if platform doesn't give its type, use 'lowest' one in the
|
|
# following order, if any
|
|
#
|
|
# "FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"
|
|
#
|
|
PcdType = self._PCD_TYPE_STRING_[Type]
|
|
if Type in [MODEL_PCD_DYNAMIC, MODEL_PCD_DYNAMIC_EX]:
|
|
Pcd.Pending = True
|
|
for T in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
|
|
if (PcdCName, TokenSpaceGuid, T) in Package.Pcds:
|
|
PcdType = T
|
|
break
|
|
else:
|
|
Pcd.Pending = False
|
|
|
|
if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds:
|
|
PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType]
|
|
Pcd.Type = PcdType
|
|
Pcd.TokenValue = PcdInPackage.TokenValue
|
|
Pcd.DatumType = PcdInPackage.DatumType
|
|
Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize
|
|
Pcd.InfDefaultValue = Pcd.DefaultValue
|
|
if Pcd.DefaultValue in [None, '']:
|
|
Pcd.DefaultValue = PcdInPackage.DefaultValue
|
|
break
|
|
else:
|
|
EdkLogger.error(
|
|
'build',
|
|
PARSER_ERROR,
|
|
"PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdCName, self.MetaFile),
|
|
File =self.MetaFile, Line=LineNo,
|
|
ExtraData="\t%s" % '\n\t'.join([str(P) for P in self.Packages])
|
|
)
|
|
Pcds[PcdCName, TokenSpaceGuid] = Pcd
|
|
return Pcds
|
|
|
|
Arch = property(_GetArch, _SetArch)
|
|
Platform = property(_GetPlatform, _SetPlatform)
|
|
|
|
AutoGenVersion = property(_GetInfVersion)
|
|
BaseName = property(_GetBaseName)
|
|
ModuleType = property(_GetModuleType)
|
|
ComponentType = property(_GetComponentType)
|
|
BuildType = property(_GetBuildType)
|
|
Guid = property(_GetFileGuid)
|
|
Version = property(_GetVersion)
|
|
PcdIsDriver = property(_GetPcdIsDriver)
|
|
Shadow = property(_GetShadow)
|
|
CustomMakefile = property(_GetMakefile)
|
|
Specification = property(_GetSpec)
|
|
LibraryClass = property(_GetLibraryClass)
|
|
ModuleEntryPointList = property(_GetEntryPoint)
|
|
ModuleUnloadImageList = property(_GetUnloadImage)
|
|
ConstructorList = property(_GetConstructor)
|
|
DestructorList = property(_GetDestructor)
|
|
Defines = property(_GetDefines)
|
|
|
|
Binaries = property(_GetBinaryFiles)
|
|
Sources = property(_GetSourceFiles)
|
|
LibraryClasses = property(_GetLibraryClassUses)
|
|
Libraries = property(_GetLibraryNames)
|
|
Protocols = property(_GetProtocols)
|
|
Ppis = property(_GetPpis)
|
|
Guids = property(_GetGuids)
|
|
Includes = property(_GetIncludes)
|
|
Packages = property(_GetPackages)
|
|
Pcds = property(_GetPcds)
|
|
BuildOptions = property(_GetBuildOptions)
|
|
Depex = property(_GetDepex)
|
|
DepexExpression = property(_GetDepexExpression)
|
|
|
|
## Database
|
|
#
|
|
# This class defined the build databse for all modules, packages and platform.
|
|
# It will call corresponding parser for the given file if it cannot find it in
|
|
# the database.
|
|
#
|
|
# @param DbPath Path of database file
|
|
# @param GlobalMacros Global macros used for replacement during file parsing
|
|
# @prarm RenewDb=False Create new database file if it's already there
|
|
#
|
|
class WorkspaceDatabase(object):
|
|
# file parser
|
|
_FILE_PARSER_ = {
|
|
MODEL_FILE_INF : InfParser,
|
|
MODEL_FILE_DEC : DecParser,
|
|
MODEL_FILE_DSC : DscParser,
|
|
MODEL_FILE_FDF : None, #FdfParser,
|
|
MODEL_FILE_CIF : None
|
|
}
|
|
|
|
# file table
|
|
_FILE_TABLE_ = {
|
|
MODEL_FILE_INF : ModuleTable,
|
|
MODEL_FILE_DEC : PackageTable,
|
|
MODEL_FILE_DSC : PlatformTable,
|
|
}
|
|
|
|
# default database file path
|
|
_DB_PATH_ = "Conf/.cache/build.db"
|
|
|
|
#
|
|
# internal class used for call corresponding file parser and caching the result
|
|
# to avoid unnecessary re-parsing
|
|
#
|
|
class BuildObjectFactory(object):
|
|
_FILE_TYPE_ = {
|
|
".inf" : MODEL_FILE_INF,
|
|
".dec" : MODEL_FILE_DEC,
|
|
".dsc" : MODEL_FILE_DSC,
|
|
".fdf" : MODEL_FILE_FDF,
|
|
}
|
|
|
|
# convert to xxxBuildData object
|
|
_GENERATOR_ = {
|
|
MODEL_FILE_INF : InfBuildData,
|
|
MODEL_FILE_DEC : DecBuildData,
|
|
MODEL_FILE_DSC : DscBuildData,
|
|
MODEL_FILE_FDF : None #FlashDefTable,
|
|
}
|
|
|
|
_CACHE_ = {} # (FilePath, Arch) : <object>
|
|
|
|
# constructor
|
|
def __init__(self, WorkspaceDb):
|
|
self.WorkspaceDb = WorkspaceDb
|
|
|
|
# key = (FilePath, Arch='COMMON')
|
|
def __contains__(self, Key):
|
|
FilePath = Key[0]
|
|
Arch = 'COMMON'
|
|
if len(Key) > 1:
|
|
Arch = Key[1]
|
|
return (FilePath, Arch) in self._CACHE_
|
|
|
|
# key = (FilePath, Arch='COMMON')
|
|
def __getitem__(self, Key):
|
|
FilePath = Key[0]
|
|
Arch = 'COMMON'
|
|
Platform = 'COMMON'
|
|
if len(Key) > 1:
|
|
Arch = Key[1]
|
|
if len(Key) > 2:
|
|
Platform = Key[2]
|
|
|
|
# if it's generated before, just return the cached one
|
|
Key = (FilePath, Arch)
|
|
if Key in self._CACHE_:
|
|
return self._CACHE_[Key]
|
|
|
|
# check file type
|
|
Ext = FilePath.Ext.lower()
|
|
if Ext not in self._FILE_TYPE_:
|
|
return None
|
|
FileType = self._FILE_TYPE_[Ext]
|
|
if FileType not in self._GENERATOR_:
|
|
return None
|
|
|
|
# get table for current file
|
|
MetaFile = self.WorkspaceDb[FilePath, FileType, self.WorkspaceDb._GlobalMacros]
|
|
BuildObject = self._GENERATOR_[FileType](
|
|
FilePath,
|
|
MetaFile,
|
|
self,
|
|
Arch,
|
|
Platform,
|
|
self.WorkspaceDb._GlobalMacros,
|
|
)
|
|
self._CACHE_[Key] = BuildObject
|
|
return BuildObject
|
|
|
|
# placeholder for file format conversion
|
|
class TransformObjectFactory:
|
|
def __init__(self, WorkspaceDb):
|
|
self.WorkspaceDb = WorkspaceDb
|
|
|
|
# key = FilePath, Arch
|
|
def __getitem__(self, Key):
|
|
pass
|
|
|
|
## Constructor of WorkspaceDatabase
|
|
#
|
|
# @param DbPath Path of database file
|
|
# @param GlobalMacros Global macros used for replacement during file parsing
|
|
# @prarm RenewDb=False Create new database file if it's already there
|
|
#
|
|
def __init__(self, DbPath, GlobalMacros={}, RenewDb=False):
|
|
self._GlobalMacros = GlobalMacros
|
|
|
|
if DbPath == None or DbPath == '':
|
|
DbPath = os.path.normpath(os.path.join(GlobalData.gWorkspace, self._DB_PATH_))
|
|
|
|
# don't create necessary path for db in memory
|
|
if DbPath != ':memory:':
|
|
DbDir = os.path.split(DbPath)[0]
|
|
if not os.path.exists(DbDir):
|
|
os.makedirs(DbDir)
|
|
|
|
# remove db file in case inconsistency between db and file in file system
|
|
if self._CheckWhetherDbNeedRenew(RenewDb, DbPath):
|
|
os.remove(DbPath)
|
|
|
|
# create db with optimized parameters
|
|
self.Conn = sqlite3.connect(DbPath, isolation_level='DEFERRED')
|
|
self.Conn.execute("PRAGMA synchronous=OFF")
|
|
self.Conn.execute("PRAGMA temp_store=MEMORY")
|
|
self.Conn.execute("PRAGMA count_changes=OFF")
|
|
self.Conn.execute("PRAGMA cache_size=8192")
|
|
#self.Conn.execute("PRAGMA page_size=8192")
|
|
|
|
# to avoid non-ascii character conversion issue
|
|
self.Conn.text_factory = str
|
|
self.Cur = self.Conn.cursor()
|
|
|
|
# create table for internal uses
|
|
self.TblDataModel = TableDataModel(self.Cur)
|
|
self.TblFile = TableFile(self.Cur)
|
|
|
|
# conversion object for build or file format conversion purpose
|
|
self.BuildObject = WorkspaceDatabase.BuildObjectFactory(self)
|
|
self.TransformObject = WorkspaceDatabase.TransformObjectFactory(self)
|
|
|
|
## Check whether workspace database need to be renew.
|
|
# The renew reason maybe:
|
|
# 1) If user force to renew;
|
|
# 2) If user do not force renew, and
|
|
# a) If the time of last modified python source is newer than database file;
|
|
# b) If the time of last modified frozen executable file is newer than database file;
|
|
#
|
|
# @param force User force renew database
|
|
# @param DbPath The absolute path of workspace database file
|
|
#
|
|
# @return Bool value for whether need renew workspace databse
|
|
#
|
|
def _CheckWhetherDbNeedRenew (self, force, DbPath):
|
|
DbDir = os.path.split(DbPath)[0]
|
|
MacroFilePath = os.path.normpath(os.path.join(DbDir, "build.mac"))
|
|
MacroMatch = False
|
|
if os.path.exists(MacroFilePath) and os.path.isfile(MacroFilePath):
|
|
LastMacros = None
|
|
try:
|
|
f = open(MacroFilePath,'r')
|
|
LastMacros = pickle.load(f)
|
|
f.close()
|
|
except IOError:
|
|
pass
|
|
except:
|
|
f.close()
|
|
|
|
if LastMacros != None and type(LastMacros) is DictType:
|
|
if LastMacros == self._GlobalMacros:
|
|
MacroMatch = True
|
|
for Macro in LastMacros.keys():
|
|
if not (Macro in self._GlobalMacros and LastMacros[Macro] == self._GlobalMacros[Macro]):
|
|
MacroMatch = False;
|
|
break;
|
|
|
|
if not MacroMatch:
|
|
# save command line macros to file
|
|
try:
|
|
f = open(MacroFilePath,'w')
|
|
pickle.dump(self._GlobalMacros, f, 2)
|
|
f.close()
|
|
except IOError:
|
|
pass
|
|
except:
|
|
f.close()
|
|
|
|
force = True
|
|
|
|
# if database does not exist, we need do nothing
|
|
if not os.path.exists(DbPath): return False
|
|
|
|
# if user force to renew database, then not check whether database is out of date
|
|
if force: return True
|
|
|
|
#
|
|
# Check the time of last modified source file or build.exe
|
|
# if is newer than time of database, then database need to be re-created.
|
|
#
|
|
timeOfToolModified = 0
|
|
if hasattr(sys, "frozen"):
|
|
exePath = os.path.abspath(sys.executable)
|
|
timeOfToolModified = os.stat(exePath).st_mtime
|
|
else:
|
|
curPath = os.path.dirname(__file__) # curPath is the path of WorkspaceDatabase.py
|
|
rootPath = os.path.split(curPath)[0] # rootPath is root path of python source, such as /BaseTools/Source/Python
|
|
if rootPath == "" or rootPath == None:
|
|
EdkLogger.verbose("\nFail to find the root path of build.exe or python sources, so can not \
|
|
determine whether database file is out of date!\n")
|
|
|
|
# walk the root path of source or build's binary to get the time last modified.
|
|
|
|
for root, dirs, files in os.walk (rootPath):
|
|
for dir in dirs:
|
|
# bypass source control folder
|
|
if dir.lower() in [".svn", "_svn", "cvs"]:
|
|
dirs.remove(dir)
|
|
|
|
for file in files:
|
|
ext = os.path.splitext(file)[1]
|
|
if ext.lower() == ".py": # only check .py files
|
|
fd = os.stat(os.path.join(root, file))
|
|
if timeOfToolModified < fd.st_mtime:
|
|
timeOfToolModified = fd.st_mtime
|
|
if timeOfToolModified > os.stat(DbPath).st_mtime:
|
|
EdkLogger.verbose("\nWorkspace database is out of data!")
|
|
return True
|
|
|
|
return False
|
|
|
|
## Initialize build database
|
|
def InitDatabase(self):
|
|
EdkLogger.verbose("\nInitialize build database started ...")
|
|
|
|
#
|
|
# Create new tables
|
|
#
|
|
self.TblDataModel.Create(False)
|
|
self.TblFile.Create(False)
|
|
|
|
#
|
|
# Initialize table DataModel
|
|
#
|
|
self.TblDataModel.InitTable()
|
|
EdkLogger.verbose("Initialize build database ... DONE!")
|
|
|
|
## Query a table
|
|
#
|
|
# @param Table: The instance of the table to be queried
|
|
#
|
|
def QueryTable(self, Table):
|
|
Table.Query()
|
|
|
|
## Close entire database
|
|
#
|
|
# Commit all first
|
|
# Close the connection and cursor
|
|
#
|
|
def Close(self):
|
|
self.Conn.commit()
|
|
self.Cur.close()
|
|
self.Conn.close()
|
|
|
|
## Get unique file ID for the gvien file
|
|
def GetFileId(self, FilePath):
|
|
return self.TblFile.GetFileId(FilePath)
|
|
|
|
## Get file type value for the gvien file ID
|
|
def GetFileType(self, FileId):
|
|
return self.TblFile.GetFileType(FileId)
|
|
|
|
## Get time stamp stored in file table
|
|
def GetTimeStamp(self, FileId):
|
|
return self.TblFile.GetFileTimeStamp(FileId)
|
|
|
|
## Update time stamp in file table
|
|
def SetTimeStamp(self, FileId, TimeStamp):
|
|
return self.TblFile.SetFileTimeStamp(FileId, TimeStamp)
|
|
|
|
## Check if a table integrity flag exists or not
|
|
def CheckIntegrity(self, TableName):
|
|
try:
|
|
Result = self.Cur.execute("select min(ID) from %s" % (TableName)).fetchall()
|
|
if Result[0][0] != -1:
|
|
return False
|
|
except:
|
|
return False
|
|
return True
|
|
|
|
## Compose table name for given file type and file ID
|
|
def GetTableName(self, FileType, FileId):
|
|
return "_%s_%s" % (FileType, FileId)
|
|
|
|
## Return a temp table containing all content of the given file
|
|
#
|
|
# @param FileInfo The tuple containing path and type of a file
|
|
#
|
|
def __getitem__(self, FileInfo):
|
|
FilePath, FileType, Macros = FileInfo
|
|
if FileType not in self._FILE_TABLE_:
|
|
return None
|
|
|
|
# flag used to indicate if it's parsed or not
|
|
FilePath = str(FilePath)
|
|
Parsed = False
|
|
FileId = self.GetFileId(FilePath)
|
|
if FileId != None:
|
|
TimeStamp = os.stat(FilePath)[8]
|
|
TableName = self.GetTableName(FileType, FileId)
|
|
if TimeStamp != self.GetTimeStamp(FileId):
|
|
# update the timestamp in database
|
|
self.SetTimeStamp(FileId, TimeStamp)
|
|
else:
|
|
# if the table exists and is integrity, don't parse it
|
|
Parsed = self.CheckIntegrity(TableName)
|
|
else:
|
|
FileId = self.TblFile.InsertFile(FilePath, FileType)
|
|
TableName = self.GetTableName(FileType, FileId)
|
|
|
|
FileTable = self._FILE_TABLE_[FileType](self.Cur, TableName, FileId)
|
|
FileTable.Create(not Parsed)
|
|
Parser = self._FILE_PARSER_[FileType](FilePath, FileType, FileTable, Macros)
|
|
# set the "Finished" flag in parser in order to avoid re-parsing (if parsed)
|
|
Parser.Finished = Parsed
|
|
return Parser
|
|
|
|
## Summarize all packages in the database
|
|
def _GetPackageList(self):
|
|
PackageList = []
|
|
for Module in self.ModuleList:
|
|
for Package in Module.Packages:
|
|
if Package not in PackageList:
|
|
PackageList.append(Package)
|
|
return PackageList
|
|
|
|
## Summarize all platforms in the database
|
|
def _GetPlatformList(self):
|
|
PlatformList = []
|
|
for PlatformFile in self.TblFile.GetFileList(MODEL_FILE_DSC):
|
|
try:
|
|
Platform = self.BuildObject[PathClass(PlatformFile), 'COMMON']
|
|
except:
|
|
Platform = None
|
|
if Platform != None:
|
|
PlatformList.append(Platform)
|
|
return PlatformList
|
|
|
|
## Summarize all modules in the database
|
|
def _GetModuleList(self):
|
|
ModuleList = []
|
|
for ModuleFile in self.TblFile.GetFileList(MODEL_FILE_INF):
|
|
try:
|
|
Module = self.BuildObject[PathClass(ModuleFile), 'COMMON']
|
|
except:
|
|
Module = None
|
|
if Module != None:
|
|
ModuleList.append(Module)
|
|
return ModuleList
|
|
|
|
PlatformList = property(_GetPlatformList)
|
|
PackageList = property(_GetPackageList)
|
|
ModuleList = property(_GetModuleList)
|
|
|
|
##
|
|
#
|
|
# This acts like the main() function for the script, unless it is 'import'ed into another
|
|
# script.
|
|
#
|
|
if __name__ == '__main__':
|
|
pass
|
|
|