]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/AutoGen/AutoGen.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
BaseTools: Modify class OrderedListDict
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / AutoGen.py
... / ...
CommitLineData
1## @file\r
2# Generate AutoGen.h, AutoGen.c and *.depex files\r
3#\r
4# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
5# Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>\r
6#\r
7# This program and the accompanying materials\r
8# are licensed and made available under the terms and conditions of the BSD License\r
9# which accompanies this distribution. The full text of the license may be found at\r
10# http://opensource.org/licenses/bsd-license.php\r
11#\r
12# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
13# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
14#\r
15\r
16## Import Modules\r
17#\r
18from __future__ import print_function\r
19from __future__ import absolute_import\r
20import Common.LongFilePathOs as os\r
21import re\r
22import os.path as path\r
23import copy\r
24import uuid\r
25\r
26from . import GenC\r
27from . import GenMake\r
28from . import GenDepex\r
29from io import BytesIO\r
30\r
31from .StrGather import *\r
32from .BuildEngine import BuildRule\r
33\r
34from Common.LongFilePathSupport import CopyLongFilePath\r
35from Common.BuildToolError import *\r
36from Common.DataType import *\r
37from Common.Misc import *\r
38from Common.StringUtils import *\r
39import Common.GlobalData as GlobalData\r
40from GenFds.FdfParser import *\r
41from CommonDataClass.CommonClass import SkuInfoClass\r
42from Workspace.BuildClassObject import *\r
43from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile\r
44import Common.VpdInfoFile as VpdInfoFile\r
45from .GenPcdDb import CreatePcdDatabaseCode\r
46from Workspace.MetaFileCommentParser import UsageList\r
47from Workspace.WorkspaceCommon import GetModuleLibInstances\r
48from Common.MultipleWorkspace import MultipleWorkspace as mws\r
49from . import InfSectionParser\r
50import datetime\r
51import hashlib\r
52from .GenVar import VariableMgr, var_info\r
53from collections import OrderedDict\r
54from collections import defaultdict\r
55from Workspace.WorkspaceCommon import OrderedListDict\r
56\r
57from Common.caching import cached_property, cached_class_function\r
58\r
59## Regular expression for splitting Dependency Expression string into tokens\r
60gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
61\r
62## Regular expression for match: PCD(xxxx.yyy)\r
63gPCDAsGuidPattern = re.compile(r"^PCD\(.+\..+\)$")\r
64\r
65#\r
66# Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
67# is the former use /I , the Latter used -I to specify include directories\r
68#\r
69gBuildOptIncludePatternMsft = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
70gBuildOptIncludePatternOther = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)\r
71\r
72#\r
73# Match name = variable\r
74#\r
75gEfiVarStoreNamePattern = re.compile("\s*name\s*=\s*(\w+)")\r
76#\r
77# The format of guid in efivarstore statement likes following and must be correct:\r
78# guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}\r
79#\r
80gEfiVarStoreGuidPattern = re.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")\r
81\r
82## Mapping Makefile type\r
83gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}\r
84\r
85\r
86## Build rule configuration file\r
87gDefaultBuildRuleFile = 'build_rule.txt'\r
88\r
89## Tools definition configuration file\r
90gDefaultToolsDefFile = 'tools_def.txt'\r
91\r
92## Build rule default version\r
93AutoGenReqBuildRuleVerNum = "0.1"\r
94\r
95## default file name for AutoGen\r
96gAutoGenCodeFileName = "AutoGen.c"\r
97gAutoGenHeaderFileName = "AutoGen.h"\r
98gAutoGenStringFileName = "%(module_name)sStrDefs.h"\r
99gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"\r
100gAutoGenDepexFileName = "%(module_name)s.depex"\r
101gAutoGenImageDefFileName = "%(module_name)sImgDefs.h"\r
102gAutoGenIdfFileName = "%(module_name)sIdf.hpk"\r
103gInfSpecVersion = "0x00010017"\r
104\r
105#\r
106# Template string to generic AsBuilt INF\r
107#\r
108gAsBuiltInfHeaderString = TemplateString("""${header_comments}\r
109\r
110# DO NOT EDIT\r
111# FILE auto-generated\r
112\r
113[Defines]\r
114 INF_VERSION = ${module_inf_version}\r
115 BASE_NAME = ${module_name}\r
116 FILE_GUID = ${module_guid}\r
117 MODULE_TYPE = ${module_module_type}${BEGIN}\r
118 VERSION_STRING = ${module_version_string}${END}${BEGIN}\r
119 PCD_IS_DRIVER = ${pcd_is_driver_string}${END}${BEGIN}\r
120 UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}\r
121 PI_SPECIFICATION_VERSION = ${module_pi_specification_version}${END}${BEGIN}\r
122 ENTRY_POINT = ${module_entry_point}${END}${BEGIN}\r
123 UNLOAD_IMAGE = ${module_unload_image}${END}${BEGIN}\r
124 CONSTRUCTOR = ${module_constructor}${END}${BEGIN}\r
125 DESTRUCTOR = ${module_destructor}${END}${BEGIN}\r
126 SHADOW = ${module_shadow}${END}${BEGIN}\r
127 PCI_VENDOR_ID = ${module_pci_vendor_id}${END}${BEGIN}\r
128 PCI_DEVICE_ID = ${module_pci_device_id}${END}${BEGIN}\r
129 PCI_CLASS_CODE = ${module_pci_class_code}${END}${BEGIN}\r
130 PCI_REVISION = ${module_pci_revision}${END}${BEGIN}\r
131 BUILD_NUMBER = ${module_build_number}${END}${BEGIN}\r
132 SPEC = ${module_spec}${END}${BEGIN}\r
133 UEFI_HII_RESOURCE_SECTION = ${module_uefi_hii_resource_section}${END}${BEGIN}\r
134 MODULE_UNI_FILE = ${module_uni_file}${END}\r
135\r
136[Packages.${module_arch}]${BEGIN}\r
137 ${package_item}${END}\r
138\r
139[Binaries.${module_arch}]${BEGIN}\r
140 ${binary_item}${END}\r
141\r
142[PatchPcd.${module_arch}]${BEGIN}\r
143 ${patchablepcd_item}\r
144${END}\r
145\r
146[Protocols.${module_arch}]${BEGIN}\r
147 ${protocol_item}\r
148${END}\r
149\r
150[Ppis.${module_arch}]${BEGIN}\r
151 ${ppi_item}\r
152${END}\r
153\r
154[Guids.${module_arch}]${BEGIN}\r
155 ${guid_item}\r
156${END}\r
157\r
158[PcdEx.${module_arch}]${BEGIN}\r
159 ${pcd_item}\r
160${END}\r
161\r
162[LibraryClasses.${module_arch}]\r
163## @LIB_INSTANCES${BEGIN}\r
164# ${libraryclasses_item}${END}\r
165\r
166${depexsection_item}\r
167\r
168${userextension_tianocore_item}\r
169\r
170${tail_comments}\r
171\r
172[BuildOptions.${module_arch}]\r
173## @AsBuilt${BEGIN}\r
174## ${flags_item}${END}\r
175""")\r
176\r
177## Base class for AutoGen\r
178#\r
179# This class just implements the cache mechanism of AutoGen objects.\r
180#\r
181class AutoGen(object):\r
182 # database to maintain the objects in each child class\r
183 __ObjectCache = {} # (BuildTarget, ToolChain, ARCH, platform file): AutoGen object\r
184\r
185 ## Factory method\r
186 #\r
187 # @param Class class object of real AutoGen class\r
188 # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)\r
189 # @param Workspace Workspace directory or WorkspaceAutoGen object\r
190 # @param MetaFile The path of meta file\r
191 # @param Target Build target\r
192 # @param Toolchain Tool chain name\r
193 # @param Arch Target arch\r
194 # @param *args The specific class related parameters\r
195 # @param **kwargs The specific class related dict parameters\r
196 #\r
197 def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
198 # check if the object has been created\r
199 Key = (Target, Toolchain, Arch, MetaFile)\r
200 if Key in cls.__ObjectCache:\r
201 # if it exists, just return it directly\r
202 return cls.__ObjectCache[Key]\r
203 # it didnt exist. create it, cache it, then return it\r
204 RetVal = cls.__ObjectCache[Key] = super(AutoGen, cls).__new__(cls)\r
205 return RetVal\r
206\r
207 def __init__ (self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
208 super(AutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
209\r
210 ## hash() operator\r
211 #\r
212 # The file path of platform file will be used to represent hash value of this object\r
213 #\r
214 # @retval int Hash value of the file path of platform file\r
215 #\r
216 def __hash__(self):\r
217 return hash(self.MetaFile)\r
218\r
219 ## str() operator\r
220 #\r
221 # The file path of platform file will be used to represent this object\r
222 #\r
223 # @retval string String of platform file path\r
224 #\r
225 def __str__(self):\r
226 return str(self.MetaFile)\r
227\r
228 ## "==" operator\r
229 def __eq__(self, Other):\r
230 return Other and self.MetaFile == Other\r
231\r
232## Workspace AutoGen class\r
233#\r
234# This class is used mainly to control the whole platform build for different\r
235# architecture. This class will generate top level makefile.\r
236#\r
237class WorkspaceAutoGen(AutoGen):\r
238 # call super().__init__ then call the worker function with different parameter count\r
239 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
240 if not hasattr(self, "_Init"):\r
241 super(WorkspaceAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
242 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
243 self._Init = True\r
244\r
245 ## Initialize WorkspaceAutoGen\r
246 #\r
247 # @param WorkspaceDir Root directory of workspace\r
248 # @param ActivePlatform Meta-file of active platform\r
249 # @param Target Build target\r
250 # @param Toolchain Tool chain name\r
251 # @param ArchList List of architecture of current build\r
252 # @param MetaFileDb Database containing meta-files\r
253 # @param BuildConfig Configuration of build\r
254 # @param ToolDefinition Tool chain definitions\r
255 # @param FlashDefinitionFile File of flash definition\r
256 # @param Fds FD list to be generated\r
257 # @param Fvs FV list to be generated\r
258 # @param Caps Capsule list to be generated\r
259 # @param SkuId SKU id from command line\r
260 #\r
261 def _InitWorker(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
262 BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None,\r
263 Progress=None, BuildModule=None):\r
264 self.BuildDatabase = MetaFileDb\r
265 self.MetaFile = ActivePlatform\r
266 self.WorkspaceDir = WorkspaceDir\r
267 self.Platform = self.BuildDatabase[self.MetaFile, TAB_ARCH_COMMON, Target, Toolchain]\r
268 GlobalData.gActivePlatform = self.Platform\r
269 self.BuildTarget = Target\r
270 self.ToolChain = Toolchain\r
271 self.ArchList = ArchList\r
272 self.SkuId = SkuId\r
273 self.UniFlag = UniFlag\r
274\r
275 self.TargetTxt = BuildConfig\r
276 self.ToolDef = ToolDefinition\r
277 self.FdfFile = FlashDefinitionFile\r
278 self.FdTargetList = Fds if Fds else []\r
279 self.FvTargetList = Fvs if Fvs else []\r
280 self.CapTargetList = Caps if Caps else []\r
281 self.AutoGenObjectList = []\r
282 self._BuildDir = None\r
283 self._FvDir = None\r
284 self._MakeFileDir = None\r
285 self._BuildCommand = None\r
286 self._GuidDict = {}\r
287\r
288 # there's many relative directory operations, so ...\r
289 os.chdir(self.WorkspaceDir)\r
290\r
291 #\r
292 # Merge Arch\r
293 #\r
294 if not self.ArchList:\r
295 ArchList = set(self.Platform.SupArchList)\r
296 else:\r
297 ArchList = set(self.ArchList) & set(self.Platform.SupArchList)\r
298 if not ArchList:\r
299 EdkLogger.error("build", PARAMETER_INVALID,\r
300 ExtraData = "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self.Platform.SupArchList)))\r
301 elif self.ArchList and len(ArchList) != len(self.ArchList):\r
302 SkippedArchList = set(self.ArchList).symmetric_difference(set(self.Platform.SupArchList))\r
303 EdkLogger.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"\r
304 % (" ".join(SkippedArchList), " ".join(self.Platform.SupArchList)))\r
305 self.ArchList = tuple(ArchList)\r
306\r
307 # Validate build target\r
308 if self.BuildTarget not in self.Platform.BuildTargets:\r
309 EdkLogger.error("build", PARAMETER_INVALID,\r
310 ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
311 % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
312\r
313\r
314 # parse FDF file to get PCDs in it, if any\r
315 if not self.FdfFile:\r
316 self.FdfFile = self.Platform.FlashDefinition\r
317\r
318 EdkLogger.info("")\r
319 if self.ArchList:\r
320 EdkLogger.info('%-16s = %s' % ("Architecture(s)", ' '.join(self.ArchList)))\r
321 EdkLogger.info('%-16s = %s' % ("Build target", self.BuildTarget))\r
322 EdkLogger.info('%-16s = %s' % ("Toolchain", self.ToolChain))\r
323\r
324 EdkLogger.info('\n%-24s = %s' % ("Active Platform", self.Platform))\r
325 if BuildModule:\r
326 EdkLogger.info('%-24s = %s' % ("Active Module", BuildModule))\r
327\r
328 if self.FdfFile:\r
329 EdkLogger.info('%-24s = %s' % ("Flash Image Definition", self.FdfFile))\r
330\r
331 EdkLogger.verbose("\nFLASH_DEFINITION = %s" % self.FdfFile)\r
332\r
333 if Progress:\r
334 Progress.Start("\nProcessing meta-data")\r
335\r
336 if self.FdfFile:\r
337 #\r
338 # Mark now build in AutoGen Phase\r
339 #\r
340 GlobalData.gAutoGenPhase = True\r
341 Fdf = FdfParser(self.FdfFile.Path)\r
342 Fdf.ParseFile()\r
343 GlobalData.gFdfParser = Fdf\r
344 GlobalData.gAutoGenPhase = False\r
345 PcdSet = Fdf.Profile.PcdDict\r
346 if Fdf.CurrentFdName and Fdf.CurrentFdName in Fdf.Profile.FdDict:\r
347 FdDict = Fdf.Profile.FdDict[Fdf.CurrentFdName]\r
348 for FdRegion in FdDict.RegionList:\r
349 if str(FdRegion.RegionType) is 'FILE' and self.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r
350 if int(FdRegion.Offset) % 8 != 0:\r
351 EdkLogger.error("build", FORMAT_INVALID, 'The VPD Base Address %s must be 8-byte aligned.' % (FdRegion.Offset))\r
352 ModuleList = Fdf.Profile.InfList\r
353 self.FdfProfile = Fdf.Profile\r
354 for fvname in self.FvTargetList:\r
355 if fvname.upper() not in self.FdfProfile.FvDict:\r
356 EdkLogger.error("build", OPTION_VALUE_INVALID,\r
357 "No such an FV in FDF file: %s" % fvname)\r
358\r
359 # In DSC file may use FILE_GUID to override the module, then in the Platform.Modules use FILE_GUIDmodule.inf as key,\r
360 # but the path (self.MetaFile.Path) is the real path\r
361 for key in self.FdfProfile.InfDict:\r
362 if key == 'ArchTBD':\r
363 MetaFile_cache = defaultdict(set)\r
364 for Arch in self.ArchList:\r
365 Current_Platform_cache = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
366 for Pkey in Current_Platform_cache.Modules:\r
367 MetaFile_cache[Arch].add(Current_Platform_cache.Modules[Pkey].MetaFile)\r
368 for Inf in self.FdfProfile.InfDict[key]:\r
369 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
370 for Arch in self.ArchList:\r
371 if ModuleFile in MetaFile_cache[Arch]:\r
372 break\r
373 else:\r
374 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]\r
375 if not ModuleData.IsBinaryModule:\r
376 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)\r
377\r
378 else:\r
379 for Arch in self.ArchList:\r
380 if Arch == key:\r
381 Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
382 MetaFileList = set()\r
383 for Pkey in Platform.Modules:\r
384 MetaFileList.add(Platform.Modules[Pkey].MetaFile)\r
385 for Inf in self.FdfProfile.InfDict[key]:\r
386 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
387 if ModuleFile in MetaFileList:\r
388 continue\r
389 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]\r
390 if not ModuleData.IsBinaryModule:\r
391 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)\r
392\r
393 else:\r
394 PcdSet = {}\r
395 ModuleList = []\r
396 self.FdfProfile = None\r
397 if self.FdTargetList:\r
398 EdkLogger.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self.FdTargetList))\r
399 self.FdTargetList = []\r
400 if self.FvTargetList:\r
401 EdkLogger.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self.FvTargetList))\r
402 self.FvTargetList = []\r
403 if self.CapTargetList:\r
404 EdkLogger.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self.CapTargetList))\r
405 self.CapTargetList = []\r
406\r
407 # apply SKU and inject PCDs from Flash Definition file\r
408 for Arch in self.ArchList:\r
409 Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
410 PlatformPcds = Platform.Pcds\r
411 self._GuidDict = Platform._GuidDict\r
412 SourcePcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set(),TAB_PCDS_DYNAMIC:set(),TAB_PCDS_FIXED_AT_BUILD:set()}\r
413 BinaryPcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set()}\r
414 SourcePcdDict_Keys = SourcePcdDict.keys()\r
415 BinaryPcdDict_Keys = BinaryPcdDict.keys()\r
416\r
417 # generate the SourcePcdDict and BinaryPcdDict\r
418 PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
419 for BuildData in PGen.BuildDatabase._CACHE_.values():\r
420 if BuildData.Arch != Arch:\r
421 continue\r
422 if BuildData.MetaFile.Ext == '.inf':\r
423 for key in BuildData.Pcds:\r
424 if BuildData.Pcds[key].Pending:\r
425 if key in Platform.Pcds:\r
426 PcdInPlatform = Platform.Pcds[key]\r
427 if PcdInPlatform.Type:\r
428 BuildData.Pcds[key].Type = PcdInPlatform.Type\r
429 BuildData.Pcds[key].Pending = False\r
430\r
431 if BuildData.MetaFile in Platform.Modules:\r
432 PlatformModule = Platform.Modules[str(BuildData.MetaFile)]\r
433 if key in PlatformModule.Pcds:\r
434 PcdInPlatform = PlatformModule.Pcds[key]\r
435 if PcdInPlatform.Type:\r
436 BuildData.Pcds[key].Type = PcdInPlatform.Type\r
437 BuildData.Pcds[key].Pending = False\r
438 else:\r
439 #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending\r
440 if BuildData.Pcds[key].Pending:\r
441 MGen = ModuleAutoGen(self, BuildData.MetaFile, Target, Toolchain, Arch, self.MetaFile)\r
442 if MGen and MGen.IsLibrary:\r
443 if MGen in PGen.LibraryAutoGenList:\r
444 ReferenceModules = MGen.ReferenceModules\r
445 for ReferenceModule in ReferenceModules:\r
446 if ReferenceModule.MetaFile in Platform.Modules:\r
447 RefPlatformModule = Platform.Modules[str(ReferenceModule.MetaFile)]\r
448 if key in RefPlatformModule.Pcds:\r
449 PcdInReferenceModule = RefPlatformModule.Pcds[key]\r
450 if PcdInReferenceModule.Type:\r
451 BuildData.Pcds[key].Type = PcdInReferenceModule.Type\r
452 BuildData.Pcds[key].Pending = False\r
453 break\r
454\r
455 if TAB_PCDS_DYNAMIC_EX in BuildData.Pcds[key].Type:\r
456 if BuildData.IsBinaryModule:\r
457 BinaryPcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
458 else:\r
459 SourcePcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
460\r
461 elif TAB_PCDS_PATCHABLE_IN_MODULE in BuildData.Pcds[key].Type:\r
462 if BuildData.MetaFile.Ext == '.inf':\r
463 if BuildData.IsBinaryModule:\r
464 BinaryPcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
465 else:\r
466 SourcePcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
467\r
468 elif TAB_PCDS_DYNAMIC in BuildData.Pcds[key].Type:\r
469 SourcePcdDict[TAB_PCDS_DYNAMIC].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
470 elif TAB_PCDS_FIXED_AT_BUILD in BuildData.Pcds[key].Type:\r
471 SourcePcdDict[TAB_PCDS_FIXED_AT_BUILD].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
472 else:\r
473 pass\r
474 #\r
475 # A PCD can only use one type for all source modules\r
476 #\r
477 for i in SourcePcdDict_Keys:\r
478 for j in SourcePcdDict_Keys:\r
479 if i != j:\r
480 Intersections = SourcePcdDict[i].intersection(SourcePcdDict[j])\r
481 if len(Intersections) > 0:\r
482 EdkLogger.error(\r
483 'build',\r
484 FORMAT_INVALID,\r
485 "Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i, j),\r
486 ExtraData='\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
487 )\r
488\r
489 #\r
490 # intersection the BinaryPCD for Mixed PCD\r
491 #\r
492 for i in BinaryPcdDict_Keys:\r
493 for j in BinaryPcdDict_Keys:\r
494 if i != j:\r
495 Intersections = BinaryPcdDict[i].intersection(BinaryPcdDict[j])\r
496 for item in Intersections:\r
497 NewPcd1 = (item[0] + '_' + i, item[1])\r
498 NewPcd2 = (item[0] + '_' + j, item[1])\r
499 if item not in GlobalData.MixedPcd:\r
500 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]\r
501 else:\r
502 if NewPcd1 not in GlobalData.MixedPcd[item]:\r
503 GlobalData.MixedPcd[item].append(NewPcd1)\r
504 if NewPcd2 not in GlobalData.MixedPcd[item]:\r
505 GlobalData.MixedPcd[item].append(NewPcd2)\r
506\r
507 #\r
508 # intersection the SourcePCD and BinaryPCD for Mixed PCD\r
509 #\r
510 for i in SourcePcdDict_Keys:\r
511 for j in BinaryPcdDict_Keys:\r
512 if i != j:\r
513 Intersections = SourcePcdDict[i].intersection(BinaryPcdDict[j])\r
514 for item in Intersections:\r
515 NewPcd1 = (item[0] + '_' + i, item[1])\r
516 NewPcd2 = (item[0] + '_' + j, item[1])\r
517 if item not in GlobalData.MixedPcd:\r
518 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]\r
519 else:\r
520 if NewPcd1 not in GlobalData.MixedPcd[item]:\r
521 GlobalData.MixedPcd[item].append(NewPcd1)\r
522 if NewPcd2 not in GlobalData.MixedPcd[item]:\r
523 GlobalData.MixedPcd[item].append(NewPcd2)\r
524\r
525 for BuildData in PGen.BuildDatabase._CACHE_.values():\r
526 if BuildData.Arch != Arch:\r
527 continue\r
528 for key in BuildData.Pcds:\r
529 for SinglePcd in GlobalData.MixedPcd:\r
530 if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
531 for item in GlobalData.MixedPcd[SinglePcd]:\r
532 Pcd_Type = item[0].split('_')[-1]\r
533 if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
534 (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
535 Value = BuildData.Pcds[key]\r
536 Value.TokenCName = BuildData.Pcds[key].TokenCName + '_' + Pcd_Type\r
537 if len(key) == 2:\r
538 newkey = (Value.TokenCName, key[1])\r
539 elif len(key) == 3:\r
540 newkey = (Value.TokenCName, key[1], key[2])\r
541 del BuildData.Pcds[key]\r
542 BuildData.Pcds[newkey] = Value\r
543 break\r
544 break\r
545\r
546 # handle the mixed pcd in FDF file\r
547 for key in PcdSet:\r
548 if key in GlobalData.MixedPcd:\r
549 Value = PcdSet[key]\r
550 del PcdSet[key]\r
551 for item in GlobalData.MixedPcd[key]:\r
552 PcdSet[item] = Value\r
553\r
554 #Collect package set information from INF of FDF\r
555 PkgSet = set()\r
556 for Inf in ModuleList:\r
557 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
558 if ModuleFile in Platform.Modules:\r
559 continue\r
560 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]\r
561 PkgSet.update(ModuleData.Packages)\r
562 Pkgs = list(PkgSet) + list(PGen.PackageList)\r
563 DecPcds = set()\r
564 DecPcdsKey = set()\r
565 for Pkg in Pkgs:\r
566 for Pcd in Pkg.Pcds:\r
567 DecPcds.add((Pcd[0], Pcd[1]))\r
568 DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))\r
569\r
570 Platform.SkuName = self.SkuId\r
571 for Name, Guid,Fileds in PcdSet:\r
572 if (Name, Guid) not in DecPcds:\r
573 EdkLogger.error(\r
574 'build',\r
575 PARSER_ERROR,\r
576 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid, Name),\r
577 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
578 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
579 )\r
580 else:\r
581 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.\r
582 if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \\r
583 or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \\r
584 or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:\r
585 continue\r
586 elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:\r
587 EdkLogger.error(\r
588 'build',\r
589 PARSER_ERROR,\r
590 "Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid, Name),\r
591 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
592 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
593 )\r
594\r
595 Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
596 #\r
597 # Explicitly collect platform's dynamic PCDs\r
598 #\r
599 Pa.CollectPlatformDynamicPcds()\r
600 Pa.CollectFixedAtBuildPcds()\r
601 self.AutoGenObjectList.append(Pa)\r
602\r
603 #\r
604 # Generate Package level hash value\r
605 #\r
606 GlobalData.gPackageHash[Arch] = {}\r
607 if GlobalData.gUseHashCache:\r
608 for Pkg in Pkgs:\r
609 self._GenPkgLevelHash(Pkg)\r
610\r
611 #\r
612 # Check PCDs token value conflict in each DEC file.\r
613 #\r
614 self._CheckAllPcdsTokenValueConflict()\r
615\r
616 #\r
617 # Check PCD type and definition between DSC and DEC\r
618 #\r
619 self._CheckPcdDefineAndType()\r
620\r
621 #\r
622 # Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.\r
623 #\r
624 content = 'gCommandLineDefines: '\r
625 content += str(GlobalData.gCommandLineDefines)\r
626 content += os.linesep\r
627 content += 'BuildOptionPcd: '\r
628 content += str(GlobalData.BuildOptionPcd)\r
629 content += os.linesep\r
630 content += 'Active Platform: '\r
631 content += str(self.Platform)\r
632 content += os.linesep\r
633 if self.FdfFile:\r
634 content += 'Flash Image Definition: '\r
635 content += str(self.FdfFile)\r
636 content += os.linesep\r
637 SaveFileOnChange(os.path.join(self.BuildDir, 'BuildOptions'), content, False)\r
638\r
639 #\r
640 # Create PcdToken Number file for Dynamic/DynamicEx Pcd.\r
641 #\r
642 PcdTokenNumber = 'PcdTokenNumber: '\r
643 if Pa.PcdTokenNumber:\r
644 if Pa.DynamicPcdList:\r
645 for Pcd in Pa.DynamicPcdList:\r
646 PcdTokenNumber += os.linesep\r
647 PcdTokenNumber += str((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
648 PcdTokenNumber += ' : '\r
649 PcdTokenNumber += str(Pa.PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName])\r
650 SaveFileOnChange(os.path.join(self.BuildDir, 'PcdTokenNumber'), PcdTokenNumber, False)\r
651\r
652 #\r
653 # Get set of workspace metafiles\r
654 #\r
655 AllWorkSpaceMetaFiles = self._GetMetaFiles(Target, Toolchain, Arch)\r
656\r
657 #\r
658 # Retrieve latest modified time of all metafiles\r
659 #\r
660 SrcTimeStamp = 0\r
661 for f in AllWorkSpaceMetaFiles:\r
662 if os.stat(f)[8] > SrcTimeStamp:\r
663 SrcTimeStamp = os.stat(f)[8]\r
664 self._SrcTimeStamp = SrcTimeStamp\r
665\r
666 if GlobalData.gUseHashCache:\r
667 m = hashlib.md5()\r
668 for files in AllWorkSpaceMetaFiles:\r
669 if files.endswith('.dec'):\r
670 continue\r
671 f = open(files, 'r')\r
672 Content = f.read()\r
673 f.close()\r
674 m.update(Content)\r
675 SaveFileOnChange(os.path.join(self.BuildDir, 'AutoGen.hash'), m.hexdigest(), True)\r
676 GlobalData.gPlatformHash = m.hexdigest()\r
677\r
678 #\r
679 # Write metafile list to build directory\r
680 #\r
681 AutoGenFilePath = os.path.join(self.BuildDir, 'AutoGen')\r
682 if os.path.exists (AutoGenFilePath):\r
683 os.remove(AutoGenFilePath)\r
684 if not os.path.exists(self.BuildDir):\r
685 os.makedirs(self.BuildDir)\r
686 with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:\r
687 for f in AllWorkSpaceMetaFiles:\r
688 print(f, file=file)\r
689 return True\r
690\r
691 def _GenPkgLevelHash(self, Pkg):\r
692 if Pkg.PackageName in GlobalData.gPackageHash[Pkg.Arch]:\r
693 return\r
694\r
695 PkgDir = os.path.join(self.BuildDir, Pkg.Arch, Pkg.PackageName)\r
696 CreateDirectory(PkgDir)\r
697 HashFile = os.path.join(PkgDir, Pkg.PackageName + '.hash')\r
698 m = hashlib.md5()\r
699 # Get .dec file's hash value\r
700 f = open(Pkg.MetaFile.Path, 'r')\r
701 Content = f.read()\r
702 f.close()\r
703 m.update(Content)\r
704 # Get include files hash value\r
705 if Pkg.Includes:\r
706 for inc in sorted(Pkg.Includes, key=lambda x: str(x)):\r
707 for Root, Dirs, Files in os.walk(str(inc)):\r
708 for File in sorted(Files):\r
709 File_Path = os.path.join(Root, File)\r
710 f = open(File_Path, 'r')\r
711 Content = f.read()\r
712 f.close()\r
713 m.update(Content)\r
714 SaveFileOnChange(HashFile, m.hexdigest(), True)\r
715 GlobalData.gPackageHash[Pkg.Arch][Pkg.PackageName] = m.hexdigest()\r
716\r
717 def _GetMetaFiles(self, Target, Toolchain, Arch):\r
718 AllWorkSpaceMetaFiles = set()\r
719 #\r
720 # add fdf\r
721 #\r
722 if self.FdfFile:\r
723 AllWorkSpaceMetaFiles.add (self.FdfFile.Path)\r
724 for f in GlobalData.gFdfParser.GetAllIncludedFile():\r
725 AllWorkSpaceMetaFiles.add (f.FileName)\r
726 #\r
727 # add dsc\r
728 #\r
729 AllWorkSpaceMetaFiles.add(self.MetaFile.Path)\r
730\r
731 #\r
732 # add build_rule.txt & tools_def.txt\r
733 #\r
734 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultBuildRuleFile))\r
735 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultToolsDefFile))\r
736\r
737 # add BuildOption metafile\r
738 #\r
739 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'BuildOptions'))\r
740\r
741 # add PcdToken Number file for Dynamic/DynamicEx Pcd\r
742 #\r
743 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'PcdTokenNumber'))\r
744\r
745 for Arch in self.ArchList:\r
746 #\r
747 # add dec\r
748 #\r
749 for Package in PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch).PackageList:\r
750 AllWorkSpaceMetaFiles.add(Package.MetaFile.Path)\r
751\r
752 #\r
753 # add included dsc\r
754 #\r
755 for filePath in self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]._RawData.IncludedFiles:\r
756 AllWorkSpaceMetaFiles.add(filePath.Path)\r
757\r
758 return AllWorkSpaceMetaFiles\r
759\r
760 def _CheckPcdDefineAndType(self):\r
761 PcdTypeSet = {TAB_PCDS_FIXED_AT_BUILD,\r
762 TAB_PCDS_PATCHABLE_IN_MODULE,\r
763 TAB_PCDS_FEATURE_FLAG,\r
764 TAB_PCDS_DYNAMIC,\r
765 TAB_PCDS_DYNAMIC_EX}\r
766\r
767 # This dict store PCDs which are not used by any modules with specified arches\r
768 UnusedPcd = OrderedDict()\r
769 for Pa in self.AutoGenObjectList:\r
770 # Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid\r
771 for Pcd in Pa.Platform.Pcds:\r
772 PcdType = Pa.Platform.Pcds[Pcd].Type\r
773\r
774 # If no PCD type, this PCD comes from FDF\r
775 if not PcdType:\r
776 continue\r
777\r
778 # Try to remove Hii and Vpd suffix\r
779 if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r
780 PcdType = TAB_PCDS_DYNAMIC_EX\r
781 elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r
782 PcdType = TAB_PCDS_DYNAMIC\r
783\r
784 for Package in Pa.PackageList:\r
785 # Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
786 if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
787 break\r
788 for Type in PcdTypeSet:\r
789 if (Pcd[0], Pcd[1], Type) in Package.Pcds:\r
790 EdkLogger.error(\r
791 'build',\r
792 FORMAT_INVALID,\r
793 "Type [%s] of PCD [%s.%s] in DSC file doesn't match the type [%s] defined in DEC file." \\r
794 % (Pa.Platform.Pcds[Pcd].Type, Pcd[1], Pcd[0], Type),\r
795 ExtraData=None\r
796 )\r
797 return\r
798 else:\r
799 UnusedPcd.setdefault(Pcd, []).append(Pa.Arch)\r
800\r
801 for Pcd in UnusedPcd:\r
802 EdkLogger.warn(\r
803 'build',\r
804 "The PCD was not specified by any INF module in the platform for the given architecture.\n"\r
805 "\tPCD: [%s.%s]\n\tPlatform: [%s]\n\tArch: %s"\r
806 % (Pcd[1], Pcd[0], os.path.basename(str(self.MetaFile)), str(UnusedPcd[Pcd])),\r
807 ExtraData=None\r
808 )\r
809\r
810 def __repr__(self):\r
811 return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))\r
812\r
813 ## Return the directory to store FV files\r
814 def _GetFvDir(self):\r
815 if self._FvDir is None:\r
816 self._FvDir = path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
817 return self._FvDir\r
818\r
819 ## Return the directory to store all intermediate and final files built\r
820 def _GetBuildDir(self):\r
821 if self._BuildDir is None:\r
822 return self.AutoGenObjectList[0].BuildDir\r
823\r
824 ## Return the build output directory platform specifies\r
825 def _GetOutputDir(self):\r
826 return self.Platform.OutputDirectory\r
827\r
828 ## Return platform name\r
829 def _GetName(self):\r
830 return self.Platform.PlatformName\r
831\r
832 ## Return meta-file GUID\r
833 def _GetGuid(self):\r
834 return self.Platform.Guid\r
835\r
836 ## Return platform version\r
837 def _GetVersion(self):\r
838 return self.Platform.Version\r
839\r
840 ## Return paths of tools\r
841 def _GetToolDefinition(self):\r
842 return self.AutoGenObjectList[0].ToolDefinition\r
843\r
844 ## Return directory of platform makefile\r
845 #\r
846 # @retval string Makefile directory\r
847 #\r
848 def _GetMakeFileDir(self):\r
849 if self._MakeFileDir is None:\r
850 self._MakeFileDir = self.BuildDir\r
851 return self._MakeFileDir\r
852\r
853 ## Return build command string\r
854 #\r
855 # @retval string Build command string\r
856 #\r
857 def _GetBuildCommand(self):\r
858 if self._BuildCommand is None:\r
859 # BuildCommand should be all the same. So just get one from platform AutoGen\r
860 self._BuildCommand = self.AutoGenObjectList[0].BuildCommand\r
861 return self._BuildCommand\r
862\r
863 ## Check the PCDs token value conflict in each DEC file.\r
864 #\r
865 # Will cause build break and raise error message while two PCDs conflict.\r
866 #\r
867 # @return None\r
868 #\r
869 def _CheckAllPcdsTokenValueConflict(self):\r
870 for Pa in self.AutoGenObjectList:\r
871 for Package in Pa.PackageList:\r
872 PcdList = Package.Pcds.values()\r
873 PcdList.sort(lambda x, y: cmp(int(x.TokenValue, 0), int(y.TokenValue, 0)))\r
874 Count = 0\r
875 while (Count < len(PcdList) - 1) :\r
876 Item = PcdList[Count]\r
877 ItemNext = PcdList[Count + 1]\r
878 #\r
879 # Make sure in the same token space the TokenValue should be unique\r
880 #\r
881 if (int(Item.TokenValue, 0) == int(ItemNext.TokenValue, 0)):\r
882 SameTokenValuePcdList = []\r
883 SameTokenValuePcdList.append(Item)\r
884 SameTokenValuePcdList.append(ItemNext)\r
885 RemainPcdListLength = len(PcdList) - Count - 2\r
886 for ValueSameCount in range(RemainPcdListLength):\r
887 if int(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue, 0) == int(Item.TokenValue, 0):\r
888 SameTokenValuePcdList.append(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount])\r
889 else:\r
890 break;\r
891 #\r
892 # Sort same token value PCD list with TokenGuid and TokenCName\r
893 #\r
894 SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
895 SameTokenValuePcdListCount = 0\r
896 while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):\r
897 Flag = False\r
898 TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]\r
899 TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1]\r
900\r
901 if (TemListItem.TokenSpaceGuidCName == TemListItemNext.TokenSpaceGuidCName) and (TemListItem.TokenCName != TemListItemNext.TokenCName):\r
902 for PcdItem in GlobalData.MixedPcd:\r
903 if (TemListItem.TokenCName, TemListItem.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem] or \\r
904 (TemListItemNext.TokenCName, TemListItemNext.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
905 Flag = True\r
906 if not Flag:\r
907 EdkLogger.error(\r
908 'build',\r
909 FORMAT_INVALID,\r
910 "The TokenValue [%s] of PCD [%s.%s] is conflict with: [%s.%s] in %s"\\r
911 % (TemListItem.TokenValue, TemListItem.TokenSpaceGuidCName, TemListItem.TokenCName, TemListItemNext.TokenSpaceGuidCName, TemListItemNext.TokenCName, Package),\r
912 ExtraData=None\r
913 )\r
914 SameTokenValuePcdListCount += 1\r
915 Count += SameTokenValuePcdListCount\r
916 Count += 1\r
917\r
918 PcdList = Package.Pcds.values()\r
919 PcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))\r
920 Count = 0\r
921 while (Count < len(PcdList) - 1) :\r
922 Item = PcdList[Count]\r
923 ItemNext = PcdList[Count + 1]\r
924 #\r
925 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.\r
926 #\r
927 if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (int(Item.TokenValue, 0) != int(ItemNext.TokenValue, 0)):\r
928 EdkLogger.error(\r
929 'build',\r
930 FORMAT_INVALID,\r
931 "The TokenValue [%s] of PCD [%s.%s] in %s defined in two places should be same as well."\\r
932 % (Item.TokenValue, Item.TokenSpaceGuidCName, Item.TokenCName, Package),\r
933 ExtraData=None\r
934 )\r
935 Count += 1\r
936 ## Generate fds command\r
937 def _GenFdsCommand(self):\r
938 return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()\r
939\r
940 ## Create makefile for the platform and modules in it\r
941 #\r
942 # @param CreateDepsMakeFile Flag indicating if the makefile for\r
943 # modules will be created as well\r
944 #\r
945 def CreateMakeFile(self, CreateDepsMakeFile=False):\r
946 if not CreateDepsMakeFile:\r
947 return\r
948 for Pa in self.AutoGenObjectList:\r
949 Pa.CreateMakeFile(True)\r
950\r
951 ## Create autogen code for platform and modules\r
952 #\r
953 # Since there's no autogen code for platform, this method will do nothing\r
954 # if CreateModuleCodeFile is set to False.\r
955 #\r
956 # @param CreateDepsCodeFile Flag indicating if creating module's\r
957 # autogen code file or not\r
958 #\r
959 def CreateCodeFile(self, CreateDepsCodeFile=False):\r
960 if not CreateDepsCodeFile:\r
961 return\r
962 for Pa in self.AutoGenObjectList:\r
963 Pa.CreateCodeFile(True)\r
964\r
965 ## Create AsBuilt INF file the platform\r
966 #\r
967 def CreateAsBuiltInf(self):\r
968 return\r
969\r
970 Name = property(_GetName)\r
971 Guid = property(_GetGuid)\r
972 Version = property(_GetVersion)\r
973 OutputDir = property(_GetOutputDir)\r
974\r
975 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
976\r
977 BuildDir = property(_GetBuildDir)\r
978 FvDir = property(_GetFvDir)\r
979 MakeFileDir = property(_GetMakeFileDir)\r
980 BuildCommand = property(_GetBuildCommand)\r
981 GenFdsCommand = property(_GenFdsCommand)\r
982\r
983## AutoGen class for platform\r
984#\r
985# PlatformAutoGen class will process the original information in platform\r
986# file in order to generate makefile for platform.\r
987#\r
988class PlatformAutoGen(AutoGen):\r
989 # call super().__init__ then call the worker function with different parameter count\r
990 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
991 if not hasattr(self, "_Init"):\r
992 super(PlatformAutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
993 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)\r
994 self._Init = True\r
995 #\r
996 # Used to store all PCDs for both PEI and DXE phase, in order to generate\r
997 # correct PCD database\r
998 #\r
999 _DynaPcdList_ = []\r
1000 _NonDynaPcdList_ = []\r
1001 _PlatformPcds = {}\r
1002\r
1003 #\r
1004 # The priority list while override build option\r
1005 #\r
1006 PrioList = {"0x11111" : 16, # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE (Highest)\r
1007 "0x01111" : 15, # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
1008 "0x10111" : 14, # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE\r
1009 "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE\r
1010 "0x11011" : 12, # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
1011 "0x01011" : 11, # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
1012 "0x10011" : 10, # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE\r
1013 "0x00011" : 9, # ******_*********_****_COMMANDTYPE_ATTRIBUTE\r
1014 "0x11101" : 8, # TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE\r
1015 "0x01101" : 7, # ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE\r
1016 "0x10101" : 6, # TARGET_*********_ARCH_***********_ATTRIBUTE\r
1017 "0x00101" : 5, # ******_*********_ARCH_***********_ATTRIBUTE\r
1018 "0x11001" : 4, # TARGET_TOOLCHAIN_****_***********_ATTRIBUTE\r
1019 "0x01001" : 3, # ******_TOOLCHAIN_****_***********_ATTRIBUTE\r
1020 "0x10001" : 2, # TARGET_*********_****_***********_ATTRIBUTE\r
1021 "0x00001" : 1} # ******_*********_****_***********_ATTRIBUTE (Lowest)\r
1022\r
1023 ## Initialize PlatformAutoGen\r
1024 #\r
1025 #\r
1026 # @param Workspace WorkspaceAutoGen object\r
1027 # @param PlatformFile Platform file (DSC file)\r
1028 # @param Target Build target (DEBUG, RELEASE)\r
1029 # @param Toolchain Name of tool chain\r
1030 # @param Arch arch of the platform supports\r
1031 #\r
1032 def _InitWorker(self, Workspace, PlatformFile, Target, Toolchain, Arch):\r
1033 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))\r
1034 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)\r
1035\r
1036 self.MetaFile = PlatformFile\r
1037 self.Workspace = Workspace\r
1038 self.WorkspaceDir = Workspace.WorkspaceDir\r
1039 self.ToolChain = Toolchain\r
1040 self.BuildTarget = Target\r
1041 self.Arch = Arch\r
1042 self.SourceDir = PlatformFile.SubDir\r
1043 self.SourceOverrideDir = None\r
1044 self.FdTargetList = self.Workspace.FdTargetList\r
1045 self.FvTargetList = self.Workspace.FvTargetList\r
1046 self.AllPcdList = []\r
1047 # get the original module/package/platform objects\r
1048 self.BuildDatabase = Workspace.BuildDatabase\r
1049 self.DscBuildDataObj = Workspace.Platform\r
1050 self._GuidDict = Workspace._GuidDict\r
1051\r
1052 # flag indicating if the makefile/C-code file has been created or not\r
1053 self.IsMakeFileCreated = False\r
1054 self.IsCodeFileCreated = False\r
1055\r
1056 self._Platform = None\r
1057 self._Name = None\r
1058 self._Guid = None\r
1059 self._Version = None\r
1060\r
1061 self._BuildRule = None\r
1062 self._SourceDir = None\r
1063 self._BuildDir = None\r
1064 self._OutputDir = None\r
1065 self._FvDir = None\r
1066 self._MakeFileDir = None\r
1067 self._FdfFile = None\r
1068\r
1069 self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
1070 self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
1071 self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
1072 self._NonDynamicPcdDict = {}\r
1073\r
1074 self._ToolDefinitions = None\r
1075 self._ToolDefFile = None # toolcode : tool path\r
1076 self._ToolChainFamily = None\r
1077 self._BuildRuleFamily = None\r
1078 self._BuildOption = None # toolcode : option\r
1079 self._EdkBuildOption = None # edktoolcode : option\r
1080 self._EdkIIBuildOption = None # edkiitoolcode : option\r
1081 self._PackageList = None\r
1082 self._ModuleAutoGenList = None\r
1083 self._LibraryAutoGenList = None\r
1084 self._BuildCommand = None\r
1085 self._AsBuildInfList = []\r
1086 self._AsBuildModuleList = []\r
1087\r
1088 self.VariableInfo = None\r
1089\r
1090 if GlobalData.gFdfParser is not None:\r
1091 self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList\r
1092 for Inf in self._AsBuildInfList:\r
1093 InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)\r
1094 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
1095 if not M.IsSupportedArch:\r
1096 continue\r
1097 self._AsBuildModuleList.append(InfClass)\r
1098 # get library/modules for build\r
1099 self.LibraryBuildDirectoryList = []\r
1100 self.ModuleBuildDirectoryList = []\r
1101\r
1102 return True\r
1103\r
1104 def __repr__(self):\r
1105 return "%s [%s]" % (self.MetaFile, self.Arch)\r
1106\r
1107 ## Create autogen code for platform and modules\r
1108 #\r
1109 # Since there's no autogen code for platform, this method will do nothing\r
1110 # if CreateModuleCodeFile is set to False.\r
1111 #\r
1112 # @param CreateModuleCodeFile Flag indicating if creating module's\r
1113 # autogen code file or not\r
1114 #\r
1115 def CreateCodeFile(self, CreateModuleCodeFile=False):\r
1116 # only module has code to be greated, so do nothing if CreateModuleCodeFile is False\r
1117 if self.IsCodeFileCreated or not CreateModuleCodeFile:\r
1118 return\r
1119\r
1120 for Ma in self.ModuleAutoGenList:\r
1121 Ma.CreateCodeFile(True)\r
1122\r
1123 # don't do this twice\r
1124 self.IsCodeFileCreated = True\r
1125\r
1126 ## Generate Fds Command\r
1127 def _GenFdsCommand(self):\r
1128 return self.Workspace.GenFdsCommand\r
1129\r
1130 ## Create makefile for the platform and mdoules in it\r
1131 #\r
1132 # @param CreateModuleMakeFile Flag indicating if the makefile for\r
1133 # modules will be created as well\r
1134 #\r
1135 def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}):\r
1136 if CreateModuleMakeFile:\r
1137 for ModuleFile in self.Platform.Modules:\r
1138 Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,\r
1139 self.ToolChain, self.Arch, self.MetaFile)\r
1140 if (ModuleFile.File, self.Arch) in FfsCommand:\r
1141 Ma.CreateMakeFile(True, FfsCommand[ModuleFile.File, self.Arch])\r
1142 else:\r
1143 Ma.CreateMakeFile(True)\r
1144 #Ma.CreateAsBuiltInf()\r
1145\r
1146 # no need to create makefile for the platform more than once\r
1147 if self.IsMakeFileCreated:\r
1148 return\r
1149\r
1150 # create library/module build dirs for platform\r
1151 Makefile = GenMake.PlatformMakefile(self)\r
1152 self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()\r
1153 self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()\r
1154\r
1155 self.IsMakeFileCreated = True\r
1156\r
1157 ## Deal with Shared FixedAtBuild Pcds\r
1158 #\r
1159 def CollectFixedAtBuildPcds(self):\r
1160 for LibAuto in self.LibraryAutoGenList:\r
1161 FixedAtBuildPcds = {}\r
1162 ShareFixedAtBuildPcdsSameValue = {}\r
1163 for Module in LibAuto.ReferenceModules:\r
1164 for Pcd in set(Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds):\r
1165 DefaultValue = Pcd.DefaultValue\r
1166 # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib\r
1167 if Pcd in Module.LibraryPcdList:\r
1168 Index = Module.LibraryPcdList.index(Pcd)\r
1169 DefaultValue = Module.LibraryPcdList[Index].DefaultValue\r
1170 key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
1171 if key not in FixedAtBuildPcds:\r
1172 ShareFixedAtBuildPcdsSameValue[key] = True\r
1173 FixedAtBuildPcds[key] = DefaultValue\r
1174 else:\r
1175 if FixedAtBuildPcds[key] != DefaultValue:\r
1176 ShareFixedAtBuildPcdsSameValue[key] = False\r
1177 for Pcd in LibAuto.FixedAtBuildPcds:\r
1178 key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
1179 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
1180 continue\r
1181 else:\r
1182 DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]\r
1183 if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
1184 continue\r
1185 if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]:\r
1186 LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]\r
1187\r
1188 def CollectVariables(self, DynamicPcdSet):\r
1189\r
1190 VpdRegionSize = 0\r
1191 VpdRegionBase = 0\r
1192 if self.Workspace.FdfFile:\r
1193 FdDict = self.Workspace.FdfProfile.FdDict[GlobalData.gFdfParser.CurrentFdName]\r
1194 for FdRegion in FdDict.RegionList:\r
1195 for item in FdRegion.RegionDataList:\r
1196 if self.Platform.VpdToolGuid.strip() and self.Platform.VpdToolGuid in item:\r
1197 VpdRegionSize = FdRegion.Size\r
1198 VpdRegionBase = FdRegion.Offset\r
1199 break\r
1200\r
1201\r
1202 VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj._GetSkuIds())\r
1203 VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)\r
1204 VariableInfo.SetVpdRegionOffset(VpdRegionBase)\r
1205 Index = 0\r
1206 for Pcd in DynamicPcdSet:\r
1207 pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
1208 for SkuName in Pcd.SkuInfoList:\r
1209 Sku = Pcd.SkuInfoList[SkuName]\r
1210 SkuId = Sku.SkuId\r
1211 if SkuId is None or SkuId == '':\r
1212 continue\r
1213 if len(Sku.VariableName) > 0:\r
1214 VariableGuidStructure = Sku.VariableGuidValue\r
1215 VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)\r
1216 for StorageName in Sku.DefaultStoreDict:\r
1217 VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName], Pcd.DatumType))\r
1218 Index += 1\r
1219 return VariableInfo\r
1220\r
1221 def UpdateNVStoreMaxSize(self, OrgVpdFile):\r
1222 if self.VariableInfo:\r
1223 VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
1224 PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]\r
1225\r
1226 if PcdNvStoreDfBuffer:\r
1227 if os.path.exists(VpdMapFilePath):\r
1228 OrgVpdFile.Read(VpdMapFilePath)\r
1229 PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])\r
1230 NvStoreOffset = PcdItems.values()[0].strip() if PcdItems else '0'\r
1231 else:\r
1232 EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
1233\r
1234 NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)\r
1235 default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)\r
1236 maxsize = self.VariableInfo.VpdRegionSize - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))\r
1237 var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)\r
1238\r
1239 if var_data and default_skuobj:\r
1240 default_skuobj.DefaultValue = var_data\r
1241 PcdNvStoreDfBuffer[0].DefaultValue = var_data\r
1242 PcdNvStoreDfBuffer[0].SkuInfoList.clear()\r
1243 PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj\r
1244 PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))\r
1245\r
1246 return OrgVpdFile\r
1247\r
1248 ## Collect dynamic PCDs\r
1249 #\r
1250 # Gather dynamic PCDs list from each module and their settings from platform\r
1251 # This interface should be invoked explicitly when platform action is created.\r
1252 #\r
1253 def CollectPlatformDynamicPcds(self):\r
1254\r
1255 for key in self.Platform.Pcds:\r
1256 for SinglePcd in GlobalData.MixedPcd:\r
1257 if (self.Platform.Pcds[key].TokenCName, self.Platform.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
1258 for item in GlobalData.MixedPcd[SinglePcd]:\r
1259 Pcd_Type = item[0].split('_')[-1]\r
1260 if (Pcd_Type == self.Platform.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and self.Platform.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
1261 (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
1262 Value = self.Platform.Pcds[key]\r
1263 Value.TokenCName = self.Platform.Pcds[key].TokenCName + '_' + Pcd_Type\r
1264 if len(key) == 2:\r
1265 newkey = (Value.TokenCName, key[1])\r
1266 elif len(key) == 3:\r
1267 newkey = (Value.TokenCName, key[1], key[2])\r
1268 del self.Platform.Pcds[key]\r
1269 self.Platform.Pcds[newkey] = Value\r
1270 break\r
1271 break\r
1272\r
1273 # for gathering error information\r
1274 NoDatumTypePcdList = set()\r
1275 FdfModuleList = []\r
1276 for InfName in self._AsBuildInfList:\r
1277 InfName = mws.join(self.WorkspaceDir, InfName)\r
1278 FdfModuleList.append(os.path.normpath(InfName))\r
1279 for F in self.Platform.Modules.keys():\r
1280 M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)\r
1281 #GuidValue.update(M.Guids)\r
1282\r
1283 self.Platform.Modules[F].M = M\r
1284\r
1285 for PcdFromModule in M.ModulePcdList + M.LibraryPcdList:\r
1286 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
1287 if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
1288 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
1289\r
1290 # Check the PCD from Binary INF or Source INF\r
1291 if M.IsBinaryModule == True:\r
1292 PcdFromModule.IsFromBinaryInf = True\r
1293\r
1294 # Check the PCD from DSC or not\r
1295 PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds\r
1296\r
1297 if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1298 if F.Path not in FdfModuleList:\r
1299 # If one of the Source built modules listed in the DSC is not listed\r
1300 # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic\r
1301 # access method (it is only listed in the DEC file that declares the\r
1302 # PCD as PcdsDynamic), then build tool will report warning message\r
1303 # notify the PI that they are attempting to build a module that must\r
1304 # be included in a flash image in order to be functional. These Dynamic\r
1305 # PCD will not be added into the Database unless it is used by other\r
1306 # modules that are included in the FDF file.\r
1307 if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \\r
1308 PcdFromModule.IsFromBinaryInf == False:\r
1309 # Print warning message to let the developer make a determine.\r
1310 continue\r
1311 # If one of the Source built modules listed in the DSC is not listed in\r
1312 # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx\r
1313 # access method (it is only listed in the DEC file that declares the\r
1314 # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the\r
1315 # PCD to the Platform's PCD Database.\r
1316 if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1317 continue\r
1318 #\r
1319 # If a dynamic PCD used by a PEM module/PEI module & DXE module,\r
1320 # it should be stored in Pcd PEI database, If a dynamic only\r
1321 # used by DXE module, it should be stored in DXE PCD database.\r
1322 # The default Phase is DXE\r
1323 #\r
1324 if M.ModuleType in SUP_MODULE_SET_PEI:\r
1325 PcdFromModule.Phase = "PEI"\r
1326 if PcdFromModule not in self._DynaPcdList_:\r
1327 self._DynaPcdList_.append(PcdFromModule)\r
1328 elif PcdFromModule.Phase == 'PEI':\r
1329 # overwrite any the same PCD existing, if Phase is PEI\r
1330 Index = self._DynaPcdList_.index(PcdFromModule)\r
1331 self._DynaPcdList_[Index] = PcdFromModule\r
1332 elif PcdFromModule not in self._NonDynaPcdList_:\r
1333 self._NonDynaPcdList_.append(PcdFromModule)\r
1334 elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:\r
1335 Index = self._NonDynaPcdList_.index(PcdFromModule)\r
1336 if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:\r
1337 #The PCD from Binary INF will override the same one from source INF\r
1338 self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])\r
1339 PcdFromModule.Pending = False\r
1340 self._NonDynaPcdList_.append (PcdFromModule)\r
1341 DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}\r
1342 # add the PCD from modules that listed in FDF but not in DSC to Database\r
1343 for InfName in FdfModuleList:\r
1344 if InfName not in DscModuleSet:\r
1345 InfClass = PathClass(InfName)\r
1346 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
1347 # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)\r
1348 # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.\r
1349 # For binary module, if in current arch, we need to list the PCDs into database.\r
1350 if not M.IsSupportedArch:\r
1351 continue\r
1352 # Override the module PCD setting by platform setting\r
1353 ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)\r
1354 for PcdFromModule in ModulePcdList:\r
1355 PcdFromModule.IsFromBinaryInf = True\r
1356 PcdFromModule.IsFromDsc = False\r
1357 # Only allow the DynamicEx and Patchable PCD in AsBuild INF\r
1358 if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:\r
1359 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
1360 File=self.MetaFile,\r
1361 ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"\r
1362 % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))\r
1363 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
1364 if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:\r
1365 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))\r
1366 if M.ModuleType in SUP_MODULE_SET_PEI:\r
1367 PcdFromModule.Phase = "PEI"\r
1368 if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1369 self._DynaPcdList_.append(PcdFromModule)\r
1370 elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:\r
1371 self._NonDynaPcdList_.append(PcdFromModule)\r
1372 if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1373 # Overwrite the phase of any the same PCD existing, if Phase is PEI.\r
1374 # It is to solve the case that a dynamic PCD used by a PEM module/PEI\r
1375 # module & DXE module at a same time.\r
1376 # Overwrite the type of the PCDs in source INF by the type of AsBuild\r
1377 # INF file as DynamicEx.\r
1378 Index = self._DynaPcdList_.index(PcdFromModule)\r
1379 self._DynaPcdList_[Index].Phase = PcdFromModule.Phase\r
1380 self._DynaPcdList_[Index].Type = PcdFromModule.Type\r
1381 for PcdFromModule in self._NonDynaPcdList_:\r
1382 # If a PCD is not listed in the DSC file, but binary INF files used by\r
1383 # this platform all (that use this PCD) list the PCD in a [PatchPcds]\r
1384 # section, AND all source INF files used by this platform the build\r
1385 # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]\r
1386 # section, then the tools must NOT add the PCD to the Platform's PCD\r
1387 # Database; the build must assign the access method for this PCD as\r
1388 # PcdsPatchableInModule.\r
1389 if PcdFromModule not in self._DynaPcdList_:\r
1390 continue\r
1391 Index = self._DynaPcdList_.index(PcdFromModule)\r
1392 if PcdFromModule.IsFromDsc == False and \\r
1393 PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \\r
1394 PcdFromModule.IsFromBinaryInf == True and \\r
1395 self._DynaPcdList_[Index].IsFromBinaryInf == False:\r
1396 Index = self._DynaPcdList_.index(PcdFromModule)\r
1397 self._DynaPcdList_.remove (self._DynaPcdList_[Index])\r
1398\r
1399 # print out error information and break the build, if error found\r
1400 if len(NoDatumTypePcdList) > 0:\r
1401 NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)\r
1402 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
1403 File=self.MetaFile,\r
1404 ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"\r
1405 % NoDatumTypePcdListString)\r
1406 self._NonDynamicPcdList = self._NonDynaPcdList_\r
1407 self._DynamicPcdList = self._DynaPcdList_\r
1408 #\r
1409 # Sort dynamic PCD list to:\r
1410 # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should\r
1411 # try to be put header of dynamicd List\r
1412 # 2) If PCD is HII type, the PCD item should be put after unicode type PCD\r
1413 #\r
1414 # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.\r
1415 #\r
1416 UnicodePcdArray = set()\r
1417 HiiPcdArray = set()\r
1418 OtherPcdArray = set()\r
1419 VpdPcdDict = {}\r
1420 VpdFile = VpdInfoFile.VpdInfoFile()\r
1421 NeedProcessVpdMapFile = False\r
1422\r
1423 for pcd in self.Platform.Pcds:\r
1424 if pcd not in self._PlatformPcds:\r
1425 self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]\r
1426\r
1427 for item in self._PlatformPcds:\r
1428 if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
1429 self._PlatformPcds[item].DatumType = TAB_VOID\r
1430\r
1431 if (self.Workspace.ArchList[-1] == self.Arch):\r
1432 for Pcd in self._DynamicPcdList:\r
1433 # just pick the a value to determine whether is unicode string type\r
1434 Sku = Pcd.SkuInfoList.values()[0]\r
1435 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1436\r
1437 if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
1438 Pcd.DatumType = TAB_VOID\r
1439\r
1440 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
1441 # if found HII type PCD then insert to right of UnicodeIndex\r
1442 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
1443 VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
1444\r
1445 #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer\r
1446 PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))\r
1447 if PcdNvStoreDfBuffer:\r
1448 self.VariableInfo = self.CollectVariables(self._DynamicPcdList)\r
1449 vardump = self.VariableInfo.dump()\r
1450 if vardump:\r
1451 PcdNvStoreDfBuffer.DefaultValue = vardump\r
1452 for skuname in PcdNvStoreDfBuffer.SkuInfoList:\r
1453 PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump\r
1454 PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))\r
1455\r
1456 PlatformPcds = sorted(self._PlatformPcds.keys())\r
1457 #\r
1458 # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
1459 #\r
1460 VpdSkuMap = {}\r
1461 for PcdKey in PlatformPcds:\r
1462 Pcd = self._PlatformPcds[PcdKey]\r
1463 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \\r
1464 PcdKey in VpdPcdDict:\r
1465 Pcd = VpdPcdDict[PcdKey]\r
1466 SkuValueMap = {}\r
1467 DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)\r
1468 if DefaultSku:\r
1469 PcdValue = DefaultSku.DefaultValue\r
1470 if PcdValue not in SkuValueMap:\r
1471 SkuValueMap[PcdValue] = []\r
1472 VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)\r
1473 SkuValueMap[PcdValue].append(DefaultSku)\r
1474\r
1475 for (SkuName, Sku) in Pcd.SkuInfoList.items():\r
1476 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1477 PcdValue = Sku.DefaultValue\r
1478 if PcdValue == "":\r
1479 PcdValue = Pcd.DefaultValue\r
1480 if Sku.VpdOffset != '*':\r
1481 if PcdValue.startswith("{"):\r
1482 Alignment = 8\r
1483 elif PcdValue.startswith("L"):\r
1484 Alignment = 2\r
1485 else:\r
1486 Alignment = 1\r
1487 try:\r
1488 VpdOffset = int(Sku.VpdOffset)\r
1489 except:\r
1490 try:\r
1491 VpdOffset = int(Sku.VpdOffset, 16)\r
1492 except:\r
1493 EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
1494 if VpdOffset % Alignment != 0:\r
1495 if PcdValue.startswith("{"):\r
1496 EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName), File=self.MetaFile)\r
1497 else:\r
1498 EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))\r
1499 if PcdValue not in SkuValueMap:\r
1500 SkuValueMap[PcdValue] = []\r
1501 VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)\r
1502 SkuValueMap[PcdValue].append(Sku)\r
1503 # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
1504 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
1505 NeedProcessVpdMapFile = True\r
1506 if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '':\r
1507 EdkLogger.error("Build", FILE_NOT_FOUND, \\r
1508 "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
1509\r
1510 VpdSkuMap[PcdKey] = SkuValueMap\r
1511 #\r
1512 # Fix the PCDs define in VPD PCD section that never referenced by module.\r
1513 # An example is PCD for signature usage.\r
1514 #\r
1515 for DscPcd in PlatformPcds:\r
1516 DscPcdEntry = self._PlatformPcds[DscPcd]\r
1517 if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
1518 if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):\r
1519 FoundFlag = False\r
1520 for VpdPcd in VpdFile._VpdArray:\r
1521 # This PCD has been referenced by module\r
1522 if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
1523 (VpdPcd.TokenCName == DscPcdEntry.TokenCName):\r
1524 FoundFlag = True\r
1525\r
1526 # Not found, it should be signature\r
1527 if not FoundFlag :\r
1528 # just pick the a value to determine whether is unicode string type\r
1529 SkuValueMap = {}\r
1530 SkuObjList = DscPcdEntry.SkuInfoList.items()\r
1531 DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)\r
1532 if DefaultSku:\r
1533 defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))\r
1534 SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]\r
1535 for (SkuName, Sku) in SkuObjList:\r
1536 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1537\r
1538 # Need to iterate DEC pcd information to get the value & datumtype\r
1539 for eachDec in self.PackageList:\r
1540 for DecPcd in eachDec.Pcds:\r
1541 DecPcdEntry = eachDec.Pcds[DecPcd]\r
1542 if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
1543 (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):\r
1544 # Print warning message to let the developer make a determine.\r
1545 EdkLogger.warn("build", "Unreferenced vpd pcd used!",\r
1546 File=self.MetaFile, \\r
1547 ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \\r
1548 %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))\r
1549\r
1550 DscPcdEntry.DatumType = DecPcdEntry.DatumType\r
1551 DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue\r
1552 DscPcdEntry.TokenValue = DecPcdEntry.TokenValue\r
1553 DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
1554 # Only fix the value while no value provided in DSC file.\r
1555 if not Sku.DefaultValue:\r
1556 DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
1557\r
1558 if DscPcdEntry not in self._DynamicPcdList:\r
1559 self._DynamicPcdList.append(DscPcdEntry)\r
1560 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1561 PcdValue = Sku.DefaultValue\r
1562 if PcdValue == "":\r
1563 PcdValue = DscPcdEntry.DefaultValue\r
1564 if Sku.VpdOffset != '*':\r
1565 if PcdValue.startswith("{"):\r
1566 Alignment = 8\r
1567 elif PcdValue.startswith("L"):\r
1568 Alignment = 2\r
1569 else:\r
1570 Alignment = 1\r
1571 try:\r
1572 VpdOffset = int(Sku.VpdOffset)\r
1573 except:\r
1574 try:\r
1575 VpdOffset = int(Sku.VpdOffset, 16)\r
1576 except:\r
1577 EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName))\r
1578 if VpdOffset % Alignment != 0:\r
1579 if PcdValue.startswith("{"):\r
1580 EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName), File=self.MetaFile)\r
1581 else:\r
1582 EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))\r
1583 if PcdValue not in SkuValueMap:\r
1584 SkuValueMap[PcdValue] = []\r
1585 VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)\r
1586 SkuValueMap[PcdValue].append(Sku)\r
1587 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
1588 NeedProcessVpdMapFile = True\r
1589 if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
1590 UnicodePcdArray.add(DscPcdEntry)\r
1591 elif len(Sku.VariableName) > 0:\r
1592 HiiPcdArray.add(DscPcdEntry)\r
1593 else:\r
1594 OtherPcdArray.add(DscPcdEntry)\r
1595\r
1596 # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
1597 VpdSkuMap[DscPcd] = SkuValueMap\r
1598 if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \\r
1599 VpdFile.GetCount() != 0:\r
1600 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,\r
1601 "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))\r
1602\r
1603 if VpdFile.GetCount() != 0:\r
1604\r
1605 self.FixVpdOffset(VpdFile)\r
1606\r
1607 self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile))\r
1608\r
1609 # Process VPD map file generated by third party BPDG tool\r
1610 if NeedProcessVpdMapFile:\r
1611 VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)\r
1612 if os.path.exists(VpdMapFilePath):\r
1613 VpdFile.Read(VpdMapFilePath)\r
1614\r
1615 # Fixup "*" offset\r
1616 for pcd in VpdSkuMap:\r
1617 vpdinfo = VpdFile.GetVpdInfo(pcd)\r
1618 if vpdinfo is None:\r
1619 # just pick the a value to determine whether is unicode string type\r
1620 continue\r
1621 for pcdvalue in VpdSkuMap[pcd]:\r
1622 for sku in VpdSkuMap[pcd][pcdvalue]:\r
1623 for item in vpdinfo:\r
1624 if item[2] == pcdvalue:\r
1625 sku.VpdOffset = item[1]\r
1626 else:\r
1627 EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
1628\r
1629 # Delete the DynamicPcdList At the last time enter into this function\r
1630 for Pcd in self._DynamicPcdList:\r
1631 # just pick the a value to determine whether is unicode string type\r
1632 Sku = Pcd.SkuInfoList.values()[0]\r
1633 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1634\r
1635 if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:\r
1636 Pcd.DatumType = TAB_VOID\r
1637\r
1638 PcdValue = Sku.DefaultValue\r
1639 if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):\r
1640 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
1641 UnicodePcdArray.add(Pcd)\r
1642 elif len(Sku.VariableName) > 0:\r
1643 # if found HII type PCD then insert to right of UnicodeIndex\r
1644 HiiPcdArray.add(Pcd)\r
1645 else:\r
1646 OtherPcdArray.add(Pcd)\r
1647 del self._DynamicPcdList[:]\r
1648 self._DynamicPcdList.extend(list(UnicodePcdArray))\r
1649 self._DynamicPcdList.extend(list(HiiPcdArray))\r
1650 self._DynamicPcdList.extend(list(OtherPcdArray))\r
1651 allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]\r
1652 for pcd in self._DynamicPcdList:\r
1653 if len(pcd.SkuInfoList) == 1:\r
1654 for (SkuName, SkuId) in allskuset:\r
1655 if type(SkuId) in (str, unicode) and eval(SkuId) == 0 or SkuId == 0:\r
1656 continue\r
1657 pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])\r
1658 pcd.SkuInfoList[SkuName].SkuId = SkuId\r
1659 self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
1660\r
1661 def FixVpdOffset(self, VpdFile ):\r
1662 FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
1663 if not os.path.exists(FvPath):\r
1664 try:\r
1665 os.makedirs(FvPath)\r
1666 except:\r
1667 EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)\r
1668\r
1669 VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)\r
1670\r
1671 if VpdFile.Write(VpdFilePath):\r
1672 # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.\r
1673 BPDGToolName = None\r
1674 for ToolDef in self.ToolDefinition.values():\r
1675 if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:\r
1676 if "PATH" not in ToolDef:\r
1677 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)\r
1678 BPDGToolName = ToolDef["PATH"]\r
1679 break\r
1680 # Call third party GUID BPDG tool.\r
1681 if BPDGToolName is not None:\r
1682 VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)\r
1683 else:\r
1684 EdkLogger.error("Build", FILE_NOT_FOUND, "Fail to find third-party BPDG tool to process VPD PCDs. BPDG Guid tool need to be defined in tools_def.txt and VPD_TOOL_GUID need to be provided in DSC file.")\r
1685\r
1686 ## Return the platform build data object\r
1687 def _GetPlatform(self):\r
1688 if self._Platform is None:\r
1689 self._Platform = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
1690 return self._Platform\r
1691\r
1692 ## Return platform name\r
1693 def _GetName(self):\r
1694 return self.Platform.PlatformName\r
1695\r
1696 ## Return the meta file GUID\r
1697 def _GetGuid(self):\r
1698 return self.Platform.Guid\r
1699\r
1700 ## Return the platform version\r
1701 def _GetVersion(self):\r
1702 return self.Platform.Version\r
1703\r
1704 ## Return the FDF file name\r
1705 def _GetFdfFile(self):\r
1706 if self._FdfFile is None:\r
1707 if self.Workspace.FdfFile != "":\r
1708 self._FdfFile= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
1709 else:\r
1710 self._FdfFile = ''\r
1711 return self._FdfFile\r
1712\r
1713 ## Return the build output directory platform specifies\r
1714 def _GetOutputDir(self):\r
1715 return self.Platform.OutputDirectory\r
1716\r
1717 ## Return the directory to store all intermediate and final files built\r
1718 def _GetBuildDir(self):\r
1719 if self._BuildDir is None:\r
1720 if os.path.isabs(self.OutputDir):\r
1721 self._BuildDir = path.join(\r
1722 path.abspath(self.OutputDir),\r
1723 self.BuildTarget + "_" + self.ToolChain,\r
1724 )\r
1725 else:\r
1726 self._BuildDir = path.join(\r
1727 self.WorkspaceDir,\r
1728 self.OutputDir,\r
1729 self.BuildTarget + "_" + self.ToolChain,\r
1730 )\r
1731 GlobalData.gBuildDirectory = self._BuildDir\r
1732 return self._BuildDir\r
1733\r
1734 ## Return directory of platform makefile\r
1735 #\r
1736 # @retval string Makefile directory\r
1737 #\r
1738 def _GetMakeFileDir(self):\r
1739 if self._MakeFileDir is None:\r
1740 self._MakeFileDir = path.join(self.BuildDir, self.Arch)\r
1741 return self._MakeFileDir\r
1742\r
1743 ## Return build command string\r
1744 #\r
1745 # @retval string Build command string\r
1746 #\r
1747 def _GetBuildCommand(self):\r
1748 if self._BuildCommand is None:\r
1749 self._BuildCommand = []\r
1750 if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:\r
1751 self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])\r
1752 if "FLAGS" in self.ToolDefinition["MAKE"]:\r
1753 NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()\r
1754 if NewOption != '':\r
1755 self._BuildCommand += SplitOption(NewOption)\r
1756 if "MAKE" in self.EdkIIBuildOption:\r
1757 if "FLAGS" in self.EdkIIBuildOption["MAKE"]:\r
1758 Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]\r
1759 if Flags.startswith('='):\r
1760 self._BuildCommand = [self._BuildCommand[0]] + [Flags[1:]]\r
1761 else:\r
1762 self._BuildCommand.append(Flags)\r
1763 return self._BuildCommand\r
1764\r
1765 ## Get tool chain definition\r
1766 #\r
1767 # Get each tool defition for given tool chain from tools_def.txt and platform\r
1768 #\r
1769 def _GetToolDefinition(self):\r
1770 if self._ToolDefinitions is None:\r
1771 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary\r
1772 if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:\r
1773 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",\r
1774 ExtraData="[%s]" % self.MetaFile)\r
1775 self._ToolDefinitions = {}\r
1776 DllPathList = set()\r
1777 for Def in ToolDefinition:\r
1778 Target, Tag, Arch, Tool, Attr = Def.split("_")\r
1779 if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:\r
1780 continue\r
1781\r
1782 Value = ToolDefinition[Def]\r
1783 # don't record the DLL\r
1784 if Attr == "DLL":\r
1785 DllPathList.add(Value)\r
1786 continue\r
1787\r
1788 if Tool not in self._ToolDefinitions:\r
1789 self._ToolDefinitions[Tool] = {}\r
1790 self._ToolDefinitions[Tool][Attr] = Value\r
1791\r
1792 ToolsDef = ''\r
1793 if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:\r
1794 if "FLAGS" not in self._ToolDefinitions["MAKE"]:\r
1795 self._ToolDefinitions["MAKE"]["FLAGS"] = ""\r
1796 self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"\r
1797 MakeFlags = ''\r
1798 for Tool in self._ToolDefinitions:\r
1799 for Attr in self._ToolDefinitions[Tool]:\r
1800 Value = self._ToolDefinitions[Tool][Attr]\r
1801 if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:\r
1802 # check if override is indicated\r
1803 if self.BuildOption[Tool][Attr].startswith('='):\r
1804 Value = self.BuildOption[Tool][Attr][1:]\r
1805 else:\r
1806 if Attr != 'PATH':\r
1807 Value += " " + self.BuildOption[Tool][Attr]\r
1808 else:\r
1809 Value = self.BuildOption[Tool][Attr]\r
1810\r
1811 if Attr == "PATH":\r
1812 # Don't put MAKE definition in the file\r
1813 if Tool != "MAKE":\r
1814 ToolsDef += "%s = %s\n" % (Tool, Value)\r
1815 elif Attr != "DLL":\r
1816 # Don't put MAKE definition in the file\r
1817 if Tool == "MAKE":\r
1818 if Attr == "FLAGS":\r
1819 MakeFlags = Value\r
1820 else:\r
1821 ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)\r
1822 ToolsDef += "\n"\r
1823\r
1824 SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)\r
1825 for DllPath in DllPathList:\r
1826 os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]\r
1827 os.environ["MAKE_FLAGS"] = MakeFlags\r
1828\r
1829 return self._ToolDefinitions\r
1830\r
1831 ## Return the paths of tools\r
1832 def _GetToolDefFile(self):\r
1833 if self._ToolDefFile is None:\r
1834 self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)\r
1835 return self._ToolDefFile\r
1836\r
1837 ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.\r
1838 def _GetToolChainFamily(self):\r
1839 if self._ToolChainFamily is None:\r
1840 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
1841 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \\r
1842 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
1843 or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:\r
1844 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
1845 % self.ToolChain)\r
1846 self._ToolChainFamily = "MSFT"\r
1847 else:\r
1848 self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]\r
1849 return self._ToolChainFamily\r
1850\r
1851 def _GetBuildRuleFamily(self):\r
1852 if self._BuildRuleFamily is None:\r
1853 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
1854 if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \\r
1855 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
1856 or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:\r
1857 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
1858 % self.ToolChain)\r
1859 self._BuildRuleFamily = "MSFT"\r
1860 else:\r
1861 self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]\r
1862 return self._BuildRuleFamily\r
1863\r
1864 ## Return the build options specific for all modules in this platform\r
1865 def _GetBuildOptions(self):\r
1866 if self._BuildOption is None:\r
1867 self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)\r
1868 return self._BuildOption\r
1869\r
1870 ## Return the build options specific for EDK modules in this platform\r
1871 def _GetEdkBuildOptions(self):\r
1872 if self._EdkBuildOption is None:\r
1873 self._EdkBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)\r
1874 return self._EdkBuildOption\r
1875\r
1876 ## Return the build options specific for EDKII modules in this platform\r
1877 def _GetEdkIIBuildOptions(self):\r
1878 if self._EdkIIBuildOption is None:\r
1879 self._EdkIIBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)\r
1880 return self._EdkIIBuildOption\r
1881\r
1882 ## Parse build_rule.txt in Conf Directory.\r
1883 #\r
1884 # @retval BuildRule object\r
1885 #\r
1886 def _GetBuildRule(self):\r
1887 if self._BuildRule is None:\r
1888 BuildRuleFile = None\r
1889 if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:\r
1890 BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
1891 if not BuildRuleFile:\r
1892 BuildRuleFile = gDefaultBuildRuleFile\r
1893 self._BuildRule = BuildRule(BuildRuleFile)\r
1894 if self._BuildRule._FileVersion == "":\r
1895 self._BuildRule._FileVersion = AutoGenReqBuildRuleVerNum\r
1896 else:\r
1897 if self._BuildRule._FileVersion < AutoGenReqBuildRuleVerNum :\r
1898 # If Build Rule's version is less than the version number required by the tools, halting the build.\r
1899 EdkLogger.error("build", AUTOGEN_ERROR,\r
1900 ExtraData="The version number [%s] of build_rule.txt is less than the version number required by the AutoGen.(the minimum required version number is [%s])"\\r
1901 % (self._BuildRule._FileVersion, AutoGenReqBuildRuleVerNum))\r
1902\r
1903 return self._BuildRule\r
1904\r
1905 ## Summarize the packages used by modules in this platform\r
1906 def _GetPackageList(self):\r
1907 if self._PackageList is None:\r
1908 self._PackageList = set()\r
1909 for La in self.LibraryAutoGenList:\r
1910 self._PackageList.update(La.DependentPackageList)\r
1911 for Ma in self.ModuleAutoGenList:\r
1912 self._PackageList.update(Ma.DependentPackageList)\r
1913 #Collect package set information from INF of FDF\r
1914 PkgSet = set()\r
1915 for ModuleFile in self._AsBuildModuleList:\r
1916 if ModuleFile in self.Platform.Modules:\r
1917 continue\r
1918 ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]\r
1919 PkgSet.update(ModuleData.Packages)\r
1920 self._PackageList = list(self._PackageList) + list (PkgSet)\r
1921 return self._PackageList\r
1922\r
1923 def _GetNonDynamicPcdDict(self):\r
1924 if self._NonDynamicPcdDict:\r
1925 return self._NonDynamicPcdDict\r
1926 for Pcd in self.NonDynamicPcdList:\r
1927 self._NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd\r
1928 return self._NonDynamicPcdDict\r
1929\r
1930 ## Get list of non-dynamic PCDs\r
1931 def _GetNonDynamicPcdList(self):\r
1932 if self._NonDynamicPcdList is None:\r
1933 self.CollectPlatformDynamicPcds()\r
1934 return self._NonDynamicPcdList\r
1935\r
1936 ## Get list of dynamic PCDs\r
1937 def _GetDynamicPcdList(self):\r
1938 if self._DynamicPcdList is None:\r
1939 self.CollectPlatformDynamicPcds()\r
1940 return self._DynamicPcdList\r
1941\r
1942 ## Generate Token Number for all PCD\r
1943 def _GetPcdTokenNumbers(self):\r
1944 if self._PcdTokenNumber is None:\r
1945 self._PcdTokenNumber = OrderedDict()\r
1946 TokenNumber = 1\r
1947 #\r
1948 # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.\r
1949 # Such as:\r
1950 #\r
1951 # Dynamic PCD:\r
1952 # TokenNumber 0 ~ 10\r
1953 # DynamicEx PCD:\r
1954 # TokeNumber 11 ~ 20\r
1955 #\r
1956 for Pcd in self.DynamicPcdList:\r
1957 if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
1958 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1959 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1960 TokenNumber += 1\r
1961\r
1962 for Pcd in self.DynamicPcdList:\r
1963 if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1964 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1965 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1966 TokenNumber += 1\r
1967\r
1968 for Pcd in self.DynamicPcdList:\r
1969 if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:\r
1970 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1971 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1972 TokenNumber += 1\r
1973\r
1974 for Pcd in self.DynamicPcdList:\r
1975 if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
1976 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1977 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1978 TokenNumber += 1\r
1979\r
1980 for Pcd in self.NonDynamicPcdList:\r
1981 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1982 TokenNumber += 1\r
1983 return self._PcdTokenNumber\r
1984\r
1985 ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform\r
1986 def _GetAutoGenObjectList(self):\r
1987 self._ModuleAutoGenList = []\r
1988 self._LibraryAutoGenList = []\r
1989 for ModuleFile in self.Platform.Modules:\r
1990 Ma = ModuleAutoGen(\r
1991 self.Workspace,\r
1992 ModuleFile,\r
1993 self.BuildTarget,\r
1994 self.ToolChain,\r
1995 self.Arch,\r
1996 self.MetaFile\r
1997 )\r
1998 if Ma not in self._ModuleAutoGenList:\r
1999 self._ModuleAutoGenList.append(Ma)\r
2000 for La in Ma.LibraryAutoGenList:\r
2001 if La not in self._LibraryAutoGenList:\r
2002 self._LibraryAutoGenList.append(La)\r
2003 if Ma not in La.ReferenceModules:\r
2004 La.ReferenceModules.append(Ma)\r
2005\r
2006 ## Summarize ModuleAutoGen objects of all modules to be built for this platform\r
2007 def _GetModuleAutoGenList(self):\r
2008 if self._ModuleAutoGenList is None:\r
2009 self._GetAutoGenObjectList()\r
2010 return self._ModuleAutoGenList\r
2011\r
2012 ## Summarize ModuleAutoGen objects of all libraries to be built for this platform\r
2013 def _GetLibraryAutoGenList(self):\r
2014 if self._LibraryAutoGenList is None:\r
2015 self._GetAutoGenObjectList()\r
2016 return self._LibraryAutoGenList\r
2017\r
2018 ## Test if a module is supported by the platform\r
2019 #\r
2020 # An error will be raised directly if the module or its arch is not supported\r
2021 # by the platform or current configuration\r
2022 #\r
2023 def ValidModule(self, Module):\r
2024 return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \\r
2025 or Module in self._AsBuildModuleList\r
2026\r
2027 ## Resolve the library classes in a module to library instances\r
2028 #\r
2029 # This method will not only resolve library classes but also sort the library\r
2030 # instances according to the dependency-ship.\r
2031 #\r
2032 # @param Module The module from which the library classes will be resolved\r
2033 #\r
2034 # @retval library_list List of library instances sorted\r
2035 #\r
2036 def ApplyLibraryInstance(self, Module):\r
2037 # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly\r
2038 if str(Module) not in self.Platform.Modules:\r
2039 return []\r
2040\r
2041 return GetModuleLibInstances(Module,\r
2042 self.Platform,\r
2043 self.BuildDatabase,\r
2044 self.Arch,\r
2045 self.BuildTarget,\r
2046 self.ToolChain,\r
2047 self.MetaFile,\r
2048 EdkLogger)\r
2049\r
2050 ## Override PCD setting (type, value, ...)\r
2051 #\r
2052 # @param ToPcd The PCD to be overrided\r
2053 # @param FromPcd The PCD overrideing from\r
2054 #\r
2055 def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):\r
2056 #\r
2057 # in case there's PCDs coming from FDF file, which have no type given.\r
2058 # at this point, ToPcd.Type has the type found from dependent\r
2059 # package\r
2060 #\r
2061 TokenCName = ToPcd.TokenCName\r
2062 for PcdItem in GlobalData.MixedPcd:\r
2063 if (ToPcd.TokenCName, ToPcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
2064 TokenCName = PcdItem[0]\r
2065 break\r
2066 if FromPcd is not None:\r
2067 if ToPcd.Pending and FromPcd.Type:\r
2068 ToPcd.Type = FromPcd.Type\r
2069 elif ToPcd.Type and FromPcd.Type\\r
2070 and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:\r
2071 if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:\r
2072 ToPcd.Type = FromPcd.Type\r
2073 elif ToPcd.Type and FromPcd.Type \\r
2074 and ToPcd.Type != FromPcd.Type:\r
2075 if Library:\r
2076 Module = str(Module) + " 's library file (" + str(Library) + ")"\r
2077 EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",\r
2078 ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\\r
2079 % (ToPcd.TokenSpaceGuidCName, TokenCName,\r
2080 ToPcd.Type, Module, FromPcd.Type, Msg),\r
2081 File=self.MetaFile)\r
2082\r
2083 if FromPcd.MaxDatumSize:\r
2084 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize\r
2085 ToPcd.MaxSizeUserSet = FromPcd.MaxDatumSize\r
2086 if FromPcd.DefaultValue:\r
2087 ToPcd.DefaultValue = FromPcd.DefaultValue\r
2088 if FromPcd.TokenValue:\r
2089 ToPcd.TokenValue = FromPcd.TokenValue\r
2090 if FromPcd.DatumType:\r
2091 ToPcd.DatumType = FromPcd.DatumType\r
2092 if FromPcd.SkuInfoList:\r
2093 ToPcd.SkuInfoList = FromPcd.SkuInfoList\r
2094 # Add Flexible PCD format parse\r
2095 if ToPcd.DefaultValue:\r
2096 try:\r
2097 ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self._GuidDict)(True)\r
2098 except BadExpression as Value:\r
2099 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),\r
2100 File=self.MetaFile)\r
2101\r
2102 # check the validation of datum\r
2103 IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)\r
2104 if not IsValid:\r
2105 EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,\r
2106 ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, TokenCName))\r
2107 ToPcd.validateranges = FromPcd.validateranges\r
2108 ToPcd.validlists = FromPcd.validlists\r
2109 ToPcd.expressions = FromPcd.expressions\r
2110\r
2111 if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:\r
2112 EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \\r
2113 % (ToPcd.TokenSpaceGuidCName, TokenCName))\r
2114 Value = ToPcd.DefaultValue\r
2115 if not Value:\r
2116 ToPcd.MaxDatumSize = '1'\r
2117 elif Value[0] == 'L':\r
2118 ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
2119 elif Value[0] == '{':\r
2120 ToPcd.MaxDatumSize = str(len(Value.split(',')))\r
2121 else:\r
2122 ToPcd.MaxDatumSize = str(len(Value) - 1)\r
2123\r
2124 # apply default SKU for dynamic PCDS if specified one is not available\r
2125 if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \\r
2126 and not ToPcd.SkuInfoList:\r
2127 if self.Platform.SkuName in self.Platform.SkuIds:\r
2128 SkuName = self.Platform.SkuName\r
2129 else:\r
2130 SkuName = TAB_DEFAULT\r
2131 ToPcd.SkuInfoList = {\r
2132 SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)\r
2133 }\r
2134\r
2135 ## Apply PCD setting defined platform to a module\r
2136 #\r
2137 # @param Module The module from which the PCD setting will be overrided\r
2138 #\r
2139 # @retval PCD_list The list PCDs with settings from platform\r
2140 #\r
2141 def ApplyPcdSetting(self, Module, Pcds, Library=""):\r
2142 # for each PCD in module\r
2143 for Name, Guid in Pcds:\r
2144 PcdInModule = Pcds[Name, Guid]\r
2145 # find out the PCD setting in platform\r
2146 if (Name, Guid) in self.Platform.Pcds:\r
2147 PcdInPlatform = self.Platform.Pcds[Name, Guid]\r
2148 else:\r
2149 PcdInPlatform = None\r
2150 # then override the settings if any\r
2151 self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)\r
2152 # resolve the VariableGuid value\r
2153 for SkuId in PcdInModule.SkuInfoList:\r
2154 Sku = PcdInModule.SkuInfoList[SkuId]\r
2155 if Sku.VariableGuid == '': continue\r
2156 Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)\r
2157 if Sku.VariableGuidValue is None:\r
2158 PackageList = "\n\t".join(str(P) for P in self.PackageList)\r
2159 EdkLogger.error(\r
2160 'build',\r
2161 RESOURCE_NOT_AVAILABLE,\r
2162 "Value of GUID [%s] is not found in" % Sku.VariableGuid,\r
2163 ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \\r
2164 % (Guid, Name, str(Module)),\r
2165 File=self.MetaFile\r
2166 )\r
2167\r
2168 # override PCD settings with module specific setting\r
2169 if Module in self.Platform.Modules:\r
2170 PlatformModule = self.Platform.Modules[str(Module)]\r
2171 for Key in PlatformModule.Pcds:\r
2172 Flag = False\r
2173 if Key in Pcds:\r
2174 ToPcd = Pcds[Key]\r
2175 Flag = True\r
2176 elif Key in GlobalData.MixedPcd:\r
2177 for PcdItem in GlobalData.MixedPcd[Key]:\r
2178 if PcdItem in Pcds:\r
2179 ToPcd = Pcds[PcdItem]\r
2180 Flag = True\r
2181 break\r
2182 if Flag:\r
2183 self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)\r
2184 # use PCD value to calculate the MaxDatumSize when it is not specified\r
2185 for Name, Guid in Pcds:\r
2186 Pcd = Pcds[Name, Guid]\r
2187 if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:\r
2188 Pcd.MaxSizeUserSet = None\r
2189 Value = Pcd.DefaultValue\r
2190 if not Value:\r
2191 Pcd.MaxDatumSize = '1'\r
2192 elif Value[0] == 'L':\r
2193 Pcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
2194 elif Value[0] == '{':\r
2195 Pcd.MaxDatumSize = str(len(Value.split(',')))\r
2196 else:\r
2197 Pcd.MaxDatumSize = str(len(Value) - 1)\r
2198 return Pcds.values()\r
2199\r
2200 ## Resolve library names to library modules\r
2201 #\r
2202 # (for Edk.x modules)\r
2203 #\r
2204 # @param Module The module from which the library names will be resolved\r
2205 #\r
2206 # @retval library_list The list of library modules\r
2207 #\r
2208 def ResolveLibraryReference(self, Module):\r
2209 EdkLogger.verbose("")\r
2210 EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
2211 LibraryConsumerList = [Module]\r
2212\r
2213 # "CompilerStub" is a must for Edk modules\r
2214 if Module.Libraries:\r
2215 Module.Libraries.append("CompilerStub")\r
2216 LibraryList = []\r
2217 while len(LibraryConsumerList) > 0:\r
2218 M = LibraryConsumerList.pop()\r
2219 for LibraryName in M.Libraries:\r
2220 Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']\r
2221 if Library is None:\r
2222 for Key in self.Platform.LibraryClasses.data:\r
2223 if LibraryName.upper() == Key.upper():\r
2224 Library = self.Platform.LibraryClasses[Key, ':dummy:']\r
2225 break\r
2226 if Library is None:\r
2227 EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),\r
2228 ExtraData="\t%s [%s]" % (str(Module), self.Arch))\r
2229 continue\r
2230\r
2231 if Library not in LibraryList:\r
2232 LibraryList.append(Library)\r
2233 LibraryConsumerList.append(Library)\r
2234 EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))\r
2235 return LibraryList\r
2236\r
2237 ## Calculate the priority value of the build option\r
2238 #\r
2239 # @param Key Build option definition contain: TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
2240 #\r
2241 # @retval Value Priority value based on the priority list.\r
2242 #\r
2243 def CalculatePriorityValue(self, Key):\r
2244 Target, ToolChain, Arch, CommandType, Attr = Key.split('_')\r
2245 PriorityValue = 0x11111\r
2246 if Target == "*":\r
2247 PriorityValue &= 0x01111\r
2248 if ToolChain == "*":\r
2249 PriorityValue &= 0x10111\r
2250 if Arch == "*":\r
2251 PriorityValue &= 0x11011\r
2252 if CommandType == "*":\r
2253 PriorityValue &= 0x11101\r
2254 if Attr == "*":\r
2255 PriorityValue &= 0x11110\r
2256\r
2257 return self.PrioList["0x%0.5x" % PriorityValue]\r
2258\r
2259\r
2260 ## Expand * in build option key\r
2261 #\r
2262 # @param Options Options to be expanded\r
2263 #\r
2264 # @retval options Options expanded\r
2265 #\r
2266 def _ExpandBuildOption(self, Options, ModuleStyle=None):\r
2267 BuildOptions = {}\r
2268 FamilyMatch = False\r
2269 FamilyIsNull = True\r
2270\r
2271 OverrideList = {}\r
2272 #\r
2273 # Construct a list contain the build options which need override.\r
2274 #\r
2275 for Key in Options:\r
2276 #\r
2277 # Key[0] -- tool family\r
2278 # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
2279 #\r
2280 if (Key[0] == self.BuildRuleFamily and\r
2281 (ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):\r
2282 Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')\r
2283 if (Target == self.BuildTarget or Target == "*") and\\r
2284 (ToolChain == self.ToolChain or ToolChain == "*") and\\r
2285 (Arch == self.Arch or Arch == "*") and\\r
2286 Options[Key].startswith("="):\r
2287\r
2288 if OverrideList.get(Key[1]) is not None:\r
2289 OverrideList.pop(Key[1])\r
2290 OverrideList[Key[1]] = Options[Key]\r
2291\r
2292 #\r
2293 # Use the highest priority value.\r
2294 #\r
2295 if (len(OverrideList) >= 2):\r
2296 KeyList = OverrideList.keys()\r
2297 for Index in range(len(KeyList)):\r
2298 NowKey = KeyList[Index]\r
2299 Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")\r
2300 for Index1 in range(len(KeyList) - Index - 1):\r
2301 NextKey = KeyList[Index1 + Index + 1]\r
2302 #\r
2303 # Compare two Key, if one is included by another, choose the higher priority one\r
2304 #\r
2305 Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")\r
2306 if (Target1 == Target2 or Target1 == "*" or Target2 == "*") and\\r
2307 (ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*") and\\r
2308 (Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*") and\\r
2309 (CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*") and\\r
2310 (Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*"):\r
2311\r
2312 if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
2313 if Options.get((self.BuildRuleFamily, NextKey)) is not None:\r
2314 Options.pop((self.BuildRuleFamily, NextKey))\r
2315 else:\r
2316 if Options.get((self.BuildRuleFamily, NowKey)) is not None:\r
2317 Options.pop((self.BuildRuleFamily, NowKey))\r
2318\r
2319 for Key in Options:\r
2320 if ModuleStyle is not None and len (Key) > 2:\r
2321 # Check Module style is EDK or EDKII.\r
2322 # Only append build option for the matched style module.\r
2323 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:\r
2324 continue\r
2325 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:\r
2326 continue\r
2327 Family = Key[0]\r
2328 Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
2329 # if tool chain family doesn't match, skip it\r
2330 if Tool in self.ToolDefinition and Family != "":\r
2331 FamilyIsNull = False\r
2332 if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":\r
2333 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:\r
2334 continue\r
2335 elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
2336 continue\r
2337 FamilyMatch = True\r
2338 # expand any wildcard\r
2339 if Target == "*" or Target == self.BuildTarget:\r
2340 if Tag == "*" or Tag == self.ToolChain:\r
2341 if Arch == "*" or Arch == self.Arch:\r
2342 if Tool not in BuildOptions:\r
2343 BuildOptions[Tool] = {}\r
2344 if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
2345 BuildOptions[Tool][Attr] = Options[Key]\r
2346 else:\r
2347 # append options for the same tool except PATH\r
2348 if Attr != 'PATH':\r
2349 BuildOptions[Tool][Attr] += " " + Options[Key]\r
2350 else:\r
2351 BuildOptions[Tool][Attr] = Options[Key]\r
2352 # Build Option Family has been checked, which need't to be checked again for family.\r
2353 if FamilyMatch or FamilyIsNull:\r
2354 return BuildOptions\r
2355\r
2356 for Key in Options:\r
2357 if ModuleStyle is not None and len (Key) > 2:\r
2358 # Check Module style is EDK or EDKII.\r
2359 # Only append build option for the matched style module.\r
2360 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:\r
2361 continue\r
2362 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:\r
2363 continue\r
2364 Family = Key[0]\r
2365 Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
2366 # if tool chain family doesn't match, skip it\r
2367 if Tool not in self.ToolDefinition or Family == "":\r
2368 continue\r
2369 # option has been added before\r
2370 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
2371 continue\r
2372\r
2373 # expand any wildcard\r
2374 if Target == "*" or Target == self.BuildTarget:\r
2375 if Tag == "*" or Tag == self.ToolChain:\r
2376 if Arch == "*" or Arch == self.Arch:\r
2377 if Tool not in BuildOptions:\r
2378 BuildOptions[Tool] = {}\r
2379 if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):\r
2380 BuildOptions[Tool][Attr] = Options[Key]\r
2381 else:\r
2382 # append options for the same tool except PATH\r
2383 if Attr != 'PATH':\r
2384 BuildOptions[Tool][Attr] += " " + Options[Key]\r
2385 else:\r
2386 BuildOptions[Tool][Attr] = Options[Key]\r
2387 return BuildOptions\r
2388\r
2389 ## Append build options in platform to a module\r
2390 #\r
2391 # @param Module The module to which the build options will be appened\r
2392 #\r
2393 # @retval options The options appended with build options in platform\r
2394 #\r
2395 def ApplyBuildOption(self, Module):\r
2396 # Get the different options for the different style module\r
2397 if Module.AutoGenVersion < 0x00010005:\r
2398 PlatformOptions = self.EdkBuildOption\r
2399 ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDK_NAME, Module.ModuleType)\r
2400 else:\r
2401 PlatformOptions = self.EdkIIBuildOption\r
2402 ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)\r
2403 ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)\r
2404 ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)\r
2405 if Module in self.Platform.Modules:\r
2406 PlatformModule = self.Platform.Modules[str(Module)]\r
2407 PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)\r
2408 else:\r
2409 PlatformModuleOptions = {}\r
2410\r
2411 BuildRuleOrder = None\r
2412 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
2413 for Tool in Options:\r
2414 for Attr in Options[Tool]:\r
2415 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
2416 BuildRuleOrder = Options[Tool][Attr]\r
2417\r
2418 AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() +\r
2419 PlatformModuleOptions.keys() + ModuleTypeOptions.keys() +\r
2420 self.ToolDefinition.keys())\r
2421 BuildOptions = defaultdict(lambda: defaultdict(str))\r
2422 for Tool in AllTools:\r
2423 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:\r
2424 if Tool not in Options:\r
2425 continue\r
2426 for Attr in Options[Tool]:\r
2427 #\r
2428 # Do not generate it in Makefile\r
2429 #\r
2430 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
2431 continue\r
2432 Value = Options[Tool][Attr]\r
2433 # check if override is indicated\r
2434 if Value.startswith('='):\r
2435 BuildOptions[Tool][Attr] = mws.handleWsMacro(Value[1:])\r
2436 else:\r
2437 if Attr != 'PATH':\r
2438 BuildOptions[Tool][Attr] += " " + mws.handleWsMacro(Value)\r
2439 else:\r
2440 BuildOptions[Tool][Attr] = mws.handleWsMacro(Value)\r
2441\r
2442 if Module.AutoGenVersion < 0x00010005 and self.Workspace.UniFlag is not None:\r
2443 #\r
2444 # Override UNI flag only for EDK module.\r
2445 #\r
2446 BuildOptions['BUILD']['FLAGS'] = self.Workspace.UniFlag\r
2447 return BuildOptions, BuildRuleOrder\r
2448\r
2449 Platform = property(_GetPlatform)\r
2450 Name = property(_GetName)\r
2451 Guid = property(_GetGuid)\r
2452 Version = property(_GetVersion)\r
2453\r
2454 OutputDir = property(_GetOutputDir)\r
2455 BuildDir = property(_GetBuildDir)\r
2456 MakeFileDir = property(_GetMakeFileDir)\r
2457 FdfFile = property(_GetFdfFile)\r
2458\r
2459 PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
2460 DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
2461 NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
2462 NonDynamicPcdDict = property(_GetNonDynamicPcdDict)\r
2463 PackageList = property(_GetPackageList)\r
2464\r
2465 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
2466 ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path\r
2467 ToolChainFamily = property(_GetToolChainFamily)\r
2468 BuildRuleFamily = property(_GetBuildRuleFamily)\r
2469 BuildOption = property(_GetBuildOptions) # toolcode : option\r
2470 EdkBuildOption = property(_GetEdkBuildOptions) # edktoolcode : option\r
2471 EdkIIBuildOption = property(_GetEdkIIBuildOptions) # edkiitoolcode : option\r
2472\r
2473 BuildCommand = property(_GetBuildCommand)\r
2474 BuildRule = property(_GetBuildRule)\r
2475 ModuleAutoGenList = property(_GetModuleAutoGenList)\r
2476 LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
2477 GenFdsCommand = property(_GenFdsCommand)\r
2478\r
2479#\r
2480# extend lists contained in a dictionary with lists stored in another dictionary\r
2481# if CopyToDict is not derived from DefaultDict(list) then this may raise exception\r
2482#\r
2483def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict):\r
2484 for Key in CopyFromDict:\r
2485 CopyToDict[Key].extend(CopyFromDict[Key])\r
2486\r
2487# Create a directory specified by a set of path elements and return the full path\r
2488def _MakeDir(PathList):\r
2489 RetVal = path.join(*PathList)\r
2490 CreateDirectory(RetVal)\r
2491 return RetVal\r
2492\r
2493## ModuleAutoGen class\r
2494#\r
2495# This class encapsules the AutoGen behaviors for the build tools. In addition to\r
2496# the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according\r
2497# to the [depex] section in module's inf file.\r
2498#\r
2499class ModuleAutoGen(AutoGen):\r
2500 # call super().__init__ then call the worker function with different parameter count\r
2501 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
2502 if not hasattr(self, "_Init"):\r
2503 super(ModuleAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
2504 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args)\r
2505 self._Init = True\r
2506\r
2507 ## Cache the timestamps of metafiles of every module in a class attribute\r
2508 #\r
2509 TimeDict = {}\r
2510\r
2511 def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
2512 # check if this module is employed by active platform\r
2513 if not PlatformAutoGen(Workspace, args[0], Target, Toolchain, Arch).ValidModule(MetaFile):\r
2514 EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
2515 % (MetaFile, Arch))\r
2516 return None\r
2517 return super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
2518\r
2519 ## Initialize ModuleAutoGen\r
2520 #\r
2521 # @param Workspace EdkIIWorkspaceBuild object\r
2522 # @param ModuleFile The path of module file\r
2523 # @param Target Build target (DEBUG, RELEASE)\r
2524 # @param Toolchain Name of tool chain\r
2525 # @param Arch The arch the module supports\r
2526 # @param PlatformFile Platform meta-file\r
2527 #\r
2528 def _InitWorker(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):\r
2529 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))\r
2530 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)\r
2531\r
2532 self.Workspace = Workspace\r
2533 self.WorkspaceDir = Workspace.WorkspaceDir\r
2534 self._GuidDict = Workspace._GuidDict\r
2535 self.MetaFile = ModuleFile\r
2536 self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)\r
2537\r
2538 self.SourceDir = self.MetaFile.SubDir\r
2539 self.SourceDir = mws.relpath(self.SourceDir, self.WorkspaceDir)\r
2540\r
2541 self.SourceOverrideDir = None\r
2542 # use overrided path defined in DSC file\r
2543 if self.MetaFile.Key in GlobalData.gOverrideDir:\r
2544 self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]\r
2545\r
2546 self.ToolChain = Toolchain\r
2547 self.BuildTarget = Target\r
2548 self.Arch = Arch\r
2549 self.ToolChainFamily = self.PlatformInfo.ToolChainFamily\r
2550 self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily\r
2551\r
2552 self.IsCodeFileCreated = False\r
2553 self.IsAsBuiltInfCreated = False\r
2554 self.DepexGenerated = False\r
2555\r
2556 self.BuildDatabase = self.Workspace.BuildDatabase\r
2557 self.BuildRuleOrder = None\r
2558 self.BuildTime = 0\r
2559\r
2560 self._PcdComments = OrderedListDict()\r
2561 self._GuidComments = OrderedListDict()\r
2562 self._ProtocolComments = OrderedListDict()\r
2563 self._PpiComments = OrderedListDict()\r
2564 self._BuildTargets = None\r
2565 self._IntroBuildTargetList = None\r
2566 self._FinalBuildTargetList = None\r
2567 self._FileTypes = None\r
2568\r
2569 self.AutoGenDepSet = set()\r
2570 self.ReferenceModules = []\r
2571 self.ConstPcd = {}\r
2572\r
2573\r
2574 def __repr__(self):\r
2575 return "%s [%s]" % (self.MetaFile, self.Arch)\r
2576\r
2577 # Get FixedAtBuild Pcds of this Module\r
2578 @cached_property\r
2579 def FixedAtBuildPcds(self):\r
2580 RetVal = []\r
2581 for Pcd in self.ModulePcdList:\r
2582 if Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:\r
2583 continue\r
2584 if Pcd not in RetVal:\r
2585 RetVal.append(Pcd)\r
2586 return RetVal\r
2587\r
2588 @cached_property\r
2589 def FixedVoidTypePcds(self):\r
2590 RetVal = {}\r
2591 for Pcd in self.FixedAtBuildPcds:\r
2592 if Pcd.DatumType == TAB_VOID:\r
2593 if '{}.{}'.format(Pcd.TokenSpaceGuidCName, Pcd.TokenCName) not in RetVal:\r
2594 RetVal['{}.{}'.format(Pcd.TokenSpaceGuidCName, Pcd.TokenCName)] = Pcd.DefaultValue\r
2595 return RetVal\r
2596\r
2597 @property\r
2598 def UniqueBaseName(self):\r
2599 BaseName = self.Name\r
2600 for Module in self.PlatformInfo.ModuleAutoGenList:\r
2601 if Module.MetaFile == self.MetaFile:\r
2602 continue\r
2603 if Module.Name == self.Name:\r
2604 if uuid.UUID(Module.Guid) == uuid.UUID(self.Guid):\r
2605 EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n'\r
2606 ' %s\n %s' % (Module.MetaFile, self.MetaFile))\r
2607 BaseName = '%s_%s' % (self.Name, self.Guid)\r
2608 return BaseName\r
2609\r
2610 # Macros could be used in build_rule.txt (also Makefile)\r
2611 @cached_property\r
2612 def Macros(self):\r
2613 return OrderedDict((\r
2614 ("WORKSPACE" ,self.WorkspaceDir),\r
2615 ("MODULE_NAME" ,self.Name),\r
2616 ("MODULE_NAME_GUID" ,self.UniqueBaseName),\r
2617 ("MODULE_GUID" ,self.Guid),\r
2618 ("MODULE_VERSION" ,self.Version),\r
2619 ("MODULE_TYPE" ,self.ModuleType),\r
2620 ("MODULE_FILE" ,str(self.MetaFile)),\r
2621 ("MODULE_FILE_BASE_NAME" ,self.MetaFile.BaseName),\r
2622 ("MODULE_RELATIVE_DIR" ,self.SourceDir),\r
2623 ("MODULE_DIR" ,self.SourceDir),\r
2624 ("BASE_NAME" ,self.Name),\r
2625 ("ARCH" ,self.Arch),\r
2626 ("TOOLCHAIN" ,self.ToolChain),\r
2627 ("TOOLCHAIN_TAG" ,self.ToolChain),\r
2628 ("TOOL_CHAIN_TAG" ,self.ToolChain),\r
2629 ("TARGET" ,self.BuildTarget),\r
2630 ("BUILD_DIR" ,self.PlatformInfo.BuildDir),\r
2631 ("BIN_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
2632 ("LIB_DIR" ,os.path.join(self.PlatformInfo.BuildDir, self.Arch)),\r
2633 ("MODULE_BUILD_DIR" ,self.BuildDir),\r
2634 ("OUTPUT_DIR" ,self.OutputDir),\r
2635 ("DEBUG_DIR" ,self.DebugDir),\r
2636 ("DEST_DIR_OUTPUT" ,self.OutputDir),\r
2637 ("DEST_DIR_DEBUG" ,self.DebugDir),\r
2638 ("PLATFORM_NAME" ,self.PlatformInfo.Name),\r
2639 ("PLATFORM_GUID" ,self.PlatformInfo.Guid),\r
2640 ("PLATFORM_VERSION" ,self.PlatformInfo.Version),\r
2641 ("PLATFORM_RELATIVE_DIR" ,self.PlatformInfo.SourceDir),\r
2642 ("PLATFORM_DIR" ,mws.join(self.WorkspaceDir, self.PlatformInfo.SourceDir)),\r
2643 ("PLATFORM_OUTPUT_DIR" ,self.PlatformInfo.OutputDir),\r
2644 ("FFS_OUTPUT_DIR" ,self.FfsOutputDir)\r
2645 ))\r
2646\r
2647 ## Return the module build data object\r
2648 @cached_property\r
2649 def Module(self):\r
2650 return self.Workspace.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
2651\r
2652 ## Return the module name\r
2653 @cached_property\r
2654 def Name(self):\r
2655 return self.Module.BaseName\r
2656\r
2657 ## Return the module DxsFile if exist\r
2658 @cached_property\r
2659 def DxsFile(self):\r
2660 return self.Module.DxsFile\r
2661\r
2662 ## Return the module meta-file GUID\r
2663 @cached_property\r
2664 def Guid(self):\r
2665 #\r
2666 # To build same module more than once, the module path with FILE_GUID overridden has\r
2667 # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the realy path\r
2668 # in DSC. The overridden GUID can be retrieved from file name\r
2669 #\r
2670 if os.path.basename(self.MetaFile.File) != os.path.basename(self.MetaFile.Path):\r
2671 #\r
2672 # Length of GUID is 36\r
2673 #\r
2674 return os.path.basename(self.MetaFile.Path)[:36]\r
2675 return self.Module.Guid\r
2676\r
2677 ## Return the module version\r
2678 @cached_property\r
2679 def Version(self):\r
2680 return self.Module.Version\r
2681\r
2682 ## Return the module type\r
2683 @cached_property\r
2684 def ModuleType(self):\r
2685 return self.Module.ModuleType\r
2686\r
2687 ## Return the component type (for Edk.x style of module)\r
2688 @cached_property\r
2689 def ComponentType(self):\r
2690 return self.Module.ComponentType\r
2691\r
2692 ## Return the build type\r
2693 @cached_property\r
2694 def BuildType(self):\r
2695 return self.Module.BuildType\r
2696\r
2697 ## Return the PCD_IS_DRIVER setting\r
2698 @cached_property\r
2699 def PcdIsDriver(self):\r
2700 return self.Module.PcdIsDriver\r
2701\r
2702 ## Return the autogen version, i.e. module meta-file version\r
2703 @cached_property\r
2704 def AutoGenVersion(self):\r
2705 return self.Module.AutoGenVersion\r
2706\r
2707 ## Check if the module is library or not\r
2708 @cached_property\r
2709 def IsLibrary(self):\r
2710 return bool(self.Module.LibraryClass)\r
2711\r
2712 ## Check if the module is binary module or not\r
2713 @cached_property\r
2714 def IsBinaryModule(self):\r
2715 return self.Module.IsBinaryModule\r
2716\r
2717 ## Return the directory to store intermediate files of the module\r
2718 @cached_property\r
2719 def BuildDir(self):\r
2720 return _MakeDir((\r
2721 self.PlatformInfo.BuildDir,\r
2722 self.Arch,\r
2723 self.SourceDir,\r
2724 self.MetaFile.BaseName\r
2725 ))\r
2726\r
2727 ## Return the directory to store the intermediate object files of the mdoule\r
2728 @cached_property\r
2729 def OutputDir(self):\r
2730 return _MakeDir((self.BuildDir, "OUTPUT"))\r
2731\r
2732 ## Return the directory path to store ffs file\r
2733 @cached_property\r
2734 def FfsOutputDir(self):\r
2735 if GlobalData.gFdfParser:\r
2736 return path.join(self.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)\r
2737 return ''\r
2738\r
2739 ## Return the directory to store auto-gened source files of the mdoule\r
2740 @cached_property\r
2741 def DebugDir(self):\r
2742 return _MakeDir((self.BuildDir, "DEBUG"))\r
2743\r
2744 ## Return the path of custom file\r
2745 @cached_property\r
2746 def CustomMakefile(self):\r
2747 RetVal = {}\r
2748 for Type in self.Module.CustomMakefile:\r
2749 MakeType = gMakeTypeMap[Type] if Type in gMakeTypeMap else 'nmake'\r
2750 if self.SourceOverrideDir is not None:\r
2751 File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])\r
2752 if not os.path.exists(File):\r
2753 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
2754 else:\r
2755 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
2756 RetVal[MakeType] = File\r
2757 return RetVal\r
2758\r
2759 ## Return the directory of the makefile\r
2760 #\r
2761 # @retval string The directory string of module's makefile\r
2762 #\r
2763 @cached_property\r
2764 def MakeFileDir(self):\r
2765 return self.BuildDir\r
2766\r
2767 ## Return build command string\r
2768 #\r
2769 # @retval string Build command string\r
2770 #\r
2771 @cached_property\r
2772 def BuildCommand(self):\r
2773 return self.PlatformInfo.BuildCommand\r
2774\r
2775 ## Get object list of all packages the module and its dependent libraries belong to\r
2776 #\r
2777 # @retval list The list of package object\r
2778 #\r
2779 @cached_property\r
2780 def DerivedPackageList(self):\r
2781 PackageList = []\r
2782 for M in [self.Module] + self.DependentLibraryList:\r
2783 for Package in M.Packages:\r
2784 if Package in PackageList:\r
2785 continue\r
2786 PackageList.append(Package)\r
2787 return PackageList\r
2788\r
2789 ## Get the depex string\r
2790 #\r
2791 # @return : a string contain all depex expresion.\r
2792 def _GetDepexExpresionString(self):\r
2793 DepexStr = ''\r
2794 DepexList = []\r
2795 ## DPX_SOURCE IN Define section.\r
2796 if self.Module.DxsFile:\r
2797 return DepexStr\r
2798 for M in [self.Module] + self.DependentLibraryList:\r
2799 Filename = M.MetaFile.Path\r
2800 InfObj = InfSectionParser.InfSectionParser(Filename)\r
2801 DepexExpresionList = InfObj.GetDepexExpresionList()\r
2802 for DepexExpresion in DepexExpresionList:\r
2803 for key in DepexExpresion:\r
2804 Arch, ModuleType = key\r
2805 DepexExpr = [x for x in DepexExpresion[key] if not str(x).startswith('#')]\r
2806 # the type of build module is USER_DEFINED.\r
2807 # All different DEPEX section tags would be copied into the As Built INF file\r
2808 # and there would be separate DEPEX section tags\r
2809 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
2810 if (Arch.upper() == self.Arch.upper()) and (ModuleType.upper() != TAB_ARCH_COMMON):\r
2811 DepexList.append({(Arch, ModuleType): DepexExpr})\r
2812 else:\r
2813 if Arch.upper() == TAB_ARCH_COMMON or \\r
2814 (Arch.upper() == self.Arch.upper() and \\r
2815 ModuleType.upper() in [TAB_ARCH_COMMON, self.ModuleType.upper()]):\r
2816 DepexList.append({(Arch, ModuleType): DepexExpr})\r
2817\r
2818 #the type of build module is USER_DEFINED.\r
2819 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
2820 for Depex in DepexList:\r
2821 for key in Depex:\r
2822 DepexStr += '[Depex.%s.%s]\n' % key\r
2823 DepexStr += '\n'.join('# '+ val for val in Depex[key])\r
2824 DepexStr += '\n\n'\r
2825 if not DepexStr:\r
2826 return '[Depex.%s]\n' % self.Arch\r
2827 return DepexStr\r
2828\r
2829 #the type of build module not is USER_DEFINED.\r
2830 Count = 0\r
2831 for Depex in DepexList:\r
2832 Count += 1\r
2833 if DepexStr != '':\r
2834 DepexStr += ' AND '\r
2835 DepexStr += '('\r
2836 for D in Depex.values():\r
2837 DepexStr += ' '.join(val for val in D)\r
2838 Index = DepexStr.find('END')\r
2839 if Index > -1 and Index == len(DepexStr) - 3:\r
2840 DepexStr = DepexStr[:-3]\r
2841 DepexStr = DepexStr.strip()\r
2842 DepexStr += ')'\r
2843 if Count == 1:\r
2844 DepexStr = DepexStr.lstrip('(').rstrip(')').strip()\r
2845 if not DepexStr:\r
2846 return '[Depex.%s]\n' % self.Arch\r
2847 return '[Depex.%s]\n# ' % self.Arch + DepexStr\r
2848\r
2849 ## Merge dependency expression\r
2850 #\r
2851 # @retval list The token list of the dependency expression after parsed\r
2852 #\r
2853 @cached_property\r
2854 def DepexList(self):\r
2855 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
2856 return {}\r
2857\r
2858 DepexList = []\r
2859 #\r
2860 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
2861 #\r
2862 for M in [self.Module] + self.DependentLibraryList:\r
2863 Inherited = False\r
2864 for D in M.Depex[self.Arch, self.ModuleType]:\r
2865 if DepexList != []:\r
2866 DepexList.append('AND')\r
2867 DepexList.append('(')\r
2868 #replace D with value if D is FixedAtBuild PCD\r
2869 NewList = []\r
2870 for item in D:\r
2871 if '.' not in item:\r
2872 NewList.append(item)\r
2873 else:\r
2874 if item not in self._FixedPcdVoidTypeDict:\r
2875 EdkLogger.error("build", FORMAT_INVALID, "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type in the module.".format(item))\r
2876 else:\r
2877 Value = self._FixedPcdVoidTypeDict[item]\r
2878 if len(Value.split(',')) != 16:\r
2879 EdkLogger.error("build", FORMAT_INVALID,\r
2880 "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type and 16 bytes in the module.".format(item))\r
2881 NewList.append(Value)\r
2882 DepexList.extend(NewList)\r
2883 if DepexList[-1] == 'END': # no need of a END at this time\r
2884 DepexList.pop()\r
2885 DepexList.append(')')\r
2886 Inherited = True\r
2887 if Inherited:\r
2888 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))\r
2889 if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
2890 break\r
2891 if len(DepexList) > 0:\r
2892 EdkLogger.verbose('')\r
2893 return {self.ModuleType:DepexList}\r
2894\r
2895 ## Merge dependency expression\r
2896 #\r
2897 # @retval list The token list of the dependency expression after parsed\r
2898 #\r
2899 @cached_property\r
2900 def DepexExpressionDict(self):\r
2901 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
2902 return {}\r
2903\r
2904 DepexExpressionString = ''\r
2905 #\r
2906 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
2907 #\r
2908 for M in [self.Module] + self.DependentLibraryList:\r
2909 Inherited = False\r
2910 for D in M.DepexExpression[self.Arch, self.ModuleType]:\r
2911 if DepexExpressionString != '':\r
2912 DepexExpressionString += ' AND '\r
2913 DepexExpressionString += '('\r
2914 DepexExpressionString += D\r
2915 DepexExpressionString = DepexExpressionString.rstrip('END').strip()\r
2916 DepexExpressionString += ')'\r
2917 Inherited = True\r
2918 if Inherited:\r
2919 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionString))\r
2920 if 'BEFORE' in DepexExpressionString or 'AFTER' in DepexExpressionString:\r
2921 break\r
2922 if len(DepexExpressionString) > 0:\r
2923 EdkLogger.verbose('')\r
2924\r
2925 return {self.ModuleType:DepexExpressionString}\r
2926\r
2927 # Get the tiano core user extension, it is contain dependent library.\r
2928 # @retval: a list contain tiano core userextension.\r
2929 #\r
2930 def _GetTianoCoreUserExtensionList(self):\r
2931 TianoCoreUserExtentionList = []\r
2932 for M in [self.Module] + self.DependentLibraryList:\r
2933 Filename = M.MetaFile.Path\r
2934 InfObj = InfSectionParser.InfSectionParser(Filename)\r
2935 TianoCoreUserExtenList = InfObj.GetUserExtensionTianoCore()\r
2936 for TianoCoreUserExtent in TianoCoreUserExtenList:\r
2937 for Section in TianoCoreUserExtent:\r
2938 ItemList = Section.split(TAB_SPLIT)\r
2939 Arch = self.Arch\r
2940 if len(ItemList) == 4:\r
2941 Arch = ItemList[3]\r
2942 if Arch.upper() == TAB_ARCH_COMMON or Arch.upper() == self.Arch.upper():\r
2943 TianoCoreList = []\r
2944 TianoCoreList.extend([TAB_SECTION_START + Section + TAB_SECTION_END])\r
2945 TianoCoreList.extend(TianoCoreUserExtent[Section][:])\r
2946 TianoCoreList.append('\n')\r
2947 TianoCoreUserExtentionList.append(TianoCoreList)\r
2948\r
2949 return TianoCoreUserExtentionList\r
2950\r
2951 ## Return the list of specification version required for the module\r
2952 #\r
2953 # @retval list The list of specification defined in module file\r
2954 #\r
2955 @cached_property\r
2956 def Specification(self):\r
2957 return self.Module.Specification\r
2958\r
2959 ## Tool option for the module build\r
2960 #\r
2961 # @param PlatformInfo The object of PlatformBuildInfo\r
2962 # @retval dict The dict containing valid options\r
2963 #\r
2964 @cached_property\r
2965 def BuildOption(self):\r
2966 RetVal, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)\r
2967 if self.BuildRuleOrder:\r
2968 self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]\r
2969 return RetVal\r
2970\r
2971 ## Get include path list from tool option for the module build\r
2972 #\r
2973 # @retval list The include path list\r
2974 #\r
2975 @cached_property\r
2976 def BuildOptionIncPathList(self):\r
2977 #\r
2978 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
2979 # is the former use /I , the Latter used -I to specify include directories\r
2980 #\r
2981 if self.PlatformInfo.ToolChainFamily in ('MSFT'):\r
2982 BuildOptIncludeRegEx = gBuildOptIncludePatternMsft\r
2983 elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
2984 BuildOptIncludeRegEx = gBuildOptIncludePatternOther\r
2985 else:\r
2986 #\r
2987 # New ToolChainFamily, don't known whether there is option to specify include directories\r
2988 #\r
2989 return []\r
2990\r
2991 RetVal = []\r
2992 for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
2993 try:\r
2994 FlagOption = self.BuildOption[Tool]['FLAGS']\r
2995 except KeyError:\r
2996 FlagOption = ''\r
2997\r
2998 if self.PlatformInfo.ToolChainFamily != 'RVCT':\r
2999 IncPathList = [NormPath(Path, self.Macros) for Path in BuildOptIncludeRegEx.findall(FlagOption)]\r
3000 else:\r
3001 #\r
3002 # RVCT may specify a list of directory seperated by commas\r
3003 #\r
3004 IncPathList = []\r
3005 for Path in BuildOptIncludeRegEx.findall(FlagOption):\r
3006 PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
3007 IncPathList.extend(NormPath(PathEntry, self.Macros) for PathEntry in PathList)\r
3008\r
3009 #\r
3010 # EDK II modules must not reference header files outside of the packages they depend on or\r
3011 # within the module's directory tree. Report error if violation.\r
3012 #\r
3013 if self.AutoGenVersion >= 0x00010005:\r
3014 for Path in IncPathList:\r
3015 if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
3016 ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)\r
3017 EdkLogger.error("build",\r
3018 PARAMETER_INVALID,\r
3019 ExtraData=ErrMsg,\r
3020 File=str(self.MetaFile))\r
3021 RetVal += IncPathList\r
3022 return RetVal\r
3023\r
3024 ## Return a list of files which can be built from source\r
3025 #\r
3026 # What kind of files can be built is determined by build rules in\r
3027 # $(CONF_DIRECTORY)/build_rule.txt and toolchain family.\r
3028 #\r
3029 @cached_property\r
3030 def SourceFileList(self):\r
3031 RetVal = []\r
3032 ToolChainTagSet = {"", "*", self.ToolChain}\r
3033 ToolChainFamilySet = {"", "*", self.ToolChainFamily, self.BuildRuleFamily}\r
3034 for F in self.Module.Sources:\r
3035 # match tool chain\r
3036 if F.TagName not in ToolChainTagSet:\r
3037 EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "\r
3038 "but [%s] is currently used" % (F.TagName, str(F), self.ToolChain))\r
3039 continue\r
3040 # match tool chain family or build rule family\r
3041 if F.ToolChainFamily not in ToolChainFamilySet:\r
3042 EdkLogger.debug(\r
3043 EdkLogger.DEBUG_0,\r
3044 "The file [%s] must be built by tools of [%s], " \\r
3045 "but current toolchain family is [%s], buildrule family is [%s]" \\r
3046 % (str(F), F.ToolChainFamily, self.ToolChainFamily, self.BuildRuleFamily))\r
3047 continue\r
3048\r
3049 # add the file path into search path list for file including\r
3050 if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:\r
3051 self.IncludePathList.insert(0, F.Dir)\r
3052 RetVal.append(F)\r
3053\r
3054 self._MatchBuildRuleOrder(RetVal)\r
3055\r
3056 for F in RetVal:\r
3057 self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)\r
3058 return RetVal\r
3059\r
3060 def _MatchBuildRuleOrder(self, FileList):\r
3061 Order_Dict = {}\r
3062 self.BuildOption\r
3063 for SingleFile in FileList:\r
3064 if self.BuildRuleOrder and SingleFile.Ext in self.BuildRuleOrder and SingleFile.Ext in self.BuildRules:\r
3065 key = SingleFile.Path.split(SingleFile.Ext)[0]\r
3066 if key in Order_Dict:\r
3067 Order_Dict[key].append(SingleFile.Ext)\r
3068 else:\r
3069 Order_Dict[key] = [SingleFile.Ext]\r
3070\r
3071 RemoveList = []\r
3072 for F in Order_Dict:\r
3073 if len(Order_Dict[F]) > 1:\r
3074 Order_Dict[F].sort(key=lambda i: self.BuildRuleOrder.index(i))\r
3075 for Ext in Order_Dict[F][1:]:\r
3076 RemoveList.append(F + Ext)\r
3077\r
3078 for item in RemoveList:\r
3079 FileList.remove(item)\r
3080\r
3081 return FileList\r
3082\r
3083 ## Return the list of unicode files\r
3084 @cached_property\r
3085 def UnicodeFileList(self):\r
3086 return self.FileTypes.get(TAB_UNICODE_FILE,[])\r
3087\r
3088 ## Return the list of vfr files\r
3089 @cached_property\r
3090 def VfrFileList(self):\r
3091 return self.FileTypes.get(TAB_VFR_FILE, [])\r
3092\r
3093 ## Return the list of Image Definition files\r
3094 @cached_property\r
3095 def IdfFileList(self):\r
3096 return self.FileTypes.get(TAB_IMAGE_FILE,[])\r
3097\r
3098 ## Return a list of files which can be built from binary\r
3099 #\r
3100 # "Build" binary files are just to copy them to build directory.\r
3101 #\r
3102 # @retval list The list of files which can be built later\r
3103 #\r
3104 @cached_property\r
3105 def BinaryFileList(self):\r
3106 RetVal = []\r
3107 for F in self.Module.Binaries:\r
3108 if F.Target not in [TAB_ARCH_COMMON, '*'] and F.Target != self.BuildTarget:\r
3109 continue\r
3110 RetVal.append(F)\r
3111 self._ApplyBuildRule(F, F.Type, BinaryFileList=RetVal)\r
3112 return RetVal\r
3113\r
3114 @cached_property\r
3115 def BuildRules(self):\r
3116 RetVal = {}\r
3117 BuildRuleDatabase = self.PlatformInfo.BuildRule\r
3118 for Type in BuildRuleDatabase.FileTypeList:\r
3119 #first try getting build rule by BuildRuleFamily\r
3120 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]\r
3121 if not RuleObject:\r
3122 # build type is always module type, but ...\r
3123 if self.ModuleType != self.BuildType:\r
3124 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]\r
3125 #second try getting build rule by ToolChainFamily\r
3126 if not RuleObject:\r
3127 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]\r
3128 if not RuleObject:\r
3129 # build type is always module type, but ...\r
3130 if self.ModuleType != self.BuildType:\r
3131 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]\r
3132 if not RuleObject:\r
3133 continue\r
3134 RuleObject = RuleObject.Instantiate(self.Macros)\r
3135 RetVal[Type] = RuleObject\r
3136 for Ext in RuleObject.SourceFileExtList:\r
3137 RetVal[Ext] = RuleObject\r
3138 return RetVal\r
3139\r
3140 def _ApplyBuildRule(self, File, FileType, BinaryFileList=None):\r
3141 if self._BuildTargets is None:\r
3142 self._IntroBuildTargetList = set()\r
3143 self._FinalBuildTargetList = set()\r
3144 self._BuildTargets = defaultdict(set)\r
3145 self._FileTypes = defaultdict(set)\r
3146\r
3147 if not BinaryFileList:\r
3148 BinaryFileList = self.BinaryFileList\r
3149\r
3150 SubDirectory = os.path.join(self.OutputDir, File.SubDir)\r
3151 if not os.path.exists(SubDirectory):\r
3152 CreateDirectory(SubDirectory)\r
3153 LastTarget = None\r
3154 RuleChain = set()\r
3155 SourceList = [File]\r
3156 Index = 0\r
3157 #\r
3158 # Make sure to get build rule order value\r
3159 #\r
3160 self.BuildOption\r
3161\r
3162 while Index < len(SourceList):\r
3163 Source = SourceList[Index]\r
3164 Index = Index + 1\r
3165\r
3166 if Source != File:\r
3167 CreateDirectory(Source.Dir)\r
3168\r
3169 if File.IsBinary and File == Source and File in BinaryFileList:\r
3170 # Skip all files that are not binary libraries\r
3171 if not self.IsLibrary:\r
3172 continue\r
3173 RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]\r
3174 elif FileType in self.BuildRules:\r
3175 RuleObject = self.BuildRules[FileType]\r
3176 elif Source.Ext in self.BuildRules:\r
3177 RuleObject = self.BuildRules[Source.Ext]\r
3178 else:\r
3179 # stop at no more rules\r
3180 if LastTarget:\r
3181 self._FinalBuildTargetList.add(LastTarget)\r
3182 break\r
3183\r
3184 FileType = RuleObject.SourceFileType\r
3185 self._FileTypes[FileType].add(Source)\r
3186\r
3187 # stop at STATIC_LIBRARY for library\r
3188 if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:\r
3189 if LastTarget:\r
3190 self._FinalBuildTargetList.add(LastTarget)\r
3191 break\r
3192\r
3193 Target = RuleObject.Apply(Source, self.BuildRuleOrder)\r
3194 if not Target:\r
3195 if LastTarget:\r
3196 self._FinalBuildTargetList.add(LastTarget)\r
3197 break\r
3198 elif not Target.Outputs:\r
3199 # Only do build for target with outputs\r
3200 self._FinalBuildTargetList.add(Target)\r
3201\r
3202 self._BuildTargets[FileType].add(Target)\r
3203\r
3204 if not Source.IsBinary and Source == File:\r
3205 self._IntroBuildTargetList.add(Target)\r
3206\r
3207 # to avoid cyclic rule\r
3208 if FileType in RuleChain:\r
3209 break\r
3210\r
3211 RuleChain.add(FileType)\r
3212 SourceList.extend(Target.Outputs)\r
3213 LastTarget = Target\r
3214 FileType = TAB_UNKNOWN_FILE\r
3215\r
3216 @cached_property\r
3217 def Targets(self):\r
3218 if self._BuildTargets is None:\r
3219 self._IntroBuildTargetList = set()\r
3220 self._FinalBuildTargetList = set()\r
3221 self._BuildTargets = defaultdict(set)\r
3222 self._FileTypes = defaultdict(set)\r
3223\r
3224 #TRICK: call SourceFileList property to apply build rule for source files\r
3225 self.SourceFileList\r
3226\r
3227 #TRICK: call _GetBinaryFileList to apply build rule for binary files\r
3228 self.BinaryFileList\r
3229\r
3230 return self._BuildTargets\r
3231\r
3232 @cached_property\r
3233 def IntroTargetList(self):\r
3234 self.Targets\r
3235 return self._IntroBuildTargetList\r
3236\r
3237 @cached_property\r
3238 def CodaTargetList(self):\r
3239 self.Targets\r
3240 return self._FinalBuildTargetList\r
3241\r
3242 @cached_property\r
3243 def FileTypes(self):\r
3244 self.Targets\r
3245 return self._FileTypes\r
3246\r
3247 ## Get the list of package object the module depends on\r
3248 #\r
3249 # @retval list The package object list\r
3250 #\r
3251 @cached_property\r
3252 def DependentPackageList(self):\r
3253 return self.Module.Packages\r
3254\r
3255 ## Return the list of auto-generated code file\r
3256 #\r
3257 # @retval list The list of auto-generated file\r
3258 #\r
3259 @cached_property\r
3260 def AutoGenFileList(self):\r
3261 AutoGenUniIdf = self.BuildType != 'UEFI_HII'\r
3262 UniStringBinBuffer = BytesIO()\r
3263 IdfGenBinBuffer = BytesIO()\r
3264 RetVal = {}\r
3265 AutoGenC = TemplateString()\r
3266 AutoGenH = TemplateString()\r
3267 StringH = TemplateString()\r
3268 StringIdf = TemplateString()\r
3269 GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, AutoGenUniIdf, UniStringBinBuffer, StringIdf, AutoGenUniIdf, IdfGenBinBuffer)\r
3270 #\r
3271 # AutoGen.c is generated if there are library classes in inf, or there are object files\r
3272 #\r
3273 if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
3274 or TAB_OBJECT_FILE in self.FileTypes):\r
3275 AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
3276 RetVal[AutoFile] = str(AutoGenC)\r
3277 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3278 if str(AutoGenH) != "":\r
3279 AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)\r
3280 RetVal[AutoFile] = str(AutoGenH)\r
3281 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3282 if str(StringH) != "":\r
3283 AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
3284 RetVal[AutoFile] = str(StringH)\r
3285 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3286 if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != "":\r
3287 AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
3288 RetVal[AutoFile] = UniStringBinBuffer.getvalue()\r
3289 AutoFile.IsBinary = True\r
3290 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3291 if UniStringBinBuffer is not None:\r
3292 UniStringBinBuffer.close()\r
3293 if str(StringIdf) != "":\r
3294 AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)\r
3295 RetVal[AutoFile] = str(StringIdf)\r
3296 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3297 if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != "":\r
3298 AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)\r
3299 RetVal[AutoFile] = IdfGenBinBuffer.getvalue()\r
3300 AutoFile.IsBinary = True\r
3301 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
3302 if IdfGenBinBuffer is not None:\r
3303 IdfGenBinBuffer.close()\r
3304 return RetVal\r
3305\r
3306 ## Return the list of library modules explicitly or implicityly used by this module\r
3307 @cached_property\r
3308 def DependentLibraryList(self):\r
3309 # only merge library classes and PCD for non-library module\r
3310 if self.IsLibrary:\r
3311 return []\r
3312 if self.AutoGenVersion < 0x00010005:\r
3313 return self.PlatformInfo.ResolveLibraryReference(self.Module)\r
3314 return self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
3315\r
3316 ## Get the list of PCDs from current module\r
3317 #\r
3318 # @retval list The list of PCD\r
3319 #\r
3320 @cached_property\r
3321 def ModulePcdList(self):\r
3322 # apply PCD settings from platform\r
3323 RetVal = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
3324 ExtendCopyDictionaryLists(self._PcdComments, self.Module.PcdComments)\r
3325 return RetVal\r
3326\r
3327 ## Get the list of PCDs from dependent libraries\r
3328 #\r
3329 # @retval list The list of PCD\r
3330 #\r
3331 @cached_property\r
3332 def LibraryPcdList(self):\r
3333 if self.IsLibrary:\r
3334 return []\r
3335 RetVal = []\r
3336 Pcds = set()\r
3337 # get PCDs from dependent libraries\r
3338 for Library in self.DependentLibraryList:\r
3339 PcdsInLibrary = OrderedDict()\r
3340 ExtendCopyDictionaryLists(self._PcdComments, Library.PcdComments)\r
3341 for Key in Library.Pcds:\r
3342 # skip duplicated PCDs\r
3343 if Key in self.Module.Pcds or Key in Pcds:\r
3344 continue\r
3345 Pcds.add(Key)\r
3346 PcdsInLibrary[Key] = copy.copy(Library.Pcds[Key])\r
3347 RetVal.extend(self.PlatformInfo.ApplyPcdSetting(self.Module, PcdsInLibrary, Library=Library))\r
3348 return RetVal\r
3349\r
3350 ## Get the GUID value mapping\r
3351 #\r
3352 # @retval dict The mapping between GUID cname and its value\r
3353 #\r
3354 @cached_property\r
3355 def GuidList(self):\r
3356 RetVal = OrderedDict(self.Module.Guids)\r
3357 for Library in self.DependentLibraryList:\r
3358 RetVal.update(Library.Guids)\r
3359 ExtendCopyDictionaryLists(self._GuidComments, Library.GuidComments)\r
3360 ExtendCopyDictionaryLists(self._GuidComments, self.Module.GuidComments)\r
3361 return RetVal\r
3362\r
3363 @cached_property\r
3364 def GetGuidsUsedByPcd(self):\r
3365 RetVal = OrderedDict(self.Module.GetGuidsUsedByPcd())\r
3366 for Library in self.DependentLibraryList:\r
3367 RetVal.update(Library.GetGuidsUsedByPcd())\r
3368 return RetVal\r
3369 ## Get the protocol value mapping\r
3370 #\r
3371 # @retval dict The mapping between protocol cname and its value\r
3372 #\r
3373 @cached_property\r
3374 def ProtocolList(self):\r
3375 RetVal = OrderedDict(self.Module.Protocols)\r
3376 for Library in self.DependentLibraryList:\r
3377 RetVal.update(Library.Protocols)\r
3378 ExtendCopyDictionaryLists(self._ProtocolComments, Library.ProtocolComments)\r
3379 ExtendCopyDictionaryLists(self._ProtocolComments, self.Module.ProtocolComments)\r
3380 return RetVal\r
3381\r
3382 ## Get the PPI value mapping\r
3383 #\r
3384 # @retval dict The mapping between PPI cname and its value\r
3385 #\r
3386 @cached_property\r
3387 def PpiList(self):\r
3388 RetVal = OrderedDict(self.Module.Ppis)\r
3389 for Library in self.DependentLibraryList:\r
3390 RetVal.update(Library.Ppis)\r
3391 ExtendCopyDictionaryLists(self._PpiComments, Library.PpiComments)\r
3392 ExtendCopyDictionaryLists(self._PpiComments, self.Module.PpiComments)\r
3393 return RetVal\r
3394\r
3395 ## Get the list of include search path\r
3396 #\r
3397 # @retval list The list path\r
3398 #\r
3399 @cached_property\r
3400 def IncludePathList(self):\r
3401 RetVal = []\r
3402 if self.AutoGenVersion < 0x00010005:\r
3403 for Inc in self.Module.Includes:\r
3404 if Inc not in RetVal:\r
3405 RetVal.append(Inc)\r
3406 # for Edk modules\r
3407 Inc = path.join(Inc, self.Arch.capitalize())\r
3408 if os.path.exists(Inc) and Inc not in RetVal:\r
3409 RetVal.append(Inc)\r
3410 # Edk module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time\r
3411 RetVal.append(self.DebugDir)\r
3412 else:\r
3413 RetVal.append(self.MetaFile.Dir)\r
3414 RetVal.append(self.DebugDir)\r
3415\r
3416 for Package in self.Module.Packages:\r
3417 PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
3418 if PackageDir not in RetVal:\r
3419 RetVal.append(PackageDir)\r
3420 IncludesList = Package.Includes\r
3421 if Package._PrivateIncludes:\r
3422 if not self.MetaFile.Path.startswith(PackageDir):\r
3423 IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))\r
3424 for Inc in IncludesList:\r
3425 if Inc not in RetVal:\r
3426 RetVal.append(str(Inc))\r
3427 return RetVal\r
3428\r
3429 @cached_property\r
3430 def IncludePathLength(self):\r
3431 return sum(len(inc)+1 for inc in self.IncludePathList)\r
3432\r
3433 ## Get HII EX PCDs which maybe used by VFR\r
3434 #\r
3435 # efivarstore used by VFR may relate with HII EX PCDs\r
3436 # Get the variable name and GUID from efivarstore and HII EX PCD\r
3437 # List the HII EX PCDs in As Built INF if both name and GUID match.\r
3438 #\r
3439 # @retval list HII EX PCDs\r
3440 #\r
3441 def _GetPcdsMaybeUsedByVfr(self):\r
3442 if not self.SourceFileList:\r
3443 return []\r
3444\r
3445 NameGuids = set()\r
3446 for SrcFile in self.SourceFileList:\r
3447 if SrcFile.Ext.lower() != '.vfr':\r
3448 continue\r
3449 Vfri = os.path.join(self.OutputDir, SrcFile.BaseName + '.i')\r
3450 if not os.path.exists(Vfri):\r
3451 continue\r
3452 VfriFile = open(Vfri, 'r')\r
3453 Content = VfriFile.read()\r
3454 VfriFile.close()\r
3455 Pos = Content.find('efivarstore')\r
3456 while Pos != -1:\r
3457 #\r
3458 # Make sure 'efivarstore' is the start of efivarstore statement\r
3459 # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'\r
3460 #\r
3461 Index = Pos - 1\r
3462 while Index >= 0 and Content[Index] in ' \t\r\n':\r
3463 Index -= 1\r
3464 if Index >= 0 and Content[Index] != ';':\r
3465 Pos = Content.find('efivarstore', Pos + len('efivarstore'))\r
3466 continue\r
3467 #\r
3468 # 'efivarstore' must be followed by name and guid\r
3469 #\r
3470 Name = gEfiVarStoreNamePattern.search(Content, Pos)\r
3471 if not Name:\r
3472 break\r
3473 Guid = gEfiVarStoreGuidPattern.search(Content, Pos)\r
3474 if not Guid:\r
3475 break\r
3476 NameArray = ConvertStringToByteArray('L"' + Name.group(1) + '"')\r
3477 NameGuids.add((NameArray, GuidStructureStringToGuidString(Guid.group(1))))\r
3478 Pos = Content.find('efivarstore', Name.end())\r
3479 if not NameGuids:\r
3480 return []\r
3481 HiiExPcds = []\r
3482 for Pcd in self.PlatformInfo.Platform.Pcds.values():\r
3483 if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:\r
3484 continue\r
3485 for SkuInfo in Pcd.SkuInfoList.values():\r
3486 Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList, self.MetaFile.Path)\r
3487 if not Value:\r
3488 continue\r
3489 Name = ConvertStringToByteArray(SkuInfo.VariableName)\r
3490 Guid = GuidStructureStringToGuidString(Value)\r
3491 if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:\r
3492 HiiExPcds.append(Pcd)\r
3493 break\r
3494\r
3495 return HiiExPcds\r
3496\r
3497 def _GenOffsetBin(self):\r
3498 VfrUniBaseName = {}\r
3499 for SourceFile in self.Module.Sources:\r
3500 if SourceFile.Type.upper() == ".VFR" :\r
3501 #\r
3502 # search the .map file to find the offset of vfr binary in the PE32+/TE file.\r
3503 #\r
3504 VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")\r
3505 elif SourceFile.Type.upper() == ".UNI" :\r
3506 #\r
3507 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.\r
3508 #\r
3509 VfrUniBaseName["UniOffsetName"] = (self.Name + "Strings")\r
3510\r
3511 if not VfrUniBaseName:\r
3512 return None\r
3513 MapFileName = os.path.join(self.OutputDir, self.Name + ".map")\r
3514 EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")\r
3515 VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())\r
3516 if not VfrUniOffsetList:\r
3517 return None\r
3518\r
3519 OutputName = '%sOffset.bin' % self.Name\r
3520 UniVfrOffsetFileName = os.path.join( self.OutputDir, OutputName)\r
3521\r
3522 try:\r
3523 fInputfile = open(UniVfrOffsetFileName, "wb+", 0)\r
3524 except:\r
3525 EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)\r
3526\r
3527 # Use a instance of BytesIO to cache data\r
3528 fStringIO = BytesIO('')\r
3529\r
3530 for Item in VfrUniOffsetList:\r
3531 if (Item[0].find("Strings") != -1):\r
3532 #\r
3533 # UNI offset in image.\r
3534 # GUID + Offset\r
3535 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }\r
3536 #\r
3537 UniGuid = [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]\r
3538 UniGuid = [chr(ItemGuid) for ItemGuid in UniGuid]\r
3539 fStringIO.write(''.join(UniGuid))\r
3540 UniValue = pack ('Q', int (Item[1], 16))\r
3541 fStringIO.write (UniValue)\r
3542 else:\r
3543 #\r
3544 # VFR binary offset in image.\r
3545 # GUID + Offset\r
3546 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };\r
3547 #\r
3548 VfrGuid = [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]\r
3549 VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]\r
3550 fStringIO.write(''.join(VfrGuid))\r
3551 VfrValue = pack ('Q', int (Item[1], 16))\r
3552 fStringIO.write (VfrValue)\r
3553 #\r
3554 # write data into file.\r
3555 #\r
3556 try :\r
3557 fInputfile.write (fStringIO.getvalue())\r
3558 except:\r
3559 EdkLogger.error("build", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the "\r
3560 "file been locked or using by other applications." %UniVfrOffsetFileName, None)\r
3561\r
3562 fStringIO.close ()\r
3563 fInputfile.close ()\r
3564 return OutputName\r
3565\r
3566 ## Create AsBuilt INF file the module\r
3567 #\r
3568 def CreateAsBuiltInf(self, IsOnlyCopy = False):\r
3569 self.OutputFile = set()\r
3570 if IsOnlyCopy and GlobalData.gBinCacheDest:\r
3571 self.CopyModuleToCache()\r
3572 return\r
3573\r
3574 if self.IsAsBuiltInfCreated:\r
3575 return\r
3576\r
3577 # Skip the following code for EDK I inf\r
3578 if self.AutoGenVersion < 0x00010005:\r
3579 return\r
3580\r
3581 # Skip the following code for libraries\r
3582 if self.IsLibrary:\r
3583 return\r
3584\r
3585 # Skip the following code for modules with no source files\r
3586 if not self.SourceFileList:\r
3587 return\r
3588\r
3589 # Skip the following code for modules without any binary files\r
3590 if self.BinaryFileList:\r
3591 return\r
3592\r
3593 ### TODO: How to handles mixed source and binary modules\r
3594\r
3595 # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries\r
3596 # Also find all packages that the DynamicEx PCDs depend on\r
3597 Pcds = []\r
3598 PatchablePcds = []\r
3599 Packages = []\r
3600 PcdCheckList = []\r
3601 PcdTokenSpaceList = []\r
3602 for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
3603 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
3604 PatchablePcds.append(Pcd)\r
3605 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))\r
3606 elif Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:\r
3607 if Pcd not in Pcds:\r
3608 Pcds.append(Pcd)\r
3609 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX))\r
3610 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC))\r
3611 PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
3612 GuidList = OrderedDict(self.GuidList)\r
3613 for TokenSpace in self.GetGuidsUsedByPcd:\r
3614 # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list\r
3615 # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs\r
3616 if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:\r
3617 GuidList.pop(TokenSpace)\r
3618 CheckList = (GuidList, self.PpiList, self.ProtocolList, PcdCheckList)\r
3619 for Package in self.DerivedPackageList:\r
3620 if Package in Packages:\r
3621 continue\r
3622 BeChecked = (Package.Guids, Package.Ppis, Package.Protocols, Package.Pcds)\r
3623 Found = False\r
3624 for Index in range(len(BeChecked)):\r
3625 for Item in CheckList[Index]:\r
3626 if Item in BeChecked[Index]:\r
3627 Packages.append(Package)\r
3628 Found = True\r
3629 break\r
3630 if Found:\r
3631 break\r
3632\r
3633 VfrPcds = self._GetPcdsMaybeUsedByVfr()\r
3634 for Pkg in self.PlatformInfo.PackageList:\r
3635 if Pkg in Packages:\r
3636 continue\r
3637 for VfrPcd in VfrPcds:\r
3638 if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX) in Pkg.Pcds or\r
3639 (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC) in Pkg.Pcds):\r
3640 Packages.append(Pkg)\r
3641 break\r
3642\r
3643 ModuleType = SUP_MODULE_DXE_DRIVER if self.ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated else self.ModuleType\r
3644 DriverType = self.PcdIsDriver if self.PcdIsDriver else ''\r
3645 Guid = self.Guid\r
3646 MDefs = self.Module.Defines\r
3647\r
3648 AsBuiltInfDict = {\r
3649 'module_name' : self.Name,\r
3650 'module_guid' : Guid,\r
3651 'module_module_type' : ModuleType,\r
3652 'module_version_string' : [MDefs['VERSION_STRING']] if 'VERSION_STRING' in MDefs else [],\r
3653 'pcd_is_driver_string' : [],\r
3654 'module_uefi_specification_version' : [],\r
3655 'module_pi_specification_version' : [],\r
3656 'module_entry_point' : self.Module.ModuleEntryPointList,\r
3657 'module_unload_image' : self.Module.ModuleUnloadImageList,\r
3658 'module_constructor' : self.Module.ConstructorList,\r
3659 'module_destructor' : self.Module.DestructorList,\r
3660 'module_shadow' : [MDefs['SHADOW']] if 'SHADOW' in MDefs else [],\r
3661 'module_pci_vendor_id' : [MDefs['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs else [],\r
3662 'module_pci_device_id' : [MDefs['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs else [],\r
3663 'module_pci_class_code' : [MDefs['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs else [],\r
3664 'module_pci_revision' : [MDefs['PCI_REVISION']] if 'PCI_REVISION' in MDefs else [],\r
3665 'module_build_number' : [MDefs['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs else [],\r
3666 'module_spec' : [MDefs['SPEC']] if 'SPEC' in MDefs else [],\r
3667 'module_uefi_hii_resource_section' : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],\r
3668 'module_uni_file' : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],\r
3669 'module_arch' : self.Arch,\r
3670 'package_item' : [Package.MetaFile.File.replace('\\', '/') for Package in Packages],\r
3671 'binary_item' : [],\r
3672 'patchablepcd_item' : [],\r
3673 'pcd_item' : [],\r
3674 'protocol_item' : [],\r
3675 'ppi_item' : [],\r
3676 'guid_item' : [],\r
3677 'flags_item' : [],\r
3678 'libraryclasses_item' : []\r
3679 }\r
3680\r
3681 if 'MODULE_UNI_FILE' in MDefs:\r
3682 UNIFile = os.path.join(self.MetaFile.Dir, MDefs['MODULE_UNI_FILE'])\r
3683 if os.path.isfile(UNIFile):\r
3684 shutil.copy2(UNIFile, self.OutputDir)\r
3685\r
3686 if self.AutoGenVersion > int(gInfSpecVersion, 0):\r
3687 AsBuiltInfDict['module_inf_version'] = '0x%08x' % self.AutoGenVersion\r
3688 else:\r
3689 AsBuiltInfDict['module_inf_version'] = gInfSpecVersion\r
3690\r
3691 if DriverType:\r
3692 AsBuiltInfDict['pcd_is_driver_string'].append(DriverType)\r
3693\r
3694 if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
3695 AsBuiltInfDict['module_uefi_specification_version'].append(self.Specification['UEFI_SPECIFICATION_VERSION'])\r
3696 if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
3697 AsBuiltInfDict['module_pi_specification_version'].append(self.Specification['PI_SPECIFICATION_VERSION'])\r
3698\r
3699 OutputDir = self.OutputDir.replace('\\', '/').strip('/')\r
3700 DebugDir = self.DebugDir.replace('\\', '/').strip('/')\r
3701 for Item in self.CodaTargetList:\r
3702 File = Item.Target.Path.replace('\\', '/').strip('/').replace(DebugDir, '').replace(OutputDir, '').strip('/')\r
3703 self.OutputFile.add(File)\r
3704 if os.path.isabs(File):\r
3705 File = File.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')\r
3706 if Item.Target.Ext.lower() == '.aml':\r
3707 AsBuiltInfDict['binary_item'].append('ASL|' + File)\r
3708 elif Item.Target.Ext.lower() == '.acpi':\r
3709 AsBuiltInfDict['binary_item'].append('ACPI|' + File)\r
3710 elif Item.Target.Ext.lower() == '.efi':\r
3711 AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')\r
3712 else:\r
3713 AsBuiltInfDict['binary_item'].append('BIN|' + File)\r
3714 if self.DepexGenerated:\r
3715 self.OutputFile.add(self.Name + '.depex')\r
3716 if self.ModuleType in [SUP_MODULE_PEIM]:\r
3717 AsBuiltInfDict['binary_item'].append('PEI_DEPEX|' + self.Name + '.depex')\r
3718 elif self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:\r
3719 AsBuiltInfDict['binary_item'].append('DXE_DEPEX|' + self.Name + '.depex')\r
3720 elif self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:\r
3721 AsBuiltInfDict['binary_item'].append('SMM_DEPEX|' + self.Name + '.depex')\r
3722\r
3723 Bin = self._GenOffsetBin()\r
3724 if Bin:\r
3725 AsBuiltInfDict['binary_item'].append('BIN|%s' % Bin)\r
3726 self.OutputFile.add(Bin)\r
3727\r
3728 for Root, Dirs, Files in os.walk(OutputDir):\r
3729 for File in Files:\r
3730 if File.lower().endswith('.pdb'):\r
3731 AsBuiltInfDict['binary_item'].append('DISPOSABLE|' + File)\r
3732 self.OutputFile.add(File)\r
3733 HeaderComments = self.Module.HeaderComments\r
3734 StartPos = 0\r
3735 for Index in range(len(HeaderComments)):\r
3736 if HeaderComments[Index].find('@BinaryHeader') != -1:\r
3737 HeaderComments[Index] = HeaderComments[Index].replace('@BinaryHeader', '@file')\r
3738 StartPos = Index\r
3739 break\r
3740 AsBuiltInfDict['header_comments'] = '\n'.join(HeaderComments[StartPos:]).replace(':#', '://')\r
3741 AsBuiltInfDict['tail_comments'] = '\n'.join(self.Module.TailComments)\r
3742\r
3743 GenList = [\r
3744 (self.ProtocolList, self._ProtocolComments, 'protocol_item'),\r
3745 (self.PpiList, self._PpiComments, 'ppi_item'),\r
3746 (GuidList, self._GuidComments, 'guid_item')\r
3747 ]\r
3748 for Item in GenList:\r
3749 for CName in Item[0]:\r
3750 Comments = '\n '.join(Item[1][CName]) if CName in Item[1] else ''\r
3751 Entry = Comments + '\n ' + CName if Comments else CName\r
3752 AsBuiltInfDict[Item[2]].append(Entry)\r
3753 PatchList = parsePcdInfoFromMapFile(\r
3754 os.path.join(self.OutputDir, self.Name + '.map'),\r
3755 os.path.join(self.OutputDir, self.Name + '.efi')\r
3756 )\r
3757 if PatchList:\r
3758 for Pcd in PatchablePcds:\r
3759 TokenCName = Pcd.TokenCName\r
3760 for PcdItem in GlobalData.MixedPcd:\r
3761 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
3762 TokenCName = PcdItem[0]\r
3763 break\r
3764 for PatchPcd in PatchList:\r
3765 if TokenCName == PatchPcd[0]:\r
3766 break\r
3767 else:\r
3768 continue\r
3769 PcdValue = ''\r
3770 if Pcd.DatumType == 'BOOLEAN':\r
3771 BoolValue = Pcd.DefaultValue.upper()\r
3772 if BoolValue == 'TRUE':\r
3773 Pcd.DefaultValue = '1'\r
3774 elif BoolValue == 'FALSE':\r
3775 Pcd.DefaultValue = '0'\r
3776\r
3777 if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:\r
3778 HexFormat = '0x%02x'\r
3779 if Pcd.DatumType == TAB_UINT16:\r
3780 HexFormat = '0x%04x'\r
3781 elif Pcd.DatumType == TAB_UINT32:\r
3782 HexFormat = '0x%08x'\r
3783 elif Pcd.DatumType == TAB_UINT64:\r
3784 HexFormat = '0x%016x'\r
3785 PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
3786 else:\r
3787 if Pcd.MaxDatumSize is None or Pcd.MaxDatumSize == '':\r
3788 EdkLogger.error("build", AUTOGEN_ERROR,\r
3789 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName)\r
3790 )\r
3791 ArraySize = int(Pcd.MaxDatumSize, 0)\r
3792 PcdValue = Pcd.DefaultValue\r
3793 if PcdValue[0] != '{':\r
3794 Unicode = False\r
3795 if PcdValue[0] == 'L':\r
3796 Unicode = True\r
3797 PcdValue = PcdValue.lstrip('L')\r
3798 PcdValue = eval(PcdValue)\r
3799 NewValue = '{'\r
3800 for Index in range(0, len(PcdValue)):\r
3801 if Unicode:\r
3802 CharVal = ord(PcdValue[Index])\r
3803 NewValue = NewValue + '0x%02x' % (CharVal & 0x00FF) + ', ' \\r
3804 + '0x%02x' % (CharVal >> 8) + ', '\r
3805 else:\r
3806 NewValue = NewValue + '0x%02x' % (ord(PcdValue[Index]) % 0x100) + ', '\r
3807 Padding = '0x00, '\r
3808 if Unicode:\r
3809 Padding = Padding * 2\r
3810 ArraySize = ArraySize / 2\r
3811 if ArraySize < (len(PcdValue) + 1):\r
3812 if Pcd.MaxSizeUserSet:\r
3813 EdkLogger.error("build", AUTOGEN_ERROR,\r
3814 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)\r
3815 )\r
3816 else:\r
3817 ArraySize = len(PcdValue) + 1\r
3818 if ArraySize > len(PcdValue) + 1:\r
3819 NewValue = NewValue + Padding * (ArraySize - len(PcdValue) - 1)\r
3820 PcdValue = NewValue + Padding.strip().rstrip(',') + '}'\r
3821 elif len(PcdValue.split(',')) <= ArraySize:\r
3822 PcdValue = PcdValue.rstrip('}') + ', 0x00' * (ArraySize - len(PcdValue.split(',')))\r
3823 PcdValue += '}'\r
3824 else:\r
3825 if Pcd.MaxSizeUserSet:\r
3826 EdkLogger.error("build", AUTOGEN_ERROR,\r
3827 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)\r
3828 )\r
3829 else:\r
3830 ArraySize = len(PcdValue) + 1\r
3831 PcdItem = '%s.%s|%s|0x%X' % \\r
3832 (Pcd.TokenSpaceGuidCName, TokenCName, PcdValue, PatchPcd[1])\r
3833 PcdComments = ''\r
3834 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
3835 PcdComments = '\n '.join(self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName])\r
3836 if PcdComments:\r
3837 PcdItem = PcdComments + '\n ' + PcdItem\r
3838 AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r
3839\r
3840 for Pcd in Pcds + VfrPcds:\r
3841 PcdCommentList = []\r
3842 HiiInfo = ''\r
3843 TokenCName = Pcd.TokenCName\r
3844 for PcdItem in GlobalData.MixedPcd:\r
3845 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
3846 TokenCName = PcdItem[0]\r
3847 break\r
3848 if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
3849 for SkuName in Pcd.SkuInfoList:\r
3850 SkuInfo = Pcd.SkuInfoList[SkuName]\r
3851 HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
3852 break\r
3853 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
3854 PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
3855 if HiiInfo:\r
3856 UsageIndex = -1\r
3857 UsageStr = ''\r
3858 for Index, Comment in enumerate(PcdCommentList):\r
3859 for Usage in UsageList:\r
3860 if Comment.find(Usage) != -1:\r
3861 UsageStr = Usage\r
3862 UsageIndex = Index\r
3863 break\r
3864 if UsageIndex != -1:\r
3865 PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, ''))\r
3866 else:\r
3867 PcdCommentList.append('## UNDEFINED ' + HiiInfo)\r
3868 PcdComments = '\n '.join(PcdCommentList)\r
3869 PcdEntry = Pcd.TokenSpaceGuidCName + '.' + TokenCName\r
3870 if PcdComments:\r
3871 PcdEntry = PcdComments + '\n ' + PcdEntry\r
3872 AsBuiltInfDict['pcd_item'].append(PcdEntry)\r
3873 for Item in self.BuildOption:\r
3874 if 'FLAGS' in self.BuildOption[Item]:\r
3875 AsBuiltInfDict['flags_item'].append('%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip()))\r
3876\r
3877 # Generated LibraryClasses section in comments.\r
3878 for Library in self.LibraryAutoGenList:\r
3879 AsBuiltInfDict['libraryclasses_item'].append(Library.MetaFile.File.replace('\\', '/'))\r
3880\r
3881 # Generated UserExtensions TianoCore section.\r
3882 # All tianocore user extensions are copied.\r
3883 UserExtStr = ''\r
3884 for TianoCore in self._GetTianoCoreUserExtensionList():\r
3885 UserExtStr += '\n'.join(TianoCore)\r
3886 ExtensionFile = os.path.join(self.MetaFile.Dir, TianoCore[1])\r
3887 if os.path.isfile(ExtensionFile):\r
3888 shutil.copy2(ExtensionFile, self.OutputDir)\r
3889 AsBuiltInfDict['userextension_tianocore_item'] = UserExtStr\r
3890\r
3891 # Generated depex expression section in comments.\r
3892 DepexExpresion = self._GetDepexExpresionString()\r
3893 AsBuiltInfDict['depexsection_item'] = DepexExpresion if DepexExpresion else ''\r
3894\r
3895 AsBuiltInf = TemplateString()\r
3896 AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))\r
3897\r
3898 SaveFileOnChange(os.path.join(self.OutputDir, self.Name + '.inf'), str(AsBuiltInf), False)\r
3899\r
3900 self.IsAsBuiltInfCreated = True\r
3901 if GlobalData.gBinCacheDest:\r
3902 self.CopyModuleToCache()\r
3903\r
3904 def CopyModuleToCache(self):\r
3905 FileDir = path.join(GlobalData.gBinCacheDest, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
3906 CreateDirectory (FileDir)\r
3907 HashFile = path.join(self.BuildDir, self.Name + '.hash')\r
3908 ModuleFile = path.join(self.OutputDir, self.Name + '.inf')\r
3909 if os.path.exists(HashFile):\r
3910 shutil.copy2(HashFile, FileDir)\r
3911 if os.path.exists(ModuleFile):\r
3912 shutil.copy2(ModuleFile, FileDir)\r
3913 if not self.OutputFile:\r
3914 Ma = self.Workspace.BuildDatabase[PathClass(ModuleFile), self.Arch, self.BuildTarget, self.ToolChain]\r
3915 self.OutputFile = Ma.Binaries\r
3916 if self.OutputFile:\r
3917 for File in self.OutputFile:\r
3918 File = str(File)\r
3919 if not os.path.isabs(File):\r
3920 File = os.path.join(self.OutputDir, File)\r
3921 if os.path.exists(File):\r
3922 shutil.copy2(File, FileDir)\r
3923\r
3924 def AttemptModuleCacheCopy(self):\r
3925 if self.IsBinaryModule:\r
3926 return False\r
3927 FileDir = path.join(GlobalData.gBinCacheSource, self.Arch, self.SourceDir, self.MetaFile.BaseName)\r
3928 HashFile = path.join(FileDir, self.Name + '.hash')\r
3929 if os.path.exists(HashFile):\r
3930 f = open(HashFile, 'r')\r
3931 CacheHash = f.read()\r
3932 f.close()\r
3933 if GlobalData.gModuleHash[self.Arch][self.Name]:\r
3934 if CacheHash == GlobalData.gModuleHash[self.Arch][self.Name]:\r
3935 for root, dir, files in os.walk(FileDir):\r
3936 for f in files:\r
3937 if self.Name + '.hash' in f:\r
3938 shutil.copy2(HashFile, self.BuildDir)\r
3939 else:\r
3940 File = path.join(root, f)\r
3941 shutil.copy2(File, self.OutputDir)\r
3942 if self.Name == "PcdPeim" or self.Name == "PcdDxe":\r
3943 CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
3944 return True\r
3945 return False\r
3946\r
3947 ## Create makefile for the module and its dependent libraries\r
3948 #\r
3949 # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of\r
3950 # dependent libraries will be created\r
3951 #\r
3952 @cached_class_function\r
3953 def CreateMakeFile(self, CreateLibraryMakeFile=True, GenFfsList = []):\r
3954 # nest this function inside it's only caller.\r
3955 def CreateTimeStamp():\r
3956 FileSet = {self.MetaFile.Path}\r
3957\r
3958 for SourceFile in self.Module.Sources:\r
3959 FileSet.add (SourceFile.Path)\r
3960\r
3961 for Lib in self.DependentLibraryList:\r
3962 FileSet.add (Lib.MetaFile.Path)\r
3963\r
3964 for f in self.AutoGenDepSet:\r
3965 FileSet.add (f.Path)\r
3966\r
3967 if os.path.exists (self.TimeStampPath):\r
3968 os.remove (self.TimeStampPath)\r
3969 with open(self.TimeStampPath, 'w+') as file:\r
3970 for f in FileSet:\r
3971 print(f, file=file)\r
3972\r
3973 # Ignore generating makefile when it is a binary module\r
3974 if self.IsBinaryModule:\r
3975 return\r
3976\r
3977 self.GenFfsList = GenFfsList\r
3978 if not self.IsLibrary and CreateLibraryMakeFile:\r
3979 for LibraryAutoGen in self.LibraryAutoGenList:\r
3980 LibraryAutoGen.CreateMakeFile()\r
3981\r
3982 if self.CanSkip():\r
3983 return\r
3984\r
3985 if len(self.CustomMakefile) == 0:\r
3986 Makefile = GenMake.ModuleMakefile(self)\r
3987 else:\r
3988 Makefile = GenMake.CustomMakefile(self)\r
3989 if Makefile.Generate():\r
3990 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %\r
3991 (self.Name, self.Arch))\r
3992 else:\r
3993 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %\r
3994 (self.Name, self.Arch))\r
3995\r
3996 CreateTimeStamp()\r
3997\r
3998 def CopyBinaryFiles(self):\r
3999 for File in self.Module.Binaries:\r
4000 SrcPath = File.Path\r
4001 DstPath = os.path.join(self.OutputDir, os.path.basename(SrcPath))\r
4002 CopyLongFilePath(SrcPath, DstPath)\r
4003 ## Create autogen code for the module and its dependent libraries\r
4004 #\r
4005 # @param CreateLibraryCodeFile Flag indicating if or not the code of\r
4006 # dependent libraries will be created\r
4007 #\r
4008 def CreateCodeFile(self, CreateLibraryCodeFile=True):\r
4009 if self.IsCodeFileCreated:\r
4010 return\r
4011\r
4012 # Need to generate PcdDatabase even PcdDriver is binarymodule\r
4013 if self.IsBinaryModule and self.PcdIsDriver != '':\r
4014 CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
4015 return\r
4016 if self.IsBinaryModule:\r
4017 if self.IsLibrary:\r
4018 self.CopyBinaryFiles()\r
4019 return\r
4020\r
4021 if not self.IsLibrary and CreateLibraryCodeFile:\r
4022 for LibraryAutoGen in self.LibraryAutoGenList:\r
4023 LibraryAutoGen.CreateCodeFile()\r
4024\r
4025 if self.CanSkip():\r
4026 return\r
4027\r
4028 AutoGenList = []\r
4029 IgoredAutoGenList = []\r
4030\r
4031 for File in self.AutoGenFileList:\r
4032 if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):\r
4033 #Ignore Edk AutoGen.c\r
4034 if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':\r
4035 continue\r
4036\r
4037 AutoGenList.append(str(File))\r
4038 else:\r
4039 IgoredAutoGenList.append(str(File))\r
4040\r
4041 # Skip the following code for EDK I inf\r
4042 if self.AutoGenVersion < 0x00010005:\r
4043 return\r
4044\r
4045 for ModuleType in self.DepexList:\r
4046 # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module\r
4047 if len(self.DepexList[ModuleType]) == 0 or ModuleType == SUP_MODULE_USER_DEFINED:\r
4048 continue\r
4049\r
4050 Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
4051 DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
4052\r
4053 if len(Dpx.PostfixNotation) != 0:\r
4054 self.DepexGenerated = True\r
4055\r
4056 if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
4057 AutoGenList.append(str(DpxFile))\r
4058 else:\r
4059 IgoredAutoGenList.append(str(DpxFile))\r
4060\r
4061 if IgoredAutoGenList == []:\r
4062 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %\r
4063 (" ".join(AutoGenList), self.Name, self.Arch))\r
4064 elif AutoGenList == []:\r
4065 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %\r
4066 (" ".join(IgoredAutoGenList), self.Name, self.Arch))\r
4067 else:\r
4068 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %\r
4069 (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))\r
4070\r
4071 self.IsCodeFileCreated = True\r
4072 return AutoGenList\r
4073\r
4074 ## Summarize the ModuleAutoGen objects of all libraries used by this module\r
4075 @cached_property\r
4076 def LibraryAutoGenList(self):\r
4077 RetVal = []\r
4078 for Library in self.DependentLibraryList:\r
4079 La = ModuleAutoGen(\r
4080 self.Workspace,\r
4081 Library.MetaFile,\r
4082 self.BuildTarget,\r
4083 self.ToolChain,\r
4084 self.Arch,\r
4085 self.PlatformInfo.MetaFile\r
4086 )\r
4087 if La not in RetVal:\r
4088 RetVal.append(La)\r
4089 for Lib in La.CodaTargetList:\r
4090 self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)\r
4091 return RetVal\r
4092\r
4093 def GenModuleHash(self):\r
4094 if self.Arch not in GlobalData.gModuleHash:\r
4095 GlobalData.gModuleHash[self.Arch] = {}\r
4096 m = hashlib.md5()\r
4097 # Add Platform level hash\r
4098 m.update(GlobalData.gPlatformHash)\r
4099 # Add Package level hash\r
4100 if self.DependentPackageList:\r
4101 for Pkg in sorted(self.DependentPackageList, key=lambda x: x.PackageName):\r
4102 if Pkg.PackageName in GlobalData.gPackageHash[self.Arch]:\r
4103 m.update(GlobalData.gPackageHash[self.Arch][Pkg.PackageName])\r
4104\r
4105 # Add Library hash\r
4106 if self.LibraryAutoGenList:\r
4107 for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.Name):\r
4108 if Lib.Name not in GlobalData.gModuleHash[self.Arch]:\r
4109 Lib.GenModuleHash()\r
4110 m.update(GlobalData.gModuleHash[self.Arch][Lib.Name])\r
4111\r
4112 # Add Module self\r
4113 f = open(str(self.MetaFile), 'r')\r
4114 Content = f.read()\r
4115 f.close()\r
4116 m.update(Content)\r
4117 # Add Module's source files\r
4118 if self.SourceFileList:\r
4119 for File in sorted(self.SourceFileList, key=lambda x: str(x)):\r
4120 f = open(str(File), 'r')\r
4121 Content = f.read()\r
4122 f.close()\r
4123 m.update(Content)\r
4124\r
4125 ModuleHashFile = path.join(self.BuildDir, self.Name + ".hash")\r
4126 if self.Name not in GlobalData.gModuleHash[self.Arch]:\r
4127 GlobalData.gModuleHash[self.Arch][self.Name] = m.hexdigest()\r
4128 if GlobalData.gBinCacheSource:\r
4129 if self.AttemptModuleCacheCopy():\r
4130 return False\r
4131 return SaveFileOnChange(ModuleHashFile, m.hexdigest(), True)\r
4132\r
4133 ## Decide whether we can skip the ModuleAutoGen process\r
4134 def CanSkipbyHash(self):\r
4135 if GlobalData.gUseHashCache:\r
4136 return not self.GenModuleHash()\r
4137 return False\r
4138\r
4139 ## Decide whether we can skip the ModuleAutoGen process\r
4140 # If any source file is newer than the module than we cannot skip\r
4141 #\r
4142 def CanSkip(self):\r
4143 if self.MakeFileDir in GlobalData.gSikpAutoGenCache:\r
4144 return True\r
4145 if not os.path.exists(self.TimeStampPath):\r
4146 return False\r
4147 #last creation time of the module\r
4148 DstTimeStamp = os.stat(self.TimeStampPath)[8]\r
4149\r
4150 SrcTimeStamp = self.Workspace._SrcTimeStamp\r
4151 if SrcTimeStamp > DstTimeStamp:\r
4152 return False\r
4153\r
4154 with open(self.TimeStampPath,'r') as f:\r
4155 for source in f:\r
4156 source = source.rstrip('\n')\r
4157 if not os.path.exists(source):\r
4158 return False\r
4159 if source not in ModuleAutoGen.TimeDict :\r
4160 ModuleAutoGen.TimeDict[source] = os.stat(source)[8]\r
4161 if ModuleAutoGen.TimeDict[source] > DstTimeStamp:\r
4162 return False\r
4163 GlobalData.gSikpAutoGenCache.add(self.MakeFileDir)\r
4164 return True\r
4165\r
4166 @cached_property\r
4167 def TimeStampPath(self):\r
4168 return os.path.join(self.MakeFileDir, 'AutoGenTimeStamp')\r
EFI Development Kit II mirror for PVE