]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/Python/AutoGen/AutoGen.py
projects / mirror_edk2.git / blob
? search:


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