]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/Python/AutoGen/AutoGen.py
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
BaseTool: Fixed the incorrect cache key.
[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
2692 self._Guid = None
2693 self._Version = None
2694 self._ModuleType = None
2695 self._ComponentType = None
2696 self._PcdIsDriver = None
2697 self._AutoGenVersion = None
2698 self._LibraryFlag = None
2699 self._CustomMakefile = None
2700 self._Macro = None
2701
2702 self._BuildDir = None
2703 self._OutputDir = None
2704 self._FfsOutputDir = None
2705 self._DebugDir = None
2706 self._MakeFileDir = None
2707
2708 self._IncludePathList = None
2709 self._AutoGenFileList = None
2710 self._UnicodeFileList = None
2711 self._VfrFileList = None
2712 self._IdfFileList = None
2713 self._SourceFileList = None
2714 self._ObjectFileList = None
2715 self._BinaryFileList = None
2716
2717 self._DependentPackageList = None
2718 self._DependentLibraryList = None
2719 self._LibraryAutoGenList = None
2720 self._DerivedPackageList = None
2721 self._ModulePcdList = None
2722 self._LibraryPcdList = None
2723 self._PcdComments = OrderedListDict()
2724 self._GuidList = None
2725 self._GuidsUsedByPcd = None
2726 self._GuidComments = OrderedListDict()
2727 self._ProtocolList = None
2728 self._ProtocolComments = OrderedListDict()
2729 self._PpiList = None
2730 self._PpiComments = OrderedListDict()
2731 self._DepexDict = None
2732 self._DepexExpressionDict = None
2733 self._BuildOption = None
2734 self._BuildOptionIncPathList = None
2735 self._BuildTargets = None
2736 self._IntroBuildTargetList = None
2737 self._FinalBuildTargetList = None
2738 self._FileTypes = None
2739 self._BuildRules = None
2740
2741 self._TimeStampPath = None
2742
2743 self.AutoGenDepSet = set()
2744
2745
2746 ## The Modules referenced to this Library
2747 # Only Library has this attribute
2748 self._ReferenceModules = []
2749
2750 ## Store the FixedAtBuild Pcds
2751 #
2752 self._FixedAtBuildPcds = []
2753 self.ConstPcd = {}
2754
2755 def __repr__(self):
2756 return "%s [%s]" % (self.MetaFile, self.Arch)
2757
2758 # Get FixedAtBuild Pcds of this Module
2759 def _GetFixedAtBuildPcds(self):
2760 if self._FixedAtBuildPcds:
2761 return self._FixedAtBuildPcds
2762 for Pcd in self.ModulePcdList:
2763 if Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:
2764 continue
2765 if Pcd not in self._FixedAtBuildPcds:
2766 self._FixedAtBuildPcds.append(Pcd)
2767
2768 return self._FixedAtBuildPcds
2769
2770 def _GetUniqueBaseName(self):
2771 BaseName = self.Name
2772 for Module in self.PlatformInfo.ModuleAutoGenList:
2773 if Module.MetaFile == self.MetaFile:
2774 continue
2775 if Module.Name == self.Name:
2776 if uuid.UUID(Module.Guid) == uuid.UUID(self.Guid):
2777 EdkLogger.error("build", FILE_DUPLICATED, 'Modules have same BaseName and FILE_GUID:\n'
2778 ' %s\n %s' % (Module.MetaFile, self.MetaFile))
2779 BaseName = '%s_%s' % (self.Name, self.Guid)
2780 return BaseName
2781
2782 # Macros could be used in build_rule.txt (also Makefile)
2783 def _GetMacros(self):
2784 if self._Macro is None:
2785 self._Macro = OrderedDict()
2786 self._Macro["WORKSPACE" ] = self.WorkspaceDir
2787 self._Macro["MODULE_NAME" ] = self.Name
2788 self._Macro["MODULE_NAME_GUID" ] = self.UniqueBaseName
2789 self._Macro["MODULE_GUID" ] = self.Guid
2790 self._Macro["MODULE_VERSION" ] = self.Version
2791 self._Macro["MODULE_TYPE" ] = self.ModuleType
2792 self._Macro["MODULE_FILE" ] = str(self.MetaFile)
2793 self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName
2794 self._Macro["MODULE_RELATIVE_DIR" ] = self.SourceDir
2795 self._Macro["MODULE_DIR" ] = self.SourceDir
2796
2797 self._Macro["BASE_NAME" ] = self.Name
2798
2799 self._Macro["ARCH" ] = self.Arch
2800 self._Macro["TOOLCHAIN" ] = self.ToolChain
2801 self._Macro["TOOLCHAIN_TAG" ] = self.ToolChain
2802 self._Macro["TOOL_CHAIN_TAG" ] = self.ToolChain
2803 self._Macro["TARGET" ] = self.BuildTarget
2804
2805 self._Macro["BUILD_DIR" ] = self.PlatformInfo.BuildDir
2806 self._Macro["BIN_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
2807 self._Macro["LIB_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
2808 self._Macro["MODULE_BUILD_DIR" ] = self.BuildDir
2809 self._Macro["OUTPUT_DIR" ] = self.OutputDir
2810 self._Macro["DEBUG_DIR" ] = self.DebugDir
2811 self._Macro["DEST_DIR_OUTPUT" ] = self.OutputDir
2812 self._Macro["DEST_DIR_DEBUG" ] = self.DebugDir
2813 self._Macro["PLATFORM_NAME" ] = self.PlatformInfo.Name
2814 self._Macro["PLATFORM_GUID" ] = self.PlatformInfo.Guid
2815 self._Macro["PLATFORM_VERSION" ] = self.PlatformInfo.Version
2816 self._Macro["PLATFORM_RELATIVE_DIR" ] = self.PlatformInfo.SourceDir
2817 self._Macro["PLATFORM_DIR" ] = mws.join(self.WorkspaceDir, self.PlatformInfo.SourceDir)
2818 self._Macro["PLATFORM_OUTPUT_DIR" ] = self.PlatformInfo.OutputDir
2819 self._Macro["FFS_OUTPUT_DIR" ] = self.FfsOutputDir
2820 return self._Macro
2821
2822 ## Return the module build data object
2823 def _GetModule(self):
2824 if self._Module is None:
2825 self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]
2826 return self._Module
2827
2828 ## Return the module name
2829 def _GetBaseName(self):
2830 return self.Module.BaseName
2831
2832 ## Return the module DxsFile if exist
2833 def _GetDxsFile(self):
2834 return self.Module.DxsFile
2835
2836 ## Return the module SourceOverridePath
2837 def _GetSourceOverridePath(self):
2838 return self.Module.SourceOverridePath
2839
2840 ## Return the module meta-file GUID
2841 def _GetGuid(self):
2842 #
2843 # To build same module more than once, the module path with FILE_GUID overridden has
2844 # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the realy path
2845 # in DSC. The overridden GUID can be retrieved from file name
2846 #
2847 if os.path.basename(self.MetaFile.File) != os.path.basename(self.MetaFile.Path):
2848 #
2849 # Length of GUID is 36
2850 #
2851 return os.path.basename(self.MetaFile.Path)[:36]
2852 return self.Module.Guid
2853
2854 ## Return the module version
2855 def _GetVersion(self):
2856 return self.Module.Version
2857
2858 ## Return the module type
2859 def _GetModuleType(self):
2860 return self.Module.ModuleType
2861
2862 ## Return the component type (for Edk.x style of module)
2863 def _GetComponentType(self):
2864 return self.Module.ComponentType
2865
2866 ## Return the build type
2867 def _GetBuildType(self):
2868 return self.Module.BuildType
2869
2870 ## Return the PCD_IS_DRIVER setting
2871 def _GetPcdIsDriver(self):
2872 return self.Module.PcdIsDriver
2873
2874 ## Return the autogen version, i.e. module meta-file version
2875 def _GetAutoGenVersion(self):
2876 return self.Module.AutoGenVersion
2877
2878 ## Check if the module is library or not
2879 def _IsLibrary(self):
2880 if self._LibraryFlag is None:
2881 self._LibraryFlag = True if self.Module.LibraryClass else False
2882 return self._LibraryFlag
2883
2884 ## Check if the module is binary module or not
2885 def _IsBinaryModule(self):
2886 return self.Module.IsBinaryModule
2887
2888 ## Return the directory to store intermediate files of the module
2889 def _GetBuildDir(self):
2890 if self._BuildDir is None:
2891 self._BuildDir = path.join(
2892 self.PlatformInfo.BuildDir,
2893 self.Arch,
2894 self.SourceDir,
2895 self.MetaFile.BaseName
2896 )
2897 CreateDirectory(self._BuildDir)
2898 return self._BuildDir
2899
2900 ## Return the directory to store the intermediate object files of the mdoule
2901 def _GetOutputDir(self):
2902 if self._OutputDir is None:
2903 self._OutputDir = path.join(self.BuildDir, "OUTPUT")
2904 CreateDirectory(self._OutputDir)
2905 return self._OutputDir
2906
2907 ## Return the directory to store ffs file
2908 def _GetFfsOutputDir(self):
2909 if self._FfsOutputDir is None:
2910 if GlobalData.gFdfParser is not None:
2911 self._FfsOutputDir = path.join(self.PlatformInfo.BuildDir, TAB_FV_DIRECTORY, "Ffs", self.Guid + self.Name)
2912 else:
2913 self._FfsOutputDir = ''
2914 return self._FfsOutputDir
2915
2916 ## Return the directory to store auto-gened source files of the mdoule
2917 def _GetDebugDir(self):
2918 if self._DebugDir is None:
2919 self._DebugDir = path.join(self.BuildDir, "DEBUG")
2920 CreateDirectory(self._DebugDir)
2921 return self._DebugDir
2922
2923 ## Return the path of custom file
2924 def _GetCustomMakefile(self):
2925 if self._CustomMakefile is None:
2926 self._CustomMakefile = {}
2927 for Type in self.Module.CustomMakefile:
2928 if Type in gMakeTypeMap:
2929 MakeType = gMakeTypeMap[Type]
2930 else:
2931 MakeType = 'nmake'
2932 if self.SourceOverrideDir is not None:
2933 File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])
2934 if not os.path.exists(File):
2935 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
2936 else:
2937 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
2938 self._CustomMakefile[MakeType] = File
2939 return self._CustomMakefile
2940
2941 ## Return the directory of the makefile
2942 #
2943 # @retval string The directory string of module's makefile
2944 #
2945 def _GetMakeFileDir(self):
2946 return self.BuildDir
2947
2948 ## Return build command string
2949 #
2950 # @retval string Build command string
2951 #
2952 def _GetBuildCommand(self):
2953 return self.PlatformInfo.BuildCommand
2954
2955 ## Get object list of all packages the module and its dependent libraries belong to
2956 #
2957 # @retval list The list of package object
2958 #
2959 def _GetDerivedPackageList(self):
2960 PackageList = []
2961 for M in [self.Module] + self.DependentLibraryList:
2962 for Package in M.Packages:
2963 if Package in PackageList:
2964 continue
2965 PackageList.append(Package)
2966 return PackageList
2967
2968 ## Get the depex string
2969 #
2970 # @return : a string contain all depex expresion.
2971 def _GetDepexExpresionString(self):
2972 DepexStr = ''
2973 DepexList = []
2974 ## DPX_SOURCE IN Define section.
2975 if self.Module.DxsFile:
2976 return DepexStr
2977 for M in [self.Module] + self.DependentLibraryList:
2978 Filename = M.MetaFile.Path
2979 InfObj = InfSectionParser.InfSectionParser(Filename)
2980 DepexExpresionList = InfObj.GetDepexExpresionList()
2981 for DepexExpresion in DepexExpresionList:
2982 for key in DepexExpresion:
2983 Arch, ModuleType = key
2984 DepexExpr = [x for x in DepexExpresion[key] if not str(x).startswith('#')]
2985 # the type of build module is USER_DEFINED.
2986 # All different DEPEX section tags would be copied into the As Built INF file
2987 # and there would be separate DEPEX section tags
2988 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:
2989 if (Arch.upper() == self.Arch.upper()) and (ModuleType.upper() != TAB_ARCH_COMMON):
2990 DepexList.append({(Arch, ModuleType): DepexExpr})
2991 else:
2992 if Arch.upper() == TAB_ARCH_COMMON or \
2993 (Arch.upper() == self.Arch.upper() and \
2994 ModuleType.upper() in [TAB_ARCH_COMMON, self.ModuleType.upper()]):
2995 DepexList.append({(Arch, ModuleType): DepexExpr})
2996
2997 #the type of build module is USER_DEFINED.
2998 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:
2999 for Depex in DepexList:
3000 for key in Depex:
3001 DepexStr += '[Depex.%s.%s]\n' % key
3002 DepexStr += '\n'.join('# '+ val for val in Depex[key])
3003 DepexStr += '\n\n'
3004 if not DepexStr:
3005 return '[Depex.%s]\n' % self.Arch
3006 return DepexStr
3007
3008 #the type of build module not is USER_DEFINED.
3009 Count = 0
3010 for Depex in DepexList:
3011 Count += 1
3012 if DepexStr != '':
3013 DepexStr += ' AND '
3014 DepexStr += '('
3015 for D in Depex.values():
3016 DepexStr += ' '.join(val for val in D)
3017 Index = DepexStr.find('END')
3018 if Index > -1 and Index == len(DepexStr) - 3:
3019 DepexStr = DepexStr[:-3]
3020 DepexStr = DepexStr.strip()
3021 DepexStr += ')'
3022 if Count == 1:
3023 DepexStr = DepexStr.lstrip('(').rstrip(')').strip()
3024 if not DepexStr:
3025 return '[Depex.%s]\n' % self.Arch
3026 return '[Depex.%s]\n# ' % self.Arch + DepexStr
3027
3028 ## Merge dependency expression
3029 #
3030 # @retval list The token list of the dependency expression after parsed
3031 #
3032 def _GetDepexTokenList(self):
3033 if self._DepexDict is None:
3034 self._DepexDict = {}
3035 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
3036 return self._DepexDict
3037
3038 self._DepexDict[self.ModuleType] = []
3039
3040 for ModuleType in self._DepexDict:
3041 DepexList = self._DepexDict[ModuleType]
3042 #
3043 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
3044 #
3045 for M in [self.Module] + self.DependentLibraryList:
3046 Inherited = False
3047 for D in M.Depex[self.Arch, ModuleType]:
3048 if DepexList != []:
3049 DepexList.append('AND')
3050 DepexList.append('(')
3051 DepexList.extend(D)
3052 if DepexList[-1] == 'END': # no need of a END at this time
3053 DepexList.pop()
3054 DepexList.append(')')
3055 Inherited = True
3056 if Inherited:
3057 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))
3058 if 'BEFORE' in DepexList or 'AFTER' in DepexList:
3059 break
3060 if len(DepexList) > 0:
3061 EdkLogger.verbose('')
3062 return self._DepexDict
3063
3064 ## Merge dependency expression
3065 #
3066 # @retval list The token list of the dependency expression after parsed
3067 #
3068 def _GetDepexExpressionTokenList(self):
3069 if self._DepexExpressionDict is None:
3070 self._DepexExpressionDict = {}
3071 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
3072 return self._DepexExpressionDict
3073
3074 self._DepexExpressionDict[self.ModuleType] = ''
3075
3076 for ModuleType in self._DepexExpressionDict:
3077 DepexExpressionString = self._DepexExpressionDict[ModuleType]
3078 #
3079 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
3080 #
3081 for M in [self.Module] + self.DependentLibraryList:
3082 Inherited = False
3083 for D in M.DepexExpression[self.Arch, ModuleType]:
3084 if DepexExpressionString != '':
3085 DepexExpressionString += ' AND '
3086 DepexExpressionString += '('
3087 DepexExpressionString += D
3088 DepexExpressionString = DepexExpressionString.rstrip('END').strip()
3089 DepexExpressionString += ')'
3090 Inherited = True
3091 if Inherited:
3092 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionString))
3093 if 'BEFORE' in DepexExpressionString or 'AFTER' in DepexExpressionString:
3094 break
3095 if len(DepexExpressionString) > 0:
3096 EdkLogger.verbose('')
3097 self._DepexExpressionDict[ModuleType] = DepexExpressionString
3098 return self._DepexExpressionDict
3099
3100 # Get the tiano core user extension, it is contain dependent library.
3101 # @retval: a list contain tiano core userextension.
3102 #
3103 def _GetTianoCoreUserExtensionList(self):
3104 TianoCoreUserExtentionList = []
3105 for M in [self.Module] + self.DependentLibraryList:
3106 Filename = M.MetaFile.Path
3107 InfObj = InfSectionParser.InfSectionParser(Filename)
3108 TianoCoreUserExtenList = InfObj.GetUserExtensionTianoCore()
3109 for TianoCoreUserExtent in TianoCoreUserExtenList:
3110 for Section in TianoCoreUserExtent:
3111 ItemList = Section.split(TAB_SPLIT)
3112 Arch = self.Arch
3113 if len(ItemList) == 4:
3114 Arch = ItemList[3]
3115 if Arch.upper() == TAB_ARCH_COMMON or Arch.upper() == self.Arch.upper():
3116 TianoCoreList = []
3117 TianoCoreList.extend([TAB_SECTION_START + Section + TAB_SECTION_END])
3118 TianoCoreList.extend(TianoCoreUserExtent[Section][:])
3119 TianoCoreList.append('\n')
3120 TianoCoreUserExtentionList.append(TianoCoreList)
3121
3122 return TianoCoreUserExtentionList
3123
3124 ## Return the list of specification version required for the module
3125 #
3126 # @retval list The list of specification defined in module file
3127 #
3128 def _GetSpecification(self):
3129 return self.Module.Specification
3130
3131 ## Tool option for the module build
3132 #
3133 # @param PlatformInfo The object of PlatformBuildInfo
3134 # @retval dict The dict containing valid options
3135 #
3136 def _GetModuleBuildOption(self):
3137 if self._BuildOption is None:
3138 self._BuildOption, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)
3139 if self.BuildRuleOrder:
3140 self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]
3141 return self._BuildOption
3142
3143 ## Get include path list from tool option for the module build
3144 #
3145 # @retval list The include path list
3146 #
3147 def _GetBuildOptionIncPathList(self):
3148 if self._BuildOptionIncPathList is None:
3149 #
3150 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
3151 # is the former use /I , the Latter used -I to specify include directories
3152 #
3153 if self.PlatformInfo.ToolChainFamily in ('MSFT'):
3154 BuildOptIncludeRegEx = gBuildOptIncludePatternMsft
3155 elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):
3156 BuildOptIncludeRegEx = gBuildOptIncludePatternOther
3157 else:
3158 #
3159 # New ToolChainFamily, don't known whether there is option to specify include directories
3160 #
3161 self._BuildOptionIncPathList = []
3162 return self._BuildOptionIncPathList
3163
3164 BuildOptionIncPathList = []
3165 for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):
3166 try:
3167 FlagOption = self.BuildOption[Tool]['FLAGS']
3168 except KeyError:
3169 FlagOption = ''
3170
3171 if self.PlatformInfo.ToolChainFamily != 'RVCT':
3172 IncPathList = [NormPath(Path, self.Macros) for Path in BuildOptIncludeRegEx.findall(FlagOption)]
3173 else:
3174 #
3175 # RVCT may specify a list of directory seperated by commas
3176 #
3177 IncPathList = []
3178 for Path in BuildOptIncludeRegEx.findall(FlagOption):
3179 PathList = GetSplitList(Path, TAB_COMMA_SPLIT)
3180 IncPathList.extend(NormPath(PathEntry, self.Macros) for PathEntry in PathList)
3181
3182 #
3183 # EDK II modules must not reference header files outside of the packages they depend on or
3184 # within the module's directory tree. Report error if violation.
3185 #
3186 if self.AutoGenVersion >= 0x00010005:
3187 for Path in IncPathList:
3188 if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):
3189 ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption)
3190 EdkLogger.error("build",
3191 PARAMETER_INVALID,
3192 ExtraData=ErrMsg,
3193 File=str(self.MetaFile))
3194
3195
3196 BuildOptionIncPathList += IncPathList
3197
3198 self._BuildOptionIncPathList = BuildOptionIncPathList
3199
3200 return self._BuildOptionIncPathList
3201
3202 ## Return a list of files which can be built from source
3203 #
3204 # What kind of files can be built is determined by build rules in
3205 # $(CONF_DIRECTORY)/build_rule.txt and toolchain family.
3206 #
3207 def _GetSourceFileList(self):
3208 if self._SourceFileList is None:
3209 self._SourceFileList = []
3210 ToolChainTagSet = {"", "*", self.ToolChain}
3211 ToolChainFamilySet = {"", "*", self.ToolChainFamily, self.BuildRuleFamily}
3212 for F in self.Module.Sources:
3213 # match tool chain
3214 if F.TagName not in ToolChainTagSet:
3215 EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "
3216 "but [%s] is needed" % (F.TagName, str(F), self.ToolChain))
3217 continue
3218 # match tool chain family or build rule family
3219 if F.ToolChainFamily not in ToolChainFamilySet:
3220 EdkLogger.debug(
3221 EdkLogger.DEBUG_0,
3222 "The file [%s] must be built by tools of [%s], " \
3223 "but current toolchain family is [%s], buildrule family is [%s]" \
3224 % (str(F), F.ToolChainFamily, self.ToolChainFamily, self.BuildRuleFamily))
3225 continue
3226
3227 # add the file path into search path list for file including
3228 if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:
3229 self.IncludePathList.insert(0, F.Dir)
3230 self._SourceFileList.append(F)
3231
3232 self._MatchBuildRuleOrder(self._SourceFileList)
3233
3234 for F in self._SourceFileList:
3235 self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)
3236 return self._SourceFileList
3237
3238 def _MatchBuildRuleOrder(self, FileList):
3239 Order_Dict = {}
3240 self._GetModuleBuildOption()
3241 for SingleFile in FileList:
3242 if self.BuildRuleOrder and SingleFile.Ext in self.BuildRuleOrder and SingleFile.Ext in self.BuildRules:
3243 key = SingleFile.Path.split(SingleFile.Ext)[0]
3244 if key in Order_Dict:
3245 Order_Dict[key].append(SingleFile.Ext)
3246 else:
3247 Order_Dict[key] = [SingleFile.Ext]
3248
3249 RemoveList = []
3250 for F in Order_Dict:
3251 if len(Order_Dict[F]) > 1:
3252 Order_Dict[F].sort(key=lambda i: self.BuildRuleOrder.index(i))
3253 for Ext in Order_Dict[F][1:]:
3254 RemoveList.append(F + Ext)
3255
3256 for item in RemoveList:
3257 FileList.remove(item)
3258
3259 return FileList
3260
3261 ## Return the list of unicode files
3262 def _GetUnicodeFileList(self):
3263 if self._UnicodeFileList is None:
3264 if TAB_UNICODE_FILE in self.FileTypes:
3265 self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE]
3266 else:
3267 self._UnicodeFileList = []
3268 return self._UnicodeFileList
3269
3270 ## Return the list of vfr files
3271 def _GetVfrFileList(self):
3272 if self._VfrFileList is None:
3273 if TAB_VFR_FILE in self.FileTypes:
3274 self._VfrFileList = self.FileTypes[TAB_VFR_FILE]
3275 else:
3276 self._VfrFileList = []
3277 return self._VfrFileList
3278
3279 ## Return the list of Image Definition files
3280 def _GetIdfFileList(self):
3281 if self._IdfFileList is None:
3282 if TAB_IMAGE_FILE in self.FileTypes:
3283 self._IdfFileList = self.FileTypes[TAB_IMAGE_FILE]
3284 else:
3285 self._IdfFileList = []
3286 return self._IdfFileList
3287
3288 ## Return a list of files which can be built from binary
3289 #
3290 # "Build" binary files are just to copy them to build directory.
3291 #
3292 # @retval list The list of files which can be built later
3293 #
3294 def _GetBinaryFiles(self):
3295 if self._BinaryFileList is None:
3296 self._BinaryFileList = []
3297 for F in self.Module.Binaries:
3298 if F.Target not in [TAB_ARCH_COMMON, '*'] and F.Target != self.BuildTarget:
3299 continue
3300 self._BinaryFileList.append(F)
3301 self._ApplyBuildRule(F, F.Type)
3302 return self._BinaryFileList
3303
3304 def _GetBuildRules(self):
3305 if self._BuildRules is None:
3306 BuildRules = {}
3307 BuildRuleDatabase = self.PlatformInfo.BuildRule
3308 for Type in BuildRuleDatabase.FileTypeList:
3309 #first try getting build rule by BuildRuleFamily
3310 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]
3311 if not RuleObject:
3312 # build type is always module type, but ...
3313 if self.ModuleType != self.BuildType:
3314 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]
3315 #second try getting build rule by ToolChainFamily
3316 if not RuleObject:
3317 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]
3318 if not RuleObject:
3319 # build type is always module type, but ...
3320 if self.ModuleType != self.BuildType:
3321 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]
3322 if not RuleObject:
3323 continue
3324 RuleObject = RuleObject.Instantiate(self.Macros)
3325 BuildRules[Type] = RuleObject
3326 for Ext in RuleObject.SourceFileExtList:
3327 BuildRules[Ext] = RuleObject
3328 self._BuildRules = BuildRules
3329 return self._BuildRules
3330
3331 def _ApplyBuildRule(self, File, FileType):
3332 if self._BuildTargets is None:
3333 self._IntroBuildTargetList = set()
3334 self._FinalBuildTargetList = set()
3335 self._BuildTargets = defaultdict(set)
3336 self._FileTypes = defaultdict(set)
3337
3338 SubDirectory = os.path.join(self.OutputDir, File.SubDir)
3339 if not os.path.exists(SubDirectory):
3340 CreateDirectory(SubDirectory)
3341 LastTarget = None
3342 RuleChain = set()
3343 SourceList = [File]
3344 Index = 0
3345 #
3346 # Make sure to get build rule order value
3347 #
3348 self._GetModuleBuildOption()
3349
3350 while Index < len(SourceList):
3351 Source = SourceList[Index]
3352 Index = Index + 1
3353
3354 if Source != File:
3355 CreateDirectory(Source.Dir)
3356
3357 if File.IsBinary and File == Source and self._BinaryFileList is not None and File in self._BinaryFileList:
3358 # Skip all files that are not binary libraries
3359 if not self.IsLibrary:
3360 continue
3361 RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]
3362 elif FileType in self.BuildRules:
3363 RuleObject = self.BuildRules[FileType]
3364 elif Source.Ext in self.BuildRules:
3365 RuleObject = self.BuildRules[Source.Ext]
3366 else:
3367 # stop at no more rules
3368 if LastTarget:
3369 self._FinalBuildTargetList.add(LastTarget)
3370 break
3371
3372 FileType = RuleObject.SourceFileType
3373 self._FileTypes[FileType].add(Source)
3374
3375 # stop at STATIC_LIBRARY for library
3376 if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:
3377 if LastTarget:
3378 self._FinalBuildTargetList.add(LastTarget)
3379 break
3380
3381 Target = RuleObject.Apply(Source, self.BuildRuleOrder)
3382 if not Target:
3383 if LastTarget:
3384 self._FinalBuildTargetList.add(LastTarget)
3385 break
3386 elif not Target.Outputs:
3387 # Only do build for target with outputs
3388 self._FinalBuildTargetList.add(Target)
3389
3390 self._BuildTargets[FileType].add(Target)
3391
3392 if not Source.IsBinary and Source == File:
3393 self._IntroBuildTargetList.add(Target)
3394
3395 # to avoid cyclic rule
3396 if FileType in RuleChain:
3397 break
3398
3399 RuleChain.add(FileType)
3400 SourceList.extend(Target.Outputs)
3401 LastTarget = Target
3402 FileType = TAB_UNKNOWN_FILE
3403
3404 def _GetTargets(self):
3405 if self._BuildTargets is None:
3406 self._IntroBuildTargetList = set()
3407 self._FinalBuildTargetList = set()
3408 self._BuildTargets = defaultdict(set)
3409 self._FileTypes = defaultdict(set)
3410
3411 #TRICK: call _GetSourceFileList to apply build rule for source files
3412 if self.SourceFileList:
3413 pass
3414
3415 #TRICK: call _GetBinaryFileList to apply build rule for binary files
3416 if self.BinaryFileList:
3417 pass
3418
3419 return self._BuildTargets
3420
3421 def _GetIntroTargetList(self):
3422 self._GetTargets()
3423 return self._IntroBuildTargetList
3424
3425 def _GetFinalTargetList(self):
3426 self._GetTargets()
3427 return self._FinalBuildTargetList
3428
3429 def _GetFileTypes(self):
3430 self._GetTargets()
3431 return self._FileTypes
3432
3433 ## Get the list of package object the module depends on
3434 #
3435 # @retval list The package object list
3436 #
3437 def _GetDependentPackageList(self):
3438 return self.Module.Packages
3439
3440 ## Return the list of auto-generated code file
3441 #
3442 # @retval list The list of auto-generated file
3443 #
3444 def _GetAutoGenFileList(self):
3445 UniStringAutoGenC = True
3446 IdfStringAutoGenC = True
3447 UniStringBinBuffer = BytesIO()
3448 IdfGenBinBuffer = BytesIO()
3449 if self.BuildType == 'UEFI_HII':
3450 UniStringAutoGenC = False
3451 IdfStringAutoGenC = False
3452 if self._AutoGenFileList is None:
3453 self._AutoGenFileList = {}
3454 AutoGenC = TemplateString()
3455 AutoGenH = TemplateString()
3456 StringH = TemplateString()
3457 StringIdf = TemplateString()
3458 GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer, StringIdf, IdfStringAutoGenC, IdfGenBinBuffer)
3459 #
3460 # AutoGen.c is generated if there are library classes in inf, or there are object files
3461 #
3462 if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0
3463 or TAB_OBJECT_FILE in self.FileTypes):
3464 AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)
3465 self._AutoGenFileList[AutoFile] = str(AutoGenC)
3466 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3467 if str(AutoGenH) != "":
3468 AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)
3469 self._AutoGenFileList[AutoFile] = str(AutoGenH)
3470 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3471 if str(StringH) != "":
3472 AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)
3473 self._AutoGenFileList[AutoFile] = str(StringH)
3474 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3475 if UniStringBinBuffer is not None and UniStringBinBuffer.getvalue() != "":
3476 AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)
3477 self._AutoGenFileList[AutoFile] = UniStringBinBuffer.getvalue()
3478 AutoFile.IsBinary = True
3479 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3480 if UniStringBinBuffer is not None:
3481 UniStringBinBuffer.close()
3482 if str(StringIdf) != "":
3483 AutoFile = PathClass(gAutoGenImageDefFileName % {"module_name":self.Name}, self.DebugDir)
3484 self._AutoGenFileList[AutoFile] = str(StringIdf)
3485 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3486 if IdfGenBinBuffer is not None and IdfGenBinBuffer.getvalue() != "":
3487 AutoFile = PathClass(gAutoGenIdfFileName % {"module_name":self.Name}, self.OutputDir)
3488 self._AutoGenFileList[AutoFile] = IdfGenBinBuffer.getvalue()
3489 AutoFile.IsBinary = True
3490 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
3491 if IdfGenBinBuffer is not None:
3492 IdfGenBinBuffer.close()
3493 return self._AutoGenFileList
3494
3495 ## Return the list of library modules explicitly or implicityly used by this module
3496 def _GetLibraryList(self):
3497 if self._DependentLibraryList is None:
3498 # only merge library classes and PCD for non-library module
3499 if self.IsLibrary:
3500 self._DependentLibraryList = []
3501 else:
3502 if self.AutoGenVersion < 0x00010005:
3503 self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)
3504 else:
3505 self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)
3506 return self._DependentLibraryList
3507
3508 ## Get the list of PCDs from current module
3509 #
3510 # @retval list The list of PCD
3511 #
3512 def _GetModulePcdList(self):
3513 if self._ModulePcdList is None:
3514 # apply PCD settings from platform
3515 self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)
3516 ExtendCopyDictionaryLists(self._PcdComments, self.Module.PcdComments)
3517 return self._ModulePcdList
3518
3519 ## Get the list of PCDs from dependent libraries
3520 #
3521 # @retval list The list of PCD
3522 #
3523 def _GetLibraryPcdList(self):
3524 if self._LibraryPcdList is None:
3525 Pcds = OrderedDict()
3526 if not self.IsLibrary:
3527 # get PCDs from dependent libraries
3528 self._LibraryPcdList = []
3529 for Library in self.DependentLibraryList:
3530 PcdsInLibrary = OrderedDict()
3531 ExtendCopyDictionaryLists(self._PcdComments, Library.PcdComments)
3532 for Key in Library.Pcds:
3533 # skip duplicated PCDs
3534 if Key in self.Module.Pcds or Key in Pcds:
3535 continue
3536 Pcds[Key] = copy.copy(Library.Pcds[Key])
3537 PcdsInLibrary[Key] = Pcds[Key]
3538 self._LibraryPcdList.extend(self.PlatformInfo.ApplyPcdSetting(self.Module, PcdsInLibrary, Library=Library))
3539 else:
3540 self._LibraryPcdList = []
3541 return self._LibraryPcdList
3542
3543 ## Get the GUID value mapping
3544 #
3545 # @retval dict The mapping between GUID cname and its value
3546 #
3547 def _GetGuidList(self):
3548 if self._GuidList is None:
3549 self._GuidList = OrderedDict()
3550 self._GuidList.update(self.Module.Guids)
3551 for Library in self.DependentLibraryList:
3552 self._GuidList.update(Library.Guids)
3553 ExtendCopyDictionaryLists(self._GuidComments, Library.GuidComments)
3554 ExtendCopyDictionaryLists(self._GuidComments, self.Module.GuidComments)
3555 return self._GuidList
3556
3557 def GetGuidsUsedByPcd(self):
3558 if self._GuidsUsedByPcd is None:
3559 self._GuidsUsedByPcd = OrderedDict()
3560 self._GuidsUsedByPcd.update(self.Module.GetGuidsUsedByPcd())
3561 for Library in self.DependentLibraryList:
3562 self._GuidsUsedByPcd.update(Library.GetGuidsUsedByPcd())
3563 return self._GuidsUsedByPcd
3564 ## Get the protocol value mapping
3565 #
3566 # @retval dict The mapping between protocol cname and its value
3567 #
3568 def _GetProtocolList(self):
3569 if self._ProtocolList is None:
3570 self._ProtocolList = OrderedDict()
3571 self._ProtocolList.update(self.Module.Protocols)
3572 for Library in self.DependentLibraryList:
3573 self._ProtocolList.update(Library.Protocols)
3574 ExtendCopyDictionaryLists(self._ProtocolComments, Library.ProtocolComments)
3575 ExtendCopyDictionaryLists(self._ProtocolComments, self.Module.ProtocolComments)
3576 return self._ProtocolList
3577
3578 ## Get the PPI value mapping
3579 #
3580 # @retval dict The mapping between PPI cname and its value
3581 #
3582 def _GetPpiList(self):
3583 if self._PpiList is None:
3584 self._PpiList = OrderedDict()
3585 self._PpiList.update(self.Module.Ppis)
3586 for Library in self.DependentLibraryList:
3587 self._PpiList.update(Library.Ppis)
3588 ExtendCopyDictionaryLists(self._PpiComments, Library.PpiComments)
3589 ExtendCopyDictionaryLists(self._PpiComments, self.Module.PpiComments)
3590 return self._PpiList
3591
3592 ## Get the list of include search path
3593 #
3594 # @retval list The list path
3595 #
3596 def _GetIncludePathList(self):
3597 if self._IncludePathList is None:
3598 self._IncludePathList = []
3599 if self.AutoGenVersion < 0x00010005:
3600 for Inc in self.Module.Includes:
3601 if Inc not in self._IncludePathList:
3602 self._IncludePathList.append(Inc)
3603 # for Edk modules
3604 Inc = path.join(Inc, self.Arch.capitalize())
3605 if os.path.exists(Inc) and Inc not in self._IncludePathList:
3606 self._IncludePathList.append(Inc)
3607 # Edk module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time
3608 self._IncludePathList.append(self.DebugDir)
3609 else:
3610 self._IncludePathList.append(self.MetaFile.Dir)
3611 self._IncludePathList.append(self.DebugDir)
3612
3613 for Package in self.Module.Packages:
3614 PackageDir = mws.join(self.WorkspaceDir, Package.MetaFile.Dir)
3615 if PackageDir not in self._IncludePathList:
3616 self._IncludePathList.append(PackageDir)
3617 IncludesList = Package.Includes
3618 if Package._PrivateIncludes:
3619 if not self.MetaFile.Path.startswith(PackageDir):
3620 IncludesList = list(set(Package.Includes).difference(set(Package._PrivateIncludes)))
3621 for Inc in IncludesList:
3622 if Inc not in self._IncludePathList:
3623 self._IncludePathList.append(str(Inc))
3624 return self._IncludePathList
3625
3626 def _GetIncludePathLength(self):
3627 return sum(len(inc)+1 for inc in self._IncludePathList)
3628
3629 ## Get HII EX PCDs which maybe used by VFR
3630 #
3631 # efivarstore used by VFR may relate with HII EX PCDs
3632 # Get the variable name and GUID from efivarstore and HII EX PCD
3633 # List the HII EX PCDs in As Built INF if both name and GUID match.
3634 #
3635 # @retval list HII EX PCDs
3636 #
3637 def _GetPcdsMaybeUsedByVfr(self):
3638 if not self.SourceFileList:
3639 return []
3640
3641 NameGuids = set()
3642 for SrcFile in self.SourceFileList:
3643 if SrcFile.Ext.lower() != '.vfr':
3644 continue
3645 Vfri = os.path.join(self.OutputDir, SrcFile.BaseName + '.i')
3646 if not os.path.exists(Vfri):
3647 continue
3648 VfriFile = open(Vfri, 'r')
3649 Content = VfriFile.read()
3650 VfriFile.close()
3651 Pos = Content.find('efivarstore')
3652 while Pos != -1:
3653 #
3654 # Make sure 'efivarstore' is the start of efivarstore statement
3655 # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'
3656 #
3657 Index = Pos - 1
3658 while Index >= 0 and Content[Index] in ' \t\r\n':
3659 Index -= 1
3660 if Index >= 0 and Content[Index] != ';':
3661 Pos = Content.find('efivarstore', Pos + len('efivarstore'))
3662 continue
3663 #
3664 # 'efivarstore' must be followed by name and guid
3665 #
3666 Name = gEfiVarStoreNamePattern.search(Content, Pos)
3667 if not Name:
3668 break
3669 Guid = gEfiVarStoreGuidPattern.search(Content, Pos)
3670 if not Guid:
3671 break
3672 NameArray = ConvertStringToByteArray('L"' + Name.group(1) + '"')
3673 NameGuids.add((NameArray, GuidStructureStringToGuidString(Guid.group(1))))
3674 Pos = Content.find('efivarstore', Name.end())
3675 if not NameGuids:
3676 return []
3677 HiiExPcds = []
3678 for Pcd in self.PlatformInfo.Platform.Pcds.values():
3679 if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:
3680 continue
3681 for SkuInfo in Pcd.SkuInfoList.values():
3682 Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList, self.MetaFile.Path)
3683 if not Value:
3684 continue
3685 Name = ConvertStringToByteArray(SkuInfo.VariableName)
3686 Guid = GuidStructureStringToGuidString(Value)
3687 if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:
3688 HiiExPcds.append(Pcd)
3689 break
3690
3691 return HiiExPcds
3692
3693 def _GenOffsetBin(self):
3694 VfrUniBaseName = {}
3695 for SourceFile in self.Module.Sources:
3696 if SourceFile.Type.upper() == ".VFR" :
3697 #
3698 # search the .map file to find the offset of vfr binary in the PE32+/TE file.
3699 #
3700 VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")
3701 elif SourceFile.Type.upper() == ".UNI" :
3702 #
3703 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.
3704 #
3705 VfrUniBaseName["UniOffsetName"] = (self.Name + "Strings")
3706
3707 if not VfrUniBaseName:
3708 return None
3709 MapFileName = os.path.join(self.OutputDir, self.Name + ".map")
3710 EfiFileName = os.path.join(self.OutputDir, self.Name + ".efi")
3711 VfrUniOffsetList = GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())
3712 if not VfrUniOffsetList:
3713 return None
3714
3715 OutputName = '%sOffset.bin' % self.Name
3716 UniVfrOffsetFileName = os.path.join( self.OutputDir, OutputName)
3717
3718 try:
3719 fInputfile = open(UniVfrOffsetFileName, "wb+", 0)
3720 except:
3721 EdkLogger.error("build", FILE_OPEN_FAILURE, "File open failed for %s" % UniVfrOffsetFileName, None)
3722
3723 # Use a instance of BytesIO to cache data
3724 fStringIO = BytesIO('')
3725
3726 for Item in VfrUniOffsetList:
3727 if (Item[0].find("Strings") != -1):
3728 #
3729 # UNI offset in image.
3730 # GUID + Offset
3731 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }
3732 #
3733 UniGuid = [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]
3734 UniGuid = [chr(ItemGuid) for ItemGuid in UniGuid]
3735 fStringIO.write(''.join(UniGuid))
3736 UniValue = pack ('Q', int (Item[1], 16))
3737 fStringIO.write (UniValue)
3738 else:
3739 #
3740 # VFR binary offset in image.
3741 # GUID + Offset
3742 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };
3743 #
3744 VfrGuid = [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]
3745 VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]
3746 fStringIO.write(''.join(VfrGuid))
3747 VfrValue = pack ('Q', int (Item[1], 16))
3748 fStringIO.write (VfrValue)
3749 #
3750 # write data into file.
3751 #
3752 try :
3753 fInputfile.write (fStringIO.getvalue())
3754 except:
3755 EdkLogger.error("build", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the "
3756 "file been locked or using by other applications." %UniVfrOffsetFileName, None)
3757
3758 fStringIO.close ()
3759 fInputfile.close ()
3760 return OutputName
3761
3762 ## Create AsBuilt INF file the module
3763 #
3764 def CreateAsBuiltInf(self, IsOnlyCopy = False):
3765 self.OutputFile = set()
3766 if IsOnlyCopy and GlobalData.gBinCacheDest:
3767 self.CopyModuleToCache()
3768 return
3769
3770 if self.IsAsBuiltInfCreated:
3771 return
3772
3773 # Skip the following code for EDK I inf
3774 if self.AutoGenVersion < 0x00010005:
3775 return
3776
3777 # Skip the following code for libraries
3778 if self.IsLibrary:
3779 return
3780
3781 # Skip the following code for modules with no source files
3782 if not self.SourceFileList:
3783 return
3784
3785 # Skip the following code for modules without any binary files
3786 if self.BinaryFileList:
3787 return
3788
3789 ### TODO: How to handles mixed source and binary modules
3790
3791 # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries
3792 # Also find all packages that the DynamicEx PCDs depend on
3793 Pcds = []
3794 PatchablePcds = []
3795 Packages = []
3796 PcdCheckList = []
3797 PcdTokenSpaceList = []
3798 for Pcd in self.ModulePcdList + self.LibraryPcdList:
3799 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
3800 PatchablePcds.append(Pcd)
3801 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_PATCHABLE_IN_MODULE))
3802 elif Pcd.Type in PCD_DYNAMIC_EX_TYPE_SET:
3803 if Pcd not in Pcds:
3804 Pcds.append(Pcd)
3805 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX))
3806 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC))
3807 PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)
3808 GuidList = OrderedDict()
3809 GuidList.update(self.GuidList)
3810 for TokenSpace in self.GetGuidsUsedByPcd():
3811 # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list
3812 # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs
3813 if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:
3814 GuidList.pop(TokenSpace)
3815 CheckList = (GuidList, self.PpiList, self.ProtocolList, PcdCheckList)
3816 for Package in self.DerivedPackageList:
3817 if Package in Packages:
3818 continue
3819 BeChecked = (Package.Guids, Package.Ppis, Package.Protocols, Package.Pcds)
3820 Found = False
3821 for Index in range(len(BeChecked)):
3822 for Item in CheckList[Index]:
3823 if Item in BeChecked[Index]:
3824 Packages.append(Package)
3825 Found = True
3826 break
3827 if Found:
3828 break
3829
3830 VfrPcds = self._GetPcdsMaybeUsedByVfr()
3831 for Pkg in self.PlatformInfo.PackageList:
3832 if Pkg in Packages:
3833 continue
3834 for VfrPcd in VfrPcds:
3835 if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC_EX) in Pkg.Pcds or
3836 (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, TAB_PCDS_DYNAMIC) in Pkg.Pcds):
3837 Packages.append(Pkg)
3838 break
3839
3840 ModuleType = SUP_MODULE_DXE_DRIVER if self.ModuleType == SUP_MODULE_UEFI_DRIVER and self.DepexGenerated else self.ModuleType
3841 DriverType = self.PcdIsDriver if self.PcdIsDriver else ''
3842 Guid = self.Guid
3843 MDefs = self.Module.Defines
3844
3845 AsBuiltInfDict = {
3846 'module_name' : self.Name,
3847 'module_guid' : Guid,
3848 'module_module_type' : ModuleType,
3849 'module_version_string' : [MDefs['VERSION_STRING']] if 'VERSION_STRING' in MDefs else [],
3850 'pcd_is_driver_string' : [],
3851 'module_uefi_specification_version' : [],
3852 'module_pi_specification_version' : [],
3853 'module_entry_point' : self.Module.ModuleEntryPointList,
3854 'module_unload_image' : self.Module.ModuleUnloadImageList,
3855 'module_constructor' : self.Module.ConstructorList,
3856 'module_destructor' : self.Module.DestructorList,
3857 'module_shadow' : [MDefs['SHADOW']] if 'SHADOW' in MDefs else [],
3858 'module_pci_vendor_id' : [MDefs['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs else [],
3859 'module_pci_device_id' : [MDefs['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs else [],
3860 'module_pci_class_code' : [MDefs['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs else [],
3861 'module_pci_revision' : [MDefs['PCI_REVISION']] if 'PCI_REVISION' in MDefs else [],
3862 'module_build_number' : [MDefs['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs else [],
3863 'module_spec' : [MDefs['SPEC']] if 'SPEC' in MDefs else [],
3864 'module_uefi_hii_resource_section' : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],
3865 'module_uni_file' : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],
3866 'module_arch' : self.Arch,
3867 'package_item' : [Package.MetaFile.File.replace('\\', '/') for Package in Packages],
3868 'binary_item' : [],
3869 'patchablepcd_item' : [],
3870 'pcd_item' : [],
3871 'protocol_item' : [],
3872 'ppi_item' : [],
3873 'guid_item' : [],
3874 'flags_item' : [],
3875 'libraryclasses_item' : []
3876 }
3877
3878 if 'MODULE_UNI_FILE' in MDefs:
3879 UNIFile = os.path.join(self.MetaFile.Dir, MDefs['MODULE_UNI_FILE'])
3880 if os.path.isfile(UNIFile):
3881 shutil.copy2(UNIFile, self.OutputDir)
3882
3883 if self.AutoGenVersion > int(gInfSpecVersion, 0):
3884 AsBuiltInfDict['module_inf_version'] = '0x%08x' % self.AutoGenVersion
3885 else:
3886 AsBuiltInfDict['module_inf_version'] = gInfSpecVersion
3887
3888 if DriverType:
3889 AsBuiltInfDict['pcd_is_driver_string'].append(DriverType)
3890
3891 if 'UEFI_SPECIFICATION_VERSION' in self.Specification:
3892 AsBuiltInfDict['module_uefi_specification_version'].append(self.Specification['UEFI_SPECIFICATION_VERSION'])
3893 if 'PI_SPECIFICATION_VERSION' in self.Specification:
3894 AsBuiltInfDict['module_pi_specification_version'].append(self.Specification['PI_SPECIFICATION_VERSION'])
3895
3896 OutputDir = self.OutputDir.replace('\\', '/').strip('/')
3897 DebugDir = self.DebugDir.replace('\\', '/').strip('/')
3898 for Item in self.CodaTargetList:
3899 File = Item.Target.Path.replace('\\', '/').strip('/').replace(DebugDir, '').replace(OutputDir, '').strip('/')
3900 self.OutputFile.add(File)
3901 if os.path.isabs(File):
3902 File = File.replace('\\', '/').strip('/').replace(OutputDir, '').strip('/')
3903 if Item.Target.Ext.lower() == '.aml':
3904 AsBuiltInfDict['binary_item'].append('ASL|' + File)
3905 elif Item.Target.Ext.lower() == '.acpi':
3906 AsBuiltInfDict['binary_item'].append('ACPI|' + File)
3907 elif Item.Target.Ext.lower() == '.efi':
3908 AsBuiltInfDict['binary_item'].append('PE32|' + self.Name + '.efi')
3909 else:
3910 AsBuiltInfDict['binary_item'].append('BIN|' + File)
3911 if self.DepexGenerated:
3912 self.OutputFile.add(self.Name + '.depex')
3913 if self.ModuleType in [SUP_MODULE_PEIM]:
3914 AsBuiltInfDict['binary_item'].append('PEI_DEPEX|' + self.Name + '.depex')
3915 elif self.ModuleType in [SUP_MODULE_DXE_DRIVER, SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_UEFI_DRIVER]:
3916 AsBuiltInfDict['binary_item'].append('DXE_DEPEX|' + self.Name + '.depex')
3917 elif self.ModuleType in [SUP_MODULE_DXE_SMM_DRIVER]:
3918 AsBuiltInfDict['binary_item'].append('SMM_DEPEX|' + self.Name + '.depex')
3919
3920 Bin = self._GenOffsetBin()
3921 if Bin:
3922 AsBuiltInfDict['binary_item'].append('BIN|%s' % Bin)
3923 self.OutputFile.add(Bin)
3924
3925 for Root, Dirs, Files in os.walk(OutputDir):
3926 for File in Files:
3927 if File.lower().endswith('.pdb'):
3928 AsBuiltInfDict['binary_item'].append('DISPOSABLE|' + File)
3929 self.OutputFile.add(File)
3930 HeaderComments = self.Module.HeaderComments
3931 StartPos = 0
3932 for Index in range(len(HeaderComments)):
3933 if HeaderComments[Index].find('@BinaryHeader') != -1:
3934 HeaderComments[Index] = HeaderComments[Index].replace('@BinaryHeader', '@file')
3935 StartPos = Index
3936 break
3937 AsBuiltInfDict['header_comments'] = '\n'.join(HeaderComments[StartPos:]).replace(':#', '://')
3938 AsBuiltInfDict['tail_comments'] = '\n'.join(self.Module.TailComments)
3939
3940 GenList = [
3941 (self.ProtocolList, self._ProtocolComments, 'protocol_item'),
3942 (self.PpiList, self._PpiComments, 'ppi_item'),
3943 (GuidList, self._GuidComments, 'guid_item')
3944 ]
3945 for Item in GenList:
3946 for CName in Item[0]:
3947 Comments = '\n '.join(Item[1][CName]) if CName in Item[1] else ''
3948 Entry = Comments + '\n ' + CName if Comments else CName
3949 AsBuiltInfDict[Item[2]].append(Entry)
3950 PatchList = parsePcdInfoFromMapFile(
3951 os.path.join(self.OutputDir, self.Name + '.map'),
3952 os.path.join(self.OutputDir, self.Name + '.efi')
3953 )
3954 if PatchList:
3955 for Pcd in PatchablePcds:
3956 TokenCName = Pcd.TokenCName
3957 for PcdItem in GlobalData.MixedPcd:
3958 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
3959 TokenCName = PcdItem[0]
3960 break
3961 for PatchPcd in PatchList:
3962 if TokenCName == PatchPcd[0]:
3963 break
3964 else:
3965 continue
3966 PcdValue = ''
3967 if Pcd.DatumType == 'BOOLEAN':
3968 BoolValue = Pcd.DefaultValue.upper()
3969 if BoolValue == 'TRUE':
3970 Pcd.DefaultValue = '1'
3971 elif BoolValue == 'FALSE':
3972 Pcd.DefaultValue = '0'
3973
3974 if Pcd.DatumType in TAB_PCD_NUMERIC_TYPES:
3975 HexFormat = '0x%02x'
3976 if Pcd.DatumType == TAB_UINT16:
3977 HexFormat = '0x%04x'
3978 elif Pcd.DatumType == TAB_UINT32:
3979 HexFormat = '0x%08x'
3980 elif Pcd.DatumType == TAB_UINT64:
3981 HexFormat = '0x%016x'
3982 PcdValue = HexFormat % int(Pcd.DefaultValue, 0)
3983 else:
3984 if Pcd.MaxDatumSize is None or Pcd.MaxDatumSize == '':
3985 EdkLogger.error("build", AUTOGEN_ERROR,
3986 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, TokenCName)
3987 )
3988 ArraySize = int(Pcd.MaxDatumSize, 0)
3989 PcdValue = Pcd.DefaultValue
3990 if PcdValue[0] != '{':
3991 Unicode = False
3992 if PcdValue[0] == 'L':
3993 Unicode = True
3994 PcdValue = PcdValue.lstrip('L')
3995 PcdValue = eval(PcdValue)
3996 NewValue = '{'
3997 for Index in range(0, len(PcdValue)):
3998 if Unicode:
3999 CharVal = ord(PcdValue[Index])
4000 NewValue = NewValue + '0x%02x' % (CharVal & 0x00FF) + ', ' \
4001 + '0x%02x' % (CharVal >> 8) + ', '
4002 else:
4003 NewValue = NewValue + '0x%02x' % (ord(PcdValue[Index]) % 0x100) + ', '
4004 Padding = '0x00, '
4005 if Unicode:
4006 Padding = Padding * 2
4007 ArraySize = ArraySize / 2
4008 if ArraySize < (len(PcdValue) + 1):
4009 if Pcd.MaxSizeUserSet:
4010 EdkLogger.error("build", AUTOGEN_ERROR,
4011 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)
4012 )
4013 else:
4014 ArraySize = len(PcdValue) + 1
4015 if ArraySize > len(PcdValue) + 1:
4016 NewValue = NewValue + Padding * (ArraySize - len(PcdValue) - 1)
4017 PcdValue = NewValue + Padding.strip().rstrip(',') + '}'
4018 elif len(PcdValue.split(',')) <= ArraySize:
4019 PcdValue = PcdValue.rstrip('}') + ', 0x00' * (ArraySize - len(PcdValue.split(',')))
4020 PcdValue += '}'
4021 else:
4022 if Pcd.MaxSizeUserSet:
4023 EdkLogger.error("build", AUTOGEN_ERROR,
4024 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, TokenCName)
4025 )
4026 else:
4027 ArraySize = len(PcdValue) + 1
4028 PcdItem = '%s.%s|%s|0x%X' % \
4029 (Pcd.TokenSpaceGuidCName, TokenCName, PcdValue, PatchPcd[1])
4030 PcdComments = ''
4031 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:
4032 PcdComments = '\n '.join(self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName])
4033 if PcdComments:
4034 PcdItem = PcdComments + '\n ' + PcdItem
4035 AsBuiltInfDict['patchablepcd_item'].append(PcdItem)
4036
4037 for Pcd in Pcds + VfrPcds:
4038 PcdCommentList = []
4039 HiiInfo = ''
4040 TokenCName = Pcd.TokenCName
4041 for PcdItem in GlobalData.MixedPcd:
4042 if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:
4043 TokenCName = PcdItem[0]
4044 break
4045 if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:
4046 for SkuName in Pcd.SkuInfoList:
4047 SkuInfo = Pcd.SkuInfoList[SkuName]
4048 HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)
4049 break
4050 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:
4051 PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]
4052 if HiiInfo:
4053 UsageIndex = -1
4054 UsageStr = ''
4055 for Index, Comment in enumerate(PcdCommentList):
4056 for Usage in UsageList:
4057 if Comment.find(Usage) != -1:
4058 UsageStr = Usage
4059 UsageIndex = Index
4060 break
4061 if UsageIndex != -1:
4062 PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, ''))
4063 else:
4064 PcdCommentList.append('## UNDEFINED ' + HiiInfo)
4065 PcdComments = '\n '.join(PcdCommentList)
4066 PcdEntry = Pcd.TokenSpaceGuidCName + '.' + TokenCName
4067 if PcdComments:
4068 PcdEntry = PcdComments + '\n ' + PcdEntry
4069 AsBuiltInfDict['pcd_item'].append(PcdEntry)
4070 for Item in self.BuildOption:
4071 if 'FLAGS' in self.BuildOption[Item]:
4072 AsBuiltInfDict['flags_item'].append('%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip()))
4073
4074 # Generated LibraryClasses section in comments.
4075 for Library in self.LibraryAutoGenList:
4076 AsBuiltInfDict['libraryclasses_item'].append(Library.MetaFile.File.replace('\\', '/'))
4077
4078 # Generated UserExtensions TianoCore section.
4079 # All tianocore user extensions are copied.
4080 UserExtStr = ''
4081 for TianoCore in self._GetTianoCoreUserExtensionList():
4082 UserExtStr += '\n'.join(TianoCore)
4083 ExtensionFile = os.path.join(self.MetaFile.Dir, TianoCore[1])
4084 if os.path.isfile(ExtensionFile):
4085 shutil.copy2(ExtensionFile, self.OutputDir)
4086 AsBuiltInfDict['userextension_tianocore_item'] = UserExtStr
4087
4088 # Generated depex expression section in comments.
4089 DepexExpresion = self._GetDepexExpresionString()
4090 AsBuiltInfDict['depexsection_item'] = DepexExpresion if DepexExpresion else ''
4091
4092 AsBuiltInf = TemplateString()
4093 AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))
4094
4095 SaveFileOnChange(os.path.join(self.OutputDir, self.Name + '.inf'), str(AsBuiltInf), False)
4096
4097 self.IsAsBuiltInfCreated = True
4098 if GlobalData.gBinCacheDest:
4099 self.CopyModuleToCache()
4100
4101 def CopyModuleToCache(self):
4102 FileDir = path.join(GlobalData.gBinCacheDest, self.Arch, self.SourceDir, self.MetaFile.BaseName)
4103 CreateDirectory (FileDir)
4104 HashFile = path.join(self.BuildDir, self.Name + '.hash')
4105 ModuleFile = path.join(self.OutputDir, self.Name + '.inf')
4106 if os.path.exists(HashFile):
4107 shutil.copy2(HashFile, FileDir)
4108 if os.path.exists(ModuleFile):
4109 shutil.copy2(ModuleFile, FileDir)
4110 if not self.OutputFile:
4111 Ma = self.Workspace.BuildDatabase[PathClass(ModuleFile), self.Arch, self.BuildTarget, self.ToolChain]
4112 self.OutputFile = Ma.Binaries
4113 if self.OutputFile:
4114 for File in self.OutputFile:
4115 File = str(File)
4116 if not os.path.isabs(File):
4117 File = os.path.join(self.OutputDir, File)
4118 if os.path.exists(File):
4119 shutil.copy2(File, FileDir)
4120
4121 def AttemptModuleCacheCopy(self):
4122 if self.IsBinaryModule:
4123 return False
4124 FileDir = path.join(GlobalData.gBinCacheSource, self.Arch, self.SourceDir, self.MetaFile.BaseName)
4125 HashFile = path.join(FileDir, self.Name + '.hash')
4126 if os.path.exists(HashFile):
4127 f = open(HashFile, 'r')
4128 CacheHash = f.read()
4129 f.close()
4130 if GlobalData.gModuleHash[self.Arch][self.Name]:
4131 if CacheHash == GlobalData.gModuleHash[self.Arch][self.Name]:
4132 for root, dir, files in os.walk(FileDir):
4133 for f in files:
4134 if self.Name + '.hash' in f:
4135 shutil.copy2(HashFile, self.BuildDir)
4136 else:
4137 File = path.join(root, f)
4138 shutil.copy2(File, self.OutputDir)
4139 if self.Name == "PcdPeim" or self.Name == "PcdDxe":
4140 CreatePcdDatabaseCode(self, TemplateString(), TemplateString())
4141 return True
4142 return False
4143
4144 ## Create makefile for the module and its dependent libraries
4145 #
4146 # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of
4147 # dependent libraries will be created
4148 #
4149 def CreateMakeFile(self, CreateLibraryMakeFile=True, GenFfsList = []):
4150 # Ignore generating makefile when it is a binary module
4151 if self.IsBinaryModule:
4152 return
4153
4154 if self.IsMakeFileCreated:
4155 return
4156 self.GenFfsList = GenFfsList
4157 if not self.IsLibrary and CreateLibraryMakeFile:
4158 for LibraryAutoGen in self.LibraryAutoGenList:
4159 LibraryAutoGen.CreateMakeFile()
4160
4161 if self.CanSkip():
4162 return
4163
4164 if len(self.CustomMakefile) == 0:
4165 Makefile = GenMake.ModuleMakefile(self)
4166 else:
4167 Makefile = GenMake.CustomMakefile(self)
4168 if Makefile.Generate():
4169 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %
4170 (self.Name, self.Arch))
4171 else:
4172 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %
4173 (self.Name, self.Arch))
4174
4175 self.CreateTimeStamp(Makefile)
4176 self.IsMakeFileCreated = True
4177
4178 def CopyBinaryFiles(self):
4179 for File in self.Module.Binaries:
4180 SrcPath = File.Path
4181 DstPath = os.path.join(self.OutputDir, os.path.basename(SrcPath))
4182 CopyLongFilePath(SrcPath, DstPath)
4183 ## Create autogen code for the module and its dependent libraries
4184 #
4185 # @param CreateLibraryCodeFile Flag indicating if or not the code of
4186 # dependent libraries will be created
4187 #
4188 def CreateCodeFile(self, CreateLibraryCodeFile=True):
4189 if self.IsCodeFileCreated:
4190 return
4191
4192 # Need to generate PcdDatabase even PcdDriver is binarymodule
4193 if self.IsBinaryModule and self.PcdIsDriver != '':
4194 CreatePcdDatabaseCode(self, TemplateString(), TemplateString())
4195 return
4196 if self.IsBinaryModule:
4197 if self.IsLibrary:
4198 self.CopyBinaryFiles()
4199 return
4200
4201 if not self.IsLibrary and CreateLibraryCodeFile:
4202 for LibraryAutoGen in self.LibraryAutoGenList:
4203 LibraryAutoGen.CreateCodeFile()
4204
4205 if self.CanSkip():
4206 return
4207
4208 AutoGenList = []
4209 IgoredAutoGenList = []
4210
4211 for File in self.AutoGenFileList:
4212 if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):
4213 #Ignore Edk AutoGen.c
4214 if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':
4215 continue
4216
4217 AutoGenList.append(str(File))
4218 else:
4219 IgoredAutoGenList.append(str(File))
4220
4221 # Skip the following code for EDK I inf
4222 if self.AutoGenVersion < 0x00010005:
4223 return
4224
4225 for ModuleType in self.DepexList:
4226 # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module
4227 if len(self.DepexList[ModuleType]) == 0 or ModuleType == SUP_MODULE_USER_DEFINED:
4228 continue
4229
4230 Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)
4231 DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}
4232
4233 if len(Dpx.PostfixNotation) != 0:
4234 self.DepexGenerated = True
4235
4236 if Dpx.Generate(path.join(self.OutputDir, DpxFile)):
4237 AutoGenList.append(str(DpxFile))
4238 else:
4239 IgoredAutoGenList.append(str(DpxFile))
4240
4241 if IgoredAutoGenList == []:
4242 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %
4243 (" ".join(AutoGenList), self.Name, self.Arch))
4244 elif AutoGenList == []:
4245 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %
4246 (" ".join(IgoredAutoGenList), self.Name, self.Arch))
4247 else:
4248 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %
4249 (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))
4250
4251 self.IsCodeFileCreated = True
4252 return AutoGenList
4253
4254 ## Summarize the ModuleAutoGen objects of all libraries used by this module
4255 def _GetLibraryAutoGenList(self):
4256 if self._LibraryAutoGenList is None:
4257 self._LibraryAutoGenList = []
4258 for Library in self.DependentLibraryList:
4259 La = ModuleAutoGen(
4260 self.Workspace,
4261 Library.MetaFile,
4262 self.BuildTarget,
4263 self.ToolChain,
4264 self.Arch,
4265 self.PlatformInfo.MetaFile
4266 )
4267 if La not in self._LibraryAutoGenList:
4268 self._LibraryAutoGenList.append(La)
4269 for Lib in La.CodaTargetList:
4270 self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)
4271 return self._LibraryAutoGenList
4272
4273 def GenModuleHash(self):
4274 if self.Arch not in GlobalData.gModuleHash:
4275 GlobalData.gModuleHash[self.Arch] = {}
4276 m = hashlib.md5()
4277 # Add Platform level hash
4278 m.update(GlobalData.gPlatformHash)
4279 # Add Package level hash
4280 if self.DependentPackageList:
4281 for Pkg in sorted(self.DependentPackageList, key=lambda x: x.PackageName):
4282 if Pkg.PackageName in GlobalData.gPackageHash[self.Arch]:
4283 m.update(GlobalData.gPackageHash[self.Arch][Pkg.PackageName])
4284
4285 # Add Library hash
4286 if self.LibraryAutoGenList:
4287 for Lib in sorted(self.LibraryAutoGenList, key=lambda x: x.Name):
4288 if Lib.Name not in GlobalData.gModuleHash[self.Arch]:
4289 Lib.GenModuleHash()
4290 m.update(GlobalData.gModuleHash[self.Arch][Lib.Name])
4291
4292 # Add Module self
4293 f = open(str(self.MetaFile), 'r')
4294 Content = f.read()
4295 f.close()
4296 m.update(Content)
4297 # Add Module's source files
4298 if self.SourceFileList:
4299 for File in sorted(self.SourceFileList, key=lambda x: str(x)):
4300 f = open(str(File), 'r')
4301 Content = f.read()
4302 f.close()
4303 m.update(Content)
4304
4305 ModuleHashFile = path.join(self.BuildDir, self.Name + ".hash")
4306 if self.Name not in GlobalData.gModuleHash[self.Arch]:
4307 GlobalData.gModuleHash[self.Arch][self.Name] = m.hexdigest()
4308 if GlobalData.gBinCacheSource:
4309 if self.AttemptModuleCacheCopy():
4310 return False
4311 return SaveFileOnChange(ModuleHashFile, m.hexdigest(), True)
4312
4313 ## Decide whether we can skip the ModuleAutoGen process
4314 def CanSkipbyHash(self):
4315 if GlobalData.gUseHashCache:
4316 return not self.GenModuleHash()
4317 return False
4318
4319 ## Decide whether we can skip the ModuleAutoGen process
4320 # If any source file is newer than the module than we cannot skip
4321 #
4322 def CanSkip(self):
4323 if self.MakeFileDir in GlobalData.gSikpAutoGenCache:
4324 return True
4325 if not os.path.exists(self.GetTimeStampPath()):
4326 return False
4327 #last creation time of the module
4328 DstTimeStamp = os.stat(self.GetTimeStampPath())[8]
4329
4330 SrcTimeStamp = self.Workspace._SrcTimeStamp
4331 if SrcTimeStamp > DstTimeStamp:
4332 return False
4333
4334 with open(self.GetTimeStampPath(), 'r') as f:
4335 for source in f:
4336 source = source.rstrip('\n')
4337 if not os.path.exists(source):
4338 return False
4339 if source not in ModuleAutoGen.TimeDict :
4340 ModuleAutoGen.TimeDict[source] = os.stat(source)[8]
4341 if ModuleAutoGen.TimeDict[source] > DstTimeStamp:
4342 return False
4343 GlobalData.gSikpAutoGenCache.add(self.MakeFileDir)
4344 return True
4345
4346 def GetTimeStampPath(self):
4347 if self._TimeStampPath is None:
4348 self._TimeStampPath = os.path.join(self.MakeFileDir, 'AutoGenTimeStamp')
4349 return self._TimeStampPath
4350 def CreateTimeStamp(self, Makefile):
4351
4352 FileSet = {self.MetaFile.Path}
4353
4354 for SourceFile in self.Module.Sources:
4355 FileSet.add (SourceFile.Path)
4356
4357 for Lib in self.DependentLibraryList:
4358 FileSet.add (Lib.MetaFile.Path)
4359
4360 for f in self.AutoGenDepSet:
4361 FileSet.add (f.Path)
4362
4363 if os.path.exists (self.GetTimeStampPath()):
4364 os.remove (self.GetTimeStampPath())
4365 with open(self.GetTimeStampPath(), 'w+') as file:
4366 for f in FileSet:
4367 print(f, file=file)
4368
4369 Module = property(_GetModule)
4370 Name = property(_GetBaseName)
4371 Guid = property(_GetGuid)
4372 Version = property(_GetVersion)
4373 ModuleType = property(_GetModuleType)
4374 ComponentType = property(_GetComponentType)
4375 BuildType = property(_GetBuildType)
4376 PcdIsDriver = property(_GetPcdIsDriver)
4377 AutoGenVersion = property(_GetAutoGenVersion)
4378 Macros = property(_GetMacros)
4379 Specification = property(_GetSpecification)
4380
4381 IsLibrary = property(_IsLibrary)
4382 IsBinaryModule = property(_IsBinaryModule)
4383 BuildDir = property(_GetBuildDir)
4384 OutputDir = property(_GetOutputDir)
4385 FfsOutputDir = property(_GetFfsOutputDir)
4386 DebugDir = property(_GetDebugDir)
4387 MakeFileDir = property(_GetMakeFileDir)
4388 CustomMakefile = property(_GetCustomMakefile)
4389
4390 IncludePathList = property(_GetIncludePathList)
4391 IncludePathLength = property(_GetIncludePathLength)
4392 AutoGenFileList = property(_GetAutoGenFileList)
4393 UnicodeFileList = property(_GetUnicodeFileList)
4394 VfrFileList = property(_GetVfrFileList)
4395 SourceFileList = property(_GetSourceFileList)
4396 BinaryFileList = property(_GetBinaryFiles) # FileType : [File List]
4397 Targets = property(_GetTargets)
4398 IntroTargetList = property(_GetIntroTargetList)
4399 CodaTargetList = property(_GetFinalTargetList)
4400 FileTypes = property(_GetFileTypes)
4401 BuildRules = property(_GetBuildRules)
4402 IdfFileList = property(_GetIdfFileList)
4403
4404 DependentPackageList = property(_GetDependentPackageList)
4405 DependentLibraryList = property(_GetLibraryList)
4406 LibraryAutoGenList = property(_GetLibraryAutoGenList)
4407 DerivedPackageList = property(_GetDerivedPackageList)
4408
4409 ModulePcdList = property(_GetModulePcdList)
4410 LibraryPcdList = property(_GetLibraryPcdList)
4411 GuidList = property(_GetGuidList)
4412 ProtocolList = property(_GetProtocolList)
4413 PpiList = property(_GetPpiList)
4414 DepexList = property(_GetDepexTokenList)
4415 DxsFile = property(_GetDxsFile)
4416 DepexExpressionDict = property(_GetDepexExpressionTokenList)
4417 BuildOption = property(_GetModuleBuildOption)
4418 BuildOptionIncPathList = property(_GetBuildOptionIncPathList)
4419 BuildCommand = property(_GetBuildCommand)
4420
4421 FixedAtBuildPcds = property(_GetFixedAtBuildPcds)
4422 UniqueBaseName = property(_GetUniqueBaseName)
4423
4424 # This acts like the main() function for the script, unless it is 'import'ed into another script.
4425 if __name__ == '__main__':
4426 pass
4427
EFI Development Kit II mirror for PVE