b303ea726e
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@9397 6f19259b-4bc3-4df7-8a09-765794883524
2327 lines
101 KiB
Python
2327 lines
101 KiB
Python
## @file
|
|
# Generate AutoGen.h, AutoGen.c and *.depex files
|
|
#
|
|
# Copyright (c) 2007 - 2009, 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 os
|
|
import re
|
|
import os.path as path
|
|
import copy
|
|
|
|
import GenC
|
|
import GenMake
|
|
import GenDepex
|
|
from StringIO import StringIO
|
|
|
|
from StrGather import *
|
|
from BuildEngine import BuildRule
|
|
|
|
from Common.BuildToolError import *
|
|
from Common.DataType import *
|
|
from Common.Misc import *
|
|
from Common.String import *
|
|
import Common.GlobalData as GlobalData
|
|
from GenFds.FdfParser import *
|
|
from CommonDataClass.CommonClass import SkuInfoClass
|
|
from Workspace.BuildClassObject import *
|
|
|
|
## Regular expression for splitting Dependency Expression stirng into tokens
|
|
gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")
|
|
|
|
## Mapping Makefile type
|
|
gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}
|
|
|
|
|
|
## Build rule configuration file
|
|
gBuildRuleFile = 'Conf/build_rule.txt'
|
|
|
|
## default file name for AutoGen
|
|
gAutoGenCodeFileName = "AutoGen.c"
|
|
gAutoGenHeaderFileName = "AutoGen.h"
|
|
gAutoGenStringFileName = "%(module_name)sStrDefs.h"
|
|
gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"
|
|
gAutoGenDepexFileName = "%(module_name)s.depex"
|
|
|
|
## Base class for AutoGen
|
|
#
|
|
# This class just implements the cache mechanism of AutoGen objects.
|
|
#
|
|
class AutoGen(object):
|
|
# database to maintain the objects of xxxAutoGen
|
|
_CACHE_ = {} # (BuildTarget, ToolChain) : {ARCH : {platform file: AutoGen object}}}
|
|
|
|
## Factory method
|
|
#
|
|
# @param Class class object of real AutoGen class
|
|
# (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)
|
|
# @param Workspace Workspace directory or WorkspaceAutoGen object
|
|
# @param MetaFile The path of meta file
|
|
# @param Target Build target
|
|
# @param Toolchain Tool chain name
|
|
# @param Arch Target arch
|
|
# @param *args The specific class related parameters
|
|
# @param **kwargs The specific class related dict parameters
|
|
#
|
|
def __new__(Class, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
|
|
# check if the object has been created
|
|
Key = (Target, Toolchain)
|
|
if Key not in Class._CACHE_ or Arch not in Class._CACHE_[Key] \
|
|
or MetaFile not in Class._CACHE_[Key][Arch]:
|
|
AutoGenObject = super(AutoGen, Class).__new__(Class)
|
|
# call real constructor
|
|
if not AutoGenObject._Init(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
|
|
return None
|
|
if Key not in Class._CACHE_:
|
|
Class._CACHE_[Key] = {}
|
|
if Arch not in Class._CACHE_[Key]:
|
|
Class._CACHE_[Key][Arch] = {}
|
|
Class._CACHE_[Key][Arch][MetaFile] = AutoGenObject
|
|
else:
|
|
AutoGenObject = Class._CACHE_[Key][Arch][MetaFile]
|
|
|
|
return AutoGenObject
|
|
|
|
## hash() operator
|
|
#
|
|
# The file path of platform file will be used to represent hash value of this object
|
|
#
|
|
# @retval int Hash value of the file path of platform file
|
|
#
|
|
def __hash__(self):
|
|
return hash(self.MetaFile)
|
|
|
|
## str() operator
|
|
#
|
|
# The file path of platform file will be used to represent this object
|
|
#
|
|
# @retval string String of platform file path
|
|
#
|
|
def __str__(self):
|
|
return str(self.MetaFile)
|
|
|
|
## "==" operator
|
|
def __eq__(self, Other):
|
|
return Other and self.MetaFile == Other
|
|
|
|
## Workspace AutoGen class
|
|
#
|
|
# This class is used mainly to control the whole platform build for different
|
|
# architecture. This class will generate top level makefile.
|
|
#
|
|
class WorkspaceAutoGen(AutoGen):
|
|
## Real constructor of WorkspaceAutoGen
|
|
#
|
|
# This method behaves the same as __init__ except that it needs explict invoke
|
|
# (in super class's __new__ method)
|
|
#
|
|
# @param WorkspaceDir Root directory of workspace
|
|
# @param ActivePlatform Meta-file of active platform
|
|
# @param Target Build target
|
|
# @param Toolchain Tool chain name
|
|
# @param ArchList List of architecture of current build
|
|
# @param MetaFileDb Database containing meta-files
|
|
# @param BuildConfig Configuration of build
|
|
# @param ToolDefinition Tool chain definitions
|
|
# @param FlashDefinitionFile File of flash definition
|
|
# @param Fds FD list to be generated
|
|
# @param Fvs FV list to be generated
|
|
# @param SkuId SKU id from command line
|
|
#
|
|
def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,
|
|
BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=[], Fvs=[], SkuId='',
|
|
ReportFile=None, ReportType=None):
|
|
self.MetaFile = ActivePlatform.MetaFile
|
|
self.WorkspaceDir = WorkspaceDir
|
|
self.Platform = ActivePlatform
|
|
self.BuildTarget = Target
|
|
self.ToolChain = Toolchain
|
|
self.ArchList = ArchList
|
|
self.SkuId = SkuId
|
|
self.ReportFile = ReportFile
|
|
self.ReportType = ReportType
|
|
|
|
self.BuildDatabase = MetaFileDb
|
|
self.TargetTxt = BuildConfig
|
|
self.ToolDef = ToolDefinition
|
|
self.FdfFile = FlashDefinitionFile
|
|
self.FdTargetList = Fds
|
|
self.FvTargetList = Fvs
|
|
self.AutoGenObjectList = []
|
|
|
|
# there's many relative directory operations, so ...
|
|
os.chdir(self.WorkspaceDir)
|
|
|
|
# parse FDF file to get PCDs in it, if any
|
|
if self.FdfFile != None and self.FdfFile != '':
|
|
Fdf = FdfParser(self.FdfFile.Path)
|
|
Fdf.ParseFile()
|
|
PcdSet = Fdf.Profile.PcdDict
|
|
ModuleList = Fdf.Profile.InfList
|
|
else:
|
|
PcdSet = {}
|
|
ModuleList = []
|
|
|
|
# apply SKU and inject PCDs from Flash Definition file
|
|
for Arch in self.ArchList:
|
|
Platform = self.BuildDatabase[self.MetaFile, Arch]
|
|
Platform.SkuName = self.SkuId
|
|
for Name, Guid in PcdSet:
|
|
Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])
|
|
|
|
Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)
|
|
#
|
|
# Explicitly collect platform's dynamic PCDs
|
|
#
|
|
Pa.CollectPlatformDynamicPcds()
|
|
self.AutoGenObjectList.append(Pa)
|
|
|
|
AllPcds = {}
|
|
MaxLen = 0
|
|
for Pcd in Pa._DynaPcdList_ + Pa._NonDynaPcdList_:
|
|
if Pcd.TokenSpaceGuidCName not in AllPcds:
|
|
AllPcds[Pcd.TokenSpaceGuidCName] = {}
|
|
if Pcd.Type not in AllPcds[Pcd.TokenSpaceGuidCName]:
|
|
AllPcds[Pcd.TokenSpaceGuidCName][Pcd.Type] = []
|
|
AllPcds[Pcd.TokenSpaceGuidCName][Pcd.Type] += [Pcd]
|
|
if len(Pcd.TokenCName) > MaxLen:
|
|
MaxLen = len(Pcd.TokenCName)
|
|
|
|
if self.ReportFile <> None:
|
|
try:
|
|
if os.path.exists(self.ReportFile):
|
|
os.remove(self.ReportFile)
|
|
|
|
Fd = open(self.ReportFile, "w")
|
|
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write ('Platform Configuration Database Report\n')
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write (' *P - Platform scoped PCD override in DSC file\n')
|
|
Fd.write (' *F - Platform scoped PCD override in FDF file\n')
|
|
Fd.write (' *M - Module scoped PCD override in DSC file\n')
|
|
Fd.write (' *C - Library has a constructor\n')
|
|
Fd.write (' *D - Library has a destructor\n')
|
|
Fd.write (' *CD - Library has both a constructor and a destructor\n')
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write ('\n')
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write ('PLATFORM: %s\n' % (ActivePlatform.MetaFile))
|
|
Fd.write ('===============================================================================\n')
|
|
for Key in AllPcds:
|
|
Fd.write ('%s\n' % (Key))
|
|
for Type in AllPcds[Key]:
|
|
TypeName = ''
|
|
DecType = Type
|
|
if Type == 'FixedAtBuild':
|
|
TypeName = 'FIXED'
|
|
if Type == 'PatchableInModule':
|
|
TypeName = 'PATCH'
|
|
if Type == 'FeatureFlag':
|
|
TypeName = 'FLAG'
|
|
if Type == 'Dynamic':
|
|
TypeName = 'DYN'
|
|
if Type == 'DynamicHii':
|
|
TypeName = 'DYNHII'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicVpd':
|
|
TypeName = 'DYNVPD'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicEx':
|
|
TypeName = 'DEX'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicExHii':
|
|
TypeName = 'DEXHII'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicExVpd':
|
|
TypeName = 'DEXVPD'
|
|
DecType = 'Dynamic'
|
|
for Pcd in AllPcds[Key][Type]:
|
|
|
|
DecDefaultValue = None
|
|
for F in Pa.Platform.Modules.keys():
|
|
for Package in Pa.Platform.Modules[F].M.Module.Packages:
|
|
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType) in Package.Pcds:
|
|
if DecDefaultValue == None:
|
|
DecDefaultValue = Package.Pcds[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType].DefaultValue
|
|
|
|
DscDefaultValue = None
|
|
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds:
|
|
DscDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
|
|
|
|
if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
|
|
if Pcd.DefaultValue.strip()[0:2].upper() == '0X':
|
|
PcdDefaultValueNumber = int(Pcd.DefaultValue.strip(), 16)
|
|
else:
|
|
PcdDefaultValueNumber = int(Pcd.DefaultValue.strip())
|
|
|
|
if DecDefaultValue == None:
|
|
DecMatch = True
|
|
else:
|
|
if DecDefaultValue.strip()[0:2].upper() == '0X':
|
|
DecDefaultValueNumber = int(DecDefaultValue.strip(), 16)
|
|
else:
|
|
DecDefaultValueNumber = int(DecDefaultValue.strip())
|
|
DecMatch = (DecDefaultValueNumber == PcdDefaultValueNumber)
|
|
|
|
if DscDefaultValue == None:
|
|
DscMatch = True
|
|
else:
|
|
if DscDefaultValue.strip()[0:2].upper() == '0X':
|
|
DscDefaultValueNumber = int(DscDefaultValue.strip(), 16)
|
|
else:
|
|
DscDefaultValueNumber = int(DscDefaultValue.strip())
|
|
DscMatch = (DscDefaultValueNumber == PcdDefaultValueNumber)
|
|
else:
|
|
if DecDefaultValue == None:
|
|
DecMatch = True
|
|
else:
|
|
DecMatch = (DecDefaultValue == Pcd.DefaultValue)
|
|
|
|
if DscDefaultValue == None:
|
|
DscMatch = True
|
|
else:
|
|
DscMatch = (DscDefaultValue == Pcd.DefaultValue)
|
|
|
|
if DecMatch:
|
|
Fd.write (' %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
|
|
else:
|
|
if DscMatch:
|
|
if (Pcd.TokenCName, Key) in PcdSet:
|
|
Fd.write (' *F %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
|
|
else:
|
|
Fd.write (' *P %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
|
|
|
|
for F in Pa.Platform.Modules.keys():
|
|
for ModulePcd in Pa.Platform.Modules[F].M.ModulePcdList + Pa.Platform.Modules[F].M.LibraryPcdList:
|
|
if ModulePcd.TokenSpaceGuidCName <> Pcd.TokenSpaceGuidCName:
|
|
continue
|
|
if ModulePcd.TokenCName <> Pcd.TokenCName:
|
|
continue
|
|
if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
|
|
if ModulePcd.DefaultValue.strip()[0:2].upper() == '0X':
|
|
ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip(), 16)
|
|
else:
|
|
ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip())
|
|
Match = (ModulePcdDefaultValueNumber == PcdDefaultValueNumber)
|
|
else:
|
|
Match = (ModulePcd.DefaultValue == Pcd.DefaultValue)
|
|
if Match:
|
|
continue
|
|
Fd.write (' *M %*s = %s\n' % (MaxLen + 21, str(F).split('\\')[-1], ModulePcd.DefaultValue))
|
|
|
|
if not DecMatch and DscMatch and DecDefaultValue <> None:
|
|
Fd.write (' %*s = %s\n' % (MaxLen + 21, 'DEC DEFAULT', DecDefaultValue))
|
|
|
|
Fd.write ('\n')
|
|
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write ('===============================================================================\n')
|
|
|
|
for F in Pa.Platform.Modules.keys():
|
|
Fd.write ('\n')
|
|
Fd.write ('===============================================================================\n')
|
|
Fd.write ('MODULE: %s\n' % (F))
|
|
Fd.write ('===============================================================================\n')
|
|
|
|
Fd.write ('PLATFORM CONFIGURATION DATABASE\n')
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
ModuleFirst = True
|
|
for Key in AllPcds:
|
|
First = True
|
|
for Type in AllPcds[Key]:
|
|
TypeName = ''
|
|
DecType = Type
|
|
if Type == 'FixedAtBuild':
|
|
TypeName = 'FIXED'
|
|
if Type == 'PatchableInModule':
|
|
TypeName = 'PATCH'
|
|
if Type == 'FeatureFlag':
|
|
TypeName = 'FLAG'
|
|
if Type == 'Dynamic':
|
|
TypeName = 'DYN'
|
|
if Type == 'DynamicHii':
|
|
TypeName = 'DYNHII'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicVpd':
|
|
TypeName = 'DYNVPD'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicEx':
|
|
TypeName = 'DEX'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicExHii':
|
|
TypeName = 'DEXHII'
|
|
DecType = 'Dynamic'
|
|
if Type == 'DynamicExVpd':
|
|
TypeName = 'DEXVPD'
|
|
DecType = 'Dynamic'
|
|
for Pcd in AllPcds[Key][Type]:
|
|
for ModulePcd in Pa.Platform.Modules[F].M.ModulePcdList + Pa.Platform.Modules[F].M.LibraryPcdList:
|
|
if ModulePcd.TokenSpaceGuidCName <> Pcd.TokenSpaceGuidCName:
|
|
continue
|
|
if ModulePcd.TokenCName <> Pcd.TokenCName:
|
|
continue
|
|
if ModulePcd.Type <> Pcd.Type:
|
|
continue
|
|
if First:
|
|
if ModuleFirst:
|
|
ModuleFirst = False
|
|
else:
|
|
Fd.write ('\n')
|
|
Fd.write ('%s\n' % (Key))
|
|
First = False
|
|
|
|
InfDefaultValue = ModulePcd.InfDefaultValue
|
|
if InfDefaultValue == '':
|
|
InfDefaultValue = None
|
|
|
|
DecDefaultValue = None
|
|
for Package in Pa.Platform.Modules[F].M.Module.Packages:
|
|
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType) in Package.Pcds:
|
|
if DecDefaultValue == None:
|
|
DecDefaultValue = Package.Pcds[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType].DefaultValue
|
|
|
|
DscDefaultValue = None
|
|
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds:
|
|
DscDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
|
|
|
|
DscModuleOverrideDefaultValue = None
|
|
if F in self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules:
|
|
if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules[F].Pcds:
|
|
DscModuleOverrideDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules[F].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
|
|
|
|
if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
|
|
if ModulePcd.DefaultValue.strip()[0:2].upper() == '0X':
|
|
ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip(), 16)
|
|
else:
|
|
ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip())
|
|
|
|
if DecDefaultValue == None:
|
|
DecMatch = True
|
|
else:
|
|
if DecDefaultValue.strip()[0:2].upper() == '0X':
|
|
DecDefaultValueNumber = int(DecDefaultValue.strip(), 16)
|
|
else:
|
|
DecDefaultValueNumber = int(DecDefaultValue.strip())
|
|
DecMatch = (DecDefaultValueNumber == ModulePcdDefaultValueNumber)
|
|
|
|
if InfDefaultValue == None:
|
|
InfMatch = True
|
|
else:
|
|
if InfDefaultValue.strip()[0:2].upper() == '0X':
|
|
InfDefaultValueNumber = int(InfDefaultValue.strip(), 16)
|
|
else:
|
|
InfDefaultValueNumber = int(InfDefaultValue.strip())
|
|
InfMatch = (InfDefaultValueNumber == ModulePcdDefaultValueNumber)
|
|
|
|
if DscDefaultValue == None:
|
|
DscMatch = True
|
|
else:
|
|
if DscDefaultValue.strip()[0:2].upper() == '0X':
|
|
DscDefaultValueNumber = int(DscDefaultValue.strip(), 16)
|
|
else:
|
|
DscDefaultValueNumber = int(DscDefaultValue.strip())
|
|
DscMatch = (DscDefaultValueNumber == ModulePcdDefaultValueNumber)
|
|
else:
|
|
if DecDefaultValue == None:
|
|
DecMatch = True
|
|
else:
|
|
DecMatch = (DecDefaultValue == ModulePcd.DefaultValue)
|
|
|
|
if InfDefaultValue == None:
|
|
InfMatch = True
|
|
else:
|
|
InfMatch = (InfDefaultValue == ModulePcd.DefaultValue)
|
|
|
|
if DscDefaultValue == None:
|
|
DscMatch = True
|
|
else:
|
|
DscMatch = (DscDefaultValue == ModulePcd.DefaultValue)
|
|
|
|
if DecMatch and InfMatch:
|
|
Fd.write (' %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
|
|
else:
|
|
if DscMatch and DscModuleOverrideDefaultValue == None:
|
|
if (Pcd.TokenCName, Key) in PcdSet:
|
|
Fd.write (' *F %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
|
|
else:
|
|
Fd.write (' *P %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
|
|
else:
|
|
Fd.write (' *M %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
|
|
if DscDefaultValue <> None:
|
|
Fd.write (' %*s = %s\n' % (MaxLen + 19, 'DSC DEFAULT', DscDefaultValue))
|
|
if InfDefaultValue <> None:
|
|
Fd.write (' %*s = %s\n' % (MaxLen + 19, 'INF DEFAULT', InfDefaultValue))
|
|
if DecDefaultValue <> None and not DecMatch:
|
|
Fd.write (' %*s = %s\n' % (MaxLen + 19, 'DEC DEFAULT', DecDefaultValue))
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
Fd.write ('LIBRARIES\n')
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
for Lib in Pa.Platform.Modules[F].M.DependentLibraryList:
|
|
if len(Lib.ConstructorList) > 0:
|
|
if len(Lib.DestructorList) > 0:
|
|
Fd.write (' *CD')
|
|
else:
|
|
Fd.write (' *C ')
|
|
else:
|
|
if len(Lib.DestructorList) > 0:
|
|
Fd.write (' *D ')
|
|
else:
|
|
Fd.write (' ')
|
|
Fd.write (' %s\n' % (Lib))
|
|
for Depex in Lib.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]:
|
|
Fd.write (' DEPEX = %s\n' % (Depex))
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
|
|
Fd.write ('MODULE DEPENDENCY EXPRESSION\n')
|
|
if len(Pa.Platform.Modules[F].M.Module.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]) == 0:
|
|
Fd.write (' NONE\n')
|
|
else:
|
|
for Depex in Pa.Platform.Modules[F].M.Module.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]:
|
|
Fd.write (' %s\n' % (Depex))
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
|
|
Fd.write ('MODULE + LIBRARY DEPENDENCY EXPRESSION\n')
|
|
if Pa.Platform.Modules[F].M.ModuleType in Pa.Platform.Modules[F].M.DepexExpressionList:
|
|
if Pa.Platform.Modules[F].M.DepexExpressionList[Pa.Platform.Modules[F].M.ModuleType] == '':
|
|
Fd.write (' NONE\n')
|
|
else:
|
|
Fd.write (' %s\n' % (Pa.Platform.Modules[F].M.DepexExpressionList[Pa.Platform.Modules[F].M.ModuleType]))
|
|
else:
|
|
Fd.write (' NONE\n')
|
|
Fd.write ('-------------------------------------------------------------------------------\n')
|
|
|
|
Fd.close()
|
|
except:
|
|
EdkLogger.error(None, FILE_OPEN_FAILURE, ExtraData=self.ReportFile)
|
|
|
|
self._BuildDir = None
|
|
self._FvDir = None
|
|
self._MakeFileDir = None
|
|
self._BuildCommand = None
|
|
|
|
return True
|
|
|
|
def __repr__(self):
|
|
return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))
|
|
|
|
## Return the directory to store FV files
|
|
def _GetFvDir(self):
|
|
if self._FvDir == None:
|
|
self._FvDir = path.join(self.BuildDir, 'FV')
|
|
return self._FvDir
|
|
|
|
## Return the directory to store all intermediate and final files built
|
|
def _GetBuildDir(self):
|
|
return self.AutoGenObjectList[0].BuildDir
|
|
|
|
## Return the build output directory platform specifies
|
|
def _GetOutputDir(self):
|
|
return self.Platform.OutputDirectory
|
|
|
|
## Return platform name
|
|
def _GetName(self):
|
|
return self.Platform.PlatformName
|
|
|
|
## Return meta-file GUID
|
|
def _GetGuid(self):
|
|
return self.Platform.Guid
|
|
|
|
## Return platform version
|
|
def _GetVersion(self):
|
|
return self.Platform.Version
|
|
|
|
## Return paths of tools
|
|
def _GetToolDefinition(self):
|
|
return self.AutoGenObjectList[0].ToolDefinition
|
|
|
|
## Return directory of platform makefile
|
|
#
|
|
# @retval string Makefile directory
|
|
#
|
|
def _GetMakeFileDir(self):
|
|
if self._MakeFileDir == None:
|
|
self._MakeFileDir = self.BuildDir
|
|
return self._MakeFileDir
|
|
|
|
## Return build command string
|
|
#
|
|
# @retval string Build command string
|
|
#
|
|
def _GetBuildCommand(self):
|
|
if self._BuildCommand == None:
|
|
# BuildCommand should be all the same. So just get one from platform AutoGen
|
|
self._BuildCommand = self.AutoGenObjectList[0].BuildCommand
|
|
return self._BuildCommand
|
|
|
|
## Create makefile for the platform and mdoules in it
|
|
#
|
|
# @param CreateDepsMakeFile Flag indicating if the makefile for
|
|
# modules will be created as well
|
|
#
|
|
def CreateMakeFile(self, CreateDepsMakeFile=False):
|
|
# create makefile for platform
|
|
Makefile = GenMake.TopLevelMakefile(self)
|
|
if Makefile.Generate():
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] %s\n" %
|
|
(self.MetaFile, self.ArchList))
|
|
else:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] %s\n" %
|
|
(self.MetaFile, self.ArchList))
|
|
|
|
if CreateDepsMakeFile:
|
|
for Pa in self.AutoGenObjectList:
|
|
Pa.CreateMakeFile(CreateDepsMakeFile)
|
|
|
|
## Create autogen code for platform and modules
|
|
#
|
|
# Since there's no autogen code for platform, this method will do nothing
|
|
# if CreateModuleCodeFile is set to False.
|
|
#
|
|
# @param CreateDepsCodeFile Flag indicating if creating module's
|
|
# autogen code file or not
|
|
#
|
|
def CreateCodeFile(self, CreateDepsCodeFile=False):
|
|
if not CreateDepsCodeFile:
|
|
return
|
|
for Pa in self.AutoGenObjectList:
|
|
Pa.CreateCodeFile(CreateDepsCodeFile)
|
|
|
|
Name = property(_GetName)
|
|
Guid = property(_GetGuid)
|
|
Version = property(_GetVersion)
|
|
OutputDir = property(_GetOutputDir)
|
|
|
|
ToolDefinition = property(_GetToolDefinition) # toolcode : tool path
|
|
|
|
BuildDir = property(_GetBuildDir)
|
|
FvDir = property(_GetFvDir)
|
|
MakeFileDir = property(_GetMakeFileDir)
|
|
BuildCommand = property(_GetBuildCommand)
|
|
|
|
## AutoGen class for platform
|
|
#
|
|
# PlatformAutoGen class will process the original information in platform
|
|
# file in order to generate makefile for platform.
|
|
#
|
|
class PlatformAutoGen(AutoGen):
|
|
#
|
|
# Used to store all PCDs for both PEI and DXE phase, in order to generate
|
|
# correct PCD database
|
|
#
|
|
_DynaPcdList_ = []
|
|
_NonDynaPcdList_ = []
|
|
|
|
## The real constructor of PlatformAutoGen
|
|
#
|
|
# This method is not supposed to be called by users of PlatformAutoGen. It's
|
|
# only used by factory method __new__() to do real initialization work for an
|
|
# object of PlatformAutoGen
|
|
#
|
|
# @param Workspace WorkspaceAutoGen object
|
|
# @param PlatformFile Platform file (DSC file)
|
|
# @param Target Build target (DEBUG, RELEASE)
|
|
# @param Toolchain Name of tool chain
|
|
# @param Arch arch of the platform supports
|
|
#
|
|
def _Init(self, Workspace, PlatformFile, Target, Toolchain, Arch):
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))
|
|
GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)
|
|
|
|
self.MetaFile = PlatformFile
|
|
self.Workspace = Workspace
|
|
self.WorkspaceDir = Workspace.WorkspaceDir
|
|
self.ToolChain = Toolchain
|
|
self.BuildTarget = Target
|
|
self.Arch = Arch
|
|
self.SourceDir = PlatformFile.SubDir
|
|
self.SourceOverrideDir = None
|
|
self.FdTargetList = self.Workspace.FdTargetList
|
|
self.FvTargetList = self.Workspace.FvTargetList
|
|
|
|
# flag indicating if the makefile/C-code file has been created or not
|
|
self.IsMakeFileCreated = False
|
|
self.IsCodeFileCreated = False
|
|
|
|
self._Platform = None
|
|
self._Name = None
|
|
self._Guid = None
|
|
self._Version = None
|
|
|
|
self._BuildRule = None
|
|
self._SourceDir = None
|
|
self._BuildDir = None
|
|
self._OutputDir = None
|
|
self._FvDir = None
|
|
self._MakeFileDir = None
|
|
self._FdfFile = None
|
|
|
|
self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
|
|
self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
|
|
self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
|
|
|
|
self._ToolDefinitions = None
|
|
self._ToolDefFile = None # toolcode : tool path
|
|
self._ToolChainFamily = None
|
|
self._BuildRuleFamily = None
|
|
self._BuildOption = None # toolcode : option
|
|
self._PackageList = None
|
|
self._ModuleAutoGenList = None
|
|
self._LibraryAutoGenList = None
|
|
self._BuildCommand = None
|
|
|
|
# get the original module/package/platform objects
|
|
self.BuildDatabase = Workspace.BuildDatabase
|
|
return True
|
|
|
|
def __repr__(self):
|
|
return "%s [%s]" % (self.MetaFile, self.Arch)
|
|
|
|
## Create autogen code for platform and modules
|
|
#
|
|
# Since there's no autogen code for platform, this method will do nothing
|
|
# if CreateModuleCodeFile is set to False.
|
|
#
|
|
# @param CreateModuleCodeFile Flag indicating if creating module's
|
|
# autogen code file or not
|
|
#
|
|
def CreateCodeFile(self, CreateModuleCodeFile=False):
|
|
# only module has code to be greated, so do nothing if CreateModuleCodeFile is False
|
|
if self.IsCodeFileCreated or not CreateModuleCodeFile:
|
|
return
|
|
|
|
for Ma in self.ModuleAutoGenList:
|
|
Ma.CreateCodeFile(True)
|
|
|
|
# don't do this twice
|
|
self.IsCodeFileCreated = True
|
|
|
|
## Create makefile for the platform and mdoules in it
|
|
#
|
|
# @param CreateModuleMakeFile Flag indicating if the makefile for
|
|
# modules will be created as well
|
|
#
|
|
def CreateMakeFile(self, CreateModuleMakeFile=False):
|
|
if CreateModuleMakeFile:
|
|
for ModuleFile in self.Platform.Modules:
|
|
Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,
|
|
self.ToolChain, self.Arch, self.MetaFile)
|
|
Ma.CreateMakeFile(True)
|
|
|
|
# no need to create makefile for the platform more than once
|
|
if self.IsMakeFileCreated:
|
|
return
|
|
|
|
# create makefile for platform
|
|
Makefile = GenMake.PlatformMakefile(self)
|
|
if Makefile.Generate():
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] [%s]\n" %
|
|
(self.MetaFile, self.Arch))
|
|
else:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] [%s]\n" %
|
|
(self.MetaFile, self.Arch))
|
|
self.IsMakeFileCreated = True
|
|
|
|
## Collect dynamic PCDs
|
|
#
|
|
# Gather dynamic PCDs list from each module and their settings from platform
|
|
# This interface should be invoked explicitly when platform action is created.
|
|
#
|
|
def CollectPlatformDynamicPcds(self):
|
|
# for gathering error information
|
|
NoDatumTypePcdList = set()
|
|
|
|
self._GuidValue = {}
|
|
for F in self.Platform.Modules.keys():
|
|
M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)
|
|
#GuidValue.update(M.Guids)
|
|
|
|
self.Platform.Modules[F].M = M
|
|
|
|
for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:
|
|
# make sure that the "VOID*" kind of datum has MaxDatumSize set
|
|
if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize == None:
|
|
NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))
|
|
|
|
if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:
|
|
#
|
|
# If a dynamic PCD used by a PEM module/PEI module & DXE module,
|
|
# it should be stored in Pcd PEI database, If a dynamic only
|
|
# used by DXE module, it should be stored in DXE PCD database.
|
|
# The default Phase is DXE
|
|
#
|
|
if M.ModuleType in ["PEIM", "PEI_CORE"]:
|
|
PcdFromModule.Phase = "PEI"
|
|
if PcdFromModule not in self._DynaPcdList_:
|
|
self._DynaPcdList_.append(PcdFromModule)
|
|
elif PcdFromModule.Phase == 'PEI':
|
|
# overwrite any the same PCD existing, if Phase is PEI
|
|
Index = self._DynaPcdList_.index(PcdFromModule)
|
|
self._DynaPcdList_[Index] = PcdFromModule
|
|
elif PcdFromModule not in self._NonDynaPcdList_:
|
|
self._NonDynaPcdList_.append(PcdFromModule)
|
|
|
|
# print out error information and break the build, if error found
|
|
if len(NoDatumTypePcdList) > 0:
|
|
NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)
|
|
EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
|
|
File=self.MetaFile,
|
|
ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
|
|
% NoDatumTypePcdListString)
|
|
self._NonDynamicPcdList = self._NonDynaPcdList_
|
|
self._DynamicPcdList = self._DynaPcdList_
|
|
|
|
#
|
|
# Sort dynamic PCD list to:
|
|
# 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should
|
|
# try to be put header of dynamicd List
|
|
# 2) If PCD is HII type, the PCD item should be put after unicode type PCD
|
|
#
|
|
# The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
|
|
#
|
|
UnicodePcdArray = []
|
|
HiiPcdArray = []
|
|
OtherPcdArray = []
|
|
for Pcd in self._DynamicPcdList:
|
|
# just pick the a value to determine whether is unicode string type
|
|
Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]
|
|
PcdValue = Sku.DefaultValue
|
|
if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):
|
|
# if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
|
|
UnicodePcdArray.append(Pcd)
|
|
elif len(Sku.VariableName) > 0:
|
|
# if found HII type PCD then insert to right of UnicodeIndex
|
|
HiiPcdArray.append(Pcd)
|
|
else:
|
|
OtherPcdArray.append(Pcd)
|
|
del self._DynamicPcdList[:]
|
|
self._DynamicPcdList.extend(UnicodePcdArray)
|
|
self._DynamicPcdList.extend(HiiPcdArray)
|
|
self._DynamicPcdList.extend(OtherPcdArray)
|
|
|
|
|
|
## Return the platform build data object
|
|
def _GetPlatform(self):
|
|
if self._Platform == None:
|
|
self._Platform = self.BuildDatabase[self.MetaFile, self.Arch]
|
|
return self._Platform
|
|
|
|
## Return platform name
|
|
def _GetName(self):
|
|
return self.Platform.PlatformName
|
|
|
|
## Return the meta file GUID
|
|
def _GetGuid(self):
|
|
return self.Platform.Guid
|
|
|
|
## Return the platform version
|
|
def _GetVersion(self):
|
|
return self.Platform.Version
|
|
|
|
## Return the FDF file name
|
|
def _GetFdfFile(self):
|
|
if self._FdfFile == None:
|
|
if self.Workspace.FdfFile != "":
|
|
self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile)
|
|
else:
|
|
self._FdfFile = ''
|
|
return self._FdfFile
|
|
|
|
## Return the build output directory platform specifies
|
|
def _GetOutputDir(self):
|
|
return self.Platform.OutputDirectory
|
|
|
|
## Return the directory to store all intermediate and final files built
|
|
def _GetBuildDir(self):
|
|
if self._BuildDir == None:
|
|
if os.path.isabs(self.OutputDir):
|
|
self._BuildDir = path.join(
|
|
path.abspath(self.OutputDir),
|
|
self.BuildTarget + "_" + self.ToolChain,
|
|
)
|
|
else:
|
|
self._BuildDir = path.join(
|
|
self.WorkspaceDir,
|
|
self.OutputDir,
|
|
self.BuildTarget + "_" + self.ToolChain,
|
|
)
|
|
return self._BuildDir
|
|
|
|
## Return directory of platform makefile
|
|
#
|
|
# @retval string Makefile directory
|
|
#
|
|
def _GetMakeFileDir(self):
|
|
if self._MakeFileDir == None:
|
|
self._MakeFileDir = path.join(self.BuildDir, self.Arch)
|
|
return self._MakeFileDir
|
|
|
|
## Return build command string
|
|
#
|
|
# @retval string Build command string
|
|
#
|
|
def _GetBuildCommand(self):
|
|
if self._BuildCommand == None:
|
|
self._BuildCommand = []
|
|
if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:
|
|
self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])
|
|
if "FLAGS" in self.ToolDefinition["MAKE"]:
|
|
NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()
|
|
if NewOption != '':
|
|
self._BuildCommand += SplitOption(NewOption)
|
|
return self._BuildCommand
|
|
|
|
## Get tool chain definition
|
|
#
|
|
# Get each tool defition for given tool chain from tools_def.txt and platform
|
|
#
|
|
def _GetToolDefinition(self):
|
|
if self._ToolDefinitions == None:
|
|
ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary
|
|
if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:
|
|
EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",
|
|
ExtraData="[%s]" % self.MetaFile)
|
|
self._ToolDefinitions = {}
|
|
DllPathList = set()
|
|
for Def in ToolDefinition:
|
|
Target, Tag, Arch, Tool, Attr = Def.split("_")
|
|
if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:
|
|
continue
|
|
|
|
Value = ToolDefinition[Def]
|
|
# don't record the DLL
|
|
if Attr == "DLL":
|
|
DllPathList.add(Value)
|
|
continue
|
|
|
|
if Tool not in self._ToolDefinitions:
|
|
self._ToolDefinitions[Tool] = {}
|
|
self._ToolDefinitions[Tool][Attr] = Value
|
|
|
|
ToolsDef = ''
|
|
MakePath = ''
|
|
if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:
|
|
if "FLAGS" not in self._ToolDefinitions["MAKE"]:
|
|
self._ToolDefinitions["MAKE"]["FLAGS"] = ""
|
|
self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"
|
|
MakeFlags = ''
|
|
for Tool in self._ToolDefinitions:
|
|
for Attr in self._ToolDefinitions[Tool]:
|
|
Value = self._ToolDefinitions[Tool][Attr]
|
|
if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:
|
|
# check if override is indicated
|
|
if self.BuildOption[Tool][Attr].startswith('='):
|
|
Value = self.BuildOption[Tool][Attr][1:]
|
|
else:
|
|
Value += " " + self.BuildOption[Tool][Attr]
|
|
|
|
if Attr == "PATH":
|
|
# Don't put MAKE definition in the file
|
|
if Tool == "MAKE":
|
|
MakePath = Value
|
|
else:
|
|
ToolsDef += "%s = %s\n" % (Tool, Value)
|
|
elif Attr != "DLL":
|
|
# Don't put MAKE definition in the file
|
|
if Tool == "MAKE":
|
|
if Attr == "FLAGS":
|
|
MakeFlags = Value
|
|
else:
|
|
ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)
|
|
ToolsDef += "\n"
|
|
|
|
SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)
|
|
for DllPath in DllPathList:
|
|
os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]
|
|
os.environ["MAKE_FLAGS"] = MakeFlags
|
|
|
|
return self._ToolDefinitions
|
|
|
|
## Return the paths of tools
|
|
def _GetToolDefFile(self):
|
|
if self._ToolDefFile == None:
|
|
self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)
|
|
return self._ToolDefFile
|
|
|
|
## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.
|
|
def _GetToolChainFamily(self):
|
|
if self._ToolChainFamily == None:
|
|
ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
|
|
if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
|
|
or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
|
|
or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:
|
|
EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
|
|
% self.ToolChain)
|
|
self._ToolChainFamily = "MSFT"
|
|
else:
|
|
self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]
|
|
return self._ToolChainFamily
|
|
|
|
def _GetBuildRuleFamily(self):
|
|
if self._BuildRuleFamily == None:
|
|
ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
|
|
if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \
|
|
or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \
|
|
or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:
|
|
EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
|
|
% self.ToolChain)
|
|
self._BuildRuleFamily = "MSFT"
|
|
else:
|
|
self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]
|
|
return self._BuildRuleFamily
|
|
|
|
## Return the build options specific to this platform
|
|
def _GetBuildOptions(self):
|
|
if self._BuildOption == None:
|
|
self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)
|
|
return self._BuildOption
|
|
|
|
## Parse build_rule.txt in $(WORKSPACE)/Conf/build_rule.txt
|
|
#
|
|
# @retval BuildRule object
|
|
#
|
|
def _GetBuildRule(self):
|
|
if self._BuildRule == None:
|
|
BuildRuleFile = None
|
|
if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:
|
|
BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]
|
|
if BuildRuleFile in [None, '']:
|
|
BuildRuleFile = gBuildRuleFile
|
|
self._BuildRule = BuildRule(BuildRuleFile)
|
|
return self._BuildRule
|
|
|
|
## Summarize the packages used by modules in this platform
|
|
def _GetPackageList(self):
|
|
if self._PackageList == None:
|
|
self._PackageList = set()
|
|
for La in self.LibraryAutoGenList:
|
|
self._PackageList.update(La.DependentPackageList)
|
|
for Ma in self.ModuleAutoGenList:
|
|
self._PackageList.update(Ma.DependentPackageList)
|
|
self._PackageList = list(self._PackageList)
|
|
return self._PackageList
|
|
|
|
## Get list of non-dynamic PCDs
|
|
def _GetNonDynamicPcdList(self):
|
|
return self._NonDynamicPcdList
|
|
|
|
## Get list of dynamic PCDs
|
|
def _GetDynamicPcdList(self):
|
|
return self._DynamicPcdList
|
|
|
|
## Generate Token Number for all PCD
|
|
def _GetPcdTokenNumbers(self):
|
|
if self._PcdTokenNumber == None:
|
|
self._PcdTokenNumber = sdict()
|
|
TokenNumber = 1
|
|
for Pcd in self.DynamicPcdList:
|
|
if Pcd.Phase == "PEI":
|
|
EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
|
|
self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
|
|
TokenNumber += 1
|
|
|
|
for Pcd in self.DynamicPcdList:
|
|
if Pcd.Phase == "DXE":
|
|
EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
|
|
self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
|
|
TokenNumber += 1
|
|
|
|
for Pcd in self.NonDynamicPcdList:
|
|
self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
|
|
TokenNumber += 1
|
|
return self._PcdTokenNumber
|
|
|
|
## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform
|
|
def _GetAutoGenObjectList(self):
|
|
self._ModuleAutoGenList = []
|
|
self._LibraryAutoGenList = []
|
|
for ModuleFile in self.Platform.Modules:
|
|
Ma = ModuleAutoGen(
|
|
self.Workspace,
|
|
ModuleFile,
|
|
self.BuildTarget,
|
|
self.ToolChain,
|
|
self.Arch,
|
|
self.MetaFile
|
|
)
|
|
if Ma not in self._ModuleAutoGenList:
|
|
self._ModuleAutoGenList.append(Ma)
|
|
for La in Ma.LibraryAutoGenList:
|
|
if La not in self._LibraryAutoGenList:
|
|
self._LibraryAutoGenList.append(La)
|
|
|
|
## Summarize ModuleAutoGen objects of all modules to be built for this platform
|
|
def _GetModuleAutoGenList(self):
|
|
if self._ModuleAutoGenList == None:
|
|
self._GetAutoGenObjectList()
|
|
return self._ModuleAutoGenList
|
|
|
|
## Summarize ModuleAutoGen objects of all libraries to be built for this platform
|
|
def _GetLibraryAutoGenList(self):
|
|
if self._LibraryAutoGenList == None:
|
|
self._GetAutoGenObjectList()
|
|
return self._LibraryAutoGenList
|
|
|
|
## Test if a module is supported by the platform
|
|
#
|
|
# An error will be raised directly if the module or its arch is not supported
|
|
# by the platform or current configuration
|
|
#
|
|
def ValidModule(self, Module):
|
|
return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances
|
|
|
|
## Resolve the library classes in a module to library instances
|
|
#
|
|
# This method will not only resolve library classes but also sort the library
|
|
# instances according to the dependency-ship.
|
|
#
|
|
# @param Module The module from which the library classes will be resolved
|
|
#
|
|
# @retval library_list List of library instances sorted
|
|
#
|
|
def ApplyLibraryInstance(self, Module):
|
|
ModuleType = Module.ModuleType
|
|
|
|
# for overridding library instances with module specific setting
|
|
PlatformModule = self.Platform.Modules[str(Module)]
|
|
|
|
# add forced library instance
|
|
for LibraryClass in PlatformModule.LibraryClasses:
|
|
if LibraryClass.startswith("NULL"):
|
|
Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]
|
|
|
|
# R9 module
|
|
LibraryConsumerList = [Module]
|
|
Constructor = []
|
|
ConsumedByList = sdict()
|
|
LibraryInstance = sdict()
|
|
|
|
EdkLogger.verbose("")
|
|
EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))
|
|
while len(LibraryConsumerList) > 0:
|
|
M = LibraryConsumerList.pop()
|
|
for LibraryClassName in M.LibraryClasses:
|
|
if LibraryClassName not in LibraryInstance:
|
|
# override library instance for this module
|
|
if LibraryClassName in PlatformModule.LibraryClasses:
|
|
LibraryPath = PlatformModule.LibraryClasses[LibraryClassName]
|
|
else:
|
|
LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]
|
|
if LibraryPath == None or LibraryPath == "":
|
|
LibraryPath = M.LibraryClasses[LibraryClassName]
|
|
if LibraryPath == None or LibraryPath == "":
|
|
EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
|
|
"Instance of library class [%s] is not found" % LibraryClassName,
|
|
File=self.MetaFile,
|
|
ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module)))
|
|
|
|
LibraryModule = self.BuildDatabase[LibraryPath, self.Arch]
|
|
# for those forced library instance (NULL library), add a fake library class
|
|
if LibraryClassName.startswith("NULL"):
|
|
LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))
|
|
elif LibraryModule.LibraryClass == None \
|
|
or len(LibraryModule.LibraryClass) == 0 \
|
|
or (ModuleType != 'USER_DEFINED'
|
|
and ModuleType not in LibraryModule.LibraryClass[0].SupModList):
|
|
# only USER_DEFINED can link against any library instance despite of its SupModList
|
|
EdkLogger.error("build", OPTION_MISSING,
|
|
"Module type [%s] is not supported by library instance [%s]" \
|
|
% (ModuleType, LibraryPath), File=self.MetaFile,
|
|
ExtraData="consumed by [%s]" % str(Module))
|
|
|
|
LibraryInstance[LibraryClassName] = LibraryModule
|
|
LibraryConsumerList.append(LibraryModule)
|
|
EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))
|
|
else:
|
|
LibraryModule = LibraryInstance[LibraryClassName]
|
|
|
|
if LibraryModule == None:
|
|
continue
|
|
|
|
if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:
|
|
Constructor.append(LibraryModule)
|
|
|
|
if LibraryModule not in ConsumedByList:
|
|
ConsumedByList[LibraryModule] = []
|
|
# don't add current module itself to consumer list
|
|
if M != Module:
|
|
if M in ConsumedByList[LibraryModule]:
|
|
continue
|
|
ConsumedByList[LibraryModule].append(M)
|
|
#
|
|
# Initialize the sorted output list to the empty set
|
|
#
|
|
SortedLibraryList = []
|
|
#
|
|
# Q <- Set of all nodes with no incoming edges
|
|
#
|
|
LibraryList = [] #LibraryInstance.values()
|
|
Q = []
|
|
for LibraryClassName in LibraryInstance:
|
|
M = LibraryInstance[LibraryClassName]
|
|
LibraryList.append(M)
|
|
if ConsumedByList[M] == []:
|
|
Q.insert(0, M)
|
|
|
|
#
|
|
# start the DAG algorithm
|
|
#
|
|
while True:
|
|
EdgeRemoved = True
|
|
while Q == [] and EdgeRemoved:
|
|
EdgeRemoved = False
|
|
# for each node Item with a Constructor
|
|
for Item in LibraryList:
|
|
if Item not in Constructor:
|
|
continue
|
|
# for each Node without a constructor with an edge e from Item to Node
|
|
for Node in ConsumedByList[Item]:
|
|
if Node in Constructor:
|
|
continue
|
|
# remove edge e from the graph if Node has no constructor
|
|
ConsumedByList[Item].remove(Node)
|
|
EdgeRemoved = True
|
|
if ConsumedByList[Item] == []:
|
|
# insert Item into Q
|
|
Q.insert(0, Item)
|
|
break
|
|
if Q != []:
|
|
break
|
|
# DAG is done if there's no more incoming edge for all nodes
|
|
if Q == []:
|
|
break
|
|
|
|
# remove node from Q
|
|
Node = Q.pop()
|
|
# output Node
|
|
SortedLibraryList.append(Node)
|
|
|
|
# for each node Item with an edge e from Node to Item do
|
|
for Item in LibraryList:
|
|
if Node not in ConsumedByList[Item]:
|
|
continue
|
|
# remove edge e from the graph
|
|
ConsumedByList[Item].remove(Node)
|
|
|
|
if ConsumedByList[Item] != []:
|
|
continue
|
|
# insert Item into Q, if Item has no other incoming edges
|
|
Q.insert(0, Item)
|
|
|
|
#
|
|
# if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle
|
|
#
|
|
for Item in LibraryList:
|
|
if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:
|
|
ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])
|
|
EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),
|
|
ExtraData=ErrorMessage, File=self.MetaFile)
|
|
if Item not in SortedLibraryList:
|
|
SortedLibraryList.append(Item)
|
|
|
|
#
|
|
# Build the list of constructor and destructir names
|
|
# The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order
|
|
#
|
|
SortedLibraryList.reverse()
|
|
return SortedLibraryList
|
|
|
|
|
|
## Override PCD setting (type, value, ...)
|
|
#
|
|
# @param ToPcd The PCD to be overrided
|
|
# @param FromPcd The PCD overrideing from
|
|
#
|
|
def _OverridePcd(self, ToPcd, FromPcd, Module=""):
|
|
#
|
|
# in case there's PCDs coming from FDF file, which have no type given.
|
|
# at this point, ToPcd.Type has the type found from dependent
|
|
# package
|
|
#
|
|
if FromPcd != None:
|
|
if ToPcd.Pending and FromPcd.Type not in [None, '']:
|
|
ToPcd.Type = FromPcd.Type
|
|
elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \
|
|
and ToPcd.Type != FromPcd.Type:
|
|
EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",
|
|
ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\
|
|
% (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName,
|
|
ToPcd.Type, Module, FromPcd.Type),
|
|
File=self.MetaFile)
|
|
|
|
if FromPcd.MaxDatumSize not in [None, '']:
|
|
ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
|
|
if FromPcd.DefaultValue not in [None, '']:
|
|
ToPcd.DefaultValue = FromPcd.DefaultValue
|
|
if FromPcd.TokenValue not in [None, '']:
|
|
ToPcd.TokenValue = FromPcd.TokenValue
|
|
if FromPcd.MaxDatumSize not in [None, '']:
|
|
ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
|
|
if FromPcd.DatumType not in [None, '']:
|
|
ToPcd.DatumType = FromPcd.DatumType
|
|
if FromPcd.SkuInfoList not in [None, '', []]:
|
|
ToPcd.SkuInfoList = FromPcd.SkuInfoList
|
|
|
|
# check the validation of datum
|
|
IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)
|
|
if not IsValid:
|
|
EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,
|
|
ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))
|
|
|
|
if ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \
|
|
% (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))
|
|
Value = ToPcd.DefaultValue
|
|
if Value in [None, '']:
|
|
ToPcd.MaxDatumSize = 1
|
|
elif Value[0] == 'L':
|
|
ToPcd.MaxDatumSize = str(len(Value) * 2)
|
|
elif Value[0] == '{':
|
|
ToPcd.MaxDatumSize = str(len(Value.split(',')))
|
|
else:
|
|
ToPcd.MaxDatumSize = str(len(Value))
|
|
|
|
# apply default SKU for dynamic PCDS if specified one is not available
|
|
if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \
|
|
and ToPcd.SkuInfoList in [None, {}, '']:
|
|
if self.Platform.SkuName in self.Platform.SkuIds:
|
|
SkuName = self.Platform.SkuName
|
|
else:
|
|
SkuName = 'DEFAULT'
|
|
ToPcd.SkuInfoList = {
|
|
SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName], '', '', '', '', '', ToPcd.DefaultValue)
|
|
}
|
|
|
|
## Apply PCD setting defined platform to a module
|
|
#
|
|
# @param Module The module from which the PCD setting will be overrided
|
|
#
|
|
# @retval PCD_list The list PCDs with settings from platform
|
|
#
|
|
def ApplyPcdSetting(self, Module, Pcds):
|
|
# for each PCD in module
|
|
for Name,Guid in Pcds:
|
|
PcdInModule = Pcds[Name,Guid]
|
|
# find out the PCD setting in platform
|
|
if (Name,Guid) in self.Platform.Pcds:
|
|
PcdInPlatform = self.Platform.Pcds[Name,Guid]
|
|
else:
|
|
PcdInPlatform = None
|
|
# then override the settings if any
|
|
self._OverridePcd(PcdInModule, PcdInPlatform, Module)
|
|
# resolve the VariableGuid value
|
|
for SkuId in PcdInModule.SkuInfoList:
|
|
Sku = PcdInModule.SkuInfoList[SkuId]
|
|
if Sku.VariableGuid == '': continue
|
|
Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList)
|
|
if Sku.VariableGuidValue == None:
|
|
PackageList = "\n\t".join([str(P) for P in self.PackageList])
|
|
EdkLogger.error(
|
|
'build',
|
|
RESOURCE_NOT_AVAILABLE,
|
|
"Value of GUID [%s] is not found in" % Sku.VariableGuid,
|
|
ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \
|
|
% (Guid, Name, str(Module)),
|
|
File=self.MetaFile
|
|
)
|
|
|
|
# override PCD settings with module specific setting
|
|
if Module in self.Platform.Modules:
|
|
PlatformModule = self.Platform.Modules[str(Module)]
|
|
for Key in PlatformModule.Pcds:
|
|
if Key in Pcds:
|
|
self._OverridePcd(Pcds[Key], PlatformModule.Pcds[Key], Module)
|
|
return Pcds.values()
|
|
|
|
## Resolve library names to library modules
|
|
#
|
|
# (for R8.x modules)
|
|
#
|
|
# @param Module The module from which the library names will be resolved
|
|
#
|
|
# @retval library_list The list of library modules
|
|
#
|
|
def ResolveLibraryReference(self, Module):
|
|
EdkLogger.verbose("")
|
|
EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))
|
|
LibraryConsumerList = [Module]
|
|
|
|
# "CompilerStub" is a must for R8 modules
|
|
if Module.Libraries:
|
|
Module.Libraries.append("CompilerStub")
|
|
LibraryList = []
|
|
while len(LibraryConsumerList) > 0:
|
|
M = LibraryConsumerList.pop()
|
|
for LibraryName in M.Libraries:
|
|
Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']
|
|
if Library == None:
|
|
for Key in self.Platform.LibraryClasses.data.keys():
|
|
if LibraryName.upper() == Key.upper():
|
|
Library = self.Platform.LibraryClasses[Key, ':dummy:']
|
|
break
|
|
if Library == None:
|
|
EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),
|
|
ExtraData="\t%s [%s]" % (str(Module), self.Arch))
|
|
continue
|
|
|
|
if Library not in LibraryList:
|
|
LibraryList.append(Library)
|
|
LibraryConsumerList.append(Library)
|
|
EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))
|
|
return LibraryList
|
|
|
|
## Expand * in build option key
|
|
#
|
|
# @param Options Options to be expanded
|
|
#
|
|
# @retval options Options expanded
|
|
#
|
|
def _ExpandBuildOption(self, Options):
|
|
BuildOptions = {}
|
|
FamilyMatch = False
|
|
FamilyIsNull = True
|
|
for Key in Options:
|
|
Family = Key[0]
|
|
Target, Tag, Arch, Tool, Attr = Key[1].split("_")
|
|
# if tool chain family doesn't match, skip it
|
|
if Tool in self.ToolDefinition and Family != "":
|
|
FamilyIsNull = False
|
|
if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":
|
|
if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:
|
|
continue
|
|
elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
|
|
continue
|
|
FamilyMatch = True
|
|
# expand any wildcard
|
|
if Target == "*" or Target == self.BuildTarget:
|
|
if Tag == "*" or Tag == self.ToolChain:
|
|
if Arch == "*" or Arch == self.Arch:
|
|
if Tool not in BuildOptions:
|
|
BuildOptions[Tool] = {}
|
|
if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:
|
|
BuildOptions[Tool][Attr] = Options[Key]
|
|
else:
|
|
# append options for the same tool
|
|
BuildOptions[Tool][Attr] += " " + Options[Key]
|
|
# Build Option Family has been checked, which need't to be checked again for family.
|
|
if FamilyMatch or FamilyIsNull:
|
|
return BuildOptions
|
|
|
|
for Key in Options:
|
|
Family = Key[0]
|
|
Target, Tag, Arch, Tool, Attr = Key[1].split("_")
|
|
# if tool chain family doesn't match, skip it
|
|
if Tool not in self.ToolDefinition or Family =="":
|
|
continue
|
|
# option has been added before
|
|
if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
|
|
continue
|
|
|
|
# expand any wildcard
|
|
if Target == "*" or Target == self.BuildTarget:
|
|
if Tag == "*" or Tag == self.ToolChain:
|
|
if Arch == "*" or Arch == self.Arch:
|
|
if Tool not in BuildOptions:
|
|
BuildOptions[Tool] = {}
|
|
if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:
|
|
BuildOptions[Tool][Attr] = Options[Key]
|
|
else:
|
|
# append options for the same tool
|
|
BuildOptions[Tool][Attr] += " " + Options[Key]
|
|
return BuildOptions
|
|
|
|
## Append build options in platform to a module
|
|
#
|
|
# @param Module The module to which the build options will be appened
|
|
#
|
|
# @retval options The options appended with build options in platform
|
|
#
|
|
def ApplyBuildOption(self, Module):
|
|
PlatformOptions = self.BuildOption
|
|
ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)
|
|
if Module in self.Platform.Modules:
|
|
PlatformModule = self.Platform.Modules[str(Module)]
|
|
PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)
|
|
else:
|
|
PlatformModuleOptions = {}
|
|
|
|
AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() + PlatformModuleOptions.keys() + self.ToolDefinition.keys())
|
|
BuildOptions = {}
|
|
for Tool in AllTools:
|
|
if Tool not in BuildOptions:
|
|
BuildOptions[Tool] = {}
|
|
|
|
for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:
|
|
if Tool not in Options:
|
|
continue
|
|
for Attr in Options[Tool]:
|
|
Value = Options[Tool][Attr]
|
|
if Attr not in BuildOptions[Tool]:
|
|
BuildOptions[Tool][Attr] = ""
|
|
# check if override is indicated
|
|
if Value.startswith('='):
|
|
BuildOptions[Tool][Attr] = Value[1:]
|
|
else:
|
|
BuildOptions[Tool][Attr] += " " + Value
|
|
return BuildOptions
|
|
|
|
Platform = property(_GetPlatform)
|
|
Name = property(_GetName)
|
|
Guid = property(_GetGuid)
|
|
Version = property(_GetVersion)
|
|
|
|
OutputDir = property(_GetOutputDir)
|
|
BuildDir = property(_GetBuildDir)
|
|
MakeFileDir = property(_GetMakeFileDir)
|
|
FdfFile = property(_GetFdfFile)
|
|
|
|
PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
|
|
DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
|
|
NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
|
|
PackageList = property(_GetPackageList)
|
|
|
|
ToolDefinition = property(_GetToolDefinition) # toolcode : tool path
|
|
ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path
|
|
ToolChainFamily = property(_GetToolChainFamily)
|
|
BuildRuleFamily = property(_GetBuildRuleFamily)
|
|
BuildOption = property(_GetBuildOptions) # toolcode : option
|
|
|
|
BuildCommand = property(_GetBuildCommand)
|
|
BuildRule = property(_GetBuildRule)
|
|
ModuleAutoGenList = property(_GetModuleAutoGenList)
|
|
LibraryAutoGenList = property(_GetLibraryAutoGenList)
|
|
|
|
## ModuleAutoGen class
|
|
#
|
|
# This class encapsules the AutoGen behaviors for the build tools. In addition to
|
|
# the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according
|
|
# to the [depex] section in module's inf file.
|
|
#
|
|
class ModuleAutoGen(AutoGen):
|
|
## The real constructor of ModuleAutoGen
|
|
#
|
|
# This method is not supposed to be called by users of ModuleAutoGen. It's
|
|
# only used by factory method __new__() to do real initialization work for an
|
|
# object of ModuleAutoGen
|
|
#
|
|
# @param Workspace EdkIIWorkspaceBuild object
|
|
# @param ModuleFile The path of module file
|
|
# @param Target Build target (DEBUG, RELEASE)
|
|
# @param Toolchain Name of tool chain
|
|
# @param Arch The arch the module supports
|
|
# @param PlatformFile Platform meta-file
|
|
#
|
|
def _Init(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))
|
|
GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)
|
|
|
|
self.Workspace = Workspace
|
|
self.WorkspaceDir = Workspace.WorkspaceDir
|
|
|
|
self.MetaFile = ModuleFile
|
|
self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)
|
|
# check if this module is employed by active platform
|
|
if not self.PlatformInfo.ValidModule(self.MetaFile):
|
|
EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \
|
|
% (self.MetaFile, Arch))
|
|
return False
|
|
|
|
self.SourceDir = self.MetaFile.SubDir
|
|
self.SourceOverrideDir = None
|
|
# use overrided path defined in DSC file
|
|
if self.MetaFile.Key in GlobalData.gOverrideDir:
|
|
self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]
|
|
|
|
self.ToolChain = Toolchain
|
|
self.BuildTarget = Target
|
|
self.Arch = Arch
|
|
self.ToolChainFamily = self.PlatformInfo.ToolChainFamily
|
|
self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily
|
|
|
|
self.IsMakeFileCreated = False
|
|
self.IsCodeFileCreated = False
|
|
|
|
self.BuildDatabase = self.Workspace.BuildDatabase
|
|
|
|
self._Module = None
|
|
self._Name = None
|
|
self._Guid = None
|
|
self._Version = None
|
|
self._ModuleType = None
|
|
self._ComponentType = None
|
|
self._PcdIsDriver = None
|
|
self._AutoGenVersion = None
|
|
self._LibraryFlag = None
|
|
self._CustomMakefile = None
|
|
self._Macro = None
|
|
|
|
self._BuildDir = None
|
|
self._OutputDir = None
|
|
self._DebugDir = None
|
|
self._MakeFileDir = None
|
|
|
|
self._IncludePathList = None
|
|
self._AutoGenFileList = None
|
|
self._UnicodeFileList = None
|
|
self._SourceFileList = None
|
|
self._ObjectFileList = None
|
|
self._BinaryFileList = None
|
|
|
|
self._DependentPackageList = None
|
|
self._DependentLibraryList = None
|
|
self._LibraryAutoGenList = None
|
|
self._DerivedPackageList = None
|
|
self._ModulePcdList = None
|
|
self._LibraryPcdList = None
|
|
self._GuidList = None
|
|
self._ProtocolList = None
|
|
self._PpiList = None
|
|
self._DepexList = None
|
|
self._DepexExpressionList = None
|
|
self._BuildOption = None
|
|
self._BuildTargets = None
|
|
self._IntroBuildTargetList = None
|
|
self._FinalBuildTargetList = None
|
|
self._FileTypes = None
|
|
self._BuildRules = None
|
|
|
|
return True
|
|
|
|
def __repr__(self):
|
|
return "%s [%s]" % (self.MetaFile, self.Arch)
|
|
|
|
# Macros could be used in build_rule.txt (also Makefile)
|
|
def _GetMacros(self):
|
|
if self._Macro == None:
|
|
self._Macro = sdict()
|
|
self._Macro["WORKSPACE" ] = self.WorkspaceDir
|
|
self._Macro["MODULE_NAME" ] = self.Name
|
|
self._Macro["MODULE_GUID" ] = self.Guid
|
|
self._Macro["MODULE_VERSION" ] = self.Version
|
|
self._Macro["MODULE_TYPE" ] = self.ModuleType
|
|
self._Macro["MODULE_FILE" ] = str(self.MetaFile)
|
|
self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName
|
|
self._Macro["MODULE_RELATIVE_DIR" ] = self.SourceDir
|
|
self._Macro["MODULE_DIR" ] = self.SourceDir
|
|
|
|
self._Macro["BASE_NAME" ] = self.Name
|
|
|
|
self._Macro["ARCH" ] = self.Arch
|
|
self._Macro["TOOLCHAIN" ] = self.ToolChain
|
|
self._Macro["TOOLCHAIN_TAG" ] = self.ToolChain
|
|
self._Macro["TARGET" ] = self.BuildTarget
|
|
|
|
self._Macro["BUILD_DIR" ] = self.PlatformInfo.BuildDir
|
|
self._Macro["BIN_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
|
|
self._Macro["LIB_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
|
|
self._Macro["MODULE_BUILD_DIR" ] = self.BuildDir
|
|
self._Macro["OUTPUT_DIR" ] = self.OutputDir
|
|
self._Macro["DEBUG_DIR" ] = self.DebugDir
|
|
return self._Macro
|
|
|
|
## Return the module build data object
|
|
def _GetModule(self):
|
|
if self._Module == None:
|
|
self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch]
|
|
return self._Module
|
|
|
|
## Return the module name
|
|
def _GetBaseName(self):
|
|
return self.Module.BaseName
|
|
|
|
## Return the module SourceOverridePath
|
|
def _GetSourceOverridePath(self):
|
|
return self.Module.SourceOverridePath
|
|
|
|
## Return the module meta-file GUID
|
|
def _GetGuid(self):
|
|
return self.Module.Guid
|
|
|
|
## Return the module version
|
|
def _GetVersion(self):
|
|
return self.Module.Version
|
|
|
|
## Return the module type
|
|
def _GetModuleType(self):
|
|
return self.Module.ModuleType
|
|
|
|
## Return the component type (for R8.x style of module)
|
|
def _GetComponentType(self):
|
|
return self.Module.ComponentType
|
|
|
|
## Return the build type
|
|
def _GetBuildType(self):
|
|
return self.Module.BuildType
|
|
|
|
## Return the PCD_IS_DRIVER setting
|
|
def _GetPcdIsDriver(self):
|
|
return self.Module.PcdIsDriver
|
|
|
|
## Return the autogen version, i.e. module meta-file version
|
|
def _GetAutoGenVersion(self):
|
|
return self.Module.AutoGenVersion
|
|
|
|
## Check if the module is library or not
|
|
def _IsLibrary(self):
|
|
if self._LibraryFlag == None:
|
|
if self.Module.LibraryClass != None and self.Module.LibraryClass != []:
|
|
self._LibraryFlag = True
|
|
else:
|
|
self._LibraryFlag = False
|
|
return self._LibraryFlag
|
|
|
|
## Return the directory to store intermediate files of the module
|
|
def _GetBuildDir(self):
|
|
if self._BuildDir == None:
|
|
self._BuildDir = path.join(
|
|
self.PlatformInfo.BuildDir,
|
|
self.Arch,
|
|
self.SourceDir,
|
|
self.MetaFile.BaseName
|
|
)
|
|
CreateDirectory(self._BuildDir)
|
|
return self._BuildDir
|
|
|
|
## Return the directory to store the intermediate object files of the mdoule
|
|
def _GetOutputDir(self):
|
|
if self._OutputDir == None:
|
|
self._OutputDir = path.join(self.BuildDir, "OUTPUT")
|
|
CreateDirectory(self._OutputDir)
|
|
return self._OutputDir
|
|
|
|
## Return the directory to store auto-gened source files of the mdoule
|
|
def _GetDebugDir(self):
|
|
if self._DebugDir == None:
|
|
self._DebugDir = path.join(self.BuildDir, "DEBUG")
|
|
CreateDirectory(self._DebugDir)
|
|
return self._DebugDir
|
|
|
|
## Return the path of custom file
|
|
def _GetCustomMakefile(self):
|
|
if self._CustomMakefile == None:
|
|
self._CustomMakefile = {}
|
|
for Type in self.Module.CustomMakefile:
|
|
if Type in gMakeTypeMap:
|
|
MakeType = gMakeTypeMap[Type]
|
|
else:
|
|
MakeType = 'nmake'
|
|
if self.SourceOverrideDir != None:
|
|
File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])
|
|
if not os.path.exists(File):
|
|
File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
|
|
else:
|
|
File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
|
|
self._CustomMakefile[MakeType] = File
|
|
return self._CustomMakefile
|
|
|
|
## Return the directory of the makefile
|
|
#
|
|
# @retval string The directory string of module's makefile
|
|
#
|
|
def _GetMakeFileDir(self):
|
|
return self.BuildDir
|
|
|
|
## Return build command string
|
|
#
|
|
# @retval string Build command string
|
|
#
|
|
def _GetBuildCommand(self):
|
|
return self.PlatformInfo.BuildCommand
|
|
|
|
## Get object list of all packages the module and its dependent libraries belong to
|
|
#
|
|
# @retval list The list of package object
|
|
#
|
|
def _GetDerivedPackageList(self):
|
|
PackageList = []
|
|
for M in [self.Module] + self.DependentLibraryList:
|
|
for Package in M.Packages:
|
|
if Package in PackageList:
|
|
continue
|
|
PackageList.append(Package)
|
|
return PackageList
|
|
|
|
## Merge dependency expression
|
|
#
|
|
# @retval list The token list of the dependency expression after parsed
|
|
#
|
|
def _GetDepexTokenList(self):
|
|
if self._DepexList == None:
|
|
self._DepexList = {}
|
|
if self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
|
|
return self._DepexList
|
|
|
|
self._DepexList[self.ModuleType] = []
|
|
|
|
for ModuleType in self._DepexList:
|
|
DepexList = self._DepexList[ModuleType]
|
|
#
|
|
# Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
|
|
#
|
|
for M in [self.Module] + self.DependentLibraryList:
|
|
Inherited = False
|
|
for D in M.Depex[self.Arch, ModuleType]:
|
|
if DepexList != []:
|
|
DepexList.append('AND')
|
|
DepexList.append('(')
|
|
DepexList.extend(D)
|
|
if DepexList[-1] == 'END': # no need of a END at this time
|
|
DepexList.pop()
|
|
DepexList.append(')')
|
|
Inherited = True
|
|
if Inherited:
|
|
EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))
|
|
if 'BEFORE' in DepexList or 'AFTER' in DepexList:
|
|
break
|
|
if len(DepexList) > 0:
|
|
EdkLogger.verbose('')
|
|
return self._DepexList
|
|
|
|
## Merge dependency expression
|
|
#
|
|
# @retval list The token list of the dependency expression after parsed
|
|
#
|
|
def _GetDepexExpressionTokenList(self):
|
|
if self._DepexExpressionList == None:
|
|
self._DepexExpressionList = {}
|
|
if self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
|
|
return self._DepexExpressionList
|
|
|
|
self._DepexExpressionList[self.ModuleType] = ''
|
|
|
|
for ModuleType in self._DepexExpressionList:
|
|
DepexExpressionList = self._DepexExpressionList[ModuleType]
|
|
#
|
|
# Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
|
|
#
|
|
for M in [self.Module] + self.DependentLibraryList:
|
|
Inherited = False
|
|
for D in M.DepexExpression[self.Arch, ModuleType]:
|
|
if DepexExpressionList != '':
|
|
DepexExpressionList += ' AND '
|
|
DepexExpressionList += '('
|
|
DepexExpressionList += D
|
|
DepexExpressionList = DepexExpressionList.rstrip('END').strip()
|
|
DepexExpressionList += ')'
|
|
Inherited = True
|
|
if Inherited:
|
|
EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionList))
|
|
if 'BEFORE' in DepexExpressionList or 'AFTER' in DepexExpressionList:
|
|
break
|
|
if len(DepexExpressionList) > 0:
|
|
EdkLogger.verbose('')
|
|
self._DepexExpressionList[ModuleType] = DepexExpressionList
|
|
return self._DepexExpressionList
|
|
|
|
## Return the list of specification version required for the module
|
|
#
|
|
# @retval list The list of specification defined in module file
|
|
#
|
|
def _GetSpecification(self):
|
|
return self.Module.Specification
|
|
|
|
## Tool option for the module build
|
|
#
|
|
# @param PlatformInfo The object of PlatformBuildInfo
|
|
# @retval dict The dict containing valid options
|
|
#
|
|
def _GetModuleBuildOption(self):
|
|
if self._BuildOption == None:
|
|
self._BuildOption = self.PlatformInfo.ApplyBuildOption(self.Module)
|
|
return self._BuildOption
|
|
|
|
## Return a list of files which can be built from source
|
|
#
|
|
# What kind of files can be built is determined by build rules in
|
|
# $(WORKSPACE)/Conf/build_rule.txt and toolchain family.
|
|
#
|
|
def _GetSourceFileList(self):
|
|
if self._SourceFileList == None:
|
|
self._SourceFileList = []
|
|
for F in self.Module.Sources:
|
|
# match tool chain
|
|
if F.TagName != "" and F.TagName != self.ToolChain:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "
|
|
"but [%s] is needed" % (F.TagName, str(F), self.ToolChain))
|
|
continue
|
|
# match tool chain family
|
|
if F.ToolChainFamily != "" and F.ToolChainFamily != self.ToolChainFamily:
|
|
EdkLogger.debug(
|
|
EdkLogger.DEBUG_0,
|
|
"The file [%s] must be built by tools of [%s], " \
|
|
"but current toolchain family is [%s]" \
|
|
% (str(F), F.ToolChainFamily, self.ToolChainFamily))
|
|
continue
|
|
|
|
# add the file path into search path list for file including
|
|
if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:
|
|
self.IncludePathList.insert(0, F.Dir)
|
|
self._SourceFileList.append(F)
|
|
self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)
|
|
return self._SourceFileList
|
|
|
|
## Return the list of unicode files
|
|
def _GetUnicodeFileList(self):
|
|
if self._UnicodeFileList == None:
|
|
if TAB_UNICODE_FILE in self.FileTypes:
|
|
self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE]
|
|
else:
|
|
self._UnicodeFileList = []
|
|
return self._UnicodeFileList
|
|
|
|
## Return a list of files which can be built from binary
|
|
#
|
|
# "Build" binary files are just to copy them to build directory.
|
|
#
|
|
# @retval list The list of files which can be built later
|
|
#
|
|
def _GetBinaryFiles(self):
|
|
if self._BinaryFileList == None:
|
|
self._BinaryFileList = []
|
|
for F in self.Module.Binaries:
|
|
if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget:
|
|
continue
|
|
self._BinaryFileList.append(F)
|
|
self._ApplyBuildRule(F, F.Type)
|
|
return self._BinaryFileList
|
|
|
|
def _GetBuildRules(self):
|
|
if self._BuildRules == None:
|
|
BuildRules = {}
|
|
BuildRuleDatabase = self.PlatformInfo.BuildRule
|
|
for Type in BuildRuleDatabase.FileTypeList:
|
|
#first try getting build rule by BuildRuleFamily
|
|
RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]
|
|
if not RuleObject:
|
|
# build type is always module type, but ...
|
|
if self.ModuleType != self.BuildType:
|
|
RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]
|
|
#second try getting build rule by ToolChainFamily
|
|
if not RuleObject:
|
|
RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]
|
|
if not RuleObject:
|
|
# build type is always module type, but ...
|
|
if self.ModuleType != self.BuildType:
|
|
RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]
|
|
if not RuleObject:
|
|
continue
|
|
RuleObject = RuleObject.Instantiate(self.Macros)
|
|
BuildRules[Type] = RuleObject
|
|
for Ext in RuleObject.SourceFileExtList:
|
|
BuildRules[Ext] = RuleObject
|
|
self._BuildRules = BuildRules
|
|
return self._BuildRules
|
|
|
|
def _ApplyBuildRule(self, File, FileType):
|
|
if self._BuildTargets == None:
|
|
self._IntroBuildTargetList = set()
|
|
self._FinalBuildTargetList = set()
|
|
self._BuildTargets = {}
|
|
self._FileTypes = {}
|
|
|
|
LastTarget = None
|
|
RuleChain = []
|
|
SourceList = [File]
|
|
Index = 0
|
|
while Index < len(SourceList):
|
|
Source = SourceList[Index]
|
|
Index = Index + 1
|
|
|
|
if Source != File:
|
|
CreateDirectory(Source.Dir)
|
|
|
|
if File.IsBinary and File == Source:
|
|
RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]
|
|
elif FileType in self.BuildRules:
|
|
RuleObject = self.BuildRules[FileType]
|
|
elif Source.Ext in self.BuildRules:
|
|
RuleObject = self.BuildRules[Source.Ext]
|
|
else:
|
|
# stop at no more rules
|
|
if LastTarget:
|
|
self._FinalBuildTargetList.add(LastTarget)
|
|
break
|
|
|
|
FileType = RuleObject.SourceFileType
|
|
if FileType not in self._FileTypes:
|
|
self._FileTypes[FileType] = set()
|
|
self._FileTypes[FileType].add(Source)
|
|
|
|
# stop at STATIC_LIBRARY for library
|
|
if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:
|
|
if LastTarget:
|
|
self._FinalBuildTargetList.add(LastTarget)
|
|
break
|
|
|
|
Target = RuleObject.Apply(Source)
|
|
if not Target:
|
|
if LastTarget:
|
|
self._FinalBuildTargetList.add(LastTarget)
|
|
break
|
|
elif not Target.Outputs:
|
|
# Only do build for target with outputs
|
|
self._FinalBuildTargetList.add(Target)
|
|
|
|
if FileType not in self._BuildTargets:
|
|
self._BuildTargets[FileType] = set()
|
|
self._BuildTargets[FileType].add(Target)
|
|
|
|
if not Source.IsBinary and Source == File:
|
|
self._IntroBuildTargetList.add(Target)
|
|
|
|
# to avoid cyclic rule
|
|
if FileType in RuleChain:
|
|
break
|
|
|
|
RuleChain.append(FileType)
|
|
SourceList.extend(Target.Outputs)
|
|
LastTarget = Target
|
|
FileType = TAB_UNKNOWN_FILE
|
|
|
|
def _GetTargets(self):
|
|
if self._BuildTargets == None:
|
|
self._IntroBuildTargetList = set()
|
|
self._FinalBuildTargetList = set()
|
|
self._BuildTargets = {}
|
|
self._FileTypes = {}
|
|
|
|
#TRICK: call _GetSourceFileList to apply build rule for binary files
|
|
if self.SourceFileList:
|
|
pass
|
|
|
|
#TRICK: call _GetBinaryFileList to apply build rule for binary files
|
|
if self.BinaryFileList:
|
|
pass
|
|
|
|
return self._BuildTargets
|
|
|
|
def _GetIntroTargetList(self):
|
|
self._GetTargets()
|
|
return self._IntroBuildTargetList
|
|
|
|
def _GetFinalTargetList(self):
|
|
self._GetTargets()
|
|
return self._FinalBuildTargetList
|
|
|
|
def _GetFileTypes(self):
|
|
self._GetTargets()
|
|
return self._FileTypes
|
|
|
|
## Get the list of package object the module depends on
|
|
#
|
|
# @retval list The package object list
|
|
#
|
|
def _GetDependentPackageList(self):
|
|
return self.Module.Packages
|
|
|
|
## Return the list of auto-generated code file
|
|
#
|
|
# @retval list The list of auto-generated file
|
|
#
|
|
def _GetAutoGenFileList(self):
|
|
UniStringAutoGenC = True
|
|
UniStringBinBuffer = None
|
|
if self.BuildType == 'UEFI_HII':
|
|
UniStringBinBuffer = StringIO()
|
|
UniStringAutoGenC = False
|
|
if self._AutoGenFileList == None:
|
|
self._AutoGenFileList = {}
|
|
AutoGenC = TemplateString()
|
|
AutoGenH = TemplateString()
|
|
StringH = TemplateString()
|
|
GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer)
|
|
if str(AutoGenC) != "" and TAB_C_CODE_FILE in self.FileTypes:
|
|
AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)
|
|
self._AutoGenFileList[AutoFile] = str(AutoGenC)
|
|
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
|
|
if str(AutoGenH) != "":
|
|
AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)
|
|
self._AutoGenFileList[AutoFile] = str(AutoGenH)
|
|
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
|
|
if str(StringH) != "":
|
|
AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)
|
|
self._AutoGenFileList[AutoFile] = str(StringH)
|
|
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
|
|
if UniStringBinBuffer != None and UniStringBinBuffer.getvalue() != "":
|
|
AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)
|
|
self._AutoGenFileList[AutoFile] = UniStringBinBuffer.getvalue()
|
|
AutoFile.IsBinary = True
|
|
self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
|
|
if UniStringBinBuffer != None:
|
|
UniStringBinBuffer.close()
|
|
return self._AutoGenFileList
|
|
|
|
## Return the list of library modules explicitly or implicityly used by this module
|
|
def _GetLibraryList(self):
|
|
if self._DependentLibraryList == None:
|
|
# only merge library classes and PCD for non-library module
|
|
if self.IsLibrary:
|
|
self._DependentLibraryList = []
|
|
else:
|
|
if self.AutoGenVersion < 0x00010005:
|
|
self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)
|
|
else:
|
|
self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)
|
|
return self._DependentLibraryList
|
|
|
|
## Get the list of PCDs from current module
|
|
#
|
|
# @retval list The list of PCD
|
|
#
|
|
def _GetModulePcdList(self):
|
|
if self._ModulePcdList == None:
|
|
# apply PCD settings from platform
|
|
self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)
|
|
return self._ModulePcdList
|
|
|
|
## Get the list of PCDs from dependent libraries
|
|
#
|
|
# @retval list The list of PCD
|
|
#
|
|
def _GetLibraryPcdList(self):
|
|
if self._LibraryPcdList == None:
|
|
Pcds = {}
|
|
if not self.IsLibrary:
|
|
# get PCDs from dependent libraries
|
|
for Library in self.DependentLibraryList:
|
|
for Key in Library.Pcds:
|
|
# skip duplicated PCDs
|
|
if Key in self.Module.Pcds or Key in Pcds:
|
|
continue
|
|
Pcds[Key] = copy.copy(Library.Pcds[Key])
|
|
# apply PCD settings from platform
|
|
self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds)
|
|
else:
|
|
self._LibraryPcdList = []
|
|
return self._LibraryPcdList
|
|
|
|
## Get the GUID value mapping
|
|
#
|
|
# @retval dict The mapping between GUID cname and its value
|
|
#
|
|
def _GetGuidList(self):
|
|
if self._GuidList == None:
|
|
self._GuidList = self.Module.Guids
|
|
for Library in self.DependentLibraryList:
|
|
self._GuidList.update(Library.Guids)
|
|
return self._GuidList
|
|
|
|
## Get the protocol value mapping
|
|
#
|
|
# @retval dict The mapping between protocol cname and its value
|
|
#
|
|
def _GetProtocolList(self):
|
|
if self._ProtocolList == None:
|
|
self._ProtocolList = self.Module.Protocols
|
|
for Library in self.DependentLibraryList:
|
|
self._ProtocolList.update(Library.Protocols)
|
|
return self._ProtocolList
|
|
|
|
## Get the PPI value mapping
|
|
#
|
|
# @retval dict The mapping between PPI cname and its value
|
|
#
|
|
def _GetPpiList(self):
|
|
if self._PpiList == None:
|
|
self._PpiList = self.Module.Ppis
|
|
for Library in self.DependentLibraryList:
|
|
self._PpiList.update(Library.Ppis)
|
|
return self._PpiList
|
|
|
|
## Get the list of include search path
|
|
#
|
|
# @retval list The list path
|
|
#
|
|
def _GetIncludePathList(self):
|
|
if self._IncludePathList == None:
|
|
self._IncludePathList = []
|
|
if self.AutoGenVersion < 0x00010005:
|
|
for Inc in self.Module.Includes:
|
|
if Inc not in self._IncludePathList:
|
|
self._IncludePathList.append(Inc)
|
|
# for r8 modules
|
|
Inc = path.join(Inc, self.Arch.capitalize())
|
|
if os.path.exists(Inc) and Inc not in self._IncludePathList:
|
|
self._IncludePathList.append(Inc)
|
|
# r8 module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time
|
|
self._IncludePathList.append(self.DebugDir)
|
|
else:
|
|
self._IncludePathList.append(self.MetaFile.Dir)
|
|
self._IncludePathList.append(self.DebugDir)
|
|
|
|
for Package in self.Module.Packages:
|
|
PackageDir = path.join(self.WorkspaceDir, Package.MetaFile.Dir)
|
|
if PackageDir not in self._IncludePathList:
|
|
self._IncludePathList.append(PackageDir)
|
|
for Inc in Package.Includes:
|
|
if Inc not in self._IncludePathList:
|
|
self._IncludePathList.append(str(Inc))
|
|
return self._IncludePathList
|
|
|
|
## Create makefile for the module and its dependent libraries
|
|
#
|
|
# @param CreateLibraryMakeFile Flag indicating if or not the makefiles of
|
|
# dependent libraries will be created
|
|
#
|
|
def CreateMakeFile(self, CreateLibraryMakeFile=True):
|
|
if self.IsMakeFileCreated:
|
|
return
|
|
|
|
if not self.IsLibrary and CreateLibraryMakeFile:
|
|
for LibraryAutoGen in self.LibraryAutoGenList:
|
|
LibraryAutoGen.CreateMakeFile()
|
|
|
|
if len(self.CustomMakefile) == 0:
|
|
Makefile = GenMake.ModuleMakefile(self)
|
|
else:
|
|
Makefile = GenMake.CustomMakefile(self)
|
|
if Makefile.Generate():
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %
|
|
(self.Name, self.Arch))
|
|
else:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %
|
|
(self.Name, self.Arch))
|
|
|
|
self.IsMakeFileCreated = True
|
|
|
|
## Create autogen code for the module and its dependent libraries
|
|
#
|
|
# @param CreateLibraryCodeFile Flag indicating if or not the code of
|
|
# dependent libraries will be created
|
|
#
|
|
def CreateCodeFile(self, CreateLibraryCodeFile=True):
|
|
if self.IsCodeFileCreated:
|
|
return
|
|
|
|
if not self.IsLibrary and CreateLibraryCodeFile:
|
|
for LibraryAutoGen in self.LibraryAutoGenList:
|
|
LibraryAutoGen.CreateCodeFile()
|
|
|
|
AutoGenList = []
|
|
IgoredAutoGenList = []
|
|
|
|
for File in self.AutoGenFileList:
|
|
if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):
|
|
#Ignore R8 AutoGen.c
|
|
if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':
|
|
continue
|
|
|
|
AutoGenList.append(str(File))
|
|
else:
|
|
IgoredAutoGenList.append(str(File))
|
|
|
|
# Skip the following code for EDK I inf
|
|
if self.AutoGenVersion < 0x00010005:
|
|
return
|
|
|
|
for ModuleType in self.DepexList:
|
|
if len(self.DepexList[ModuleType]) == 0:
|
|
continue
|
|
Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)
|
|
DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}
|
|
|
|
if Dpx.Generate(path.join(self.OutputDir, DpxFile)):
|
|
AutoGenList.append(str(DpxFile))
|
|
else:
|
|
IgoredAutoGenList.append(str(DpxFile))
|
|
|
|
if IgoredAutoGenList == []:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %
|
|
(" ".join(AutoGenList), self.Name, self.Arch))
|
|
elif AutoGenList == []:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %
|
|
(" ".join(IgoredAutoGenList), self.Name, self.Arch))
|
|
else:
|
|
EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %
|
|
(" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))
|
|
|
|
self.IsCodeFileCreated = True
|
|
return AutoGenList
|
|
|
|
## Summarize the ModuleAutoGen objects of all libraries used by this module
|
|
def _GetLibraryAutoGenList(self):
|
|
if self._LibraryAutoGenList == None:
|
|
self._LibraryAutoGenList = []
|
|
for Library in self.DependentLibraryList:
|
|
La = ModuleAutoGen(
|
|
self.Workspace,
|
|
Library.MetaFile,
|
|
self.BuildTarget,
|
|
self.ToolChain,
|
|
self.Arch,
|
|
self.PlatformInfo.MetaFile
|
|
)
|
|
if La not in self._LibraryAutoGenList:
|
|
self._LibraryAutoGenList.append(La)
|
|
for Lib in La.CodaTargetList:
|
|
self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)
|
|
return self._LibraryAutoGenList
|
|
|
|
## Return build command string
|
|
#
|
|
# @retval string Build command string
|
|
#
|
|
def _GetBuildCommand(self):
|
|
return self.PlatformInfo.BuildCommand
|
|
|
|
|
|
Module = property(_GetModule)
|
|
Name = property(_GetBaseName)
|
|
Guid = property(_GetGuid)
|
|
Version = property(_GetVersion)
|
|
ModuleType = property(_GetModuleType)
|
|
ComponentType = property(_GetComponentType)
|
|
BuildType = property(_GetBuildType)
|
|
PcdIsDriver = property(_GetPcdIsDriver)
|
|
AutoGenVersion = property(_GetAutoGenVersion)
|
|
Macros = property(_GetMacros)
|
|
Specification = property(_GetSpecification)
|
|
|
|
IsLibrary = property(_IsLibrary)
|
|
|
|
BuildDir = property(_GetBuildDir)
|
|
OutputDir = property(_GetOutputDir)
|
|
DebugDir = property(_GetDebugDir)
|
|
MakeFileDir = property(_GetMakeFileDir)
|
|
CustomMakefile = property(_GetCustomMakefile)
|
|
|
|
IncludePathList = property(_GetIncludePathList)
|
|
AutoGenFileList = property(_GetAutoGenFileList)
|
|
UnicodeFileList = property(_GetUnicodeFileList)
|
|
SourceFileList = property(_GetSourceFileList)
|
|
BinaryFileList = property(_GetBinaryFiles) # FileType : [File List]
|
|
Targets = property(_GetTargets)
|
|
IntroTargetList = property(_GetIntroTargetList)
|
|
CodaTargetList = property(_GetFinalTargetList)
|
|
FileTypes = property(_GetFileTypes)
|
|
BuildRules = property(_GetBuildRules)
|
|
|
|
DependentPackageList = property(_GetDependentPackageList)
|
|
DependentLibraryList = property(_GetLibraryList)
|
|
LibraryAutoGenList = property(_GetLibraryAutoGenList)
|
|
DerivedPackageList = property(_GetDerivedPackageList)
|
|
|
|
ModulePcdList = property(_GetModulePcdList)
|
|
LibraryPcdList = property(_GetLibraryPcdList)
|
|
GuidList = property(_GetGuidList)
|
|
ProtocolList = property(_GetProtocolList)
|
|
PpiList = property(_GetPpiList)
|
|
DepexList = property(_GetDepexTokenList)
|
|
DepexExpressionList = property(_GetDepexExpressionTokenList)
|
|
BuildOption = property(_GetModuleBuildOption)
|
|
BuildCommand = property(_GetBuildCommand)
|
|
|
|
# This acts like the main() function for the script, unless it is 'import'ed into another script.
|
|
if __name__ == '__main__':
|
|
pass
|
|
|