projects / mirror_edk2.git / blob
? search:


54c6b7330f53ee5de6866309d38febc7de3da235
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / AutoGen.py
1 ## @file
2 # Generate AutoGen.h, AutoGen.c and *.depex files
3 #
4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 # Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
6 #
7 # This program and the accompanying materials
8 # are licensed and made available under the terms and conditions of the BSD License
9 # which accompanies this distribution. The full text of the license may be found at
10 # http://opensource.org/licenses/bsd-license.php
11 #
12 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14 #
15
16 ## Import Modules
17 #
18 from __future__ import print_function
19 import Common.LongFilePathOs as os
20 import re
21 import os.path as path
22 import copy
23 import uuid
24
25 import GenC
26 import GenMake
27 import GenDepex
28 from io import BytesIO
29
30 from StrGather import *
31 from BuildEngine import BuildRule
32
33 from Common.LongFilePathSupport import CopyLongFilePath
34 from Common.BuildToolError import *
35 from Common.DataType import *
36 from Common.Misc import *
37 from Common.StringUtils import *
38 import Common.GlobalData as GlobalData
39 from GenFds.FdfParser import *
40 from CommonDataClass.CommonClass import SkuInfoClass
41 from Workspace.BuildClassObject import *
42 from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile
43 import Common.VpdInfoFile as VpdInfoFile
44 from GenPcdDb import CreatePcdDatabaseCode
45 from Workspace.MetaFileCommentParser import UsageList
46 from Workspace.WorkspaceCommon import GetModuleLibInstances
47 from Common.MultipleWorkspace import MultipleWorkspace as mws
48 import InfSectionParser
49 import datetime
50 import hashlib
51 from GenVar import VariableMgr, var_info
52 from collections import OrderedDict
53 from collections import defaultdict
54 from Workspace.WorkspaceCommon import OrderedListDict
55
56 ## Regular expression for splitting Dependency Expression string into tokens
57 gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")
58
59 ## Regular expression for match: PCD(xxxx.yyy)
60 gPCDAsGuidPattern = re.compile(r"^PCD\(.+\..+\)$")
61
62 #
63 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
64 # is the former use /I , the Latter used -I to specify include directories
65 #
66 gBuildOptIncludePatternMsft = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)
67 gBuildOptIncludePatternOther = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE | re.DOTALL)
68
69 #
70 # Match name = variable
71 #
72 gEfiVarStoreNamePattern = re.compile("\s*name\s*=\s*(\w+)")
73 #
74 # The format of guid in efivarstore statement likes following and must be correct:
75 # guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}
76 #
77 gEfiVarStoreGuidPattern = re.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")
78
79 ## Mapping Makefile type
80 gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}
81
82
83 ## Build rule configuration file
84 gDefaultBuildRuleFile = 'build_rule.txt'
85
86 ## Tools definition configuration file
87 gDefaultToolsDefFile = 'tools_def.txt'
88
89 ## Build rule default version
90 AutoGenReqBuildRuleVerNum = "0.1"
91
92 ## default file name for AutoGen
93 gAutoGenCodeFileName = "AutoGen.c"
94 gAutoGenHeaderFileName = "AutoGen.h"
95 gAutoGenStringFileName = "%(module_name)sStrDefs.h"
96 gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"
97 gAutoGenDepexFileName = "%(module_name)s.depex"
98 gAutoGenImageDefFileName = "%(module_name)sImgDefs.h"
99 gAutoGenIdfFileName = "%(module_name)sIdf.hpk"
100 gInfSpecVersion = "0x00010017"
101
102 #
103 # Template string to generic AsBuilt INF
104 #
105 gAsBuiltInfHeaderString = TemplateString("""${header_comments}
106
107 # DO NOT EDIT
108 # FILE auto-generated
109
110 [Defines]
111 INF_VERSION = ${module_inf_version}
112 BASE_NAME = ${module_name}
113 FILE_GUID = ${module_guid}
114 MODULE_TYPE = ${module_module_type}${BEGIN}
115 VERSION_STRING = ${module_version_string}${END}${BEGIN}
116 PCD_IS_DRIVER = ${pcd_is_driver_string}${END}${BEGIN}
117 UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}
118 PI_SPECIFICATION_VERSION = ${module_pi_specification_version}${END}${BEGIN}
119 ENTRY_POINT = ${module_entry_point}${END}${BEGIN}
120 UNLOAD_IMAGE = ${module_unload_image}${END}${BEGIN}
121 CONSTRUCTOR = ${module_constructor}${END}${BEGIN}
122 DESTRUCTOR = ${module_destructor}${END}${BEGIN}
123 SHADOW = ${module_shadow}${END}${BEGIN}
124 PCI_VENDOR_ID = ${module_pci_vendor_id}${END}${BEGIN}
125 PCI_DEVICE_ID = ${module_pci_device_id}${END}${BEGIN}
126 PCI_CLASS_CODE = ${module_pci_class_code}${END}${BEGIN}
127 PCI_REVISION = ${module_pci_revision}${END}${BEGIN}
128 BUILD_NUMBER = ${module_build_number}${END}${BEGIN}
129 SPEC = ${module_spec}${END}${BEGIN}
130 UEFI_HII_RESOURCE_SECTION = ${module_uefi_hii_resource_section}${END}${BEGIN}
131 MODULE_UNI_FILE = ${module_uni_file}${END}
132
133 [Packages.${module_arch}]${BEGIN}
134 ${package_item}${END}
135
136 [Binaries.${module_arch}]${BEGIN}
137 ${binary_item}${END}
138
139 [PatchPcd.${module_arch}]${BEGIN}
140 ${patchablepcd_item}
141 ${END}
142
143 [Protocols.${module_arch}]${BEGIN}
144 ${protocol_item}
145 ${END}
146
147 [Ppis.${module_arch}]${BEGIN}
148 ${ppi_item}
149 ${END}
150
151 [Guids.${module_arch}]${BEGIN}
152 ${guid_item}
153 ${END}
154
155 [PcdEx.${module_arch}]${BEGIN}
156 ${pcd_item}
157 ${END}
158
159 [LibraryClasses.${module_arch}]
160 ## @LIB_INSTANCES${BEGIN}
161 # ${libraryclasses_item}${END}
162
163 ${depexsection_item}
164
165 ${userextension_tianocore_item}
166
167 ${tail_comments}
168
169 [BuildOptions.${module_arch}]
170 ## @AsBuilt${BEGIN}
171 ## ${flags_item}${END}
172 """)
173
174 ## Base class for AutoGen
175 #
176 # This class just implements the cache mechanism of AutoGen objects.
177 #
178 class AutoGen(object):
179 # database to maintain the objects in each child class
180 __ObjectCache = {} # (BuildTarget, ToolChain, ARCH, platform file): AutoGen object
181
182 ## Factory method
183 #
184 # @param Class class object of real AutoGen class
185 # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)
186 # @param Workspace Workspace directory or WorkspaceAutoGen object
187 # @param MetaFile The path of meta file
188 # @param Target Build target
189 # @param Toolchain Tool chain name
190 # @param Arch Target arch
191 # @param *args The specific class related parameters
192 # @param **kwargs The specific class related dict parameters
193 #
194 def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
195 # check if the object has been created
196 Key = (Target, Toolchain, Arch, MetaFile)
197 try:
198 # if it exists, just return it directly
199 return cls.__ObjectCache[Key]
200 except:
201 # it didnt exist. create it, cache it, then return it
202 cls.__ObjectCache[Key] = super(AutoGen, cls).__new__(cls)
203 return cls.__ObjectCache[Key]
204
205 def __init__ (self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
206 super(AutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
207
208 ## hash() operator
209 #
210 # The file path of platform file will be used to represent hash value of this object
211 #
212 # @retval int Hash value of the file path of platform file
213 #
214 def __hash__(self):
215 return hash(self.MetaFile)
216
217 ## str() operator
218 #
219 # The file path of platform file will be used to represent this object
220 #
221 # @retval string String of platform file path
222 #
223 def __str__(self):
224 return str(self.MetaFile)
225
226 ## "==" operator
227 def __eq__(self, Other):
228 return Other and self.MetaFile == Other
229
230 ## Workspace AutoGen class
231 #
232 # This class is used mainly to control the whole platform build for different
233 # architecture. This class will generate top level makefile.
234 #
235 class WorkspaceAutoGen(AutoGen):
236 # call super().__init__ then call the worker function with different parameter count
237 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
238 try:
239 self._Init
240 except:
241 super(WorkspaceAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
242 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
243 self._Init = True
244
245 ## Initialize WorkspaceAutoGen
246 #
247 # @param WorkspaceDir Root directory of workspace
248 # @param ActivePlatform Meta-file of active platform
249 # @param Target Build target
250 # @param Toolchain Tool chain name
251 # @param ArchList List of architecture of current build
252 # @param MetaFileDb Database containing meta-files
253 # @param BuildConfig Configuration of build
254 # @param ToolDefinition Tool chain definitions
255 # @param FlashDefinitionFile File of flash definition
256 # @param Fds FD list to be generated
257 # @param Fvs FV list to be generated
258 # @param Caps Capsule list to be generated
259 # @param SkuId SKU id from command line
260 #
261 def _InitWorker(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,
262 BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None,
263 Progress=None, BuildModule=None):
264 self.BuildDatabase = MetaFileDb
265 self.MetaFile = ActivePlatform
266 self.WorkspaceDir = WorkspaceDir
267 self.Platform = self.BuildDatabase[self.MetaFile, TAB_ARCH_COMMON, Target, Toolchain]
268 GlobalData.gActivePlatform = self.Platform
269 self.BuildTarget = Target
270 self.ToolChain = Toolchain
271 self.ArchList = ArchList
272 self.SkuId = SkuId
273 self.UniFlag = UniFlag
274
275 self.TargetTxt = BuildConfig
276 self.ToolDef = ToolDefinition
277 self.FdfFile = FlashDefinitionFile
278 self.FdTargetList = Fds if Fds else []
279 self.FvTargetList = Fvs if Fvs else []
280 self.CapTargetList = Caps if Caps else []
281 self.AutoGenObjectList = []
282 self._BuildDir = None
283 self._FvDir = None
284 self._MakeFileDir = None
285 self._BuildCommand = None
286 self._GuidDict = {}
287
288 # there's many relative directory operations, so ...
289 os.chdir(self.WorkspaceDir)
290
291 #
292 # Merge Arch
293 #
294 if not self.ArchList:
295 ArchList = set(self.Platform.SupArchList)
296 else:
297 ArchList = set(self.ArchList) & set(self.Platform.SupArchList)
298 if not ArchList:
299 EdkLogger.error("build", PARAMETER_INVALID,
300 ExtraData = "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self.Platform.SupArchList)))
301 elif self.ArchList and len(ArchList) != len(self.ArchList):
302 SkippedArchList = set(self.ArchList).symmetric_difference(set(self.Platform.SupArchList))
303 EdkLogger.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"
304 % (" ".join(SkippedArchList), " ".join(self.Platform.SupArchList)))
305 self.ArchList = tuple(ArchList)
306
307 # Validate build target
308 if self.BuildTarget not in self.Platform.BuildTargets:
309 EdkLogger.error("build", PARAMETER_INVALID,
310 ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"
311 % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))
312
313
314 # parse FDF file to get PCDs in it, if any
315 if not self.FdfFile:
316 self.FdfFile = self.Platform.FlashDefinition
317
318 EdkLogger.info("")
319 if self.ArchList:
320 EdkLogger.info('%-16s = %s' % ("Architecture(s)", ' '.join(self.ArchList)))
321 EdkLogger.info('%-16s = %s' % ("Build target", self.BuildTarget))
322 EdkLogger.info('%-16s = %s' % ("Toolchain", self.ToolChain))
323
324 EdkLogger.info('\n%-24s = %s' % ("Active Platform", self.Platform))
325 if BuildModule:
326 EdkLogger.info('%-24s = %s' % ("Active Module", BuildModule))
327
328 if self.FdfFile:
329 EdkLogger.info('%-24s = %s' % ("Flash Image Definition", self.FdfFile))
330
331 EdkLogger.verbose("\nFLASH_DEFINITION = %s" % self.FdfFile)
332
333 if Progress:
334 Progress.Start("\nProcessing meta-data")
335
336 if self.FdfFile:
337 #
338 # Mark now build in AutoGen Phase
339 #
340 GlobalData.gAutoGenPhase = True
341 Fdf = FdfParser(self.FdfFile.Path)
342 Fdf.ParseFile()
343 GlobalData.gFdfParser = Fdf
344 GlobalData.gAutoGenPhase = False
345 PcdSet = Fdf.Profile.PcdDict
346 if Fdf.CurrentFdName and Fdf.CurrentFdName in Fdf.Profile.FdDict:
347 FdDict = Fdf.Profile.FdDict[Fdf.CurrentFdName]
348 for FdRegion in FdDict.RegionList:
349 if str(FdRegion.RegionType) is 'FILE' and self.Platform.VpdToolGuid in str(FdRegion.RegionDataList):
350 if int(FdRegion.Offset) % 8 != 0:
351 EdkLogger.error("build", FORMAT_INVALID, 'The VPD Base Address %s must be 8-byte aligned.' % (FdRegion.Offset))
352 ModuleList = Fdf.Profile.InfList
353 self.FdfProfile = Fdf.Profile
354 for fvname in self.FvTargetList:
355 if fvname.upper() not in self.FdfProfile.FvDict:
356 EdkLogger.error("build", OPTION_VALUE_INVALID,
357 "No such an FV in FDF file: %s" % fvname)
358
359 # In DSC file may use FILE_GUID to override the module, then in the Platform.Modules use FILE_GUIDmodule.inf as key,
360 # but the path (self.MetaFile.Path) is the real path
361 for key in self.FdfProfile.InfDict:
362 if key == 'ArchTBD':
363 MetaFile_cache = defaultdict(set)
364 for Arch in self.ArchList:
365 Current_Platform_cache = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]
366 for Pkey in Current_Platform_cache.Modules:
367 MetaFile_cache[Arch].add(Current_Platform_cache.Modules[Pkey].MetaFile)
368 for Inf in self.FdfProfile.InfDict[key]:
369 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)
370 for Arch in self.ArchList:
371 if ModuleFile in MetaFile_cache[Arch]:
372 break
373 else:
374 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]
375 if not ModuleData.IsBinaryModule:
376 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)
377
378 else:
379 for Arch in self.ArchList:
380 if Arch == key:
381 Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]
382 MetaFileList = set()
383 for Pkey in Platform.Modules:
384 MetaFileList.add(Platform.Modules[Pkey].MetaFile)
385 for Inf in self.FdfProfile.InfDict[key]:
386 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)
387 if ModuleFile in MetaFileList:
388 continue
389 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]
390 if not ModuleData.IsBinaryModule:
391 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)
392
393 else:
394 PcdSet = {}
395 ModuleList = []
396 self.FdfProfile = None
397 if self.FdTargetList:
398 EdkLogger.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self.FdTargetList))
399 self.FdTargetList = []
400 if self.FvTargetList:
401 EdkLogger.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self.FvTargetList))
402 self.FvTargetList = []
403 if self.CapTargetList:
404 EdkLogger.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self.CapTargetList))
405 self.CapTargetList = []
406
407 # apply SKU and inject PCDs from Flash Definition file
408 for Arch in self.ArchList:
409 Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]
410 PlatformPcds = Platform.Pcds
411 self._GuidDict = Platform._GuidDict
412 SourcePcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set(),TAB_PCDS_DYNAMIC:set(),TAB_PCDS_FIXED_AT_BUILD:set()}
413 BinaryPcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set()}
414 SourcePcdDict_Keys = SourcePcdDict.keys()
415 BinaryPcdDict_Keys = BinaryPcdDict.keys()
416
417 # generate the SourcePcdDict and BinaryPcdDict
418 PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)
419 for BuildData in PGen.BuildDatabase._CACHE_.values():
420 if BuildData.Arch != Arch:
421 continue
422 if BuildData.MetaFile.Ext == '.inf':
423 for key in BuildData.Pcds:
424 if BuildData.Pcds[key].Pending:
425 if key in Platform.Pcds:
426 PcdInPlatform = Platform.Pcds[key]
427 if PcdInPlatform.Type:
428 BuildData.Pcds[key].Type = PcdInPlatform.Type
429 BuildData.Pcds[key].Pending = False
430
431 if BuildData.MetaFile in Platform.Modules:
432 PlatformModule = Platform.Modules[str(BuildData.MetaFile)]
433 if key in PlatformModule.Pcds:
434 PcdInPlatform = PlatformModule.Pcds[key]
435 if PcdInPlatform.Type:
436 BuildData.Pcds[key].Type = PcdInPlatform.Type
437 BuildData.Pcds[key].Pending = False
438 else:
439 #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending
440 if BuildData.Pcds[key].Pending:
441 MGen = ModuleAutoGen(self, BuildData.MetaFile, Target, Toolchain, Arch, self.MetaFile)
442 if MGen and MGen.IsLibrary:
443 if MGen in PGen.LibraryAutoGenList:
444 ReferenceModules = MGen._ReferenceModules
445 for ReferenceModule in ReferenceModules:
446 if ReferenceModule.MetaFile in Platform.Modules:
447 RefPlatformModule = Platform.Modules[str(ReferenceModule.MetaFile)]
448 if key in RefPlatformModule.Pcds:
449 PcdInReferenceModule = RefPlatformModule.Pcds[key]
450 if PcdInReferenceModule.Type:
451 BuildData.Pcds[key].Type = PcdInReferenceModule.Type
452 BuildData.Pcds[key].Pending = False
453 break
454
455 if TAB_PCDS_DYNAMIC_EX in BuildData.Pcds[key].Type:
456 if BuildData.IsBinaryModule:
457 BinaryPcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
458 else:
459 SourcePcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
460
461 elif TAB_PCDS_PATCHABLE_IN_MODULE in BuildData.Pcds[key].Type:
462 if BuildData.MetaFile.Ext == '.inf':
463 if BuildData.IsBinaryModule:
464 BinaryPcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
465 else:
466 SourcePcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
467
468 elif TAB_PCDS_DYNAMIC in BuildData.Pcds[key].Type:
469 SourcePcdDict[TAB_PCDS_DYNAMIC].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
470 elif TAB_PCDS_FIXED_AT_BUILD in BuildData.Pcds[key].Type:
471 SourcePcdDict[TAB_PCDS_FIXED_AT_BUILD].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))
472 else:
473 pass
474 #
475 # A PCD can only use one type for all source modules
476 #
477 for i in SourcePcdDict_Keys:
478 for j in SourcePcdDict_Keys:
479 if i != j:
480 Intersections = SourcePcdDict[i].intersection(SourcePcdDict[j])
481 if len(Intersections) > 0:
482 EdkLogger.error(
483 'build',
484 FORMAT_INVALID,
485 "Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i, j),
486 ExtraData='\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)
487 )
488
489 #
490 # intersection the BinaryPCD for Mixed PCD
491 #
492 for i in BinaryPcdDict_Keys:
493 for j in BinaryPcdDict_Keys:
494 if i != j:
495 Intersections = BinaryPcdDict[i].intersection(BinaryPcdDict[j])
496 for item in Intersections:
497 NewPcd1 = (item[0] + '_' + i, item[1])
498 NewPcd2 = (item[0] + '_' + j, item[1])
499 if item not in GlobalData.MixedPcd:
500 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]
501 else:
502 if NewPcd1 not in GlobalData.MixedPcd[item]:
503 GlobalData.MixedPcd[item].append(NewPcd1)
504 if NewPcd2 not in GlobalData.MixedPcd[item]:
505 GlobalData.MixedPcd[item].append(NewPcd2)
506
507 #
508 # intersection the SourcePCD and BinaryPCD for Mixed PCD
509 #
510 for i in SourcePcdDict_Keys:
511 for j in BinaryPcdDict_Keys:
512 if i != j:
513 Intersections = SourcePcdDict[i].intersection(BinaryPcdDict[j])
514 for item in Intersections:
515 NewPcd1 = (item[0] + '_' + i, item[1])
516 NewPcd2 = (item[0] + '_' + j, item[1])
517 if item not in GlobalData.MixedPcd:
518 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]
519 else:
520 if NewPcd1 not in GlobalData.MixedPcd[item]:
521 GlobalData.MixedPcd[item].append(NewPcd1)
522 if NewPcd2 not in GlobalData.MixedPcd[item]:
523 GlobalData.MixedPcd[item].append(NewPcd2)
524
525 for BuildData in PGen.BuildDatabase._CACHE_.values():
526 if BuildData.Arch != Arch:
527 continue
528 for key in BuildData.Pcds:
529 for SinglePcd in GlobalData.MixedPcd:
530 if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:
531 for item in GlobalData.MixedPcd[SinglePcd]:
532 Pcd_Type = item[0].split('_')[-1]
533 if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \
534 (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):
535 Value = BuildData.Pcds[key]
536 Value.TokenCName = BuildData.Pcds[key].TokenCName + '_' + Pcd_Type
537 if len(key) == 2:
538 newkey = (Value.TokenCName, key[1])
539 elif len(key) == 3:
540 newkey = (Value.TokenCName, key[1], key[2])
541 del BuildData.Pcds[key]
542 BuildData.Pcds[newkey] = Value
543 break
544 break
545
546 # handle the mixed pcd in FDF file
547 for key in PcdSet:
548 if key in GlobalData.MixedPcd:
549 Value = PcdSet[key]
550 del PcdSet[key]
551 for item in GlobalData.MixedPcd[key]:
552 PcdSet[item] = Value
553
554 #Collect package set information from INF of FDF
555 PkgSet = set()
556 for Inf in ModuleList:
557 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)
558 if ModuleFile in Platform.Modules:
559 continue
560 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]
561 PkgSet.update(ModuleData.Packages)
562 Pkgs = list(PkgSet) + list(PGen.PackageList)
563 DecPcds = set()
564 DecPcdsKey = set()
565 for Pkg in Pkgs:
566 for Pcd in Pkg.Pcds:
567 DecPcds.add((Pcd[0], Pcd[1]))
568 DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))
569
570 Platform.SkuName = self.SkuId
571 for Name, Guid in PcdSet:
572 if (Name, Guid) not in DecPcds:
573 EdkLogger.error(
574 'build',
575 PARSER_ERROR,
576 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid, Name),
577 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],
578 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]
579 )
580 else:
581 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.
582 if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \
583 or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \
584 or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:
585 Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])
586 continue
587 elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:
588 EdkLogger.error(
589 'build',
590 PARSER_ERROR,
591 "Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid, Name),
592 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],
593 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]
594 )
595
596 Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)
597 #
598 # Explicitly collect platform's dynamic PCDs
599 #
600 Pa.CollectPlatformDynamicPcds()
601 Pa.CollectFixedAtBuildPcds()
602 self.AutoGenObjectList.append(Pa)
603
604 #
605 # Generate Package level hash value
606 #
607 GlobalData.gPackageHash[Arch] = {}
608 if GlobalData.gUseHashCache:
609 for Pkg in Pkgs:
610 self._GenPkgLevelHash(Pkg)
611
612 #
613 # Check PCDs token value conflict in each DEC file.
614 #
615 self._CheckAllPcdsTokenValueConflict()
616
617 #
618 # Check PCD type and definition between DSC and DEC
619 #
620 self._CheckPcdDefineAndType()
621
622 # if self.FdfFile:
623 # self._CheckDuplicateInFV(Fdf)
624
625 #
626 # Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.
627 #
628 content = 'gCommandLineDefines: '
629 content += str(GlobalData.gCommandLineDefines)
630 content += os.linesep
631 content += 'BuildOptionPcd: '
632 content += str(GlobalData.BuildOptionPcd)
633 content += os.linesep
634 content += 'Active Platform: '
635 content += str(self.Platform)
636 content += os.linesep
637 if self.FdfFile:
638 content += 'Flash Image Definition: '
639 content += str(self.FdfFile)
640 content += os.linesep
641 SaveFileOnChange(os.path.join(self.BuildDir, 'BuildOptions'), content, False)
642
643 #
644 # Create PcdToken Number file for Dynamic/DynamicEx Pcd.
645 #
646 PcdTokenNumber = 'PcdTokenNumber: '
647 if Pa.PcdTokenNumber:
648 if Pa.DynamicPcdList:
649 for Pcd in Pa.DynamicPcdList:
650 PcdTokenNumber += os.linesep
651 PcdTokenNumber += str((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))
652 PcdTokenNumber += ' : '
653 PcdTokenNumber += str(Pa.PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName])
654 SaveFileOnChange(os.path.join(self.BuildDir, 'PcdTokenNumber'), PcdTokenNumber, False)
655
656 #
657 # Get set of workspace metafiles
658 #
659 AllWorkSpaceMetaFiles = self._GetMetaFiles(Target, Toolchain, Arch)
660
661 #
662 # Retrieve latest modified time of all metafiles
663 #
664 SrcTimeStamp = 0
665 for f in AllWorkSpaceMetaFiles:
666 if os.stat(f)[8] > SrcTimeStamp:
667 SrcTimeStamp = os.stat(f)[8]
668 self._SrcTimeStamp = SrcTimeStamp
669
670 if GlobalData.gUseHashCache:
671 m = hashlib.md5()
672 for files in AllWorkSpaceMetaFiles:
673 if files.endswith('.dec'):
674 continue
675 f = open(files, 'r')
676 Content = f.read()
677 f.close()
678 m.update(Content)
679 SaveFileOnChange(os.path.join(self.BuildDir, 'AutoGen.hash'), m.hexdigest(), True)
680 GlobalData.gPlatformHash = m.hexdigest()
681
682 #
683 # Write metafile list to build directory
684 #
685 AutoGenFilePath = os.path.join(self.BuildDir, 'AutoGen')
686 if os.path.exists (AutoGenFilePath):
687 os.remove(AutoGenFilePath)
688 if not os.path.exists(self.BuildDir):
689 os.makedirs(self.BuildDir)
690 with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:
691 for f in AllWorkSpaceMetaFiles:
692 print(f, file=file)
693 return True
694
695 def _GenPkgLevelHash(self, Pkg):
696 if Pkg.PackageName in GlobalData.gPackageHash[Pkg.Arch]:
697 return
698
699 PkgDir = os.path.join(self.BuildDir, Pkg.Arch, Pkg.PackageName)
700 CreateDirectory(PkgDir)
701 HashFile = os.path.join(PkgDir, Pkg.PackageName + '.hash')
702 m = hashlib.md5()
703 # Get .dec file's hash value
704 f = open(Pkg.MetaFile.Path, 'r')
705 Content = f.read()
706 f.close()
707 m.update(Content)
708 # Get include files hash value
709 if Pkg.Includes:
710 for inc in sorted(Pkg.Includes, key=lambda x: str(x)):
711 for Root, Dirs, Files in os.walk(str(inc)):
712 for File in sorted(Files):
713 File_Path = os.path.join(Root, File)
714 f = open(File_Path, 'r')
715 Content = f.read()
716 f.close()
717 m.update(Content)
718 SaveFileOnChange(HashFile, m.hexdigest(), True)
719 GlobalData.gPackageHash[Pkg.Arch][Pkg.PackageName] = m.hexdigest()
720
721 def _GetMetaFiles(self, Target, Toolchain, Arch):
722 AllWorkSpaceMetaFiles = set()
723 #
724 # add fdf
725 #
726 if self.FdfFile:
727 AllWorkSpaceMetaFiles.add (self.FdfFile.Path)
728 for f in GlobalData.gFdfParser.GetAllIncludedFile():
729 AllWorkSpaceMetaFiles.add (f.FileName)
730 #
731 # add dsc
732 #
733 AllWorkSpaceMetaFiles.add(self.MetaFile.Path)
734
735 #
736 # add build_rule.txt & tools_def.txt
737 #
738 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultBuildRuleFile))
739 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultToolsDefFile))
740
741 # add BuildOption metafile
742 #
743 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'BuildOptions'))
744
745 # add PcdToken Number file for Dynamic/DynamicEx Pcd
746 #
747 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'PcdTokenNumber'))
748
749 for Arch in self.ArchList:
750 #
751 # add dec
752 #
753 for Package in PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch).PackageList:
754 AllWorkSpaceMetaFiles.add(Package.MetaFile.Path)
755
756 #
757 # add included dsc
758 #
759 for filePath in self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]._RawData.IncludedFiles:
760 AllWorkSpaceMetaFiles.add(filePath.Path)
761
762 return AllWorkSpaceMetaFiles
763
764 ## _CheckDuplicateInFV() method
765 #
766 # Check whether there is duplicate modules/files exist in FV section.
767 # The check base on the file GUID;
768 #
769 def _CheckDuplicateInFV(self, Fdf):
770 for Fv in Fdf.Profile.FvDict:
771 _GuidDict = {}
772 for FfsFile in Fdf.Profile.FvDict[Fv].FfsList:
773 if FfsFile.InfFileName and FfsFile.NameGuid is None:
774 #
775 # Get INF file GUID
776 #
777 InfFoundFlag = False
778 for Pa in self.AutoGenObjectList:
779 if InfFoundFlag:
780 break
781 for Module in Pa.ModuleAutoGenList:
782 if path.normpath(Module.MetaFile.File) == path.normpath(FfsFile.InfFileName):
783 InfFoundFlag = True
784 if Module.Guid.upper() not in _GuidDict:
785 _GuidDict[Module.Guid.upper()] = FfsFile
786 break
787 else:
788 EdkLogger.error("build",
789 FORMAT_INVALID,
790 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,
791 FfsFile.CurrentLineContent,
792 _GuidDict[Module.Guid.upper()].CurrentLineNum,
793 _GuidDict[Module.Guid.upper()].CurrentLineContent,
794 Module.Guid.upper()),
795 ExtraData=self.FdfFile)
796 #
797 # Some INF files not have entity in DSC file.
798 #
799 if not InfFoundFlag:
800 if FfsFile.InfFileName.find('$') == -1:
801 InfPath = NormPath(FfsFile.InfFileName)
802 if not os.path.exists(InfPath):
803 EdkLogger.error('build', GENFDS_ERROR, "Non-existant Module %s !" % (FfsFile.InfFileName))
804
805 PathClassObj = PathClass(FfsFile.InfFileName, self.WorkspaceDir)
806 #
807 # Here we just need to get FILE_GUID from INF file, use 'COMMON' as ARCH attribute. and use
808 # BuildObject from one of AutoGenObjectList is enough.
809 #
810 InfObj = self.AutoGenObjectList[0].BuildDatabase.WorkspaceDb.BuildObject[PathClassObj, TAB_ARCH_COMMON, self.BuildTarget, self.ToolChain]
811 if InfObj.Guid.upper() not in _GuidDict:
812 _GuidDict[InfObj.Guid.upper()] = FfsFile
813 else:
814 EdkLogger.error("build",
815 FORMAT_INVALID,
816 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,
817 FfsFile.CurrentLineContent,
818 _GuidDict[InfObj.Guid.upper()].CurrentLineNum,
819 _GuidDict[InfObj.Guid.upper()].CurrentLineContent,
820 InfObj.Guid.upper()),
821 ExtraData=self.FdfFile)
822 InfFoundFlag = False
823
824 if FfsFile.NameGuid is not None:
825 #
826 # If the NameGuid reference a PCD name.
827 # The style must match: PCD(xxxx.yyy)
828 #
829 if gPCDAsGuidPattern.match(FfsFile.NameGuid):
830 #
831 # Replace the PCD value.
832 #
833 _PcdName = FfsFile.NameGuid.lstrip("PCD(").rstrip(")")
834 PcdFoundFlag = False
835 for Pa in self.AutoGenObjectList:
836 if not PcdFoundFlag:
837 for PcdItem in Pa.AllPcdList:
838 if (PcdItem.TokenSpaceGuidCName + "." + PcdItem.TokenCName) == _PcdName:
839 #
840 # First convert from CFormatGuid to GUID string
841 #
842 _PcdGuidString = GuidStructureStringToGuidString(PcdItem.DefaultValue)
843
844 if not _PcdGuidString:
845 #
846 # Then try Byte array.
847 #
848 _PcdGuidString = GuidStructureByteArrayToGuidString(PcdItem.DefaultValue)
849
850 if not _PcdGuidString:
851 #
852 # Not Byte array or CFormat GUID, raise error.
853 #
854 EdkLogger.error("build",
855 FORMAT_INVALID,
856 "The format of PCD value is incorrect. PCD: %s , Value: %s\n" % (_PcdName, PcdItem.DefaultValue),
857 ExtraData=self.FdfFile)
858
859 if _PcdGuidString.upper() not in _GuidDict:
860 _GuidDict[_PcdGuidString.upper()] = FfsFile
861 PcdFoundFlag = True
862 break
863 else:
864 EdkLogger.error("build",
865 FORMAT_INVALID,
866 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,
867 FfsFile.CurrentLineContent,
868 _GuidDict[_PcdGuidString.upper()].CurrentLineNum,
869 _GuidDict[_PcdGuidString.upper()].CurrentLineContent,
870 FfsFile.NameGuid.upper()),
871 ExtraData=self.FdfFile)
872
873 if FfsFile.NameGuid.upper() not in _GuidDict:
874 _GuidDict[FfsFile.NameGuid.upper()] = FfsFile
875 else:
876 #
877 # Two raw file GUID conflict.
878 #
879 EdkLogger.error("build",
880 FORMAT_INVALID,
881 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s" % (FfsFile.CurrentLineNum,
882 FfsFile.CurrentLineContent,
883 _GuidDict[FfsFile.NameGuid.upper()].CurrentLineNum,
884 _GuidDict[FfsFile.NameGuid.upper()].CurrentLineContent,
885 FfsFile.NameGuid.upper()),
886 ExtraData=self.FdfFile)
887
888
889 def _CheckPcdDefineAndType(self):
890 PcdTypeSet = {TAB_PCDS_FIXED_AT_BUILD,
891 TAB_PCDS_PATCHABLE_IN_MODULE,
892 TAB_PCDS_FEATURE_FLAG,
893 TAB_PCDS_DYNAMIC,
894 TAB_PCDS_DYNAMIC_EX}
895
896 # This dict store PCDs which are not used by any modules with specified arches
897 UnusedPcd = OrderedDict()
898 for Pa in self.AutoGenObjectList:
899 # Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid
900 for Pcd in Pa.Platform.Pcds:
901 PcdType = Pa.Platform.Pcds[Pcd].Type
902
903 # If no PCD type, this PCD comes from FDF
904 if not PcdType:
905 continue
906
907 # Try to remove Hii and Vpd suffix
908 if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):
909 PcdType = TAB_PCDS_DYNAMIC_EX
910 elif PcdType.startswith(TAB_PCDS_DYNAMIC):
911 PcdType = TAB_PCDS_DYNAMIC
912
913 for Package in Pa.PackageList:
914 # Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType
915 if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:
916 break
917 for Type in PcdTypeSet:
918 if (Pcd[0], Pcd[1], Type) in Package.Pcds:
919 EdkLogger.error(
920 'build',
921 FORMAT_INVALID,
922 "Type [%s] of PCD [%s.%s] in DSC file doesn't match the type [%s] defined in DEC file." \
923 % (Pa.Platform.Pcds[Pcd].Type, Pcd[1], Pcd[0], Type),
924 ExtraData=None
925 )
926 return
927 else:
928 UnusedPcd.setdefault(Pcd, []).append(Pa.Arch)
929
930 for Pcd in UnusedPcd:
931 EdkLogger.warn(
932 'build',
933 "The PCD was not specified by any INF module in the platform for the given architecture.\n"
934 "\tPCD: [%s.%s]\n\tPlatform: [%s]\n\tArch: %s"
935 % (Pcd[1], Pcd[0], os.path.basename(str(self.MetaFile)), str(UnusedPcd[Pcd])),
936 ExtraData=None
937 )
938
939 def __repr__(self):
940 return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))
941
942 ## Return the directory to store FV files
943 def _GetFvDir(self):
944 if self._FvDir is None:
945 self._FvDir = path.join(self.BuildDir, TAB_FV_DIRECTORY)
946 return self._FvDir
947
948 ## Return the directory to store all intermediate and final files built
949 def _GetBuildDir(self):
950 if self._BuildDir is None:
951 return self.AutoGenObjectList[0].BuildDir
952
953 ## Return the build output directory platform specifies
954 def _GetOutputDir(self):
955 return self.Platform.OutputDirectory
956
957 ## Return platform name
958 def _GetName(self):
959 return self.Platform.PlatformName
960
961 ## Return meta-file GUID
962 def _GetGuid(self):
963 return self.Platform.Guid
964
965 ## Return platform version
966 def _GetVersion(self):
967 return self.Platform.Version
968
969 ## Return paths of tools
970 def _GetToolDefinition(self):
971 return self.AutoGenObjectList[0].ToolDefinition
972
973 ## Return directory of platform makefile
974 #
975 # @retval string Makefile directory
976 #
977 def _GetMakeFileDir(self):
978 if self._MakeFileDir is None:
979 self._MakeFileDir = self.BuildDir
980 return self._MakeFileDir
981
982 ## Return build command string
983 #
984 # @retval string Build command string
985 #
986 def _GetBuildCommand(self):
987 if self._BuildCommand is None:
988 # BuildCommand should be all the same. So just get one from platform AutoGen
989 self._BuildCommand = self.AutoGenObjectList[0].BuildCommand
990 return self._BuildCommand
991
992 ## Check the PCDs token value conflict in each DEC file.
993 #
994 # Will cause build break and raise error message while two PCDs conflict.
995 #
996 # @return None
997 #
998 def _CheckAllPcdsTokenValueConflict(self):
999 for Pa in self.AutoGenObjectList:
1000 for Package in Pa.PackageList:
1001 PcdList = Package.Pcds.values()
1002 PcdList.sort(lambda x, y: cmp(int(x.TokenValue, 0), int(y.TokenValue, 0)))
1003 Count = 0
1004 while (Count < len(PcdList) - 1) :
1005 Item = PcdList[Count]
1006 ItemNext = PcdList[Count + 1]
1007 #
1008 # Make sure in the same token space the TokenValue should be unique
1009 #
1010 if (int(Item.TokenValue, 0) == int(ItemNext.TokenValue, 0)):
1011 SameTokenValuePcdList = []
1012 SameTokenValuePcdList.append(Item)
1013 SameTokenValuePcdList.append(ItemNext)
1014 RemainPcdListLength = len(PcdList) - Count - 2
1015 for ValueSameCount in range(RemainPcdListLength):
1016 if int(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue, 0) == int(Item.TokenValue, 0):
1017 SameTokenValuePcdList.append(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount])
1018 else:
1019 break;
1020 #
1021 # Sort same token value PCD list with TokenGuid and TokenCName
1022 #
1023 SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))
1024 SameTokenValuePcdListCount = 0
1025 while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):
1026 Flag = False
1027 TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]
1028 TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1]
1029
1030 if (TemListItem.TokenSpaceGuidCName == TemListItemNext.TokenSpaceGuidCName) and (TemListItem.TokenCName != TemListItemNext.TokenCName):
1031 for PcdItem in GlobalData.MixedPcd:
1032 if (TemListItem.TokenCName, TemListItem.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem] or \
1033 (TemListItemNext.TokenCName, TemListItemNext.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
1034 Flag = True
1035 if not Flag:
1036 EdkLogger.error(
1037 'build',
1038 FORMAT_INVALID,
1039 "The TokenValue [%s] of PCD [%s.%s] is conflict with: [%s.%s] in %s"\
1040 % (TemListItem.TokenValue, TemListItem.TokenSpaceGuidCName, TemListItem.TokenCName, TemListItemNext.TokenSpaceGuidCName, TemListItemNext.TokenCName, Package),
1041 ExtraData=None
1042 )
1043 SameTokenValuePcdListCount += 1
1044 Count += SameTokenValuePcdListCount
1045 Count += 1
1046
1047 PcdList = Package.Pcds.values()
1048 PcdList.sort(lambda x, y: cmp("%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName), "%s.%s" % (y.TokenSpaceGuidCName, y.TokenCName)))
1049 Count = 0
1050 while (Count < len(PcdList) - 1) :
1051 Item = PcdList[Count]
1052 ItemNext = PcdList[Count + 1]
1053 #
1054 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.
1055 #
1056 if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (int(Item.TokenValue, 0) != int(ItemNext.TokenValue, 0)):
1057 EdkLogger.error(
1058 'build',
1059 FORMAT_INVALID,
1060 "The TokenValue [%s] of PCD [%s.%s] in %s defined in two places should be same as well."\
1061 % (Item.TokenValue, Item.TokenSpaceGuidCName, Item.TokenCName, Package),
1062 ExtraData=None
1063 )
1064 Count += 1
1065 ## Generate fds command
1066 def _GenFdsCommand(self):
1067 return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()
1068
1069 ## Create makefile for the platform and modules in it
1070 #
1071 # @param CreateDepsMakeFile Flag indicating if the makefile for
1072 # modules will be created as well
1073 #
1074 def CreateMakeFile(self, CreateDepsMakeFile=False):
1075 if not CreateDepsMakeFile:
1076 return
1077 for Pa in self.AutoGenObjectList:
1078 Pa.CreateMakeFile(True)
1079
1080 ## Create autogen code for platform and modules
1081 #
1082 # Since there's no autogen code for platform, this method will do nothing
1083 # if CreateModuleCodeFile is set to False.
1084 #
1085 # @param CreateDepsCodeFile Flag indicating if creating module's
1086 # autogen code file or not
1087 #
1088 def CreateCodeFile(self, CreateDepsCodeFile=False):
1089 if not CreateDepsCodeFile:
1090 return
1091 for Pa in self.AutoGenObjectList:
1092 Pa.CreateCodeFile(True)
1093
1094 ## Create AsBuilt INF file the platform
1095 #
1096 def CreateAsBuiltInf(self):
1097 return
1098
1099 Name = property(_GetName)
1100 Guid = property(_GetGuid)
1101 Version = property(_GetVersion)
1102 OutputDir = property(_GetOutputDir)
1103
1104 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path
1105
1106 BuildDir = property(_GetBuildDir)
1107 FvDir = property(_GetFvDir)
1108 MakeFileDir = property(_GetMakeFileDir)
1109 BuildCommand = property(_GetBuildCommand)
1110 GenFdsCommand = property(_GenFdsCommand)
1111
1112 ## AutoGen class for platform
1113 #
1114 # PlatformAutoGen class will process the original information in platform
1115 # file in order to generate makefile for platform.
1116 #
1117 class PlatformAutoGen(AutoGen):
1118 # call super().__init__ then call the worker function with different parameter count
1119 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
1120 try:
1121 self._Init
1122 except:
1123 super(PlatformAutoGen, self).__init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
1124 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch)
1125 self._Init = True
1126 #
1127 # Used to store all PCDs for both PEI and DXE phase, in order to generate
1128 # correct PCD database
1129 #
1130 _DynaPcdList_ = []
1131 _NonDynaPcdList_ = []
1132 _PlatformPcds = {}
1133
1134 #
1135 # The priority list while override build option
1136 #
1137 PrioList = {"0x11111" : 16, # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE (Highest)
1138 "0x01111" : 15, # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
1139 "0x10111" : 14, # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE
1140 "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE
1141 "0x11011" : 12, # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE
1142 "0x01011" : 11, # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE
1143 "0x10011" : 10, # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE
1144 "0x00011" : 9, # ******_*********_****_COMMANDTYPE_ATTRIBUTE
1145 "0x11101" : 8, # TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE
1146 "0x01101" : 7, # ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE
1147 "0x10101" : 6, # TARGET_*********_ARCH_***********_ATTRIBUTE
1148 "0x00101" : 5, # ******_*********_ARCH_***********_ATTRIBUTE
1149 "0x11001" : 4, # TARGET_TOOLCHAIN_****_***********_ATTRIBUTE
1150 "0x01001" : 3, # ******_TOOLCHAIN_****_***********_ATTRIBUTE
1151 "0x10001" : 2, # TARGET_*********_****_***********_ATTRIBUTE
1152 "0x00001" : 1} # ******_*********_****_***********_ATTRIBUTE (Lowest)
1153
1154 ## Initialize PlatformAutoGen
1155 #
1156 #
1157 # @param Workspace WorkspaceAutoGen object
1158 # @param PlatformFile Platform file (DSC file)
1159 # @param Target Build target (DEBUG, RELEASE)
1160 # @param Toolchain Name of tool chain
1161 # @param Arch arch of the platform supports
1162 #
1163 def _InitWorker(self, Workspace, PlatformFile, Target, Toolchain, Arch):
1164 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))
1165 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)
1166
1167 self.MetaFile = PlatformFile
1168 self.Workspace = Workspace
1169 self.WorkspaceDir = Workspace.WorkspaceDir
1170 self.ToolChain = Toolchain
1171 self.BuildTarget = Target
1172 self.Arch = Arch
1173 self.SourceDir = PlatformFile.SubDir
1174 self.SourceOverrideDir = None
1175 self.FdTargetList = self.Workspace.FdTargetList
1176 self.FvTargetList = self.Workspace.FvTargetList
1177 self.AllPcdList = []
1178 # get the original module/package/platform objects
1179 self.BuildDatabase = Workspace.BuildDatabase
1180 self.DscBuildDataObj = Workspace.Platform
1181 self._GuidDict = Workspace._GuidDict
1182
1183 # flag indicating if the makefile/C-code file has been created or not
1184 self.IsMakeFileCreated = False
1185 self.IsCodeFileCreated = False
1186
1187 self._Platform = None
1188 self._Name = None
1189 self._Guid = None
1190 self._Version = None
1191
1192 self._BuildRule = None
1193 self._SourceDir = None
1194 self._BuildDir = None
1195 self._OutputDir = None
1196 self._FvDir = None
1197 self._MakeFileDir = None
1198 self._FdfFile = None
1199
1200 self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
1201 self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1202 self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1203 self._NonDynamicPcdDict = {}
1204
1205 self._ToolDefinitions = None
1206 self._ToolDefFile = None # toolcode : tool path
1207 self._ToolChainFamily = None
1208 self._BuildRuleFamily = None
1209 self._BuildOption = None # toolcode : option
1210 self._EdkBuildOption = None # edktoolcode : option
1211 self._EdkIIBuildOption = None # edkiitoolcode : option
1212 self._PackageList = None
1213 self._ModuleAutoGenList = None
1214 self._LibraryAutoGenList = None
1215 self._BuildCommand = None
1216 self._AsBuildInfList = []
1217 self._AsBuildModuleList = []
1218
1219 self.VariableInfo = None
1220
1221 if GlobalData.gFdfParser is not None:
1222 self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList
1223 for Inf in self._AsBuildInfList:
1224 InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)
1225 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]
1226 if not M.IsSupportedArch:
1227 continue
1228 self._AsBuildModuleList.append(InfClass)
1229 # get library/modules for build
1230 self.LibraryBuildDirectoryList = []
1231 self.ModuleBuildDirectoryList = []
1232
1233 return True
1234
1235 def __repr__(self):
1236 return "%s [%s]" % (self.MetaFile, self.Arch)
1237
1238 ## Create autogen code for platform and modules
1239 #
1240 # Since there's no autogen code for platform, this method will do nothing
1241 # if CreateModuleCodeFile is set to False.
1242 #
1243 # @param CreateModuleCodeFile Flag indicating if creating module's
1244 # autogen code file or not
1245 #
1246 def CreateCodeFile(self, CreateModuleCodeFile=False):
1247 # only module has code to be greated, so do nothing if CreateModuleCodeFile is False
1248 if self.IsCodeFileCreated or not CreateModuleCodeFile:
1249 return
1250
1251 for Ma in self.ModuleAutoGenList:
1252 Ma.CreateCodeFile(True)
1253
1254 # don't do this twice
1255 self.IsCodeFileCreated = True
1256
1257 ## Generate Fds Command
1258 def _GenFdsCommand(self):
1259 return self.Workspace.GenFdsCommand
1260
1261 ## Create makefile for the platform and mdoules in it
1262 #
1263 # @param CreateModuleMakeFile Flag indicating if the makefile for
1264 # modules will be created as well
1265 #
1266 def CreateMakeFile(self, CreateModuleMakeFile=False, FfsCommand = {}):
1267 if CreateModuleMakeFile:
1268 for ModuleFile in self.Platform.Modules:
1269 Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,
1270 self.ToolChain, self.Arch, self.MetaFile)
1271 if (ModuleFile.File, self.Arch) in FfsCommand:
1272 Ma.CreateMakeFile(True, FfsCommand[ModuleFile.File, self.Arch])
1273 else:
1274 Ma.CreateMakeFile(True)
1275 #Ma.CreateAsBuiltInf()
1276
1277 # no need to create makefile for the platform more than once
1278 if self.IsMakeFileCreated:
1279 return
1280
1281 # create library/module build dirs for platform
1282 Makefile = GenMake.PlatformMakefile(self)
1283 self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()
1284 self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()
1285
1286 self.IsMakeFileCreated = True
1287
1288 ## Deal with Shared FixedAtBuild Pcds
1289 #
1290 def CollectFixedAtBuildPcds(self):
1291 for LibAuto in self.LibraryAutoGenList:
1292 FixedAtBuildPcds = {}
1293 ShareFixedAtBuildPcdsSameValue = {}
1294 for Module in LibAuto._ReferenceModules:
1295 for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:
1296 DefaultValue = Pcd.DefaultValue
1297 # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib
1298 if Pcd in Module.LibraryPcdList:
1299 Index = Module.LibraryPcdList.index(Pcd)
1300 DefaultValue = Module.LibraryPcdList[Index].DefaultValue
1301 key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1302 if key not in FixedAtBuildPcds:
1303 ShareFixedAtBuildPcdsSameValue[key] = True
1304 FixedAtBuildPcds[key] = DefaultValue
1305 else:
1306 if FixedAtBuildPcds[key] != DefaultValue:
1307 ShareFixedAtBuildPcdsSameValue[key] = False
1308 for Pcd in LibAuto.FixedAtBuildPcds:
1309 key = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1310 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:
1311 continue
1312 else:
1313 DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)]
1314 if DscPcd.Type != TAB_PCDS_FIXED_AT_BUILD:
1315 continue
1316 if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]:
1317 LibAuto.ConstPcd[key] = FixedAtBuildPcds[key]
1318
1319 def CollectVariables(self, DynamicPcdSet):
1320
1321 VpdRegionSize = 0
1322 VpdRegionBase = 0
1323 if self.Workspace.FdfFile:
1324 FdDict = self.Workspace.FdfProfile.FdDict[GlobalData.gFdfParser.CurrentFdName]
1325 for FdRegion in FdDict.RegionList:
1326 for item in FdRegion.RegionDataList:
1327 if self.Platform.VpdToolGuid.strip() and self.Platform.VpdToolGuid in item:
1328 VpdRegionSize = FdRegion.Size
1329 VpdRegionBase = FdRegion.Offset
1330 break
1331
1332
1333 VariableInfo = VariableMgr(self.DscBuildDataObj._GetDefaultStores(), self.DscBuildDataObj._GetSkuIds())
1334 VariableInfo.SetVpdRegionMaxSize(VpdRegionSize)
1335 VariableInfo.SetVpdRegionOffset(VpdRegionBase)
1336 Index = 0
1337 for Pcd in DynamicPcdSet:
1338 pcdname = ".".join((Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1339 for SkuName in Pcd.SkuInfoList:
1340 Sku = Pcd.SkuInfoList[SkuName]
1341 SkuId = Sku.SkuId
1342 if SkuId is None or SkuId == '':
1343 continue
1344 if len(Sku.VariableName) > 0:
1345 VariableGuidStructure = Sku.VariableGuidValue
1346 VariableGuid = GuidStructureStringToGuidString(VariableGuidStructure)
1347 for StorageName in Sku.DefaultStoreDict:
1348 VariableInfo.append_variable(var_info(Index, pcdname, StorageName, SkuName, StringToArray(Sku.VariableName), VariableGuid, Sku.VariableOffset, Sku.VariableAttribute, Sku.HiiDefaultValue, Sku.DefaultStoreDict[StorageName], Pcd.DatumType))
1349 Index += 1
1350 return VariableInfo
1351
1352 def UpdateNVStoreMaxSize(self, OrgVpdFile):
1353 if self.VariableInfo:
1354 VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)
1355 PcdNvStoreDfBuffer = [item for item in self._DynamicPcdList if item.TokenCName == "PcdNvStoreDefaultValueBuffer" and item.TokenSpaceGuidCName == "gEfiMdeModulePkgTokenSpaceGuid"]
1356
1357 if PcdNvStoreDfBuffer:
1358 if os.path.exists(VpdMapFilePath):
1359 OrgVpdFile.Read(VpdMapFilePath)
1360 PcdItems = OrgVpdFile.GetOffset(PcdNvStoreDfBuffer[0])
1361 NvStoreOffset = PcdItems.values()[0].strip() if PcdItems else '0'
1362 else:
1363 EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)
1364
1365 NvStoreOffset = int(NvStoreOffset, 16) if NvStoreOffset.upper().startswith("0X") else int(NvStoreOffset)
1366 default_skuobj = PcdNvStoreDfBuffer[0].SkuInfoList.get(TAB_DEFAULT)
1367 maxsize = self.VariableInfo.VpdRegionSize - NvStoreOffset if self.VariableInfo.VpdRegionSize else len(default_skuobj.DefaultValue.split(","))
1368 var_data = self.VariableInfo.PatchNVStoreDefaultMaxSize(maxsize)
1369
1370 if var_data and default_skuobj:
1371 default_skuobj.DefaultValue = var_data
1372 PcdNvStoreDfBuffer[0].DefaultValue = var_data
1373 PcdNvStoreDfBuffer[0].SkuInfoList.clear()
1374 PcdNvStoreDfBuffer[0].SkuInfoList[TAB_DEFAULT] = default_skuobj
1375 PcdNvStoreDfBuffer[0].MaxDatumSize = str(len(default_skuobj.DefaultValue.split(",")))
1376
1377 return OrgVpdFile
1378
1379 ## Collect dynamic PCDs
1380 #
1381 # Gather dynamic PCDs list from each module and their settings from platform
1382 # This interface should be invoked explicitly when platform action is created.
1383 #
1384 def CollectPlatformDynamicPcds(self):
1385
1386 for key in self.Platform.Pcds:
1387 for SinglePcd in GlobalData.MixedPcd:
1388 if (self.Platform.Pcds[key].TokenCName, self.Platform.Pcds[key].TokenSpaceGuidCName) == SinglePcd:
1389 for item in GlobalData.MixedPcd[SinglePcd]:
1390 Pcd_Type = item[0].split('_')[-1]
1391 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 \
1392 (Pcd_Type == TAB_PCDS_DYNAMIC and self.Platform.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):
1393 Value = self.Platform.Pcds[key]
1394 Value.TokenCName = self.Platform.Pcds[key].TokenCName + '_' + Pcd_Type
1395 if len(key) == 2:
1396 newkey = (Value.TokenCName, key[1])
1397 elif len(key) == 3:
1398 newkey = (Value.TokenCName, key[1], key[2])
1399 del self.Platform.Pcds[key]
1400 self.Platform.Pcds[newkey] = Value
1401 break
1402 break
1403
1404 # for gathering error information
1405 NoDatumTypePcdList = set()
1406 FdfModuleList = []
1407 for InfName in self._AsBuildInfList:
1408 InfName = mws.join(self.WorkspaceDir, InfName)
1409 FdfModuleList.append(os.path.normpath(InfName))
1410 for F in self.Platform.Modules.keys():
1411 M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)
1412 #GuidValue.update(M.Guids)
1413
1414 self.Platform.Modules[F].M = M
1415
1416 for PcdFromModule in M.ModulePcdList + M.LibraryPcdList:
1417 # make sure that the "VOID*" kind of datum has MaxDatumSize set
1418 if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:
1419 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))
1420
1421 # Check the PCD from Binary INF or Source INF
1422 if M.IsBinaryModule == True:
1423 PcdFromModule.IsFromBinaryInf = True
1424
1425 # Check the PCD from DSC or not
1426 PcdFromModule.IsFromDsc = (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds
1427
1428 if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET or PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
1429 if F.Path not in FdfModuleList:
1430 # If one of the Source built modules listed in the DSC is not listed
1431 # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic
1432 # access method (it is only listed in the DEC file that declares the
1433 # PCD as PcdsDynamic), then build tool will report warning message
1434 # notify the PI that they are attempting to build a module that must
1435 # be included in a flash image in order to be functional. These Dynamic
1436 # PCD will not be added into the Database unless it is used by other
1437 # modules that are included in the FDF file.
1438 if PcdFromModule.Type in PCD_DYNAMIC_TYPE_SET and \
1439 PcdFromModule.IsFromBinaryInf == False:
1440 # Print warning message to let the developer make a determine.
1441 continue
1442 # If one of the Source built modules listed in the DSC is not listed in
1443 # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx
1444 # access method (it is only listed in the DEC file that declares the
1445 # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the
1446 # PCD to the Platform's PCD Database.
1447 if PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
1448 continue
1449 #
1450 # If a dynamic PCD used by a PEM module/PEI module & DXE module,
1451 # it should be stored in Pcd PEI database, If a dynamic only
1452 # used by DXE module, it should be stored in DXE PCD database.
1453 # The default Phase is DXE
1454 #
1455 if M.ModuleType in SUP_MODULE_SET_PEI:
1456 PcdFromModule.Phase = "PEI"
1457 if PcdFromModule not in self._DynaPcdList_:
1458 self._DynaPcdList_.append(PcdFromModule)
1459 elif PcdFromModule.Phase == 'PEI':
1460 # overwrite any the same PCD existing, if Phase is PEI
1461 Index = self._DynaPcdList_.index(PcdFromModule)
1462 self._DynaPcdList_[Index] = PcdFromModule
1463 elif PcdFromModule not in self._NonDynaPcdList_:
1464 self._NonDynaPcdList_.append(PcdFromModule)
1465 elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:
1466 Index = self._NonDynaPcdList_.index(PcdFromModule)
1467 if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:
1468 #The PCD from Binary INF will override the same one from source INF
1469 self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])
1470 PcdFromModule.Pending = False
1471 self._NonDynaPcdList_.append (PcdFromModule)
1472 DscModuleSet = {os.path.normpath(ModuleInf.Path) for ModuleInf in self.Platform.Modules}
1473 # add the PCD from modules that listed in FDF but not in DSC to Database
1474 for InfName in FdfModuleList:
1475 if InfName not in DscModuleSet:
1476 InfClass = PathClass(InfName)
1477 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]
1478 # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)
1479 # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.
1480 # For binary module, if in current arch, we need to list the PCDs into database.
1481 if not M.IsSupportedArch:
1482 continue
1483 # Override the module PCD setting by platform setting
1484 ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)
1485 for PcdFromModule in ModulePcdList:
1486 PcdFromModule.IsFromBinaryInf = True
1487 PcdFromModule.IsFromDsc = False
1488 # Only allow the DynamicEx and Patchable PCD in AsBuild INF
1489 if PcdFromModule.Type not in PCD_DYNAMIC_EX_TYPE_SET and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:
1490 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
1491 File=self.MetaFile,
1492 ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"
1493 % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))
1494 # make sure that the "VOID*" kind of datum has MaxDatumSize set
1495 if PcdFromModule.DatumType == TAB_VOID and not PcdFromModule.MaxDatumSize:
1496 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))
1497 if M.ModuleType in SUP_MODULE_SET_PEI:
1498 PcdFromModule.Phase = "PEI"
1499 if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
1500 self._DynaPcdList_.append(PcdFromModule)
1501 elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:
1502 self._NonDynaPcdList_.append(PcdFromModule)
1503 if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in PCD_DYNAMIC_EX_TYPE_SET:
1504 # Overwrite the phase of any the same PCD existing, if Phase is PEI.
1505 # It is to solve the case that a dynamic PCD used by a PEM module/PEI
1506 # module & DXE module at a same time.
1507 # Overwrite the type of the PCDs in source INF by the type of AsBuild
1508 # INF file as DynamicEx.
1509 Index = self._DynaPcdList_.index(PcdFromModule)
1510 self._DynaPcdList_[Index].Phase = PcdFromModule.Phase
1511 self._DynaPcdList_[Index].Type = PcdFromModule.Type
1512 for PcdFromModule in self._NonDynaPcdList_:
1513 # If a PCD is not listed in the DSC file, but binary INF files used by
1514 # this platform all (that use this PCD) list the PCD in a [PatchPcds]
1515 # section, AND all source INF files used by this platform the build
1516 # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]
1517 # section, then the tools must NOT add the PCD to the Platform's PCD
1518 # Database; the build must assign the access method for this PCD as
1519 # PcdsPatchableInModule.
1520 if PcdFromModule not in self._DynaPcdList_:
1521 continue
1522 Index = self._DynaPcdList_.index(PcdFromModule)
1523 if PcdFromModule.IsFromDsc == False and \
1524 PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \
1525 PcdFromModule.IsFromBinaryInf == True and \
1526 self._DynaPcdList_[Index].IsFromBinaryInf == False:
1527 Index = self._DynaPcdList_.index(PcdFromModule)
1528 self._DynaPcdList_.remove (self._DynaPcdList_[Index])
1529
1530 # print out error information and break the build, if error found
1531 if len(NoDatumTypePcdList) > 0:
1532 NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)
1533 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
1534 File=self.MetaFile,
1535 ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
1536 % NoDatumTypePcdListString)
1537 self._NonDynamicPcdList = self._NonDynaPcdList_
1538 self._DynamicPcdList = self._DynaPcdList_
1539 #
1540 # Sort dynamic PCD list to:
1541 # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should
1542 # try to be put header of dynamicd List
1543 # 2) If PCD is HII type, the PCD item should be put after unicode type PCD
1544 #
1545 # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
1546 #
1547 UnicodePcdArray = set()
1548 HiiPcdArray = set()
1549 OtherPcdArray = set()
1550 VpdPcdDict = {}
1551 VpdFile = VpdInfoFile.VpdInfoFile()
1552 NeedProcessVpdMapFile = False
1553
1554 for pcd in self.Platform.Pcds:
1555 if pcd not in self._PlatformPcds:
1556 self._PlatformPcds[pcd] = self.Platform.Pcds[pcd]
1557
1558 for item in self._PlatformPcds:
1559 if self._PlatformPcds[item].DatumType and self._PlatformPcds[item].DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
1560 self._PlatformPcds[item].DatumType = TAB_VOID
1561
1562 if (self.Workspace.ArchList[-1] == self.Arch):
1563 for Pcd in self._DynamicPcdList:
1564 # just pick the a value to determine whether is unicode string type
1565 Sku = Pcd.SkuInfoList.values()[0]
1566 Sku.VpdOffset = Sku.VpdOffset.strip()
1567
1568 if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
1569 Pcd.DatumType = TAB_VOID
1570
1571 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
1572 # if found HII type PCD then insert to right of UnicodeIndex
1573 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:
1574 VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd
1575
1576 #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer
1577 PcdNvStoreDfBuffer = VpdPcdDict.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))
1578 if PcdNvStoreDfBuffer:
1579 self.VariableInfo = self.CollectVariables(self._DynamicPcdList)
1580 vardump = self.VariableInfo.dump()
1581 if vardump:
1582 PcdNvStoreDfBuffer.DefaultValue = vardump
1583 for skuname in PcdNvStoreDfBuffer.SkuInfoList:
1584 PcdNvStoreDfBuffer.SkuInfoList[skuname].DefaultValue = vardump
1585 PcdNvStoreDfBuffer.MaxDatumSize = str(len(vardump.split(",")))
1586
1587 PlatformPcds = sorted(self._PlatformPcds.keys())
1588 #
1589 # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.
1590 #
1591 VpdSkuMap = {}
1592 for PcdKey in PlatformPcds:
1593 Pcd = self._PlatformPcds[PcdKey]
1594 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \
1595 PcdKey in VpdPcdDict:
1596 Pcd = VpdPcdDict[PcdKey]
1597 SkuValueMap = {}
1598 DefaultSku = Pcd.SkuInfoList.get(TAB_DEFAULT)
1599 if DefaultSku:
1600 PcdValue = DefaultSku.DefaultValue
1601 if PcdValue not in SkuValueMap:
1602 SkuValueMap[PcdValue] = []
1603 VpdFile.Add(Pcd, TAB_DEFAULT, DefaultSku.VpdOffset)
1604 SkuValueMap[PcdValue].append(DefaultSku)
1605
1606 for (SkuName, Sku) in Pcd.SkuInfoList.items():
1607 Sku.VpdOffset = Sku.VpdOffset.strip()
1608 PcdValue = Sku.DefaultValue
1609 if PcdValue == "":
1610 PcdValue = Pcd.DefaultValue
1611 if Sku.VpdOffset != '*':
1612 if PcdValue.startswith("{"):
1613 Alignment = 8
1614 elif PcdValue.startswith("L"):
1615 Alignment = 2
1616 else:
1617 Alignment = 1
1618 try:
1619 VpdOffset = int(Sku.VpdOffset)
1620 except:
1621 try:
1622 VpdOffset = int(Sku.VpdOffset, 16)
1623 except:
1624 EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
1625 if VpdOffset % Alignment != 0:
1626 if PcdValue.startswith("{"):
1627 EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName), File=self.MetaFile)
1628 else:
1629 EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Alignment))
1630 if PcdValue not in SkuValueMap:
1631 SkuValueMap[PcdValue] = []
1632 VpdFile.Add(Pcd, SkuName, Sku.VpdOffset)
1633 SkuValueMap[PcdValue].append(Sku)
1634 # if the offset of a VPD is *, then it need to be fixed up by third party tool.
1635 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":
1636 NeedProcessVpdMapFile = True
1637 if self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == '':
1638 EdkLogger.error("Build", FILE_NOT_FOUND, \
1639 "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.")
1640
1641 VpdSkuMap[PcdKey] = SkuValueMap
1642 #
1643 # Fix the PCDs define in VPD PCD section that never referenced by module.
1644 # An example is PCD for signature usage.
1645 #
1646 for DscPcd in PlatformPcds:
1647 DscPcdEntry = self._PlatformPcds[DscPcd]
1648 if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:
1649 if not (self.Platform.VpdToolGuid is None or self.Platform.VpdToolGuid == ''):
1650 FoundFlag = False
1651 for VpdPcd in VpdFile._VpdArray:
1652 # This PCD has been referenced by module
1653 if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \
1654 (VpdPcd.TokenCName == DscPcdEntry.TokenCName):
1655 FoundFlag = True
1656
1657 # Not found, it should be signature
1658 if not FoundFlag :
1659 # just pick the a value to determine whether is unicode string type
1660 SkuValueMap = {}
1661 SkuObjList = DscPcdEntry.SkuInfoList.items()
1662 DefaultSku = DscPcdEntry.SkuInfoList.get(TAB_DEFAULT)
1663 if DefaultSku:
1664 defaultindex = SkuObjList.index((TAB_DEFAULT, DefaultSku))
1665 SkuObjList[0], SkuObjList[defaultindex] = SkuObjList[defaultindex], SkuObjList[0]
1666 for (SkuName, Sku) in SkuObjList:
1667 Sku.VpdOffset = Sku.VpdOffset.strip()
1668
1669 # Need to iterate DEC pcd information to get the value & datumtype
1670 for eachDec in self.PackageList:
1671 for DecPcd in eachDec.Pcds:
1672 DecPcdEntry = eachDec.Pcds[DecPcd]
1673 if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \
1674 (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):
1675 # Print warning message to let the developer make a determine.
1676 EdkLogger.warn("build", "Unreferenced vpd pcd used!",
1677 File=self.MetaFile, \
1678 ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \
1679 %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path))
1680
1681 DscPcdEntry.DatumType = DecPcdEntry.DatumType
1682 DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue
1683 DscPcdEntry.TokenValue = DecPcdEntry.TokenValue
1684 DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]
1685 # Only fix the value while no value provided in DSC file.
1686 if not Sku.DefaultValue:
1687 DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue
1688
1689 if DscPcdEntry not in self._DynamicPcdList:
1690 self._DynamicPcdList.append(DscPcdEntry)
1691 Sku.VpdOffset = Sku.VpdOffset.strip()
1692 PcdValue = Sku.DefaultValue
1693 if PcdValue == "":
1694 PcdValue = DscPcdEntry.DefaultValue
1695 if Sku.VpdOffset != '*':
1696 if PcdValue.startswith("{"):
1697 Alignment = 8
1698 elif PcdValue.startswith("L"):
1699 Alignment = 2
1700 else:
1701 Alignment = 1
1702 try:
1703 VpdOffset = int(Sku.VpdOffset)
1704 except:
1705 try:
1706 VpdOffset = int(Sku.VpdOffset, 16)
1707 except:
1708 EdkLogger.error("build", FORMAT_INVALID, "Invalid offset value %s for PCD %s.%s." % (Sku.VpdOffset, DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName))
1709 if VpdOffset % Alignment != 0:
1710 if PcdValue.startswith("{"):
1711 EdkLogger.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName), File=self.MetaFile)
1712 else:
1713 EdkLogger.error("build", FORMAT_INVALID, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, Alignment))
1714 if PcdValue not in SkuValueMap:
1715 SkuValueMap[PcdValue] = []
1716 VpdFile.Add(DscPcdEntry, SkuName, Sku.VpdOffset)
1717 SkuValueMap[PcdValue].append(Sku)
1718 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":
1719 NeedProcessVpdMapFile = True
1720 if DscPcdEntry.DatumType == TAB_VOID and PcdValue.startswith("L"):
1721 UnicodePcdArray.add(DscPcdEntry)
1722 elif len(Sku.VariableName) > 0:
1723 HiiPcdArray.add(DscPcdEntry)
1724 else:
1725 OtherPcdArray.add(DscPcdEntry)
1726
1727 # if the offset of a VPD is *, then it need to be fixed up by third party tool.
1728 VpdSkuMap[DscPcd] = SkuValueMap
1729 if (self.Platform.FlashDefinition is None or self.Platform.FlashDefinition == '') and \
1730 VpdFile.GetCount() != 0:
1731 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE,
1732 "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))
1733
1734 if VpdFile.GetCount() != 0:
1735
1736 self.FixVpdOffset(VpdFile)
1737
1738 self.FixVpdOffset(self.UpdateNVStoreMaxSize(VpdFile))
1739
1740 # Process VPD map file generated by third party BPDG tool
1741 if NeedProcessVpdMapFile:
1742 VpdMapFilePath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY, "%s.map" % self.Platform.VpdToolGuid)
1743 if os.path.exists(VpdMapFilePath):
1744 VpdFile.Read(VpdMapFilePath)
1745
1746 # Fixup "*" offset
1747 for pcd in VpdSkuMap:
1748 vpdinfo = VpdFile.GetVpdInfo(pcd)
1749 if vpdinfo is None:
1750 # just pick the a value to determine whether is unicode string type
1751 continue
1752 for pcdvalue in VpdSkuMap[pcd]:
1753 for sku in VpdSkuMap[pcd][pcdvalue]:
1754 for item in vpdinfo:
1755 if item[2] == pcdvalue:
1756 sku.VpdOffset = item[1]
1757 else:
1758 EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)
1759
1760 # Delete the DynamicPcdList At the last time enter into this function
1761 for Pcd in self._DynamicPcdList:
1762 # just pick the a value to determine whether is unicode string type
1763 Sku = Pcd.SkuInfoList.values()[0]
1764 Sku.VpdOffset = Sku.VpdOffset.strip()
1765
1766 if Pcd.DatumType not in [TAB_UINT8, TAB_UINT16, TAB_UINT32, TAB_UINT64, TAB_VOID, "BOOLEAN"]:
1767 Pcd.DatumType = TAB_VOID
1768
1769 PcdValue = Sku.DefaultValue
1770 if Pcd.DatumType == TAB_VOID and PcdValue.startswith("L"):
1771 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
1772 UnicodePcdArray.add(Pcd)
1773 elif len(Sku.VariableName) > 0:
1774 # if found HII type PCD then insert to right of UnicodeIndex
1775 HiiPcdArray.add(Pcd)
1776 else:
1777 OtherPcdArray.add(Pcd)
1778 del self._DynamicPcdList[:]
1779 self._DynamicPcdList.extend(list(UnicodePcdArray))
1780 self._DynamicPcdList.extend(list(HiiPcdArray))
1781 self._DynamicPcdList.extend(list(OtherPcdArray))
1782 allskuset = [(SkuName, Sku.SkuId) for pcd in self._DynamicPcdList for (SkuName, Sku) in pcd.SkuInfoList.items()]
1783 for pcd in self._DynamicPcdList:
1784 if len(pcd.SkuInfoList) == 1:
1785 for (SkuName, SkuId) in allskuset:
1786 if type(SkuId) in (str, unicode) and eval(SkuId) == 0 or SkuId == 0:
1787 continue
1788 pcd.SkuInfoList[SkuName] = copy.deepcopy(pcd.SkuInfoList[TAB_DEFAULT])
1789 pcd.SkuInfoList[SkuName].SkuId = SkuId
1790 self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList
1791
1792 def FixVpdOffset(self, VpdFile ):
1793 FvPath = os.path.join(self.BuildDir, TAB_FV_DIRECTORY)
1794 if not os.path.exists(FvPath):
1795 try:
1796 os.makedirs(FvPath)
1797 except:
1798 EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)
1799
1800 VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)
1801
1802 if VpdFile.Write(VpdFilePath):
1803 # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.
1804 BPDGToolName = None
1805 for ToolDef in self.ToolDefinition.values():
1806 if TAB_GUID in ToolDef and ToolDef[TAB_GUID] == self.Platform.VpdToolGuid:
1807 if "PATH" not in ToolDef:
1808 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)
1809 BPDGToolName = ToolDef["PATH"]
1810 break
1811 # Call third party GUID BPDG tool.
1812 if BPDGToolName is not None:
1813 VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)
1814 else:
1815 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.")
1816
1817 ## Return the platform build data object
1818 def _GetPlatform(self):
1819 if self._Platform is None:
1820 self._Platform = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]
1821 return self._Platform
1822
1823 ## Return platform name
1824 def _GetName(self):
1825 return self.Platform.PlatformName
1826
1827 ## Return the meta file GUID
1828 def _GetGuid(self):
1829 return self.Platform.Guid
1830
1831 ## Return the platform version
1832 def _GetVersion(self):
1833 return self.Platform.Version
1834
1835 ## Return the FDF file name
1836 def _GetFdfFile(self):
1837 if self._FdfFile is None:
1838 if self.Workspace.FdfFile != "":
1839 self._FdfFile= mws.join(self.WorkspaceDir, self.Workspace.FdfFile)
1840 else:
1841 self._FdfFile = ''
1842 return self._FdfFile
1843
1844 ## Return the build output directory platform specifies
1845 def _GetOutputDir(self):
1846 return self.Platform.OutputDirectory
1847
1848 ## Return the directory to store all intermediate and final files built
1849 def _GetBuildDir(self):
1850 if self._BuildDir is None:
1851 if os.path.isabs(self.OutputDir):
1852 self._BuildDir = path.join(
1853 path.abspath(self.OutputDir),
1854 self.BuildTarget + "_" + self.ToolChain,
1855 )
1856 else:
1857 self._BuildDir = path.join(
1858 self.WorkspaceDir,
1859 self.OutputDir,
1860 self.BuildTarget + "_" + self.ToolChain,
1861 )
1862 GlobalData.gBuildDirectory = self._BuildDir
1863 return self._BuildDir
1864
1865 ## Return directory of platform makefile
1866 #
1867 # @retval string Makefile directory
1868 #
1869 def _GetMakeFileDir(self):
1870 if self._MakeFileDir is None:
1871 self._MakeFileDir = path.join(self.BuildDir, self.Arch)
1872 return self._MakeFileDir
1873
1874 ## Return build command string
1875 #
1876 # @retval string Build command string
1877 #
1878 def _GetBuildCommand(self):
1879 if self._BuildCommand is None:
1880 self._BuildCommand = []
1881 if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:
1882 self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])
1883 if "FLAGS" in self.ToolDefinition["MAKE"]:
1884 NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()
1885 if NewOption != '':
1886 self._BuildCommand += SplitOption(NewOption)
1887 if "MAKE" in self.EdkIIBuildOption:
1888 if "FLAGS" in self.EdkIIBuildOption["MAKE"]:
1889 Flags = self.EdkIIBuildOption["MAKE"]["FLAGS"]
1890 if Flags.startswith('='):
1891 self._BuildCommand = [self._BuildCommand[0]] + [Flags[1:]]
1892 else:
1893 self._BuildCommand.append(Flags)
1894 return self._BuildCommand
1895
1896 ## Get tool chain definition
1897 #
1898 # Get each tool defition for given tool chain from tools_def.txt and platform
1899 #
1900 def _GetToolDefinition(self):
1901 if self._ToolDefinitions is None:
1902 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary
1903 if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:
1904 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",
1905 ExtraData="[%s]" % self.MetaFile)
1906 self._ToolDefinitions = {}
1907 DllPathList = set()
1908 for Def in ToolDefinition:
1909 Target, Tag, Arch, Tool, Attr = Def.split("_")
1910 if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:
1911 continue
1912
1913 Value = ToolDefinition[Def]
1914 # don't record the DLL
1915 if Attr == "DLL":
1916 DllPathList.add(Value)
1917 continue
1918
1919 if Tool not in self._ToolDefinitions:
1920 self._ToolDefinitions[Tool] = {}
1921 self._ToolDefinitions[Tool][Attr] = Value
1922
1923 ToolsDef = ''
1924 if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:
1925 if "FLAGS" not in self._ToolDefinitions["MAKE"]:
1926 self._ToolDefinitions["MAKE"]["FLAGS"] = ""
1927 self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"
1928 MakeFlags = ''
1929 for Tool in self._ToolDefinitions:
1930 for Attr in self._ToolDefinitions[Tool]:
1931 Value = self._ToolDefinitions[Tool][Attr]
1932 if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:
1933 # check if override is indicated
1934 if self.BuildOption[Tool][Attr].startswith('='):
1935 Value = self.BuildOption[Tool][Attr][1:]
1936 else:
1937 if Attr != 'PATH':
1938 Value += " " + self.BuildOption[Tool][Attr]
1939 else:
1940 Value = self.BuildOption[Tool][Attr]
1941
1942 if Attr == "PATH":
1943 # Don't put MAKE definition in the file
1944 if Tool != "MAKE":
1945 ToolsDef += "%s = %s\n" % (Tool, Value)
1946 elif Attr != "DLL":
1947 # Don't put MAKE definition in the file
1948 if Tool == "MAKE":
1949 if Attr == "FLAGS":
1950 MakeFlags = Value
1951 else:
1952 ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)
1953 ToolsDef += "\n"
1954
1955 SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)
1956 for DllPath in DllPathList:
1957 os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]
1958 os.environ["MAKE_FLAGS"] = MakeFlags
1959
1960 return self._ToolDefinitions
1961
1962 ## Return the paths of tools
1963 def _GetToolDefFile(self):
1964 if self._ToolDefFile is None:
1965 self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)
1966 return self._ToolDefFile
1967
1968 ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.
1969 def _GetToolChainFamily(self):
1970 if self._ToolChainFamily is None:
1971 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
1972 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
1973 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
1974 or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:
1975 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
1976 % self.ToolChain)
1977 self._ToolChainFamily = "MSFT"
1978 else:
1979 self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]
1980 return self._ToolChainFamily
1981
1982 def _GetBuildRuleFamily(self):
1983 if self._BuildRuleFamily is None:
1984 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
1985 if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \
1986 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \
1987 or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:
1988 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
1989 % self.ToolChain)
1990 self._BuildRuleFamily = "MSFT"
1991 else:
1992 self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]
1993 return self._BuildRuleFamily
1994
1995 ## Return the build options specific for all modules in this platform
1996 def _GetBuildOptions(self):
1997 if self._BuildOption is None:
1998 self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)
1999 return self._BuildOption
2000
2001 ## Return the build options specific for EDK modules in this platform
2002 def _GetEdkBuildOptions(self):
2003 if self._EdkBuildOption is None:
2004 self._EdkBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)
2005 return self._EdkBuildOption
2006
2007 ## Return the build options specific for EDKII modules in this platform
2008 def _GetEdkIIBuildOptions(self):
2009 if self._EdkIIBuildOption is None:
2010 self._EdkIIBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)
2011 return self._EdkIIBuildOption
2012
2013 ## Parse build_rule.txt in Conf Directory.
2014 #
2015 # @retval BuildRule object
2016 #
2017 def _GetBuildRule(self):
2018 if self._BuildRule is None:
2019 BuildRuleFile = None
2020 if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:
2021 BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]
2022 if not BuildRuleFile:
2023 BuildRuleFile = gDefaultBuildRuleFile
2024 self._BuildRule = BuildRule(BuildRuleFile)
2025 if self._BuildRule._FileVersion == "":
2026 self._BuildRule._FileVersion = AutoGenReqBuildRuleVerNum
2027 else:
2028 if self._BuildRule._FileVersion < AutoGenReqBuildRuleVerNum :
2029 # If Build Rule's version is less than the version number required by the tools, halting the build.
2030 EdkLogger.error("build", AUTOGEN_ERROR,
2031 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])"\
2032 % (self._BuildRule._FileVersion, AutoGenReqBuildRuleVerNum))
2033
2034 return self._BuildRule
2035
2036 ## Summarize the packages used by modules in this platform
2037 def _GetPackageList(self):
2038 if self._PackageList is None:
2039 self._PackageList = set()
2040 for La in self.LibraryAutoGenList:
2041 self._PackageList.update(La.DependentPackageList)
2042 for Ma in self.ModuleAutoGenList:
2043 self._PackageList.update(Ma.DependentPackageList)
2044 #Collect package set information from INF of FDF
2045 PkgSet = set()
2046 for ModuleFile in self._AsBuildModuleList:
2047 if ModuleFile in self.Platform.Modules:
2048 continue
2049 ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]
2050 PkgSet.update(ModuleData.Packages)
2051 self._PackageList = list(self._PackageList) + list (PkgSet)
2052 return self._PackageList
2053
2054 def _GetNonDynamicPcdDict(self):
2055 if self._NonDynamicPcdDict:
2056 return self._NonDynamicPcdDict
2057 for Pcd in self.NonDynamicPcdList:
2058 self._NonDynamicPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd
2059 return self._NonDynamicPcdDict
2060
2061 ## Get list of non-dynamic PCDs
2062 def _GetNonDynamicPcdList(self):
2063 if self._NonDynamicPcdList is None:
2064 self.CollectPlatformDynamicPcds()
2065 return self._NonDynamicPcdList
2066
2067 ## Get list of dynamic PCDs
2068 def _GetDynamicPcdList(self):
2069 if self._DynamicPcdList is None:
2070 self.CollectPlatformDynamicPcds()
2071 return self._DynamicPcdList
2072
2073 ## Generate Token Number for all PCD
2074 def _GetPcdTokenNumbers(self):
2075 if self._PcdTokenNumber is None:
2076 self._PcdTokenNumber = OrderedDict()
2077 TokenNumber = 1
2078 #
2079 # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.
2080 # Such as:
2081 #
2082 # Dynamic PCD:
2083 # TokenNumber 0 ~ 10
2084 # DynamicEx PCD:
2085 # TokeNumber 11 ~ 20
2086 #
2087 for Pcd in self.DynamicPcdList:
2088 if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:
2089 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
2090 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
2091 TokenNumber += 1
2092
2093 for Pcd in self.DynamicPcdList:
2094 if Pcd.Phase == "PEI" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
2095 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
2096 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
2097 TokenNumber += 1
2098
2099 for Pcd in self.DynamicPcdList:
2100 if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_TYPE_SET:
2101 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
2102 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
2103 TokenNumber += 1
2104
2105 for Pcd in self.DynamicPcdList:
2106 if Pcd.Phase == "DXE" and Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
2107 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
2108 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
2109 TokenNumber += 1
2110
2111 for Pcd in self.NonDynamicPcdList:
2112 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
2113 TokenNumber += 1
2114 return self._PcdTokenNumber
2115
2116 ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform
2117 def _GetAutoGenObjectList(self):
2118 self._ModuleAutoGenList = []
2119 self._LibraryAutoGenList = []
2120 for ModuleFile in self.Platform.Modules:
2121 Ma = ModuleAutoGen(
2122 self.Workspace,
2123 ModuleFile,
2124 self.BuildTarget,
2125 self.ToolChain,
2126 self.Arch,
2127 self.MetaFile
2128 )
2129 if Ma not in self._ModuleAutoGenList:
2130 self._ModuleAutoGenList.append(Ma)
2131 for La in Ma.LibraryAutoGenList:
2132 if La not in self._LibraryAutoGenList:
2133 self._LibraryAutoGenList.append(La)
2134 if Ma not in La._ReferenceModules:
2135 La._ReferenceModules.append(Ma)
2136
2137 ## Summarize ModuleAutoGen objects of all modules to be built for this platform
2138 def _GetModuleAutoGenList(self):
2139 if self._ModuleAutoGenList is None:
2140 self._GetAutoGenObjectList()
2141 return self._ModuleAutoGenList
2142
2143 ## Summarize ModuleAutoGen objects of all libraries to be built for this platform
2144 def _GetLibraryAutoGenList(self):
2145 if self._LibraryAutoGenList is None:
2146 self._GetAutoGenObjectList()
2147 return self._LibraryAutoGenList
2148
2149 ## Test if a module is supported by the platform
2150 #
2151 # An error will be raised directly if the module or its arch is not supported
2152 # by the platform or current configuration
2153 #
2154 def ValidModule(self, Module):
2155 return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \
2156 or Module in self._AsBuildModuleList
2157
2158 ## Resolve the library classes in a module to library instances
2159 #
2160 # This method will not only resolve library classes but also sort the library
2161 # instances according to the dependency-ship.
2162 #
2163 # @param Module The module from which the library classes will be resolved
2164 #
2165 # @retval library_list List of library instances sorted
2166 #
2167 def ApplyLibraryInstance(self, Module):
2168 # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly
2169 if str(Module) not in self.Platform.Modules:
2170 return []
2171
2172 return GetModuleLibInstances(Module,
2173 self.Platform,
2174 self.BuildDatabase,
2175 self.Arch,
2176 self.BuildTarget,
2177 self.ToolChain,
2178 self.MetaFile,
2179 EdkLogger)
2180
2181 ## Override PCD setting (type, value, ...)
2182 #
2183 # @param ToPcd The PCD to be overrided
2184 # @param FromPcd The PCD overrideing from
2185 #
2186 def _OverridePcd(self, ToPcd, FromPcd, Module="", Msg="", Library=""):
2187 #
2188 # in case there's PCDs coming from FDF file, which have no type given.
2189 # at this point, ToPcd.Type has the type found from dependent
2190 # package
2191 #
2192 TokenCName = ToPcd.TokenCName
2193 for PcdItem in GlobalData.MixedPcd:
2194 if (ToPcd.TokenCName, ToPcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
2195 TokenCName = PcdItem[0]
2196 break
2197 if FromPcd is not None:
2198 if ToPcd.Pending and FromPcd.Type:
2199 ToPcd.Type = FromPcd.Type
2200 elif ToPcd.Type and FromPcd.Type\
2201 and ToPcd.Type != FromPcd.Type and ToPcd.Type in FromPcd.Type:
2202 if ToPcd.Type.strip() == TAB_PCDS_DYNAMIC_EX:
2203 ToPcd.Type = FromPcd.Type
2204 elif ToPcd.Type and FromPcd.Type \
2205 and ToPcd.Type != FromPcd.Type:
2206 if Library:
2207 Module = str(Module) + " 's library file (" + str(Library) + ")"
2208 EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",
2209 ExtraData="%s.%s is used as [%s] in module %s, but as [%s] in %s."\
2210 % (ToPcd.TokenSpaceGuidCName, TokenCName,
2211 ToPcd.Type, Module, FromPcd.Type, Msg),
2212 File=self.MetaFile)
2213
2214 if FromPcd.MaxDatumSize:
2215 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
2216 ToPcd.MaxSizeUserSet = FromPcd.MaxDatumSize
2217 if FromPcd.DefaultValue:
2218 ToPcd.DefaultValue = FromPcd.DefaultValue
2219 if FromPcd.TokenValue:
2220 ToPcd.TokenValue = FromPcd.TokenValue
2221 if FromPcd.DatumType:
2222 ToPcd.DatumType = FromPcd.DatumType
2223 if FromPcd.SkuInfoList:
2224 ToPcd.SkuInfoList = FromPcd.SkuInfoList
2225 # Add Flexible PCD format parse
2226 if ToPcd.DefaultValue:
2227 try:
2228 ToPcd.DefaultValue = ValueExpressionEx(ToPcd.DefaultValue, ToPcd.DatumType, self._GuidDict)(True)
2229 except BadExpression as Value:
2230 EdkLogger.error('Parser', FORMAT_INVALID, 'PCD [%s.%s] Value "%s", %s' %(ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName, ToPcd.DefaultValue, Value),
2231 File=self.MetaFile)
2232
2233 # check the validation of datum
2234 IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)
2235 if not IsValid:
2236 EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,
2237 ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, TokenCName))
2238 ToPcd.validateranges = FromPcd.validateranges
2239 ToPcd.validlists = FromPcd.validlists
2240 ToPcd.expressions = FromPcd.expressions
2241
2242 if FromPcd is not None and ToPcd.DatumType == TAB_VOID and not ToPcd.MaxDatumSize:
2243 EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \
2244 % (ToPcd.TokenSpaceGuidCName, TokenCName))
2245 Value = ToPcd.DefaultValue
2246 if not Value:
2247 ToPcd.MaxDatumSize = '1'
2248 elif Value[0] == 'L':
2249 ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)
2250 elif Value[0] == '{':
2251 ToPcd.MaxDatumSize = str(len(Value.split(',')))
2252 else:
2253 ToPcd.MaxDatumSize = str(len(Value) - 1)
2254
2255 # apply default SKU for dynamic PCDS if specified one is not available
2256 if (ToPcd.Type in PCD_DYNAMIC_TYPE_SET or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_SET) \
2257 and not ToPcd.SkuInfoList:
2258 if self.Platform.SkuName in self.Platform.SkuIds:
2259 SkuName = self.Platform.SkuName
2260 else:
2261 SkuName = TAB_DEFAULT
2262 ToPcd.SkuInfoList = {
2263 SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName][0], '', '', '', '', '', ToPcd.DefaultValue)
2264 }
2265
2266 ## Apply PCD setting defined platform to a module
2267 #
2268 # @param Module The module from which the PCD setting will be overrided
2269 #
2270 # @retval PCD_list The list PCDs with settings from platform
2271 #
2272 def ApplyPcdSetting(self, Module, Pcds, Library=""):
2273 # for each PCD in module
2274 for Name, Guid in Pcds:
2275 PcdInModule = Pcds[Name, Guid]
2276 # find out the PCD setting in platform
2277 if (Name, Guid) in self.Platform.Pcds:
2278 PcdInPlatform = self.Platform.Pcds[Name, Guid]
2279 else:
2280 PcdInPlatform = None
2281 # then override the settings if any
2282 self._OverridePcd(PcdInModule, PcdInPlatform, Module, Msg="DSC PCD sections", Library=Library)
2283 # resolve the VariableGuid value
2284 for SkuId in PcdInModule.SkuInfoList:
2285 Sku = PcdInModule.SkuInfoList[SkuId]
2286 if Sku.VariableGuid == '': continue
2287 Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList, self.MetaFile.Path)
2288 if Sku.VariableGuidValue is None:
2289 PackageList = "\n\t".join(str(P) for P in self.PackageList)
2290 EdkLogger.error(
2291 'build',
2292 RESOURCE_NOT_AVAILABLE,
2293 "Value of GUID [%s] is not found in" % Sku.VariableGuid,
2294 ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \
2295 % (Guid, Name, str(Module)),
2296 File=self.MetaFile
2297 )
2298
2299 # override PCD settings with module specific setting
2300 if Module in self.Platform.Modules:
2301 PlatformModule = self.Platform.Modules[str(Module)]
2302 for Key in PlatformModule.Pcds:
2303 Flag = False
2304 if Key in Pcds:
2305 ToPcd = Pcds[Key]
2306 Flag = True
2307 elif Key in GlobalData.MixedPcd:
2308 for PcdItem in GlobalData.MixedPcd[Key]:
2309 if PcdItem in Pcds:
2310 ToPcd = Pcds[PcdItem]
2311 Flag = True
2312 break
2313 if Flag:
2314 self._OverridePcd(ToPcd, PlatformModule.Pcds[Key], Module, Msg="DSC Components Module scoped PCD section", Library=Library)
2315 # use PCD value to calculate the MaxDatumSize when it is not specified
2316 for Name, Guid in Pcds:
2317 Pcd = Pcds[Name, Guid]
2318 if Pcd.DatumType == TAB_VOID and not Pcd.MaxDatumSize:
2319 Pcd.MaxSizeUserSet = None
2320 Value = Pcd.DefaultValue
2321 if not Value:
2322 Pcd.MaxDatumSize = '1'
2323 elif Value[0] == 'L':
2324 Pcd.MaxDatumSize = str((len(Value) - 2) * 2)
2325 elif Value[0] == '{':
2326 Pcd.MaxDatumSize = str(len(Value.split(',')))
2327 else:
2328 Pcd.MaxDatumSize = str(len(Value) - 1)
2329 return Pcds.values()
2330
2331 ## Resolve library names to library modules
2332 #
2333 # (for Edk.x modules)
2334 #
2335 # @param Module The module from which the library names will be resolved
2336 #
2337 # @retval library_list The list of library modules
2338 #
2339 def ResolveLibraryReference(self, Module):
2340 EdkLogger.verbose("")
2341 EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))
2342 LibraryConsumerList = [Module]
2343
2344 # "CompilerStub" is a must for Edk modules
2345 if Module.Libraries:
2346 Module.Libraries.append("CompilerStub")
2347 LibraryList = []
2348 while len(LibraryConsumerList) > 0:
2349 M = LibraryConsumerList.pop()
2350 for LibraryName in M.Libraries:
2351 Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']
2352 if Library is None:
2353 for Key in self.Platform.LibraryClasses.data:
2354 if LibraryName.upper() == Key.upper():
2355 Library = self.Platform.LibraryClasses[Key, ':dummy:']
2356 break
2357 if Library is None:
2358 EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),
2359 ExtraData="\t%s [%s]" % (str(Module), self.Arch))
2360 continue
2361
2362 if Library not in LibraryList:
2363 LibraryList.append(Library)
2364 LibraryConsumerList.append(Library)
2365 EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))
2366 return LibraryList
2367
2368 ## Calculate the priority value of the build option
2369 #
2370 # @param Key Build option definition contain: TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
2371 #
2372 # @retval Value Priority value based on the priority list.
2373 #
2374 def CalculatePriorityValue(self, Key):
2375 Target, ToolChain, Arch, CommandType, Attr = Key.split('_')
2376 PriorityValue = 0x11111
2377 if Target == "*":
2378 PriorityValue &= 0x01111
2379 if ToolChain == "*":
2380 PriorityValue &= 0x10111
2381 if Arch == "*":
2382 PriorityValue &= 0x11011
2383 if CommandType == "*":
2384 PriorityValue &= 0x11101
2385 if Attr == "*":
2386 PriorityValue &= 0x11110
2387
2388 return self.PrioList["0x%0.5x" % PriorityValue]
2389
2390
2391 ## Expand * in build option key
2392 #
2393 # @param Options Options to be expanded
2394 #
2395 # @retval options Options expanded
2396 #
2397 def _ExpandBuildOption(self, Options, ModuleStyle=None):
2398 BuildOptions = {}
2399 FamilyMatch = False
2400 FamilyIsNull = True
2401
2402 OverrideList = {}
2403 #
2404 # Construct a list contain the build options which need override.
2405 #
2406 for Key in Options:
2407 #
2408 # Key[0] -- tool family
2409 # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
2410 #
2411 if (Key[0] == self.BuildRuleFamily and
2412 (ModuleStyle is None or len(Key) < 3 or (len(Key) > 2 and Key[2] == ModuleStyle))):
2413 Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')
2414 if (Target == self.BuildTarget or Target == "*") and\
2415 (ToolChain == self.ToolChain or ToolChain == "*") and\
2416 (Arch == self.Arch or Arch == "*") and\
2417 Options[Key].startswith("="):
2418
2419 if OverrideList.get(Key[1]) is not None:
2420 OverrideList.pop(Key[1])
2421 OverrideList[Key[1]] = Options[Key]
2422
2423 #
2424 # Use the highest priority value.
2425 #
2426 if (len(OverrideList) >= 2):
2427 KeyList = OverrideList.keys()
2428 for Index in range(len(KeyList)):
2429 NowKey = KeyList[Index]
2430 Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")
2431 for Index1 in range(len(KeyList) - Index - 1):
2432 NextKey = KeyList[Index1 + Index + 1]
2433 #
2434 # Compare two Key, if one is included by another, choose the higher priority one
2435 #
2436 Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")
2437 if (Target1 == Target2 or Target1 == "*" or Target2 == "*") and\
2438 (ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*") and\
2439 (Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*") and\
2440 (CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*") and\
2441 (Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*"):
2442
2443 if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):
2444 if Options.get((self.BuildRuleFamily, NextKey)) is not None:
2445 Options.pop((self.BuildRuleFamily, NextKey))
2446 else:
2447 if Options.get((self.BuildRuleFamily, NowKey)) is not None:
2448 Options.pop((self.BuildRuleFamily, NowKey))
2449
2450 for Key in Options:
2451 if ModuleStyle is not None and len (Key) > 2:
2452 # Check Module style is EDK or EDKII.
2453 # Only append build option for the matched style module.
2454 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:
2455 continue
2456 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:
2457 continue
2458 Family = Key[0]
2459 Target, Tag, Arch, Tool, Attr = Key[1].split("_")
2460 # if tool chain family doesn't match, skip it
2461 if Tool in self.ToolDefinition and Family != "":
2462 FamilyIsNull = False
2463 if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":
2464 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:
2465 continue
2466 elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
2467 continue
2468 FamilyMatch = True
2469 # expand any wildcard
2470 if Target == "*" or Target == self.BuildTarget:
2471 if Tag == "*" or Tag == self.ToolChain:
2472 if Arch == "*" or Arch == self.Arch:
2473 if Tool not in BuildOptions:
2474 BuildOptions[Tool] = {}
2475 if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):
2476 BuildOptions[Tool][Attr] = Options[Key]
2477 else:
2478 # append options for the same tool except PATH
2479 if Attr != 'PATH':
2480 BuildOptions[Tool][Attr] += " " + Options[Key]
2481 else:
2482 BuildOptions[Tool][Attr] = Options[Key]
2483 # Build Option Family has been checked, which need't to be checked again for family.
2484 if FamilyMatch or FamilyIsNull:
2485 return BuildOptions
2486
2487 for Key in Options:
2488 if ModuleStyle is not None and len (Key) > 2:
2489 # Check Module style is EDK or EDKII.
2490 # Only append build option for the matched style module.
2491 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:
2492 continue
2493 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:
2494 continue
2495 Family = Key[0]
2496 Target, Tag, Arch, Tool, Attr = Key[1].split("_")
2497 # if tool chain family doesn't match, skip it
2498 if Tool not in self.ToolDefinition or Family == "":
2499 continue
2500 # option has been added before
2501 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
2502 continue
2503
2504 # expand any wildcard
2505 if Target == "*" or Target == self.BuildTarget:
2506 if Tag == "*" or Tag == self.ToolChain:
2507 if Arch == "*" or Arch == self.Arch:
2508 if Tool not in BuildOptions:
2509 BuildOptions[Tool] = {}
2510 if Attr != "FLAGS" or Attr not in BuildOptions[Tool] or Options[Key].startswith('='):
2511 BuildOptions[Tool][Attr] = Options[Key]
2512 else:
2513 # append options for the same tool except PATH
2514 if Attr != 'PATH':
2515 BuildOptions[Tool][Attr] += " " + Options[Key]
2516 else:
2517 BuildOptions[Tool][Attr] = Options[Key]
2518 return BuildOptions
2519
2520 ## Append build options in platform to a module
2521 #
2522 # @param Module The module to which the build options will be appened
2523 #
2524 # @retval options The options appended with build options in platform
2525 #
2526 def ApplyBuildOption(self, Module):
2527 # Get the different options for the different style module
2528 if Module.AutoGenVersion < 0x00010005:
2529 PlatformOptions = self.EdkBuildOption
2530 ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDK_NAME, Module.ModuleType)
2531 else:
2532 PlatformOptions = self.EdkIIBuildOption
2533 ModuleTypeOptions = self.Platform.GetBuildOptionsByModuleType(EDKII_NAME, Module.ModuleType)
2534 ModuleTypeOptions = self._ExpandBuildOption(ModuleTypeOptions)
2535 ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)
2536 if Module in self.Platform.Modules:
2537 PlatformModule = self.Platform.Modules[str(Module)]
2538 PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)
2539 else:
2540 PlatformModuleOptions = {}
2541
2542 BuildRuleOrder = None
2543 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:
2544 for Tool in Options:
2545 for Attr in Options[Tool]:
2546 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:
2547 BuildRuleOrder = Options[Tool][Attr]
2548
2549 AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() +
2550 PlatformModuleOptions.keys() + ModuleTypeOptions.keys() +
2551 self.ToolDefinition.keys())
2552 BuildOptions = defaultdict(lambda: defaultdict(str))
2553 for Tool in AllTools:
2554 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, ModuleTypeOptions, PlatformModuleOptions]:
2555 if Tool not in Options:
2556 continue
2557 for Attr in Options[Tool]:
2558 #
2559 # Do not generate it in Makefile
2560 #
2561 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:
2562 continue
2563 Value = Options[Tool][Attr]
2564 # check if override is indicated
2565 if Value.startswith('='):
2566 BuildOptions[Tool][Attr] = mws.handleWsMacro(Value[1:])
2567 else:
2568 if Attr != 'PATH':
2569 BuildOptions[Tool][Attr] += " " + mws.handleWsMacro(Value)
2570 else:
2571 BuildOptions[Tool][Attr] = mws.handleWsMacro(Value)
2572
2573 if Module.AutoGenVersion < 0x00010005 and self.Workspace.UniFlag is not None:
2574 #
2575 # Override UNI flag only for EDK module.
2576 #
2577 BuildOptions['BUILD']['FLAGS'] = self.Workspace.UniFlag
2578 return BuildOptions, BuildRuleOrder
2579
2580 Platform = property(_GetPlatform)
2581 Name = property(_GetName)
2582 Guid = property(_GetGuid)
2583 Version = property(_GetVersion)
2584
2585 OutputDir = property(_GetOutputDir)
2586 BuildDir = property(_GetBuildDir)
2587 MakeFileDir = property(_GetMakeFileDir)
2588 FdfFile = property(_GetFdfFile)
2589
2590 PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
2591 DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
2592 NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
2593 NonDynamicPcdDict = property(_GetNonDynamicPcdDict)
2594 PackageList = property(_GetPackageList)
2595
2596 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path
2597 ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path
2598 ToolChainFamily = property(_GetToolChainFamily)
2599 BuildRuleFamily = property(_GetBuildRuleFamily)
2600 BuildOption = property(_GetBuildOptions) # toolcode : option
2601 EdkBuildOption = property(_GetEdkBuildOptions) # edktoolcode : option
2602 EdkIIBuildOption = property(_GetEdkIIBuildOptions) # edkiitoolcode : option
2603
2604 BuildCommand = property(_GetBuildCommand)
2605 BuildRule = property(_GetBuildRule)
2606 ModuleAutoGenList = property(_GetModuleAutoGenList)
2607 LibraryAutoGenList = property(_GetLibraryAutoGenList)
2608 GenFdsCommand = property(_GenFdsCommand)
2609
2610 #
2611 # extend lists contained in a dictionary with lists stored in another dictionary
2612 # if CopyToDict is not derived from DefaultDict(list) then this may raise exception
2613 #
2614 def ExtendCopyDictionaryLists(CopyToDict, CopyFromDict):
2615 for Key in CopyFromDict:
2616 CopyToDict[Key].extend(CopyFromDict[Key])
2617
2618
2619 ## ModuleAutoGen class
2620 #
2621 # This class encapsules the AutoGen behaviors for the build tools. In addition to
2622 # the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according
2623 # to the [depex] section in module's inf file.
2624 #
2625 class ModuleAutoGen(AutoGen):
2626 # call super().__init__ then call the worker function with different parameter count
2627 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
2628 try:
2629 self._Init
2630 except:
2631 super(ModuleAutoGen, self).__init__(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
2632 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args)
2633 self._Init = True
2634
2635 ## Cache the timestamps of metafiles of every module in a class variable
2636 #
2637 TimeDict = {}
2638
2639 def __new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
2640 obj = super(ModuleAutoGen, cls).__new__(cls, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)
2641 # check if this module is employed by active platform
2642 if not PlatformAutoGen(Workspace, args[0], Target, Toolchain, Arch).ValidModule(MetaFile):
2643 EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \
2644 % (MetaFile, Arch))
2645 return None
2646 return obj
2647
2648 ## Initialize ModuleAutoGen
2649 #
2650 # @param Workspace EdkIIWorkspaceBuild object
2651 # @param ModuleFile The path of module file
2652 # @param Target Build target (DEBUG, RELEASE)
2653 # @param Toolchain Name of tool chain
2654 # @param Arch The arch the module supports
2655 # @param PlatformFile Platform meta-file
2656 #
2657 def _InitWorker(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):
2658 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))
2659 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)
2660
2661 self.Workspace = Workspace
2662 self.WorkspaceDir = Workspace.WorkspaceDir
2663 self._GuidDict = Workspace._GuidDict
2664 self.MetaFile = ModuleFile
2665 self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)
2666
2667 self.SourceDir = self.MetaFile.SubDir
2668 self.SourceDir = mws.relpath(self.SourceDir, self.WorkspaceDir)
2669
2670 self.SourceOverrideDir = None
2671 # use overrided path defined in DSC file
2672 if self.MetaFile.Key in GlobalData.gOverrideDir:
2673 self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]
2674
2675 self.ToolChain = Toolchain
2676 self.BuildTarget = Target
2677 self.Arch = Arch
2678 self.ToolChainFamily = self.PlatformInfo.ToolChainFamily
2679 self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily
2680
2681 self.IsMakeFileCreated = False
2682 self.IsCodeFileCreated = False
2683 self.IsAsBuiltInfCreated = False
2684 self.DepexGenerated = False
2685
2686 self.BuildDatabase = self.Workspace.BuildDatabase
2687 self.BuildRuleOrder = None
2688 self.BuildTime = 0
2689
2690 self._Module = None
2691 self._Name = None