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