## @file | |
# This file is used to create a database used by build tool | |
# | |
# Copyright (c) 2008 - 2018, Intel Corporation. All rights reserved.<BR> | |
# (C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR> | |
# SPDX-License-Identifier: BSD-2-Clause-Patent | |
# | |
from __future__ import absolute_import | |
from Common.DataType import * | |
from Common.Misc import * | |
from Common.caching import cached_property, cached_class_function | |
from types import * | |
from .MetaFileParser import * | |
from collections import OrderedDict | |
from Workspace.BuildClassObject import ModuleBuildClassObject, LibraryClassObject, PcdClassObject | |
from Common.Expression import ValueExpressionEx, PcdPattern | |
## Get Protocol value from given packages | |
# | |
# @param CName The CName of the GUID | |
# @param PackageList List of packages looking-up in | |
# @param Inffile The driver file | |
# | |
# @retval GuidValue if the CName is found in any given package | |
# @retval None if the CName is not found in all given packages | |
# | |
def _ProtocolValue(CName, PackageList, Inffile = None): | |
for P in PackageList: | |
ProtocolKeys = list(P.Protocols.keys()) | |
if Inffile and P._PrivateProtocols: | |
if not Inffile.startswith(P.MetaFile.Dir): | |
ProtocolKeys = [x for x in P.Protocols if x not in P._PrivateProtocols] | |
if CName in ProtocolKeys: | |
return P.Protocols[CName] | |
return None | |
## Get PPI value from given packages | |
# | |
# @param CName The CName of the GUID | |
# @param PackageList List of packages looking-up in | |
# @param Inffile The driver file | |
# | |
# @retval GuidValue if the CName is found in any given package | |
# @retval None if the CName is not found in all given packages | |
# | |
def _PpiValue(CName, PackageList, Inffile = None): | |
for P in PackageList: | |
PpiKeys = list(P.Ppis.keys()) | |
if Inffile and P._PrivatePpis: | |
if not Inffile.startswith(P.MetaFile.Dir): | |
PpiKeys = [x for x in P.Ppis if x not in P._PrivatePpis] | |
if CName in PpiKeys: | |
return P.Ppis[CName] | |
return None | |
## 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 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_DPX_SOURCE :"_DxsFile", | |
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" | |
} | |
# 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", | |
BINARY_FILE_TYPE_LIB : "SLINK", | |
"LINK" : "DLINK", | |
} | |
## Constructor of InfBuildData | |
# | |
# Initialize object of InfBuildData | |
# | |
# @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=TAB_ARCH_COMMON, Target=None, Toolchain=None): | |
self.MetaFile = FilePath | |
self._ModuleDir = FilePath.Dir | |
self._RawData = RawData | |
self._Bdb = BuildDatabase | |
self._Arch = Arch | |
self._Target = Target | |
self._Toolchain = Toolchain | |
self._Platform = TAB_COMMON | |
self._TailComments = None | |
self._BaseName = None | |
self._DxsFile = 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 = OrderedDict() | |
self._ProtocolComments = None | |
self._PpiComments = None | |
self._GuidsUsedByPcd = OrderedDict() | |
self._GuidComments = None | |
self._PcdComments = None | |
self._BuildOptions = None | |
self._DependencyFileList = None | |
self.UpdatePcdTypeDict() | |
self.LibInstances = [] | |
self.ReferenceModules = set() | |
def SetReferenceModule(self,Module): | |
self.ReferenceModules.add(Module) | |
return self | |
## 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_ | |
## Get current effective macros | |
@cached_property | |
def _Macros(self): | |
RetVal = {} | |
return RetVal | |
## Get architecture | |
@cached_property | |
def Arch(self): | |
return self._Arch | |
## Return the name of platform employing this module | |
@cached_property | |
def Platform(self): | |
return self._Platform | |
@cached_property | |
def HeaderComments(self): | |
return [a[0] for a in self._RawData[MODEL_META_DATA_HEADER_COMMENT]] | |
@cached_property | |
def TailComments(self): | |
return [a[0] for a in self._RawData[MODEL_META_DATA_TAIL_COMMENT]] | |
## Retrieve all information in [Defines] section | |
# | |
# (Retrieving all [Defines] information in one-shot is just to save time.) | |
# | |
@cached_class_function | |
def _GetHeaderInfo(self): | |
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform] | |
for Record in RecordList: | |
Name, Value = Record[1], ReplaceMacro(Record[2], self._Macros, False) | |
# items defined _PROPERTY_ don't need additional processing | |
if Name in self: | |
self[Name] = Value | |
self._Defs[Name] = Value | |
self._Macros[Name] = Value | |
# some special items in [Defines] section need special treatment | |
elif Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION', 'EDK_RELEASE_VERSION', 'PI_SPECIFICATION_VERSION'): | |
if Name in ('EFI_SPECIFICATION_VERSION', 'UEFI_SPECIFICATION_VERSION'): | |
Name = 'UEFI_SPECIFICATION_VERSION' | |
if self._Specification is None: | |
self._Specification = OrderedDict() | |
self._Specification[Name] = GetHexVerValue(Value) | |
if self._Specification[Name] is None: | |
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, | |
"'%s' format is not supported for %s" % (Value, Name), | |
File=self.MetaFile, Line=Record[-1]) | |
elif Name == 'LIBRARY_CLASS': | |
if self._LibraryClass is None: | |
self._LibraryClass = [] | |
ValueList = GetSplitValueList(Value) | |
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 is None: | |
self._ModuleEntryPointList = [] | |
self._ModuleEntryPointList.append(Value) | |
elif Name == 'UNLOAD_IMAGE': | |
if self._ModuleUnloadImageList is None: | |
self._ModuleUnloadImageList = [] | |
if not Value: | |
continue | |
self._ModuleUnloadImageList.append(Value) | |
elif Name == 'CONSTRUCTOR': | |
if self._ConstructorList is None: | |
self._ConstructorList = [] | |
if not Value: | |
continue | |
self._ConstructorList.append(Value) | |
elif Name == 'DESTRUCTOR': | |
if self._DestructorList is None: | |
self._DestructorList = [] | |
if not Value: | |
continue | |
self._DestructorList.append(Value) | |
elif Name == TAB_INF_DEFINES_CUSTOM_MAKEFILE: | |
TokenList = GetSplitValueList(Value) | |
if self._CustomMakefile is None: | |
self._CustomMakefile = {} | |
if len(TokenList) < 2: | |
self._CustomMakefile[TAB_COMPILER_MSFT] = TokenList[0] | |
self._CustomMakefile['GCC'] = TokenList[0] | |
else: | |
if TokenList[0] not in [TAB_COMPILER_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: | |
self._Defs[Name] = Value | |
self._Macros[Name] = Value | |
# | |
# Retrieve information in sections specific to Edk.x modules | |
# | |
if not self._ModuleType: | |
EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, | |
"MODULE_TYPE is not given", File=self.MetaFile) | |
if self._ModuleType not in SUP_MODULE_LIST: | |
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform] | |
for Record in RecordList: | |
Name = Record[1] | |
if Name == "MODULE_TYPE": | |
LineNo = Record[6] | |
break | |
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, | |
"MODULE_TYPE %s is not supported for EDK II, valid values are:\n %s" % (self._ModuleType, ' '.join(l for l in SUP_MODULE_LIST)), | |
File=self.MetaFile, Line=LineNo) | |
if (self._Specification is None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 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._Specification is None) or (not 'PI_SPECIFICATION_VERSION' in self._Specification) or (int(self._Specification['PI_SPECIFICATION_VERSION'], 16) < 0x00010032): | |
if self._ModuleType == SUP_MODULE_MM_CORE_STANDALONE: | |
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_CORE_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile) | |
if self._ModuleType == SUP_MODULE_MM_STANDALONE: | |
EdkLogger.error("build", FORMAT_NOT_SUPPORTED, "MM_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.MetaFile) | |
if 'PCI_DEVICE_ID' in self._Defs and 'PCI_VENDOR_ID' in self._Defs \ | |
and 'PCI_CLASS_CODE' in self._Defs and 'PCI_REVISION' in self._Defs: | |
self._BuildType = 'UEFI_OPTIONROM' | |
if 'PCI_COMPRESS' in self._Defs: | |
if self._Defs['PCI_COMPRESS'] not in ('TRUE', 'FALSE'): | |
EdkLogger.error("build", FORMAT_INVALID, "Expected TRUE/FALSE for PCI_COMPRESS: %s" % self.MetaFile) | |
elif '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() | |
if self._DxsFile: | |
File = PathClass(NormPath(self._DxsFile), 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 not self._DependencyFileList: | |
self._DependencyFileList = [] | |
self._DependencyFileList.append(File) | |
## Retrieve file version | |
@cached_property | |
def AutoGenVersion(self): | |
RetVal = 0x00010000 | |
RecordList = self._RawData[MODEL_META_DATA_HEADER, self._Arch, self._Platform] | |
for Record in RecordList: | |
if Record[1] == TAB_INF_DEFINES_INF_VERSION: | |
if '.' in Record[2]: | |
ValueList = Record[2].split('.') | |
Major = '%04o' % int(ValueList[0], 0) | |
Minor = '%04o' % int(ValueList[1], 0) | |
RetVal = int('0x' + Major + Minor, 0) | |
else: | |
RetVal = int(Record[2], 0) | |
break | |
return RetVal | |
## Retrieve BASE_NAME | |
@cached_property | |
def BaseName(self): | |
if self._BaseName is None: | |
self._GetHeaderInfo() | |
if self._BaseName is None: | |
EdkLogger.error('build', ATTRIBUTE_NOT_AVAILABLE, "No BASE_NAME name", File=self.MetaFile) | |
return self._BaseName | |
## Retrieve DxsFile | |
@cached_property | |
def DxsFile(self): | |
if self._DxsFile is None: | |
self._GetHeaderInfo() | |
if self._DxsFile is None: | |
self._DxsFile = '' | |
return self._DxsFile | |
## Retrieve MODULE_TYPE | |
@cached_property | |
def ModuleType(self): | |
if self._ModuleType is None: | |
self._GetHeaderInfo() | |
if self._ModuleType is None: | |
self._ModuleType = SUP_MODULE_BASE | |
if self._ModuleType not in SUP_MODULE_LIST: | |
self._ModuleType = SUP_MODULE_USER_DEFINED | |
return self._ModuleType | |
## Retrieve COMPONENT_TYPE | |
@cached_property | |
def ComponentType(self): | |
if self._ComponentType is None: | |
self._GetHeaderInfo() | |
if self._ComponentType is None: | |
self._ComponentType = SUP_MODULE_USER_DEFINED | |
return self._ComponentType | |
## Retrieve "BUILD_TYPE" | |
@cached_property | |
def BuildType(self): | |
if self._BuildType is None: | |
self._GetHeaderInfo() | |
if not self._BuildType: | |
self._BuildType = SUP_MODULE_BASE | |
return self._BuildType | |
## Retrieve file guid | |
@cached_property | |
def Guid(self): | |
if self._Guid is None: | |
self._GetHeaderInfo() | |
if self._Guid is None: | |
self._Guid = '00000000-0000-0000-0000-000000000000' | |
return self._Guid | |
## Retrieve module version | |
@cached_property | |
def Version(self): | |
if self._Version is None: | |
self._GetHeaderInfo() | |
if self._Version is None: | |
self._Version = '0.0' | |
return self._Version | |
## Retrieve PCD_IS_DRIVER | |
@cached_property | |
def PcdIsDriver(self): | |
if self._PcdIsDriver is None: | |
self._GetHeaderInfo() | |
if self._PcdIsDriver is None: | |
self._PcdIsDriver = '' | |
return self._PcdIsDriver | |
## Retrieve SHADOW | |
@cached_property | |
def Shadow(self): | |
if self._Shadow is None: | |
self._GetHeaderInfo() | |
if self._Shadow and self._Shadow.upper() == 'TRUE': | |
self._Shadow = True | |
else: | |
self._Shadow = False | |
return self._Shadow | |
## Retrieve CUSTOM_MAKEFILE | |
@cached_property | |
def CustomMakefile(self): | |
if self._CustomMakefile is None: | |
self._GetHeaderInfo() | |
if self._CustomMakefile is None: | |
self._CustomMakefile = {} | |
return self._CustomMakefile | |
## Retrieve EFI_SPECIFICATION_VERSION | |
@cached_property | |
def Specification(self): | |
if self._Specification is None: | |
self._GetHeaderInfo() | |
if self._Specification is None: | |
self._Specification = {} | |
return self._Specification | |
## Retrieve LIBRARY_CLASS | |
@cached_property | |
def LibraryClass(self): | |
if self._LibraryClass is None: | |
self._GetHeaderInfo() | |
if self._LibraryClass is None: | |
self._LibraryClass = [] | |
return self._LibraryClass | |
## Retrieve ENTRY_POINT | |
@cached_property | |
def ModuleEntryPointList(self): | |
if self._ModuleEntryPointList is None: | |
self._GetHeaderInfo() | |
if self._ModuleEntryPointList is None: | |
self._ModuleEntryPointList = [] | |
return self._ModuleEntryPointList | |
## Retrieve UNLOAD_IMAGE | |
@cached_property | |
def ModuleUnloadImageList(self): | |
if self._ModuleUnloadImageList is None: | |
self._GetHeaderInfo() | |
if self._ModuleUnloadImageList is None: | |
self._ModuleUnloadImageList = [] | |
return self._ModuleUnloadImageList | |
## Retrieve CONSTRUCTOR | |
@cached_property | |
def ConstructorList(self): | |
if self._ConstructorList is None: | |
self._GetHeaderInfo() | |
if self._ConstructorList is None: | |
self._ConstructorList = [] | |
return self._ConstructorList | |
## Retrieve DESTRUCTOR | |
@cached_property | |
def DestructorList(self): | |
if self._DestructorList is None: | |
self._GetHeaderInfo() | |
if self._DestructorList is None: | |
self._DestructorList = [] | |
return self._DestructorList | |
## Retrieve definies other than above ones | |
@cached_property | |
def Defines(self): | |
self._GetHeaderInfo() | |
return self._Defs | |
## Retrieve binary files | |
@cached_class_function | |
def _GetBinaries(self): | |
RetVal = [] | |
RecordList = self._RawData[MODEL_EFI_BINARY_FILE, self._Arch, self._Platform] | |
Macros = self._Macros | |
Macros['PROCESSOR'] = self._Arch | |
for Record in RecordList: | |
FileType = Record[0] | |
LineNo = Record[-1] | |
Target = TAB_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) | |
RetVal.append(File) | |
return RetVal | |
## Retrieve binary files with error check. | |
@cached_property | |
def Binaries(self): | |
RetVal = self._GetBinaries() | |
if GlobalData.gIgnoreSource and not RetVal: | |
ErrorInfo = "The INF file does not contain any RetVal to use in creating the image\n" | |
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, ExtraData=ErrorInfo, File=self.MetaFile) | |
return RetVal | |
## Retrieve source files | |
@cached_property | |
def Sources(self): | |
self._GetHeaderInfo() | |
# Ignore all source files in a binary build mode | |
if GlobalData.gIgnoreSource: | |
return [] | |
RetVal = [] | |
RecordList = self._RawData[MODEL_EFI_SOURCE_FILE, self._Arch, self._Platform] | |
Macros = self._Macros | |
for Record in RecordList: | |
LineNo = Record[-1] | |
ToolChainFamily = Record[1] | |
# OptionsList := [TagName, ToolCode, FeatureFlag] | |
OptionsList = ['', '', ''] | |
TokenList = GetSplitValueList(Record[2], TAB_VALUE_SPLIT) | |
for Index in range(len(TokenList)): | |
OptionsList[Index] = TokenList[Index] | |
if OptionsList[2]: | |
FeaturePcdExpression = self.CheckFeatureFlagPcd(OptionsList[2]) | |
if not FeaturePcdExpression: | |
continue | |
File = PathClass(NormPath(Record[0], Macros), self._ModuleDir, '', | |
'', False, self._Arch, ToolChainFamily, '', OptionsList[0], OptionsList[1]) | |
# check the file validation | |
ErrorCode, ErrorInfo = File.Validate() | |
if ErrorCode != 0: | |
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo) | |
RetVal.append(File) | |
# add any previously found dependency files to the source list | |
if self._DependencyFileList: | |
RetVal.extend(self._DependencyFileList) | |
return RetVal | |
## Retrieve library classes employed by this module | |
@cached_property | |
def LibraryClasses(self): | |
RetVal = OrderedDict() | |
RecordList = self._RawData[MODEL_EFI_LIBRARY_CLASS, self._Arch, self._Platform] | |
for Record in RecordList: | |
Lib = Record[0] | |
Instance = Record[1] | |
if Instance: | |
Instance = NormPath(Instance, self._Macros) | |
RetVal[Lib] = Instance | |
else: | |
RetVal[Lib] = None | |
return RetVal | |
## Retrieve library names (for Edk.x style of modules) | |
@cached_property | |
def Libraries(self): | |
RetVal = [] | |
RecordList = self._RawData[MODEL_EFI_LIBRARY_INSTANCE, self._Arch, self._Platform] | |
for Record in RecordList: | |
LibraryName = ReplaceMacro(Record[0], self._Macros, False) | |
# in case of name with '.lib' extension, which is unusual in Edk.x inf | |
LibraryName = os.path.splitext(LibraryName)[0] | |
if LibraryName not in RetVal: | |
RetVal.append(LibraryName) | |
return RetVal | |
@cached_property | |
def ProtocolComments(self): | |
self.Protocols | |
return self._ProtocolComments | |
## Retrieve protocols consumed/produced by this module | |
@cached_property | |
def Protocols(self): | |
RetVal = OrderedDict() | |
self._ProtocolComments = OrderedDict() | |
RecordList = self._RawData[MODEL_EFI_PROTOCOL, self._Arch, self._Platform] | |
for Record in RecordList: | |
CName = Record[0] | |
Value = _ProtocolValue(CName, self.Packages, self.MetaFile.Path) | |
if Value is 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]) | |
RetVal[CName] = Value | |
CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]] | |
self._ProtocolComments[CName] = [a[0] for a in CommentRecords] | |
return RetVal | |
@cached_property | |
def PpiComments(self): | |
self.Ppis | |
return self._PpiComments | |
## Retrieve PPIs consumed/produced by this module | |
@cached_property | |
def Ppis(self): | |
RetVal = OrderedDict() | |
self._PpiComments = OrderedDict() | |
RecordList = self._RawData[MODEL_EFI_PPI, self._Arch, self._Platform] | |
for Record in RecordList: | |
CName = Record[0] | |
Value = _PpiValue(CName, self.Packages, self.MetaFile.Path) | |
if Value is 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]) | |
RetVal[CName] = Value | |
CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]] | |
self._PpiComments[CName] = [a[0] for a in CommentRecords] | |
return RetVal | |
@cached_property | |
def GuidComments(self): | |
self.Guids | |
return self._GuidComments | |
## Retrieve GUIDs consumed/produced by this module | |
@cached_property | |
def Guids(self): | |
RetVal = OrderedDict() | |
self._GuidComments = OrderedDict() | |
RecordList = self._RawData[MODEL_EFI_GUID, self._Arch, self._Platform] | |
for Record in RecordList: | |
CName = Record[0] | |
Value = GuidValue(CName, self.Packages, self.MetaFile.Path) | |
if Value is 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]) | |
RetVal[CName] = Value | |
CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Record[5]] | |
self._GuidComments[CName] = [a[0] for a in CommentRecords] | |
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, self._Platform] | |
for TokenSpaceGuid, _, _, _, _, _, LineNo in RecordList: | |
# get the guid value | |
if TokenSpaceGuid not in RetVal: | |
Value = GuidValue(TokenSpaceGuid, self.Packages, self.MetaFile.Path) | |
if Value is 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) | |
RetVal[TokenSpaceGuid] = Value | |
self._GuidsUsedByPcd[TokenSpaceGuid] = Value | |
return RetVal | |
## Retrieve include paths necessary for this module (for Edk.x style of modules) | |
@cached_property | |
def Includes(self): | |
RetVal = [] | |
Macros = self._Macros | |
Macros['PROCESSOR'] = GlobalData.gEdkGlobal.get('PROCESSOR', self._Arch) | |
RecordList = self._RawData[MODEL_EFI_INCLUDE, self._Arch, self._Platform] | |
for Record in RecordList: | |
File = NormPath(Record[0], Macros) | |
if File[0] == '.': | |
File = os.path.join(self._ModuleDir, File) | |
else: | |
File = mws.join(GlobalData.gWorkspace, File) | |
File = RealPath(os.path.normpath(File)) | |
if File: | |
RetVal.append(File) | |
return RetVal | |
## Retrieve packages this module depends on | |
@cached_property | |
def Packages(self): | |
RetVal = [] | |
RecordList = self._RawData[MODEL_META_DATA_PACKAGE, self._Arch, self._Platform] | |
Macros = self._Macros | |
for Record in RecordList: | |
File = PathClass(NormPath(Record[0], Macros), GlobalData.gWorkspace, Arch=self._Arch) | |
# check the file validation | |
ErrorCode, ErrorInfo = File.Validate('.dec') | |
if ErrorCode != 0: | |
LineNo = Record[-1] | |
EdkLogger.error('build', ErrorCode, ExtraData=ErrorInfo, File=self.MetaFile, Line=LineNo) | |
# parse this package now. we need it to get protocol/ppi/guid value | |
RetVal.append(self._Bdb[File, self._Arch, self._Target, self._Toolchain]) | |
return RetVal | |
## Retrieve PCD comments | |
@cached_property | |
def PcdComments(self): | |
self.Pcds | |
return self._PcdComments | |
## Retrieve PCDs used in this module | |
@cached_property | |
def Pcds(self): | |
self._PcdComments = OrderedDict() | |
RetVal = OrderedDict() | |
RetVal.update(self._GetPcd(MODEL_PCD_FIXED_AT_BUILD)) | |
RetVal.update(self._GetPcd(MODEL_PCD_PATCHABLE_IN_MODULE)) | |
RetVal.update(self._GetPcd(MODEL_PCD_FEATURE_FLAG)) | |
RetVal.update(self._GetPcd(MODEL_PCD_DYNAMIC)) | |
RetVal.update(self._GetPcd(MODEL_PCD_DYNAMIC_EX)) | |
return RetVal | |
@cached_property | |
def ModulePcdList(self): | |
RetVal = self.Pcds | |
return RetVal | |
@cached_property | |
def LibraryPcdList(self): | |
if bool(self.LibraryClass): | |
return [] | |
RetVal = {} | |
Pcds = set() | |
for Library in self.LibInstances: | |
PcdsInLibrary = OrderedDict() | |
for Key in Library.Pcds: | |
if Key in self.Pcds or Key in Pcds: | |
continue | |
Pcds.add(Key) | |
PcdsInLibrary[Key] = copy.copy(Library.Pcds[Key]) | |
RetVal[Library] = PcdsInLibrary | |
return RetVal | |
@cached_property | |
def PcdsName(self): | |
PcdsName = set() | |
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, self._Platform] | |
for TokenSpaceGuid, PcdCName, _, _, _, _, _ in RecordList: | |
PcdsName.add((PcdCName, TokenSpaceGuid)) | |
return PcdsName | |
## Retrieve build options specific to this module | |
@cached_property | |
def BuildOptions(self): | |
if self._BuildOptions is None: | |
self._BuildOptions = OrderedDict() | |
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 or Option.startswith('='): | |
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 dependency expression | |
@cached_property | |
def Depex(self): | |
RetVal = tdict(False, 2) | |
# If the module has only Binaries and no Sources, then ignore [Depex] | |
if not self.Sources and self.Binaries: | |
return RetVal | |
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 == SUP_MODULE_DXE_DRIVER or self.ModuleType == SUP_MODULE_PEIM or self.ModuleType == SUP_MODULE_DXE_SMM_DRIVER or \ | |
self.ModuleType == SUP_MODULE_DXE_SAL_DRIVER or self.ModuleType == SUP_MODULE_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) | |
if len(RecordList) != 0 and (self.ModuleType == SUP_MODULE_USER_DEFINED or self.ModuleType == SUP_MODULE_HOST_APPLICATION): | |
for Record in RecordList: | |
if Record[4] not in [SUP_MODULE_PEIM, SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_SMM_DRIVER]: | |
EdkLogger.error('build', FORMAT_INVALID, | |
"'%s' module must specify the type of [Depex] section" % self.ModuleType, | |
File=self.MetaFile) | |
TemporaryDictionary = OrderedDict() | |
for Record in RecordList: | |
DepexStr = ReplaceMacro(Record[0], self._Macros, False) | |
Arch = Record[3] | |
ModuleType = Record[4] | |
TokenList = DepexStr.split() | |
if (Arch, ModuleType) not in TemporaryDictionary: | |
TemporaryDictionary[Arch, ModuleType] = [] | |
DepexList = TemporaryDictionary[Arch, ModuleType] | |
for Token in TokenList: | |
if Token in DEPEX_SUPPORTED_OPCODE_SET: | |
DepexList.append(Token) | |
elif Token.endswith(".inf"): # module file name | |
ModuleFile = os.path.normpath(Token) | |
Module = self.BuildDatabase[ModuleFile] | |
if Module is 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: | |
# it use the Fixed PCD format | |
if '.' in Token: | |
if tuple(Token.split('.')[::-1]) not in self.Pcds: | |
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "PCD [{}] used in [Depex] section should be listed in module PCD section".format(Token), File=self.MetaFile, Line=Record[-1]) | |
else: | |
if self.Pcds[tuple(Token.split('.')[::-1])].DatumType != TAB_VOID: | |
EdkLogger.error('build', FORMAT_INVALID, "PCD [{}] used in [Depex] section should be VOID* datum type".format(Token), File=self.MetaFile, Line=Record[-1]) | |
Value = Token | |
else: | |
# get the GUID value now | |
Value = _ProtocolValue(Token, self.Packages, self.MetaFile.Path) | |
if Value is None: | |
Value = _PpiValue(Token, self.Packages, self.MetaFile.Path) | |
if Value is None: | |
Value = GuidValue(Token, self.Packages, self.MetaFile.Path) | |
if Value is 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 TemporaryDictionary: | |
RetVal[Arch, ModuleType] = TemporaryDictionary[Arch, ModuleType] | |
return RetVal | |
## Retrieve dependency expression | |
@cached_property | |
def DepexExpression(self): | |
RetVal = tdict(False, 2) | |
RecordList = self._RawData[MODEL_EFI_DEPEX, self._Arch] | |
TemporaryDictionary = OrderedDict() | |
for Record in RecordList: | |
DepexStr = ReplaceMacro(Record[0], self._Macros, False) | |
Arch = Record[3] | |
ModuleType = Record[4] | |
TokenList = DepexStr.split() | |
if (Arch, ModuleType) not in TemporaryDictionary: | |
TemporaryDictionary[Arch, ModuleType] = '' | |
for Token in TokenList: | |
TemporaryDictionary[Arch, ModuleType] = TemporaryDictionary[Arch, ModuleType] + Token.strip() + ' ' | |
for Arch, ModuleType in TemporaryDictionary: | |
RetVal[Arch, ModuleType] = TemporaryDictionary[Arch, ModuleType] | |
return RetVal | |
def LocalPkg(self): | |
module_path = self.MetaFile.File | |
subdir = os.path.split(module_path)[0] | |
TopDir = "" | |
while subdir: | |
subdir,TopDir = os.path.split(subdir) | |
for file_name in os.listdir(os.path.join(self.MetaFile.Root,TopDir)): | |
if file_name.upper().endswith("DEC"): | |
pkg = os.path.join(TopDir,file_name) | |
return pkg | |
@cached_class_function | |
def GetGuidsUsedByPcd(self): | |
self.Guid | |
return self._GuidsUsedByPcd | |
## Retrieve PCD for given type | |
def _GetPcd(self, Type): | |
Pcds = OrderedDict() | |
PcdDict = tdict(True, 4) | |
PcdList = [] | |
RecordList = self._RawData[Type, self._Arch, self._Platform] | |
for TokenSpaceGuid, PcdCName, Setting, Arch, Platform, Id, LineNo in RecordList: | |
PcdDict[Arch, Platform, PcdCName, TokenSpaceGuid] = (Setting, LineNo) | |
PcdList.append((PcdCName, TokenSpaceGuid)) | |
CommentRecords = self._RawData[MODEL_META_DATA_COMMENT, self._Arch, self._Platform, Id] | |
Comments = [] | |
for CmtRec in CommentRecords: | |
Comments.append(CmtRec[0]) | |
self._PcdComments[TokenSpaceGuid, PcdCName] = Comments | |
# resolve PCD type, value, datum info, etc. by getting its definition from package | |
_GuidDict = self.Guids.copy() | |
for PcdCName, TokenSpaceGuid in PcdList: | |
PcdRealName = PcdCName | |
Setting, LineNo = PcdDict[self._Arch, self.Platform, PcdCName, TokenSpaceGuid] | |
if Setting is None: | |
continue | |
ValueList = AnalyzePcdData(Setting) | |
DefaultValue = ValueList[0] | |
Pcd = PcdClassObject( | |
PcdCName, | |
TokenSpaceGuid, | |
'', | |
'', | |
DefaultValue, | |
'', | |
'', | |
{}, | |
False, | |
self.Guids[TokenSpaceGuid] | |
) | |
if Type == MODEL_PCD_PATCHABLE_IN_MODULE and ValueList[1]: | |
# Patch PCD: TokenSpace.PcdCName|Value|Offset | |
Pcd.Offset = ValueList[1] | |
if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd: | |
for Package in self.Packages: | |
for key in Package.Pcds: | |
if (Package.Pcds[key].TokenCName, Package.Pcds[key].TokenSpaceGuidCName) == (PcdRealName, TokenSpaceGuid): | |
for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]: | |
Pcd_Type = item[0].split('_')[-1] | |
if Pcd_Type == Package.Pcds[key].Type: | |
Value = Package.Pcds[key] | |
Value.TokenCName = Package.Pcds[key].TokenCName + '_' + Pcd_Type | |
if len(key) == 2: | |
newkey = (Value.TokenCName, key[1]) | |
elif len(key) == 3: | |
newkey = (Value.TokenCName, key[1], key[2]) | |
del Package.Pcds[key] | |
Package.Pcds[newkey] = Value | |
break | |
else: | |
pass | |
else: | |
pass | |
# 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 | |
# | |
# TAB_PCDS_FIXED_AT_BUILD, TAB_PCDS_PATCHABLE_IN_MODULE, TAB_PCDS_FEATURE_FLAG, TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_EX | |
# | |
_GuidDict.update(Package.Guids) | |
PcdType = self._PCD_TYPE_STRING_[Type] | |
if Type == MODEL_PCD_DYNAMIC: | |
Pcd.Pending = True | |
for T in PCD_TYPE_LIST: | |
if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd: | |
for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]: | |
if str(item[0]).endswith(T) and (item[0], item[1], T) in Package.Pcds: | |
PcdType = T | |
PcdCName = item[0] | |
break | |
else: | |
pass | |
break | |
else: | |
if (PcdRealName, TokenSpaceGuid, T) in Package.Pcds: | |
PcdType = T | |
break | |
else: | |
Pcd.Pending = False | |
if (PcdRealName, TokenSpaceGuid) in GlobalData.MixedPcd: | |
for item in GlobalData.MixedPcd[(PcdRealName, TokenSpaceGuid)]: | |
Pcd_Type = item[0].split('_')[-1] | |
if Pcd_Type == PcdType: | |
PcdCName = item[0] | |
break | |
else: | |
pass | |
else: | |
pass | |
if (PcdCName, TokenSpaceGuid, PcdType) in Package.Pcds: | |
PcdInPackage = Package.Pcds[PcdCName, TokenSpaceGuid, PcdType] | |
Pcd.Type = PcdType | |
Pcd.TokenValue = PcdInPackage.TokenValue | |
# | |
# Check whether the token value exist or not. | |
# | |
if Pcd.TokenValue is None or Pcd.TokenValue == "": | |
EdkLogger.error( | |
'build', | |
FORMAT_INVALID, | |
"No TokenValue for PCD [%s.%s] in [%s]!" % (TokenSpaceGuid, PcdRealName, str(Package)), | |
File=self.MetaFile, Line=LineNo, | |
ExtraData=None | |
) | |
# | |
# Check hexadecimal token value length and format. | |
# | |
ReIsValidPcdTokenValue = re.compile(r"^[0][x|X][0]*[0-9a-fA-F]{1,8}$", re.DOTALL) | |
if Pcd.TokenValue.startswith("0x") or Pcd.TokenValue.startswith("0X"): | |
if ReIsValidPcdTokenValue.match(Pcd.TokenValue) is None: | |
EdkLogger.error( | |
'build', | |
FORMAT_INVALID, | |
"The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid:" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)), | |
File=self.MetaFile, Line=LineNo, | |
ExtraData=None | |
) | |
# | |
# Check decimal token value length and format. | |
# | |
else: | |
try: | |
TokenValueInt = int (Pcd.TokenValue, 10) | |
if (TokenValueInt < 0 or TokenValueInt > 4294967295): | |
EdkLogger.error( | |
'build', | |
FORMAT_INVALID, | |
"The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, as a decimal it should between: 0 - 4294967295!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)), | |
File=self.MetaFile, Line=LineNo, | |
ExtraData=None | |
) | |
except: | |
EdkLogger.error( | |
'build', | |
FORMAT_INVALID, | |
"The format of TokenValue [%s] of PCD [%s.%s] in [%s] is invalid, it should be hexadecimal or decimal!" % (Pcd.TokenValue, TokenSpaceGuid, PcdRealName, str(Package)), | |
File=self.MetaFile, Line=LineNo, | |
ExtraData=None | |
) | |
Pcd.DatumType = PcdInPackage.DatumType | |
Pcd.MaxDatumSize = PcdInPackage.MaxDatumSize | |
Pcd.InfDefaultValue = Pcd.DefaultValue | |
if not Pcd.DefaultValue: | |
Pcd.DefaultValue = PcdInPackage.DefaultValue | |
else: | |
try: | |
Pcd.DefaultValue = ValueExpressionEx(Pcd.DefaultValue, Pcd.DatumType, _GuidDict)(True) | |
except BadExpression as Value: | |
EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(TokenSpaceGuid, PcdRealName, Pcd.DefaultValue, Value), | |
File=self.MetaFile, Line=LineNo) | |
break | |
else: | |
EdkLogger.error( | |
'build', | |
FORMAT_INVALID, | |
"PCD [%s.%s] in [%s] is not found in dependent packages:" % (TokenSpaceGuid, PcdRealName, 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 | |
## check whether current module is binary module | |
@property | |
def IsBinaryModule(self): | |
if (self.Binaries and not self.Sources) or GlobalData.gIgnoreSource: | |
return True | |
return False | |
def CheckFeatureFlagPcd(self,Instance): | |
Pcds = GlobalData.gPlatformFinalPcds.copy() | |
if PcdPattern.search(Instance): | |
PcdTuple = tuple(Instance.split('.')[::-1]) | |
if PcdTuple in self.Pcds: | |
if not (self.Pcds[PcdTuple].Type == 'FeatureFlag' or self.Pcds[PcdTuple].Type == 'FixedAtBuild'): | |
EdkLogger.error('build', FORMAT_INVALID, | |
"\nFeatureFlagPcd must be defined in a [PcdsFeatureFlag] or [PcdsFixedAtBuild] section of Dsc or Dec file", | |
File=str(self), ExtraData=Instance) | |
if not Instance in Pcds: | |
Pcds[Instance] = self.Pcds[PcdTuple].DefaultValue | |
else: #if PcdTuple not in self.Pcds: | |
EdkLogger.error('build', FORMAT_INVALID, | |
"\nFeatureFlagPcd must be defined in [FeaturePcd] or [FixedPcd] of Inf file", | |
File=str(self), ExtraData=Instance) | |
if Instance in Pcds: | |
if Pcds[Instance] == '0': | |
return False | |
elif Pcds[Instance] == '1': | |
return True | |
try: | |
Value = ValueExpression(Instance, Pcds)() | |
if Value == True: | |
return True | |
return False | |
except: | |
EdkLogger.warn('build', FORMAT_INVALID,"The FeatureFlagExpression cannot be evaluated", File=str(self), ExtraData=Instance) | |
return False | |
else: | |
for Name, Guid in self.Pcds: | |
if self.Pcds[(Name, Guid)].Type == 'FeatureFlag' or self.Pcds[(Name, Guid)].Type == 'FixedAtBuild': | |
PcdFullName = '%s.%s' % (Guid, Name); | |
if not PcdFullName in Pcds: | |
Pcds[PcdFullName] = self.Pcds[(Name, Guid)].DefaultValue | |
try: | |
Value = ValueExpression(Instance, Pcds)() | |
if Value == True: | |
return True | |
return False | |
except: | |
EdkLogger.warn('build', FORMAT_INVALID, "The FeatureFlagExpression cannot be evaluated", File=str(self), ExtraData=Instance) | |
return False | |
def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict): | |
for Key in CopyFromDict: | |
CopyToDict[Key].extend(CopyFromDict[Key]) |