2 # Generate AutoGen.h, AutoGen.c and *.depex files
4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 # Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
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
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.
18 from __future__
import print_function
19 from __future__
import absolute_import
20 import Common
.LongFilePathOs
as os
22 import os
.path
as path
28 from . import GenDepex
29 from io
import BytesIO
31 from .StrGather
import *
32 from .BuildEngine
import BuildRule
34 from Common
.LongFilePathSupport
import CopyLongFilePath
35 from Common
.BuildToolError
import *
36 from Common
.DataType
import *
37 from Common
.Misc
import *
38 from Common
.StringUtils
import *
39 import Common
.GlobalData
as GlobalData
40 from GenFds
.FdfParser
import *
41 from CommonDataClass
.CommonClass
import SkuInfoClass
42 from Workspace
.BuildClassObject
import *
43 from GenPatchPcdTable
.GenPatchPcdTable
import parsePcdInfoFromMapFile
44 import Common
.VpdInfoFile
as VpdInfoFile
45 from .GenPcdDb
import CreatePcdDatabaseCode
46 from Workspace
.MetaFileCommentParser
import UsageList
47 from Workspace
.WorkspaceCommon
import GetModuleLibInstances
48 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
49 from . import InfSectionParser
52 from .GenVar
import VariableMgr
, var_info
53 from collections
import OrderedDict
54 from collections
import defaultdict
55 from Workspace
.WorkspaceCommon
import OrderedListDict
57 ## Regular expression for splitting Dependency Expression string into tokens
58 gDepexTokenPattern
= re
.compile("(\(|\)|\w+| \S+\.inf)")
60 ## Regular expression for match: PCD(xxxx.yyy)
61 gPCDAsGuidPattern
= re
.compile(r
"^PCD\(.+\..+\)$")
64 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
65 # is the former use /I , the Latter used -I to specify include directories
67 gBuildOptIncludePatternMsft
= re
.compile(r
"(?:.*?)/I[ \t]*([^ ]*)", re
.MULTILINE | re
.DOTALL
)
68 gBuildOptIncludePatternOther
= re
.compile(r
"(?:.*?)-I[ \t]*([^ ]*)", re
.MULTILINE | re
.DOTALL
)
71 # Match name = variable
73 gEfiVarStoreNamePattern
= re
.compile("\s*name\s*=\s*(\w+)")
75 # The format of guid in efivarstore statement likes following and must be correct:
76 # guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}
78 gEfiVarStoreGuidPattern
= re
.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")
80 ## Mapping Makefile type
81 gMakeTypeMap
= {"MSFT":"nmake", "GCC":"gmake"}
84 ## Build rule configuration file
85 gDefaultBuildRuleFile
= 'build_rule.txt'
87 ## Tools definition configuration file
88 gDefaultToolsDefFile
= 'tools_def.txt'
90 ## Build rule default version
91 AutoGenReqBuildRuleVerNum
= "0.1"
93 ## default file name for AutoGen
94 gAutoGenCodeFileName
= "AutoGen.c"
95 gAutoGenHeaderFileName
= "AutoGen.h"
96 gAutoGenStringFileName
= "%(module_name)sStrDefs.h"
97 gAutoGenStringFormFileName
= "%(module_name)sStrDefs.hpk"
98 gAutoGenDepexFileName
= "%(module_name)s.depex"
99 gAutoGenImageDefFileName
= "%(module_name)sImgDefs.h"
100 gAutoGenIdfFileName
= "%(module_name)sIdf.hpk"
101 gInfSpecVersion
= "0x00010017"
104 # Template string to generic AsBuilt INF
106 gAsBuiltInfHeaderString
= TemplateString("""${header_comments}
109 # FILE auto-generated
112 INF_VERSION = ${module_inf_version}
113 BASE_NAME = ${module_name}
114 FILE_GUID = ${module_guid}
115 MODULE_TYPE = ${module_module_type}${BEGIN}
116 VERSION_STRING = ${module_version_string}${END}${BEGIN}
117 PCD_IS_DRIVER = ${pcd_is_driver_string}${END}${BEGIN}
118 UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}
119 PI_SPECIFICATION_VERSION = ${module_pi_specification_version}${END}${BEGIN}
120 ENTRY_POINT = ${module_entry_point}${END}${BEGIN}
121 UNLOAD_IMAGE = ${module_unload_image}${END}${BEGIN}
122 CONSTRUCTOR = ${module_constructor}${END}${BEGIN}
123 DESTRUCTOR = ${module_destructor}${END}${BEGIN}
124 SHADOW = ${module_shadow}${END}${BEGIN}
125 PCI_VENDOR_ID = ${module_pci_vendor_id}${END}${BEGIN}
126 PCI_DEVICE_ID = ${module_pci_device_id}${END}${BEGIN}
127 PCI_CLASS_CODE = ${module_pci_class_code}${END}${BEGIN}
128 PCI_REVISION = ${module_pci_revision}${END}${BEGIN}
129 BUILD_NUMBER = ${module_build_number}${END}${BEGIN}
130 SPEC = ${module_spec}${END}${BEGIN}
131 UEFI_HII_RESOURCE_SECTION = ${module_uefi_hii_resource_section}${END}${BEGIN}
132 MODULE_UNI_FILE = ${module_uni_file}${END}
134 [Packages.${module_arch}]${BEGIN}
135 ${package_item}${END}
137 [Binaries.${module_arch}]${BEGIN}
140 [PatchPcd.${module_arch}]${BEGIN}
144 [Protocols.${module_arch}]${BEGIN}
148 [Ppis.${module_arch}]${BEGIN}
152 [Guids.${module_arch}]${BEGIN}
156 [PcdEx.${module_arch}]${BEGIN}
160 [LibraryClasses.${module_arch}]
161 ## @LIB_INSTANCES${BEGIN}
162 # ${libraryclasses_item}${END}
166 ${userextension_tianocore_item}
170 [BuildOptions.${module_arch}]
172 ## ${flags_item}${END}
175 ## Base class for AutoGen
177 # This class just implements the cache mechanism of AutoGen objects.
179 class AutoGen(object):
180 # database to maintain the objects in each child class
181 __ObjectCache
= {} # (BuildTarget, ToolChain, ARCH, platform file): AutoGen object
185 # @param Class class object of real AutoGen class
186 # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)
187 # @param Workspace Workspace directory or WorkspaceAutoGen object
188 # @param MetaFile The path of meta file
189 # @param Target Build target
190 # @param Toolchain Tool chain name
191 # @param Arch Target arch
192 # @param *args The specific class related parameters
193 # @param **kwargs The specific class related dict parameters
195 def __new__(cls
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
196 # check if the object has been created
197 Key
= (Target
, Toolchain
, Arch
, MetaFile
)
199 # if it exists, just return it directly
200 return cls
.__ObjectCache
[Key
]
202 # it didnt exist. create it, cache it, then return it
203 cls
.__ObjectCache
[Key
] = super(AutoGen
, cls
).__new
__(cls
)
204 return cls
.__ObjectCache
[Key
]
206 def __init__ (self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
207 super(AutoGen
, self
).__init
__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
211 # The file path of platform file will be used to represent hash value of this object
213 # @retval int Hash value of the file path of platform file
216 return hash(self
.MetaFile
)
220 # The file path of platform file will be used to represent this object
222 # @retval string String of platform file path
225 return str(self
.MetaFile
)
228 def __eq__(self
, Other
):
229 return Other
and self
.MetaFile
== Other
231 ## Workspace AutoGen class
233 # This class is used mainly to control the whole platform build for different
234 # architecture. This class will generate top level makefile.
236 class WorkspaceAutoGen(AutoGen
):
237 # call super().__init__ then call the worker function with different parameter count
238 def __init__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
242 super(WorkspaceAutoGen
, self
).__init
__(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
243 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
246 ## Initialize WorkspaceAutoGen
248 # @param WorkspaceDir Root directory of workspace
249 # @param ActivePlatform Meta-file of active platform
250 # @param Target Build target
251 # @param Toolchain Tool chain name
252 # @param ArchList List of architecture of current build
253 # @param MetaFileDb Database containing meta-files
254 # @param BuildConfig Configuration of build
255 # @param ToolDefinition Tool chain definitions
256 # @param FlashDefinitionFile File of flash definition
257 # @param Fds FD list to be generated
258 # @param Fvs FV list to be generated
259 # @param Caps Capsule list to be generated
260 # @param SkuId SKU id from command line
262 def _InitWorker(self
, WorkspaceDir
, ActivePlatform
, Target
, Toolchain
, ArchList
, MetaFileDb
,
263 BuildConfig
, ToolDefinition
, FlashDefinitionFile
='', Fds
=None, Fvs
=None, Caps
=None, SkuId
='', UniFlag
=None,
264 Progress
=None, BuildModule
=None):
265 self
.BuildDatabase
= MetaFileDb
266 self
.MetaFile
= ActivePlatform
267 self
.WorkspaceDir
= WorkspaceDir
268 self
.Platform
= self
.BuildDatabase
[self
.MetaFile
, TAB_ARCH_COMMON
, Target
, Toolchain
]
269 GlobalData
.gActivePlatform
= self
.Platform
270 self
.BuildTarget
= Target
271 self
.ToolChain
= Toolchain
272 self
.ArchList
= ArchList
274 self
.UniFlag
= UniFlag
276 self
.TargetTxt
= BuildConfig
277 self
.ToolDef
= ToolDefinition
278 self
.FdfFile
= FlashDefinitionFile
279 self
.FdTargetList
= Fds
if Fds
else []
280 self
.FvTargetList
= Fvs
if Fvs
else []
281 self
.CapTargetList
= Caps
if Caps
else []
282 self
.AutoGenObjectList
= []
283 self
._BuildDir
= None
285 self
._MakeFileDir
= None
286 self
._BuildCommand
= None
289 # there's many relative directory operations, so ...
290 os
.chdir(self
.WorkspaceDir
)
295 if not self
.ArchList
:
296 ArchList
= set(self
.Platform
.SupArchList
)
298 ArchList
= set(self
.ArchList
) & set(self
.Platform
.SupArchList
)
300 EdkLogger
.error("build", PARAMETER_INVALID
,
301 ExtraData
= "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self
.Platform
.SupArchList
)))
302 elif self
.ArchList
and len(ArchList
) != len(self
.ArchList
):
303 SkippedArchList
= set(self
.ArchList
).symmetric_difference(set(self
.Platform
.SupArchList
))
304 EdkLogger
.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"
305 % (" ".join(SkippedArchList
), " ".join(self
.Platform
.SupArchList
)))
306 self
.ArchList
= tuple(ArchList
)
308 # Validate build target
309 if self
.BuildTarget
not in self
.Platform
.BuildTargets
:
310 EdkLogger
.error("build", PARAMETER_INVALID
,
311 ExtraData
="Build target [%s] is not supported by the platform. [Valid target: %s]"
312 % (self
.BuildTarget
, " ".join(self
.Platform
.BuildTargets
)))
315 # parse FDF file to get PCDs in it, if any
317 self
.FdfFile
= self
.Platform
.FlashDefinition
321 EdkLogger
.info('%-16s = %s' % ("Architecture(s)", ' '.join(self
.ArchList
)))
322 EdkLogger
.info('%-16s = %s' % ("Build target", self
.BuildTarget
))
323 EdkLogger
.info('%-16s = %s' % ("Toolchain", self
.ToolChain
))
325 EdkLogger
.info('\n%-24s = %s' % ("Active Platform", self
.Platform
))
327 EdkLogger
.info('%-24s = %s' % ("Active Module", BuildModule
))
330 EdkLogger
.info('%-24s = %s' % ("Flash Image Definition", self
.FdfFile
))
332 EdkLogger
.verbose("\nFLASH_DEFINITION = %s" % self
.FdfFile
)
335 Progress
.Start("\nProcessing meta-data")
339 # Mark now build in AutoGen Phase
341 GlobalData
.gAutoGenPhase
= True
342 Fdf
= FdfParser(self
.FdfFile
.Path
)
344 GlobalData
.gFdfParser
= Fdf
345 GlobalData
.gAutoGenPhase
= False
346 PcdSet
= Fdf
.Profile
.PcdDict
347 if Fdf
.CurrentFdName
and Fdf
.CurrentFdName
in Fdf
.Profile
.FdDict
:
348 FdDict
= Fdf
.Profile
.FdDict
[Fdf
.CurrentFdName
]
349 for FdRegion
in FdDict
.RegionList
:
350 if str(FdRegion
.RegionType
) is 'FILE' and self
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
351 if int(FdRegion
.Offset
) % 8 != 0:
352 EdkLogger
.error("build", FORMAT_INVALID
, 'The VPD Base Address %s must be 8-byte aligned.' % (FdRegion
.Offset
))
353 ModuleList
= Fdf
.Profile
.InfList
354 self
.FdfProfile
= Fdf
.Profile
355 for fvname
in self
.FvTargetList
:
356 if fvname
.upper() not in self
.FdfProfile
.FvDict
:
357 EdkLogger
.error("build", OPTION_VALUE_INVALID
,
358 "No such an FV in FDF file: %s" % fvname
)
360 # In DSC file may use FILE_GUID to override the module, then in the Platform.Modules use FILE_GUIDmodule.inf as key,
361 # but the path (self.MetaFile.Path) is the real path
362 for key
in self
.FdfProfile
.InfDict
:
364 MetaFile_cache
= defaultdict(set)
365 for Arch
in self
.ArchList
:
366 Current_Platform_cache
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
367 for Pkey
in Current_Platform_cache
.Modules
:
368 MetaFile_cache
[Arch
].add(Current_Platform_cache
.Modules
[Pkey
].MetaFile
)
369 for Inf
in self
.FdfProfile
.InfDict
[key
]:
370 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
371 for Arch
in self
.ArchList
:
372 if ModuleFile
in MetaFile_cache
[Arch
]:
375 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
376 if not ModuleData
.IsBinaryModule
:
377 EdkLogger
.error('build', PARSER_ERROR
, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile
)
380 for Arch
in self
.ArchList
:
382 Platform
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
384 for Pkey
in Platform
.Modules
:
385 MetaFileList
.add(Platform
.Modules
[Pkey
].MetaFile
)
386 for Inf
in self
.FdfProfile
.InfDict
[key
]:
387 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
388 if ModuleFile
in MetaFileList
:
390 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
391 if not ModuleData
.IsBinaryModule
:
392 EdkLogger
.error('build', PARSER_ERROR
, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile
)
397 self
.FdfProfile
= None
398 if self
.FdTargetList
:
399 EdkLogger
.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self
.FdTargetList
))
400 self
.FdTargetList
= []
401 if self
.FvTargetList
:
402 EdkLogger
.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self
.FvTargetList
))
403 self
.FvTargetList
= []
404 if self
.CapTargetList
:
405 EdkLogger
.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self
.CapTargetList
))
406 self
.CapTargetList
= []
408 # apply SKU and inject PCDs from Flash Definition file
409 for Arch
in self
.ArchList
:
410 Platform
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
411 PlatformPcds
= Platform
.Pcds
412 self
._GuidDict
= Platform
._GuidDict
413 SourcePcdDict
= {TAB_PCDS_DYNAMIC_EX
:set(), TAB_PCDS_PATCHABLE_IN_MODULE
:set(),TAB_PCDS_DYNAMIC
:set(),TAB_PCDS_FIXED_AT_BUILD
:set()}
414 BinaryPcdDict
= {TAB_PCDS_DYNAMIC_EX
:set(), TAB_PCDS_PATCHABLE_IN_MODULE
:set()}
415 SourcePcdDict_Keys
= SourcePcdDict
.keys()
416 BinaryPcdDict_Keys
= BinaryPcdDict
.keys()
418 # generate the SourcePcdDict and BinaryPcdDict
419 PGen
= PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
)
420 for BuildData
in PGen
.BuildDatabase
._CACHE
_.values():
421 if BuildData
.Arch
!= Arch
:
423 if BuildData
.MetaFile
.Ext
== '.inf':
424 for key
in BuildData
.Pcds
:
425 if BuildData
.Pcds
[key
].Pending
:
426 if key
in Platform
.Pcds
:
427 PcdInPlatform
= Platform
.Pcds
[key
]
428 if PcdInPlatform
.Type
:
429 BuildData
.Pcds
[key
].Type
= PcdInPlatform
.Type
430 BuildData
.Pcds
[key
].Pending
= False
432 if BuildData
.MetaFile
in Platform
.Modules
:
433 PlatformModule
= Platform
.Modules
[str(BuildData
.MetaFile
)]
434 if key
in PlatformModule
.Pcds
:
435 PcdInPlatform
= PlatformModule
.Pcds
[key
]
436 if PcdInPlatform
.Type
:
437 BuildData
.Pcds
[key
].Type
= PcdInPlatform
.Type
438 BuildData
.Pcds
[key
].Pending
= False
440 #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending
441 if BuildData
.Pcds
[key
].Pending
:
442 MGen
= ModuleAutoGen(self
, BuildData
.MetaFile
, Target
, Toolchain
, Arch
, self
.MetaFile
)
443 if MGen
and MGen
.IsLibrary
:
444 if MGen
in PGen
.LibraryAutoGenList
:
445 ReferenceModules
= MGen
._ReferenceModules
446 for ReferenceModule
in ReferenceModules
:
447 if ReferenceModule
.MetaFile
in Platform
.Modules
:
448 RefPlatformModule
= Platform
.Modules
[str(ReferenceModule
.MetaFile
)]
449 if key
in RefPlatformModule
.Pcds
:
450 PcdInReferenceModule
= RefPlatformModule
.Pcds
[key
]
451 if PcdInReferenceModule
.Type
:
452 BuildData
.Pcds
[key
].Type
= PcdInReferenceModule
.Type
453 BuildData
.Pcds
[key
].Pending
= False
456 if TAB_PCDS_DYNAMIC_EX
in BuildData
.Pcds
[key
].Type
:
457 if BuildData
.IsBinaryModule
:
458 BinaryPcdDict
[TAB_PCDS_DYNAMIC_EX
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
460 SourcePcdDict
[TAB_PCDS_DYNAMIC_EX
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
462 elif TAB_PCDS_PATCHABLE_IN_MODULE
in BuildData
.Pcds
[key
].Type
:
463 if BuildData
.MetaFile
.Ext
== '.inf':
464 if BuildData
.IsBinaryModule
:
465 BinaryPcdDict
[TAB_PCDS_PATCHABLE_IN_MODULE
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
467 SourcePcdDict
[TAB_PCDS_PATCHABLE_IN_MODULE
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
469 elif TAB_PCDS_DYNAMIC
in BuildData
.Pcds
[key
].Type
:
470 SourcePcdDict
[TAB_PCDS_DYNAMIC
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
471 elif TAB_PCDS_FIXED_AT_BUILD
in BuildData
.Pcds
[key
].Type
:
472 SourcePcdDict
[TAB_PCDS_FIXED_AT_BUILD
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
476 # A PCD can only use one type for all source modules
478 for i
in SourcePcdDict_Keys
:
479 for j
in SourcePcdDict_Keys
:
481 Intersections
= SourcePcdDict
[i
].intersection(SourcePcdDict
[j
])
482 if len(Intersections
) > 0:
486 "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
),
487 ExtraData
='\n\t'.join(str(P
[1]+'.'+P
[0]) for P
in Intersections
)
491 # intersection the BinaryPCD for Mixed PCD
493 for i
in BinaryPcdDict_Keys
:
494 for j
in BinaryPcdDict_Keys
:
496 Intersections
= BinaryPcdDict
[i
].intersection(BinaryPcdDict
[j
])
497 for item
in Intersections
:
498 NewPcd1
= (item
[0] + '_' + i
, item
[1])
499 NewPcd2
= (item
[0] + '_' + j
, item
[1])
500 if item
not in GlobalData
.MixedPcd
:
501 GlobalData
.MixedPcd
[item
] = [NewPcd1
, NewPcd2
]
503 if NewPcd1
not in GlobalData
.MixedPcd
[item
]:
504 GlobalData
.MixedPcd
[item
].append(NewPcd1
)
505 if NewPcd2
not in GlobalData
.MixedPcd
[item
]:
506 GlobalData
.MixedPcd
[item
].append(NewPcd2
)
509 # intersection the SourcePCD and BinaryPCD for Mixed PCD
511 for i
in SourcePcdDict_Keys
:
512 for j
in BinaryPcdDict_Keys
:
514 Intersections
= SourcePcdDict
[i
].intersection(BinaryPcdDict
[j
])
515 for item
in Intersections
:
516 NewPcd1
= (item
[0] + '_' + i
, item
[1])
517 NewPcd2
= (item
[0] + '_' + j
, item
[1])
518 if item
not in GlobalData
.MixedPcd
:
519 GlobalData
.MixedPcd
[item
] = [NewPcd1
, NewPcd2
]
521 if NewPcd1
not in GlobalData
.MixedPcd
[item
]:
522 GlobalData
.MixedPcd
[item
].append(NewPcd1
)
523 if NewPcd2
not in GlobalData
.MixedPcd
[item
]:
524 GlobalData
.MixedPcd
[item
].append(NewPcd2
)
526 for BuildData
in PGen
.BuildDatabase
._CACHE
_.values():
527 if BuildData
.Arch
!= Arch
:
529 for key
in BuildData
.Pcds
:
530 for SinglePcd
in GlobalData
.MixedPcd
:
531 if (BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
) == SinglePcd
:
532 for item
in GlobalData
.MixedPcd
[SinglePcd
]:
533 Pcd_Type
= item
[0].split('_')[-1]
534 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 \
535 (Pcd_Type
== TAB_PCDS_DYNAMIC
and BuildData
.Pcds
[key
].Type
in PCD_DYNAMIC_TYPE_SET
):
536 Value
= BuildData
.Pcds
[key
]
537 Value
.TokenCName
= BuildData
.Pcds
[key
].TokenCName
+ '_' + Pcd_Type
539 newkey
= (Value
.TokenCName
, key
[1])
541 newkey
= (Value
.TokenCName
, key
[1], key
[2])
542 del BuildData
.Pcds
[key
]
543 BuildData
.Pcds
[newkey
] = Value
547 # handle the mixed pcd in FDF file
549 if key
in GlobalData
.MixedPcd
:
552 for item
in GlobalData
.MixedPcd
[key
]:
555 #Collect package set information from INF of FDF
557 for Inf
in ModuleList
:
558 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
559 if ModuleFile
in Platform
.Modules
:
561 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
562 PkgSet
.update(ModuleData
.Packages
)
563 Pkgs
= list(PkgSet
) + list(PGen
.PackageList
)
568 DecPcds
.add((Pcd
[0], Pcd
[1]))
569 DecPcdsKey
.add((Pcd
[0], Pcd
[1], Pcd
[2]))
571 Platform
.SkuName
= self
.SkuId
572 for Name
, Guid
,Fileds
in PcdSet
:
573 if (Name
, Guid
) not in DecPcds
:
577 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid
, Name
),
578 File
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
][0],
579 Line
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
][1]
582 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.
583 if (Name
, Guid
, TAB_PCDS_FIXED_AT_BUILD
) in DecPcdsKey \
584 or (Name
, Guid
, TAB_PCDS_PATCHABLE_IN_MODULE
) in DecPcdsKey \
585 or (Name
, Guid
, TAB_PCDS_FEATURE_FLAG
) in DecPcdsKey
:
587 elif (Name
, Guid
, TAB_PCDS_DYNAMIC
) in DecPcdsKey
or (Name
, Guid
, TAB_PCDS_DYNAMIC_EX
) in DecPcdsKey
:
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]
596 Pa
= PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
)
598 # Explicitly collect platform's dynamic PCDs
600 Pa
.CollectPlatformDynamicPcds()
601 Pa
.CollectFixedAtBuildPcds()
602 self
.AutoGenObjectList
.append(Pa
)
605 # Generate Package level hash value
607 GlobalData
.gPackageHash
[Arch
] = {}
608 if GlobalData
.gUseHashCache
:
610 self
._GenPkgLevelHash
(Pkg
)
613 # Check PCDs token value conflict in each DEC file.
615 self
._CheckAllPcdsTokenValueConflict
()
618 # Check PCD type and definition between DSC and DEC
620 self
._CheckPcdDefineAndType
()
623 # self._CheckDuplicateInFV(Fdf)
626 # Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.
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
638 content
+= 'Flash Image Definition: '
639 content
+= str(self
.FdfFile
)
640 content
+= os
.linesep
641 SaveFileOnChange(os
.path
.join(self
.BuildDir
, 'BuildOptions'), content
, False)
644 # Create PcdToken Number file for Dynamic/DynamicEx Pcd.
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)
657 # Get set of workspace metafiles
659 AllWorkSpaceMetaFiles
= self
._GetMetaFiles
(Target
, Toolchain
, Arch
)
662 # Retrieve latest modified time of all metafiles
665 for f
in AllWorkSpaceMetaFiles
:
666 if os
.stat(f
)[8] > SrcTimeStamp
:
667 SrcTimeStamp
= os
.stat(f
)[8]
668 self
._SrcTimeStamp
= SrcTimeStamp
670 if GlobalData
.gUseHashCache
:
672 for files
in AllWorkSpaceMetaFiles
:
673 if files
.endswith('.dec'):
679 SaveFileOnChange(os
.path
.join(self
.BuildDir
, 'AutoGen.hash'), m
.hexdigest(), True)
680 GlobalData
.gPlatformHash
= m
.hexdigest()
683 # Write metafile list to build directory
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
:
695 def _GenPkgLevelHash(self
, Pkg
):
696 if Pkg
.PackageName
in GlobalData
.gPackageHash
[Pkg
.Arch
]:
699 PkgDir
= os
.path
.join(self
.BuildDir
, Pkg
.Arch
, Pkg
.PackageName
)
700 CreateDirectory(PkgDir
)
701 HashFile
= os
.path
.join(PkgDir
, Pkg
.PackageName
+ '.hash')
703 # Get .dec file's hash value
704 f
= open(Pkg
.MetaFile
.Path
, 'r')
708 # Get include files hash value
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')
718 SaveFileOnChange(HashFile
, m
.hexdigest(), True)
719 GlobalData
.gPackageHash
[Pkg
.Arch
][Pkg
.PackageName
] = m
.hexdigest()
721 def _GetMetaFiles(self
, Target
, Toolchain
, Arch
):
722 AllWorkSpaceMetaFiles
= set()
727 AllWorkSpaceMetaFiles
.add (self
.FdfFile
.Path
)
728 for f
in GlobalData
.gFdfParser
.GetAllIncludedFile():
729 AllWorkSpaceMetaFiles
.add (f
.FileName
)
733 AllWorkSpaceMetaFiles
.add(self
.MetaFile
.Path
)
736 # add build_rule.txt & tools_def.txt
738 AllWorkSpaceMetaFiles
.add(os
.path
.join(GlobalData
.gConfDirectory
, gDefaultBuildRuleFile
))
739 AllWorkSpaceMetaFiles
.add(os
.path
.join(GlobalData
.gConfDirectory
, gDefaultToolsDefFile
))
741 # add BuildOption metafile
743 AllWorkSpaceMetaFiles
.add(os
.path
.join(self
.BuildDir
, 'BuildOptions'))
745 # add PcdToken Number file for Dynamic/DynamicEx Pcd
747 AllWorkSpaceMetaFiles
.add(os
.path
.join(self
.BuildDir
, 'PcdTokenNumber'))
749 for Arch
in self
.ArchList
:
753 for Package
in PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
).PackageList
:
754 AllWorkSpaceMetaFiles
.add(Package
.MetaFile
.Path
)
759 for filePath
in self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]._RawData
.IncludedFiles
:
760 AllWorkSpaceMetaFiles
.add(filePath
.Path
)
762 return AllWorkSpaceMetaFiles
764 ## _CheckDuplicateInFV() method
766 # Check whether there is duplicate modules/files exist in FV section.
767 # The check base on the file GUID;
769 def _CheckDuplicateInFV(self
, Fdf
):
770 for Fv
in Fdf
.Profile
.FvDict
:
772 for FfsFile
in Fdf
.Profile
.FvDict
[Fv
].FfsList
:
773 if FfsFile
.InfFileName
and FfsFile
.NameGuid
is None:
778 for Pa
in self
.AutoGenObjectList
:
781 for Module
in Pa
.ModuleAutoGenList
:
782 if path
.normpath(Module
.MetaFile
.File
) == path
.normpath(FfsFile
.InfFileName
):
784 if Module
.Guid
.upper() not in _GuidDict
:
785 _GuidDict
[Module
.Guid
.upper()] = FfsFile
788 EdkLogger
.error("build",
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
)
797 # Some INF files not have entity in DSC file.
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
))
805 PathClassObj
= PathClass(FfsFile
.InfFileName
, self
.WorkspaceDir
)
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.
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
814 EdkLogger
.error("build",
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
)
824 if FfsFile
.NameGuid
is not None:
826 # If the NameGuid reference a PCD name.
827 # The style must match: PCD(xxxx.yyy)
829 if gPCDAsGuidPattern
.match(FfsFile
.NameGuid
):
831 # Replace the PCD value.
833 _PcdName
= FfsFile
.NameGuid
.lstrip("PCD(").rstrip(")")
835 for Pa
in self
.AutoGenObjectList
:
837 for PcdItem
in Pa
.AllPcdList
:
838 if (PcdItem
.TokenSpaceGuidCName
+ "." + PcdItem
.TokenCName
) == _PcdName
:
840 # First convert from CFormatGuid to GUID string
842 _PcdGuidString
= GuidStructureStringToGuidString(PcdItem
.DefaultValue
)
844 if not _PcdGuidString
:
846 # Then try Byte array.
848 _PcdGuidString
= GuidStructureByteArrayToGuidString(PcdItem
.DefaultValue
)
850 if not _PcdGuidString
:
852 # Not Byte array or CFormat GUID, raise error.
854 EdkLogger
.error("build",
856 "The format of PCD value is incorrect. PCD: %s , Value: %s\n" % (_PcdName
, PcdItem
.DefaultValue
),
857 ExtraData
=self
.FdfFile
)
859 if _PcdGuidString
.upper() not in _GuidDict
:
860 _GuidDict
[_PcdGuidString
.upper()] = FfsFile
864 EdkLogger
.error("build",
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
)
873 if FfsFile
.NameGuid
.upper() not in _GuidDict
:
874 _GuidDict
[FfsFile
.NameGuid
.upper()] = FfsFile
877 # Two raw file GUID conflict.
879 EdkLogger
.error("build",
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
)
889 def _CheckPcdDefineAndType(self
):
890 PcdTypeSet
= {TAB_PCDS_FIXED_AT_BUILD
,
891 TAB_PCDS_PATCHABLE_IN_MODULE
,
892 TAB_PCDS_FEATURE_FLAG
,
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
903 # If no PCD type, this PCD comes from FDF
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
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
:
917 for Type
in PcdTypeSet
:
918 if (Pcd
[0], Pcd
[1], Type
) in Package
.Pcds
:
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
),
928 UnusedPcd
.setdefault(Pcd
, []).append(Pa
.Arch
)
930 for Pcd
in UnusedPcd
:
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
])),
940 return "%s [%s]" % (self
.MetaFile
, ", ".join(self
.ArchList
))
942 ## Return the directory to store FV files
944 if self
._FvDir
is None:
945 self
._FvDir
= path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
)
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
953 ## Return the build output directory platform specifies
954 def _GetOutputDir(self
):
955 return self
.Platform
.OutputDirectory
957 ## Return platform name
959 return self
.Platform
.PlatformName
961 ## Return meta-file GUID
963 return self
.Platform
.Guid
965 ## Return platform version
966 def _GetVersion(self
):
967 return self
.Platform
.Version
969 ## Return paths of tools
970 def _GetToolDefinition(self
):
971 return self
.AutoGenObjectList
[0].ToolDefinition
973 ## Return directory of platform makefile
975 # @retval string Makefile directory
977 def _GetMakeFileDir(self
):
978 if self
._MakeFileDir
is None:
979 self
._MakeFileDir
= self
.BuildDir
980 return self
._MakeFileDir
982 ## Return build command string
984 # @retval string Build command string
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
992 ## Check the PCDs token value conflict in each DEC file.
994 # Will cause build break and raise error message while two PCDs conflict.
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)))
1004 while (Count
< len(PcdList
) - 1) :
1005 Item
= PcdList
[Count
]
1006 ItemNext
= PcdList
[Count
+ 1]
1008 # Make sure in the same token space the TokenValue should be unique
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
])
1021 # Sort same token value PCD list with TokenGuid and TokenCName
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):
1027 TemListItem
= SameTokenValuePcdList
[SameTokenValuePcdListCount
]
1028 TemListItemNext
= SameTokenValuePcdList
[SameTokenValuePcdListCount
+ 1]
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
]:
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
),
1043 SameTokenValuePcdListCount
+= 1
1044 Count
+= SameTokenValuePcdListCount
1047 PcdList
= Package
.Pcds
.values()
1048 PcdList
.sort(lambda x
, y
: cmp("%s.%s" % (x
.TokenSpaceGuidCName
, x
.TokenCName
), "%s.%s" % (y
.TokenSpaceGuidCName
, y
.TokenCName
)))
1050 while (Count
< len(PcdList
) - 1) :
1051 Item
= PcdList
[Count
]
1052 ItemNext
= PcdList
[Count
+ 1]
1054 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.
1056 if (Item
.TokenSpaceGuidCName
== ItemNext
.TokenSpaceGuidCName
) and (Item
.TokenCName
== ItemNext
.TokenCName
) and (int(Item
.TokenValue
, 0) != int(ItemNext
.TokenValue
, 0)):
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
),
1065 ## Generate fds command
1066 def _GenFdsCommand(self
):
1067 return (GenMake
.TopLevelMakefile(self
)._TEMPLATE
_.Replace(GenMake
.TopLevelMakefile(self
)._TemplateDict
)).strip()
1069 ## Create makefile for the platform and modules in it
1071 # @param CreateDepsMakeFile Flag indicating if the makefile for
1072 # modules will be created as well
1074 def CreateMakeFile(self
, CreateDepsMakeFile
=False):
1075 if not CreateDepsMakeFile
:
1077 for Pa
in self
.AutoGenObjectList
:
1078 Pa
.CreateMakeFile(True)
1080 ## Create autogen code for platform and modules
1082 # Since there's no autogen code for platform, this method will do nothing
1083 # if CreateModuleCodeFile is set to False.
1085 # @param CreateDepsCodeFile Flag indicating if creating module's
1086 # autogen code file or not
1088 def CreateCodeFile(self
, CreateDepsCodeFile
=False):
1089 if not CreateDepsCodeFile
:
1091 for Pa
in self
.AutoGenObjectList
:
1092 Pa
.CreateCodeFile(True)
1094 ## Create AsBuilt INF file the platform
1096 def CreateAsBuiltInf(self
):
1099 Name
= property(_GetName
)
1100 Guid
= property(_GetGuid
)
1101 Version
= property(_GetVersion
)
1102 OutputDir
= property(_GetOutputDir
)
1104 ToolDefinition
= property(_GetToolDefinition
) # toolcode : tool path
1106 BuildDir
= property(_GetBuildDir
)
1107 FvDir
= property(_GetFvDir
)
1108 MakeFileDir
= property(_GetMakeFileDir
)
1109 BuildCommand
= property(_GetBuildCommand
)
1110 GenFdsCommand
= property(_GenFdsCommand
)
1112 ## AutoGen class for platform
1114 # PlatformAutoGen class will process the original information in platform
1115 # file in order to generate makefile for platform.
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
):
1123 super(PlatformAutoGen
, self
).__init
__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
1124 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
)
1127 # Used to store all PCDs for both PEI and DXE phase, in order to generate
1128 # correct PCD database
1131 _NonDynaPcdList_
= []
1135 # The priority list while override build option
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)
1154 ## Initialize PlatformAutoGen
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
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
)
1167 self
.MetaFile
= PlatformFile
1168 self
.Workspace
= Workspace
1169 self
.WorkspaceDir
= Workspace
.WorkspaceDir
1170 self
.ToolChain
= Toolchain
1171 self
.BuildTarget
= Target
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
1183 # flag indicating if the makefile/C-code file has been created or not
1184 self
.IsMakeFileCreated
= False
1185 self
.IsCodeFileCreated
= False
1187 self
._Platform
= None
1190 self
._Version
= None
1192 self
._BuildRule
= None
1193 self
._SourceDir
= None
1194 self
._BuildDir
= None
1195 self
._OutputDir
= None
1197 self
._MakeFileDir
= None
1198 self
._FdfFile
= None
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
= {}
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
= []
1219 self
.VariableInfo
= None
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
:
1228 self
._AsBuildModuleList
.append(InfClass
)
1229 # get library/modules for build
1230 self
.LibraryBuildDirectoryList
= []
1231 self
.ModuleBuildDirectoryList
= []
1236 return "%s [%s]" % (self
.MetaFile
, self
.Arch
)
1238 ## Create autogen code for platform and modules
1240 # Since there's no autogen code for platform, this method will do nothing
1241 # if CreateModuleCodeFile is set to False.
1243 # @param CreateModuleCodeFile Flag indicating if creating module's
1244 # autogen code file or not
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
:
1251 for Ma
in self
.ModuleAutoGenList
:
1252 Ma
.CreateCodeFile(True)
1254 # don't do this twice
1255 self
.IsCodeFileCreated
= True
1257 ## Generate Fds Command
1258 def _GenFdsCommand(self
):
1259 return self
.Workspace
.GenFdsCommand
1261 ## Create makefile for the platform and mdoules in it
1263 # @param CreateModuleMakeFile Flag indicating if the makefile for
1264 # modules will be created as well
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
])
1274 Ma
.CreateMakeFile(True)
1275 #Ma.CreateAsBuiltInf()
1277 # no need to create makefile for the platform more than once
1278 if self
.IsMakeFileCreated
:
1281 # create library/module build dirs for platform
1282 Makefile
= GenMake
.PlatformMakefile(self
)
1283 self
.LibraryBuildDirectoryList
= Makefile
.GetLibraryBuildDirectoryList()
1284 self
.ModuleBuildDirectoryList
= Makefile
.GetModuleBuildDirectoryList()
1286 self
.IsMakeFileCreated
= True
1288 ## Deal with Shared FixedAtBuild Pcds
1290 def CollectFixedAtBuildPcds(self
):
1291 for LibAuto
in self
.LibraryAutoGenList
:
1292 FixedAtBuildPcds
= {}
1293 ShareFixedAtBuildPcdsSameValue
= {}
1294 for Module
in LibAuto
._ReferenceModules
:
1295 for Pcd
in set(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
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
:
1313 DscPcd
= self
.NonDynamicPcdDict
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1314 if DscPcd
.Type
!= TAB_PCDS_FIXED_AT_BUILD
:
1316 if key
in ShareFixedAtBuildPcdsSameValue
and ShareFixedAtBuildPcdsSameValue
[key
]:
1317 LibAuto
.ConstPcd
[key
] = FixedAtBuildPcds
[key
]
1319 def CollectVariables(self
, DynamicPcdSet
):
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
1333 VariableInfo
= VariableMgr(self
.DscBuildDataObj
._GetDefaultStores
(), self
.DscBuildDataObj
._GetSkuIds
())
1334 VariableInfo
.SetVpdRegionMaxSize(VpdRegionSize
)
1335 VariableInfo
.SetVpdRegionOffset(VpdRegionBase
)
1337 for Pcd
in DynamicPcdSet
:
1338 pcdname
= ".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
1339 for SkuName
in Pcd
.SkuInfoList
:
1340 Sku
= Pcd
.SkuInfoList
[SkuName
]
1342 if SkuId
is None or SkuId
== '':
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
))
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"]
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'
1363 EdkLogger
.error("build", FILE_READ_FAILURE
, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath
)
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
)
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(",")))
1379 ## Collect dynamic PCDs
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.
1384 def CollectPlatformDynamicPcds(self
):
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
1396 newkey
= (Value
.TokenCName
, key
[1])
1398 newkey
= (Value
.TokenCName
, key
[1], key
[2])
1399 del self
.Platform
.Pcds
[key
]
1400 self
.Platform
.Pcds
[newkey
] = Value
1404 # for gathering error information
1405 NoDatumTypePcdList
= set()
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)
1414 self
.Platform
.Modules
[F
].M
= M
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
))
1421 # Check the PCD from Binary INF or Source INF
1422 if M
.IsBinaryModule
== True:
1423 PcdFromModule
.IsFromBinaryInf
= True
1425 # Check the PCD from DSC or not
1426 PcdFromModule
.IsFromDsc
= (PcdFromModule
.TokenCName
, PcdFromModule
.TokenSpaceGuidCName
) in self
.Platform
.Pcds
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.
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
:
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
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
:
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",
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
_:
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
])
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",
1535 ExtraData
="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
1536 % NoDatumTypePcdListString
)
1537 self
._NonDynamicPcdList
= self
._NonDynaPcdList
_
1538 self
._DynamicPcdList
= self
._DynaPcdList
_
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
1545 # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
1547 UnicodePcdArray
= set()
1549 OtherPcdArray
= set()
1551 VpdFile
= VpdInfoFile
.VpdInfoFile()
1552 NeedProcessVpdMapFile
= False
1554 for pcd
in self
.Platform
.Pcds
:
1555 if pcd
not in self
._PlatformPcds
:
1556 self
._PlatformPcds
[pcd
] = self
.Platform
.Pcds
[pcd
]
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
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()
1568 if Pcd
.DatumType
not in [TAB_UINT8
, TAB_UINT16
, TAB_UINT32
, TAB_UINT64
, TAB_VOID
, "BOOLEAN"]:
1569 Pcd
.DatumType
= TAB_VOID
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
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()
1582 PcdNvStoreDfBuffer
.DefaultValue
= vardump
1583 for skuname
in PcdNvStoreDfBuffer
.SkuInfoList
:
1584 PcdNvStoreDfBuffer
.SkuInfoList
[skuname
].DefaultValue
= vardump
1585 PcdNvStoreDfBuffer
.MaxDatumSize
= str(len(vardump
.split(",")))
1587 PlatformPcds
= sorted(self
._PlatformPcds
.keys())
1589 # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.
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
]
1598 DefaultSku
= Pcd
.SkuInfoList
.get(TAB_DEFAULT
)
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
)
1606 for (SkuName
, Sku
) in Pcd
.SkuInfoList
.items():
1607 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1608 PcdValue
= Sku
.DefaultValue
1610 PcdValue
= Pcd
.DefaultValue
1611 if Sku
.VpdOffset
!= '*':
1612 if PcdValue
.startswith("{"):
1614 elif PcdValue
.startswith("L"):
1619 VpdOffset
= int(Sku
.VpdOffset
)
1622 VpdOffset
= int(Sku
.VpdOffset
, 16)
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
)
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.")
1641 VpdSkuMap
[PcdKey
] = SkuValueMap
1643 # Fix the PCDs define in VPD PCD section that never referenced by module.
1644 # An example is PCD for signature usage.
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
== ''):
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
):
1657 # Not found, it should be signature
1659 # just pick the a value to determine whether is unicode string type
1661 SkuObjList
= DscPcdEntry
.SkuInfoList
.items()
1662 DefaultSku
= DscPcdEntry
.SkuInfoList
.get(TAB_DEFAULT
)
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()
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
))
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
1689 if DscPcdEntry
not in self
._DynamicPcdList
:
1690 self
._DynamicPcdList
.append(DscPcdEntry
)
1691 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1692 PcdValue
= Sku
.DefaultValue
1694 PcdValue
= DscPcdEntry
.DefaultValue
1695 if Sku
.VpdOffset
!= '*':
1696 if PcdValue
.startswith("{"):
1698 elif PcdValue
.startswith("L"):
1703 VpdOffset
= int(Sku
.VpdOffset
)
1706 VpdOffset
= int(Sku
.VpdOffset
, 16)
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
)
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
)
1725 OtherPcdArray
.add(DscPcdEntry
)
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
))
1734 if VpdFile
.GetCount() != 0:
1736 self
.FixVpdOffset(VpdFile
)
1738 self
.FixVpdOffset(self
.UpdateNVStoreMaxSize(VpdFile
))
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
)
1747 for pcd
in VpdSkuMap
:
1748 vpdinfo
= VpdFile
.GetVpdInfo(pcd
)
1750 # just pick the a value to determine whether is unicode string type
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]
1758 EdkLogger
.error("build", FILE_READ_FAILURE
, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath
)
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()
1766 if Pcd
.DatumType
not in [TAB_UINT8
, TAB_UINT16
, TAB_UINT32
, TAB_UINT64
, TAB_VOID
, "BOOLEAN"]:
1767 Pcd
.DatumType
= TAB_VOID
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
)
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:
1788 pcd
.SkuInfoList
[SkuName
] = copy
.deepcopy(pcd
.SkuInfoList
[TAB_DEFAULT
])
1789 pcd
.SkuInfoList
[SkuName
].SkuId
= SkuId
1790 self
.AllPcdList
= self
._NonDynamicPcdList
+ self
._DynamicPcdList
1792 def FixVpdOffset(self
, VpdFile
):
1793 FvPath
= os
.path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
)
1794 if not os
.path
.exists(FvPath
):
1798 EdkLogger
.error("build", FILE_WRITE_FAILURE
, "Fail to create FV folder under %s" % self
.BuildDir
)
1800 VpdFilePath
= os
.path
.join(FvPath
, "%s.txt" % self
.Platform
.VpdToolGuid
)
1802 if VpdFile
.Write(VpdFilePath
):
1803 # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.
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"]
1811 # Call third party GUID BPDG tool.
1812 if BPDGToolName
is not None:
1813 VpdInfoFile
.CallExtenalBPDGTool(BPDGToolName
, VpdFilePath
)
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.")
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
1823 ## Return platform name
1825 return self
.Platform
.PlatformName
1827 ## Return the meta file GUID
1829 return self
.Platform
.Guid
1831 ## Return the platform version
1832 def _GetVersion(self
):
1833 return self
.Platform
.Version
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
)
1842 return self
._FdfFile
1844 ## Return the build output directory platform specifies
1845 def _GetOutputDir(self
):
1846 return self
.Platform
.OutputDirectory
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
,
1857 self
._BuildDir
= path
.join(
1860 self
.BuildTarget
+ "_" + self
.ToolChain
,
1862 GlobalData
.gBuildDirectory
= self
._BuildDir
1863 return self
._BuildDir
1865 ## Return directory of platform makefile
1867 # @retval string Makefile directory
1869 def _GetMakeFileDir(self
):
1870 if self
._MakeFileDir
is None:
1871 self
._MakeFileDir
= path
.join(self
.BuildDir
, self
.Arch
)
1872 return self
._MakeFileDir
1874 ## Return build command string
1876 # @retval string Build command string
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()
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:]]
1893 self
._BuildCommand
.append(Flags
)
1894 return self
._BuildCommand
1896 ## Get tool chain definition
1898 # Get each tool defition for given tool chain from tools_def.txt and platform
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
= {}
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
:
1913 Value
= ToolDefinition
[Def
]
1914 # don't record the DLL
1916 DllPathList
.add(Value
)
1919 if Tool
not in self
._ToolDefinitions
:
1920 self
._ToolDefinitions
[Tool
] = {}
1921 self
._ToolDefinitions
[Tool
][Attr
] = Value
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"
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:]
1938 Value
+= " " + self
.BuildOption
[Tool
][Attr
]
1940 Value
= self
.BuildOption
[Tool
][Attr
]
1943 # Don't put MAKE definition in the file
1945 ToolsDef
+= "%s = %s\n" % (Tool
, Value
)
1947 # Don't put MAKE definition in the file
1952 ToolsDef
+= "%s_%s = %s\n" % (Tool
, Attr
, Value
)
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
1960 return self
._ToolDefinitions
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
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." \
1977 self
._ToolChainFamily
= "MSFT"
1979 self
._ToolChainFamily
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
.ToolChain
]
1980 return self
._ToolChainFamily
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." \
1990 self
._BuildRuleFamily
= "MSFT"
1992 self
._BuildRuleFamily
= ToolDefinition
[TAB_TOD_DEFINES_BUILDRULEFAMILY
][self
.ToolChain
]
1993 return self
._BuildRuleFamily
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
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
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
2013 ## Parse build_rule.txt in Conf Directory.
2015 # @retval BuildRule object
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
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
))
2034 return self
._BuildRule
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
2046 for ModuleFile
in self
._AsBuildModuleList
:
2047 if ModuleFile
in self
.Platform
.Modules
:
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
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
2061 ## Get list of non-dynamic PCDs
2062 def _GetNonDynamicPcdList(self
):
2063 if self
._NonDynamicPcdList
is None:
2064 self
.CollectPlatformDynamicPcds()
2065 return self
._NonDynamicPcdList
2067 ## Get list of dynamic PCDs
2068 def _GetDynamicPcdList(self
):
2069 if self
._DynamicPcdList
is None:
2070 self
.CollectPlatformDynamicPcds()
2071 return self
._DynamicPcdList
2073 ## Generate Token Number for all PCD
2074 def _GetPcdTokenNumbers(self
):
2075 if self
._PcdTokenNumber
is None:
2076 self
._PcdTokenNumber
= OrderedDict()
2079 # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.
2083 # TokenNumber 0 ~ 10
2085 # TokeNumber 11 ~ 20
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
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
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
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
2111 for Pcd
in self
.NonDynamicPcdList
:
2112 self
._PcdTokenNumber
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2114 return self
._PcdTokenNumber
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
:
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
)
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
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
2149 ## Test if a module is supported by the platform
2151 # An error will be raised directly if the module or its arch is not supported
2152 # by the platform or current configuration
2154 def ValidModule(self
, Module
):
2155 return Module
in self
.Platform
.Modules
or Module
in self
.Platform
.LibraryInstances \
2156 or Module
in self
._AsBuildModuleList
2158 ## Resolve the library classes in a module to library instances
2160 # This method will not only resolve library classes but also sort the library
2161 # instances according to the dependency-ship.
2163 # @param Module The module from which the library classes will be resolved
2165 # @retval library_list List of library instances sorted
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
:
2172 return GetModuleLibInstances(Module
,
2181 ## Override PCD setting (type, value, ...)
2183 # @param ToPcd The PCD to be overrided
2184 # @param FromPcd The PCD overrideing from
2186 def _OverridePcd(self
, ToPcd
, FromPcd
, Module
="", Msg
="", Library
=""):
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
2192 TokenCName
= ToPcd
.TokenCName
2193 for PcdItem
in GlobalData
.MixedPcd
:
2194 if (ToPcd
.TokenCName
, ToPcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
2195 TokenCName
= PcdItem
[0]
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
:
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
),
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
:
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
),
2233 # check the validation of datum
2234 IsValid
, Cause
= CheckPcdDatum(ToPcd
.DatumType
, ToPcd
.DefaultValue
)
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
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
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(',')))
2253 ToPcd
.MaxDatumSize
= str(len(Value
) - 1)
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
2261 SkuName
= TAB_DEFAULT
2262 ToPcd
.SkuInfoList
= {
2263 SkuName
: SkuInfoClass(SkuName
, self
.Platform
.SkuIds
[SkuName
][0], '', '', '', '', '', ToPcd
.DefaultValue
)
2266 ## Apply PCD setting defined platform to a module
2268 # @param Module The module from which the PCD setting will be overrided
2270 # @retval PCD_list The list PCDs with settings from platform
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
]
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
)
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
)),
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
:
2307 elif Key
in GlobalData
.MixedPcd
:
2308 for PcdItem
in GlobalData
.MixedPcd
[Key
]:
2310 ToPcd
= Pcds
[PcdItem
]
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
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(',')))
2328 Pcd
.MaxDatumSize
= str(len(Value
) - 1)
2329 return Pcds
.values()
2331 ## Resolve library names to library modules
2333 # (for Edk.x modules)
2335 # @param Module The module from which the library names will be resolved
2337 # @retval library_list The list of library modules
2339 def ResolveLibraryReference(self
, Module
):
2340 EdkLogger
.verbose("")
2341 EdkLogger
.verbose("Library instances of module [%s] [%s]:" % (str(Module
), self
.Arch
))
2342 LibraryConsumerList
= [Module
]
2344 # "CompilerStub" is a must for Edk modules
2345 if Module
.Libraries
:
2346 Module
.Libraries
.append("CompilerStub")
2348 while len(LibraryConsumerList
) > 0:
2349 M
= LibraryConsumerList
.pop()
2350 for LibraryName
in M
.Libraries
:
2351 Library
= self
.Platform
.LibraryClasses
[LibraryName
, ':dummy:']
2353 for Key
in self
.Platform
.LibraryClasses
.data
:
2354 if LibraryName
.upper() == Key
.upper():
2355 Library
= self
.Platform
.LibraryClasses
[Key
, ':dummy:']
2358 EdkLogger
.warn("build", "Library [%s] is not found" % LibraryName
, File
=str(M
),
2359 ExtraData
="\t%s [%s]" % (str(Module
), self
.Arch
))
2362 if Library
not in LibraryList
:
2363 LibraryList
.append(Library
)
2364 LibraryConsumerList
.append(Library
)
2365 EdkLogger
.verbose("\t" + LibraryName
+ " : " + str(Library
) + ' ' + str(type(Library
)))
2368 ## Calculate the priority value of the build option
2370 # @param Key Build option definition contain: TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
2372 # @retval Value Priority value based on the priority list.
2374 def CalculatePriorityValue(self
, Key
):
2375 Target
, ToolChain
, Arch
, CommandType
, Attr
= Key
.split('_')
2376 PriorityValue
= 0x11111
2378 PriorityValue
&= 0x01111
2379 if ToolChain
== "*":
2380 PriorityValue
&= 0x10111
2382 PriorityValue
&= 0x11011
2383 if CommandType
== "*":
2384 PriorityValue
&= 0x11101
2386 PriorityValue
&= 0x11110
2388 return self
.PrioList
["0x%0.5x" % PriorityValue
]
2391 ## Expand * in build option key
2393 # @param Options Options to be expanded
2395 # @retval options Options expanded
2397 def _ExpandBuildOption(self
, Options
, ModuleStyle
=None):
2404 # Construct a list contain the build options which need override.
2408 # Key[0] -- tool family
2409 # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
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("="):
2419 if OverrideList
.get(Key
[1]) is not None:
2420 OverrideList
.pop(Key
[1])
2421 OverrideList
[Key
[1]] = Options
[Key
]
2424 # Use the highest priority value.
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]
2434 # Compare two Key, if one is included by another, choose the higher priority one
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
== "*"):
2443 if self
.CalculatePriorityValue(NowKey
) > self
.CalculatePriorityValue(NextKey
):
2444 if Options
.get((self
.BuildRuleFamily
, NextKey
)) is not None:
2445 Options
.pop((self
.BuildRuleFamily
, NextKey
))
2447 if Options
.get((self
.BuildRuleFamily
, NowKey
)) is not None:
2448 Options
.pop((self
.BuildRuleFamily
, NowKey
))
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
:
2456 elif ModuleStyle
== EDKII_NAME
and Key
[2] != EDKII_NAME
:
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
]:
2466 elif Family
!= self
.ToolDefinition
[Tool
][TAB_TOD_DEFINES_FAMILY
]:
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
]
2478 # append options for the same tool except PATH
2480 BuildOptions
[Tool
][Attr
] += " " + Options
[Key
]
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
:
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
:
2493 elif ModuleStyle
== EDKII_NAME
and Key
[2] != EDKII_NAME
:
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
== "":
2500 # option has been added before
2501 if Family
!= self
.ToolDefinition
[Tool
][TAB_TOD_DEFINES_FAMILY
]:
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
]
2513 # append options for the same tool except PATH
2515 BuildOptions
[Tool
][Attr
] += " " + Options
[Key
]
2517 BuildOptions
[Tool
][Attr
] = Options
[Key
]
2520 ## Append build options in platform to a module
2522 # @param Module The module to which the build options will be appened
2524 # @retval options The options appended with build options in platform
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
)
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
)
2540 PlatformModuleOptions
= {}
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
]
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
:
2557 for Attr
in Options
[Tool
]:
2559 # Do not generate it in Makefile
2561 if Attr
== TAB_TOD_DEFINES_BUILDRULEORDER
:
2563 Value
= Options
[Tool
][Attr
]
2564 # check if override is indicated
2565 if Value
.startswith('='):
2566 BuildOptions
[Tool
][Attr
] = mws
.handleWsMacro(Value
[1:])
2569 BuildOptions
[Tool
][Attr
] += " " + mws
.handleWsMacro(Value
)
2571 BuildOptions
[Tool
][Attr
] = mws
.handleWsMacro(Value
)
2573 if Module
.AutoGenVersion
< 0x00010005 and self
.Workspace
.UniFlag
is not None:
2575 # Override UNI flag only for EDK module.
2577 BuildOptions
['BUILD']['FLAGS'] = self
.Workspace
.UniFlag
2578 return BuildOptions
, BuildRuleOrder
2580 Platform
= property(_GetPlatform
)
2581 Name
= property(_GetName
)
2582 Guid
= property(_GetGuid
)
2583 Version
= property(_GetVersion
)
2585 OutputDir
= property(_GetOutputDir
)
2586 BuildDir
= property(_GetBuildDir
)
2587 MakeFileDir
= property(_GetMakeFileDir
)
2588 FdfFile
= property(_GetFdfFile
)
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
)
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
2604 BuildCommand
= property(_GetBuildCommand
)
2605 BuildRule
= property(_GetBuildRule
)
2606 ModuleAutoGenList
= property(_GetModuleAutoGenList
)
2607 LibraryAutoGenList
= property(_GetLibraryAutoGenList
)
2608 GenFdsCommand
= property(_GenFdsCommand
)
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
2614 def ExtendCopyDictionaryLists(CopyToDict
, CopyFromDict
):
2615 for Key
in CopyFromDict
:
2616 CopyToDict
[Key
].extend(CopyFromDict
[Key
])
2619 ## ModuleAutoGen class
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.
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
):
2631 super(ModuleAutoGen
, self
).__init
__(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
2632 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
)
2635 ## Cache the timestamps of metafiles of every module in a class variable
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" \
2648 ## Initialize ModuleAutoGen
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
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
)
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
)
2667 self
.SourceDir
= self
.MetaFile
.SubDir
2668 self
.SourceDir
= mws
.relpath(self
.SourceDir
, self
.WorkspaceDir
)
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
]
2675 self
.ToolChain
= Toolchain
2676 self
.BuildTarget
= Target
2678 self
.ToolChainFamily
= self
.PlatformInfo
.ToolChainFamily
2679 self
.BuildRuleFamily
= self
.PlatformInfo
.BuildRuleFamily
2681 self
.IsMakeFileCreated
= False
2682 self
.IsCodeFileCreated
= False
2683 self
.IsAsBuiltInfCreated
= False
2684 self
.DepexGenerated
= False
2686 self
.BuildDatabase
= self
.Workspace
.BuildDatabase
2687 self
.BuildRuleOrder
= 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
2702 self
._BuildDir
= None
2703 self
._OutputDir
= None
2704 self
._FfsOutputDir
= None
2705 self
._DebugDir
= None
2706 self
._MakeFileDir
= None
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
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
2741 self
._TimeStampPath
= None
2743 self
.AutoGenDepSet
= set()
2746 ## The Modules referenced to this Library
2747 # Only Library has this attribute
2748 self
._ReferenceModules
= []
2750 ## Store the FixedAtBuild Pcds
2752 self
._FixedAtBuildPcds
= []
2755 ##Store the VOID* type FixedAtBuild Pcds
2757 self
._FixedPcdVoidTypeDict
= {}
2760 return "%s [%s]" % (self
.MetaFile
, self
.Arch
)
2762 # Get FixedAtBuild Pcds of this Module
2763 def _GetFixedAtBuildPcds(self
):
2764 if self
._FixedAtBuildPcds
:
2765 return self
._FixedAtBuildPcds
2766 for Pcd
in self
.ModulePcdList
:
2767 if Pcd
.Type
!= TAB_PCDS_FIXED_AT_BUILD
:
2769 if Pcd
not in self
._FixedAtBuildPcds
:
2770 self
._FixedAtBuildPcds
.append(Pcd
)
2772 return self
._FixedAtBuildPcds
2774 def _GetFixedAtBuildVoidTypePcds(self
):
2775 if self
._FixedPcdVoidTypeDict
:
2776 return self
._FixedPcdVoidTypeDict
2777 for Pcd
in self
.ModulePcdList
:
2778 if Pcd
.Type
== TAB_PCDS_FIXED_AT_BUILD
and Pcd
.DatumType
== TAB_VOID
:
2779 if '{}.{}'.format(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) not in self
._FixedPcdVoidTypeDict
:
2780 self
._FixedPcdVoidTypeDict
['{}.{}'.format(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)] = Pcd
.DefaultValue
2781 return self
._FixedPcdVoidTypeDict
2783 def _GetUniqueBaseName(self
):
2784 BaseName
= self
.Name
2785 for Module
in self
.PlatformInfo
.ModuleAutoGenList
:
2786 if Module
.MetaFile
== self
.MetaFile
:
2788 if Module
.Name
== self
.Name
:
2789 if uuid
.UUID(Module
.Guid
) == uuid
.UUID(self
.Guid
):
2790 EdkLogger
.error("build", FILE_DUPLICATED
, 'Modules have same BaseName and FILE_GUID:\n'
2791 ' %s\n %s' % (Module
.MetaFile
, self
.MetaFile
))
2792 BaseName
= '%s_%s' % (self
.Name
, self
.Guid
)
2795 # Macros could be used in build_rule.txt (also Makefile)
2796 def _GetMacros(self
):
2797 if self
._Macro
is None:
2798 self
._Macro
= OrderedDict()
2799 self
._Macro
["WORKSPACE" ] = self
.WorkspaceDir
2800 self
._Macro
["MODULE_NAME" ] = self
.Name
2801 self
._Macro
["MODULE_NAME_GUID" ] = self
.UniqueBaseName
2802 self
._Macro
["MODULE_GUID" ] = self
.Guid
2803 self
._Macro
["MODULE_VERSION" ] = self
.Version
2804 self
._Macro
["MODULE_TYPE" ] = self
.ModuleType
2805 self
._Macro
["MODULE_FILE" ] = str(self
.MetaFile
)
2806 self
._Macro
["MODULE_FILE_BASE_NAME" ] = self
.MetaFile
.BaseName
2807 self
._Macro
["MODULE_RELATIVE_DIR" ] = self
.SourceDir
2808 self
._Macro
["MODULE_DIR" ] = self
.SourceDir
2810 self
._Macro
["BASE_NAME" ] = self
.Name
2812 self
._Macro
["ARCH" ] = self
.Arch
2813 self
._Macro
["TOOLCHAIN" ] = self
.ToolChain
2814 self
._Macro
["TOOLCHAIN_TAG" ] = self
.ToolChain
2815 self
._Macro
["TOOL_CHAIN_TAG" ] = self
.ToolChain
2816 self
._Macro
["TARGET" ] = self
.BuildTarget
2818 self
._Macro
["BUILD_DIR" ] = self
.PlatformInfo
.BuildDir
2819 self
._Macro
["BIN_DIR" ] = os
.path
.join(self
.PlatformInfo
.BuildDir
, self
.Arch
)
2820 self
._Macro
["LIB_DIR" ] = os
.path
.join(self
.PlatformInfo
.BuildDir
, self
.Arch
)
2821 self
._Macro
["MODULE_BUILD_DIR" ] = self
.BuildDir
2822 self
._Macro
["OUTPUT_DIR" ] = self
.OutputDir
2823 self
._Macro
["DEBUG_DIR" ] = self
.DebugDir
2824 self
._Macro
["DEST_DIR_OUTPUT" ] = self
.OutputDir
2825 self
._Macro
["DEST_DIR_DEBUG" ] = self
.DebugDir
2826 self
._Macro
["PLATFORM_NAME" ] = self
.PlatformInfo
.Name
2827 self
._Macro
["PLATFORM_GUID" ] = self
.PlatformInfo
.Guid
2828 self
._Macro
["PLATFORM_VERSION" ] = self
.PlatformInfo
.Version
2829 self
._Macro
["PLATFORM_RELATIVE_DIR" ] = self
.PlatformInfo
.SourceDir
2830 self
._Macro
["PLATFORM_DIR" ] = mws
.join(self
.WorkspaceDir
, self
.PlatformInfo
.SourceDir
)
2831 self
._Macro
["PLATFORM_OUTPUT_DIR" ] = self
.PlatformInfo
.OutputDir
2832 self
._Macro
["FFS_OUTPUT_DIR" ] = self
.FfsOutputDir
2835 ## Return the module build data object
2836 def _GetModule(self
):
2837 if self
._Module
is None:
2838 self
._Module
= self
.Workspace
.BuildDatabase
[self
.MetaFile
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
2841 ## Return the module name
2842 def _GetBaseName(self
):
2843 return self
.Module
.BaseName
2845 ## Return the module DxsFile if exist
2846 def _GetDxsFile(self
):
2847 return self
.Module
.DxsFile
2849 ## Return the module SourceOverridePath
2850 def _GetSourceOverridePath(self
):
2851 return self
.Module
.SourceOverridePath
2853 ## Return the module meta-file GUID
2856 # To build same module more than once, the module path with FILE_GUID overridden has
2857 # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the realy path
2858 # in DSC. The overridden GUID can be retrieved from file name
2860 if os
.path
.basename(self
.MetaFile
.File
) != os
.path
.basename(self
.MetaFile
.Path
):
2862 # Length of GUID is 36
2864 return os
.path
.basename(self
.MetaFile
.Path
)[:36]
2865 return self
.Module
.Guid
2867 ## Return the module version
2868 def _GetVersion(self
):
2869 return self
.Module
.Version
2871 ## Return the module type
2872 def _GetModuleType(self
):
2873 return self
.Module
.ModuleType
2875 ## Return the component type (for Edk.x style of module)
2876 def _GetComponentType(self
):
2877 return self
.Module
.ComponentType
2879 ## Return the build type
2880 def _GetBuildType(self
):
2881 return self
.Module
.BuildType
2883 ## Return the PCD_IS_DRIVER setting
2884 def _GetPcdIsDriver(self
):
2885 return self
.Module
.PcdIsDriver
2887 ## Return the autogen version, i.e. module meta-file version
2888 def _GetAutoGenVersion(self
):
2889 return self
.Module
.AutoGenVersion
2891 ## Check if the module is library or not
2892 def _IsLibrary(self
):
2893 if self
._LibraryFlag
is None:
2894 self
._LibraryFlag
= True if self
.Module
.LibraryClass
else False
2895 return self
._LibraryFlag
2897 ## Check if the module is binary module or not
2898 def _IsBinaryModule(self
):
2899 return self
.Module
.IsBinaryModule
2901 ## Return the directory to store intermediate files of the module
2902 def _GetBuildDir(self
):
2903 if self
._BuildDir
is None:
2904 self
._BuildDir
= path
.join(
2905 self
.PlatformInfo
.BuildDir
,
2908 self
.MetaFile
.BaseName
2910 CreateDirectory(self
._BuildDir
)
2911 return self
._BuildDir
2913 ## Return the directory to store the intermediate object files of the mdoule
2914 def _GetOutputDir(self
):
2915 if self
._OutputDir
is None:
2916 self
._OutputDir
= path
.join(self
.BuildDir
, "OUTPUT")
2917 CreateDirectory(self
._OutputDir
)
2918 return self
._OutputDir
2920 ## Return the directory to store ffs file
2921 def _GetFfsOutputDir(self
):
2922 if self
._FfsOutputDir
is None:
2923 if GlobalData
.gFdfParser
is not None:
2924 self
._FfsOutputDir
= path
.join(self
.PlatformInfo
.BuildDir
, TAB_FV_DIRECTORY
, "Ffs", self
.Guid
+ self
.Name
)
2926 self
._FfsOutputDir
= ''
2927 return self
._FfsOutputDir
2929 ## Return the directory to store auto-gened source files of the mdoule
2930 def _GetDebugDir(self
):
2931 if self
._DebugDir
is None:
2932 self
._DebugDir
= path
.join(self
.BuildDir
, "DEBUG")
2933 CreateDirectory(self
._DebugDir
)
2934 return self
._DebugDir
2936 ## Return the path of custom file
2937 def _GetCustomMakefile(self
):
2938 if self
._CustomMakefile
is None:
2939 self
._CustomMakefile
= {}
2940 for Type
in self
.Module
.CustomMakefile
:
2941 if Type
in gMakeTypeMap
:
2942 MakeType
= gMakeTypeMap
[Type
]
2945 if self
.SourceOverrideDir
is not None:
2946 File
= os
.path
.join(self
.SourceOverrideDir
, self
.Module
.CustomMakefile
[Type
])
2947 if not os
.path
.exists(File
):
2948 File
= os
.path
.join(self
.SourceDir
, self
.Module
.CustomMakefile
[Type
])
2950 File
= os
.path
.join(self
.SourceDir
, self
.Module
.CustomMakefile
[Type
])
2951 self
._CustomMakefile
[MakeType
] = File
2952 return self
._CustomMakefile
2954 ## Return the directory of the makefile
2956 # @retval string The directory string of module's makefile
2958 def _GetMakeFileDir(self
):
2959 return self
.BuildDir
2961 ## Return build command string
2963 # @retval string Build command string
2965 def _GetBuildCommand(self
):
2966 return self
.PlatformInfo
.BuildCommand
2968 ## Get object list of all packages the module and its dependent libraries belong to
2970 # @retval list The list of package object
2972 def _GetDerivedPackageList(self
):
2974 for M
in [self
.Module
] + self
.DependentLibraryList
:
2975 for Package
in M
.Packages
:
2976 if Package
in PackageList
:
2978 PackageList
.append(Package
)
2981 ## Get the depex string
2983 # @return : a string contain all depex expresion.
2984 def _GetDepexExpresionString(self
):
2987 ## DPX_SOURCE IN Define section.
2988 if self
.Module
.DxsFile
:
2990 for M
in [self
.Module
] + self
.DependentLibraryList
:
2991 Filename
= M
.MetaFile
.Path
2992 InfObj
= InfSectionParser
.InfSectionParser(Filename
)
2993 DepexExpresionList
= InfObj
.GetDepexExpresionList()
2994 for DepexExpresion
in DepexExpresionList
:
2995 for key
in DepexExpresion
:
2996 Arch
, ModuleType
= key
2997 DepexExpr
= [x
for x
in DepexExpresion
[key
] if not str(x
).startswith('#')]
2998 # the type of build module is USER_DEFINED.
2999 # All different DEPEX section tags would be copied into the As Built INF file
3000 # and there would be separate DEPEX section tags
3001 if self
.ModuleType
.upper() == SUP_MODULE_USER_DEFINED
:
3002 if (Arch
.upper() == self
.Arch
.upper()) and (ModuleType
.upper() != TAB_ARCH_COMMON
):
3003 DepexList
.append({(Arch
, ModuleType
): DepexExpr
})
3005 if Arch
.upper() == TAB_ARCH_COMMON
or \
3006 (Arch
.upper() == self
.Arch
.upper() and \
3007 ModuleType
.upper() in [TAB_ARCH_COMMON
, self
.ModuleType
.upper()]):
3008 DepexList
.append({(Arch
, ModuleType
): DepexExpr
})
3010 #the type of build module is USER_DEFINED.
3011 if self
.ModuleType
.upper() == SUP_MODULE_USER_DEFINED
:
3012 for Depex
in DepexList
:
3014 DepexStr
+= '[Depex.%s.%s]\n' % key
3015 DepexStr
+= '\n'.join('# '+ val
for val
in Depex
[key
])
3018 return '[Depex.%s]\n' % self
.Arch
3021 #the type of build module not is USER_DEFINED.
3023 for Depex
in DepexList
:
3028 for D
in Depex
.values():
3029 DepexStr
+= ' '.join(val
for val
in D
)
3030 Index
= DepexStr
.find('END')
3031 if Index
> -1 and Index
== len(DepexStr
) - 3:
3032 DepexStr
= DepexStr
[:-3]
3033 DepexStr
= DepexStr
.strip()
3036 DepexStr
= DepexStr
.lstrip('(').rstrip(')').strip()
3038 return '[Depex.%s]\n' % self
.Arch
3039 return '[Depex.%s]\n# ' % self
.Arch
+ DepexStr
3041 ## Merge dependency expression
3043 # @retval list The token list of the dependency expression after parsed
3045 def _GetDepexTokenList(self
):
3046 if self
._DepexDict
is None:
3047 self
._DepexDict
= {}
3048 if self
.DxsFile
or self
.IsLibrary
or TAB_DEPENDENCY_EXPRESSION_FILE
in self
.FileTypes
:
3049 return self
._DepexDict
3051 self
._DepexDict
[self
.ModuleType
] = []
3052 self
._GetFixedAtBuildVoidTypePcds
()
3053 for ModuleType
in self
._DepexDict
:
3054 DepexList
= self
._DepexDict
[ModuleType
]
3056 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
3058 for M
in [self
.Module
] + self
.DependentLibraryList
:
3060 for D
in M
.Depex
[self
.Arch
, ModuleType
]:
3062 DepexList
.append('AND')
3063 DepexList
.append('(')
3064 #replace D with value if D is FixedAtBuild PCD
3068 NewList
.append(item
)
3070 if item
not in self
._FixedPcdVoidTypeDict
:
3071 EdkLogger
.error("build", FORMAT_INVALID
, "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type in the module.".format(item
))
3073 Value
= self
._FixedPcdVoidTypeDict
[item
]
3074 if len(Value
.split(',')) != 16:
3075 EdkLogger
.error("build", FORMAT_INVALID
,
3076 "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type and 16 bytes in the module.".format(item
))
3077 NewList
.append(Value
)
3078 DepexList
.extend(NewList
)
3079 if DepexList
[-1] == 'END': # no need of a END at this time
3081 DepexList
.append(')')
3084 EdkLogger
.verbose("DEPEX[%s] (+%s) = %s" % (self
.Name
, M
.BaseName
, DepexList
))
3085 if 'BEFORE' in DepexList
or 'AFTER' in DepexList
:
3087 if len(DepexList
) > 0:
3088 EdkLogger
.verbose('')
3089 return self
._DepexDict
3091 ## Merge dependency expression
3093 # @retval list The token list of the dependency expression after parsed
3095 def _GetDepexExpressionTokenList(self
):
3096 if self
._DepexExpressionDict
is None:
3097 self
._DepexExpressionDict
= {}
3098 if self
.DxsFile
or self
.IsLibrary
or TAB_DEPENDENCY_EXPRESSION_FILE
in self
.FileTypes
:
3099 return self
._DepexExpressionDict
3101 self
._DepexExpressionDict
[self
.ModuleType
] = ''
3103 for ModuleType
in self
._DepexExpressionDict
:
3104 DepexExpressionString
= self
._DepexExpressionDict
[ModuleType
]
3106 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
3108 for M
in [self
.Module
] + self
.DependentLibraryList
:
3110 for D
in M
.DepexExpression
[self
.Arch
, ModuleType
]:
3111 if DepexExpressionString
!= '':
3112 DepexExpressionString
+= ' AND '
3113 DepexExpressionString
+= '('
3114 DepexExpressionString
+= D
3115 DepexExpressionString
= DepexExpressionString
.rstrip('END').strip()
3116 DepexExpressionString
+= ')'
3119 EdkLogger
.verbose("DEPEX[%s] (+%s) = %s" % (self
.Name
, M
.BaseName
, DepexExpressionString
))
3120 if 'BEFORE' in DepexExpressionString
or 'AFTER' in DepexExpressionString
:
3122 if len(DepexExpressionString
) > 0:
3123 EdkLogger
.verbose('')
3124 self
._DepexExpressionDict
[ModuleType
] = DepexExpressionString
3125 return self
._DepexExpressionDict
3127 # Get the tiano core user extension, it is contain dependent library.
3128 # @retval: a list contain tiano core userextension.
3130 def _GetTianoCoreUserExtensionList(self
):
3131 TianoCoreUserExtentionList
= []
3132 for M
in [self
.Module
] + self
.DependentLibraryList
:
3133 Filename
= M
.MetaFile
.Path
3134 InfObj
= InfSectionParser
.InfSectionParser(Filename
)
3135 TianoCoreUserExtenList
= InfObj
.GetUserExtensionTianoCore()
3136 for TianoCoreUserExtent
in TianoCoreUserExtenList
:
3137 for Section
in TianoCoreUserExtent
:
3138 ItemList
= Section
.split(TAB_SPLIT
)
3140 if len(ItemList
) == 4:
3142 if Arch
.upper() == TAB_ARCH_COMMON
or Arch
.upper() == self
.Arch
.upper():
3144 TianoCoreList
.extend([TAB_SECTION_START
+ Section
+ TAB_SECTION_END
])
3145 TianoCoreList
.extend(TianoCoreUserExtent
[Section
][:])
3146 TianoCoreList
.append('\n')
3147 TianoCoreUserExtentionList
.append(TianoCoreList
)
3149 return TianoCoreUserExtentionList
3151 ## Return the list of specification version required for the module
3153 # @retval list The list of specification defined in module file
3155 def _GetSpecification(self
):
3156 return self
.Module
.Specification
3158 ## Tool option for the module build
3160 # @param PlatformInfo The object of PlatformBuildInfo
3161 # @retval dict The dict containing valid options
3163 def _GetModuleBuildOption(self
):
3164 if self
._BuildOption
is None:
3165 self
._BuildOption
, self
.BuildRuleOrder
= self
.PlatformInfo
.ApplyBuildOption(self
.Module
)
3166 if self
.BuildRuleOrder
:
3167 self
.BuildRuleOrder
= ['.%s' % Ext
for Ext
in self
.BuildRuleOrder
.split()]
3168 return self
._BuildOption
3170 ## Get include path list from tool option for the module build
3172 # @retval list The include path list
3174 def _GetBuildOptionIncPathList(self
):
3175 if self
._BuildOptionIncPathList
is None:
3177 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
3178 # is the former use /I , the Latter used -I to specify include directories
3180 if self
.PlatformInfo
.ToolChainFamily
in ('MSFT'):
3181 BuildOptIncludeRegEx
= gBuildOptIncludePatternMsft
3182 elif self
.PlatformInfo
.ToolChainFamily
in ('INTEL', 'GCC', 'RVCT'):
3183 BuildOptIncludeRegEx
= gBuildOptIncludePatternOther
3186 # New ToolChainFamily, don't known whether there is option to specify include directories
3188 self
._BuildOptionIncPathList
= []
3189 return self
._BuildOptionIncPathList
3191 BuildOptionIncPathList
= []
3192 for Tool
in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):
3194 FlagOption
= self
.BuildOption
[Tool
]['FLAGS']
3198 if self
.PlatformInfo
.ToolChainFamily
!= 'RVCT':
3199 IncPathList
= [NormPath(Path
, self
.Macros
) for Path
in BuildOptIncludeRegEx
.findall(FlagOption
)]
3202 # RVCT may specify a list of directory seperated by commas
3205 for Path
in BuildOptIncludeRegEx
.findall(FlagOption
):
3206 PathList
= GetSplitList(Path
, TAB_COMMA_SPLIT
)
3207 IncPathList
.extend(NormPath(PathEntry
, self
.Macros
) for PathEntry
in PathList
)
3210 # EDK II modules must not reference header files outside of the packages they depend on or
3211 # within the module's directory tree. Report error if violation.
3213 if self
.AutoGenVersion
>= 0x00010005:
3214 for Path
in IncPathList
:
3215 if (Path
not in self
.IncludePathList
) and (CommonPath([Path
, self
.MetaFile
.Dir
]) != self
.MetaFile
.Dir
):
3216 ErrMsg
= "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path
, Tool
, FlagOption
)
3217 EdkLogger
.error("build",
3220 File
=str(self
.MetaFile
))
3223 BuildOptionIncPathList
+= IncPathList
3225 self
._BuildOptionIncPathList
= BuildOptionIncPathList
3227 return self
._BuildOptionIncPathList
3229 ## Return a list of files which can be built from source
3231 # What kind of files can be built is determined by build rules in
3232 # $(CONF_DIRECTORY)/build_rule.txt and toolchain family.
3234 def _GetSourceFileList(self
):
3235 if self
._SourceFileList
is None:
3236 self
._SourceFileList
= []
3237 ToolChainTagSet
= {"", "*", self
.ToolChain
}
3238 ToolChainFamilySet
= {"", "*", self
.ToolChainFamily
, self
.BuildRuleFamily
}
3239 for F
in self
.Module
.Sources
:
3241 if F
.TagName
not in ToolChainTagSet
:
3242 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "The toolchain [%s] for processing file [%s] is found, "
3243 "but [%s] is needed" % (F
.TagName
, str(F
), self
.ToolChain
))
3245 # match tool chain family or build rule family
3246 if F
.ToolChainFamily
not in ToolChainFamilySet
:
3249 "The file [%s] must be built by tools of [%s], " \
3250 "but current toolchain family is [%s], buildrule family is [%s]" \
3251 % (str(F
), F
.ToolChainFamily
, self
.ToolChainFamily
, self
.BuildRuleFamily
))
3254 # add the file path into search path list for file including
3255 if F
.Dir
not in self
.IncludePathList
and self
.AutoGenVersion
>= 0x00010005:
3256 self
.IncludePathList
.insert(0, F
.Dir
)
3257 self
._SourceFileList
.append(F
)
3259 self
._MatchBuildRuleOrder
(self
._SourceFileList
)
3261 for F
in self
._SourceFileList
:
3262 self
._ApplyBuildRule
(F
, TAB_UNKNOWN_FILE
)
3263 return self
._SourceFileList
3265 def _MatchBuildRuleOrder(self
, FileList
):
3267 self
._GetModuleBuildOption
()
3268 for SingleFile
in FileList
:
3269 if self
.BuildRuleOrder
and SingleFile
.Ext
in self
.BuildRuleOrder
and SingleFile
.Ext
in self
.BuildRules
:
3270 key
= SingleFile
.Path
.split(SingleFile
.Ext
)[0]
3271 if key
in Order_Dict
:
3272 Order_Dict
[key
].append(SingleFile
.Ext
)
3274 Order_Dict
[key
] = [SingleFile
.Ext
]
3277 for F
in Order_Dict
:
3278 if len(Order_Dict
[F
]) > 1:
3279 Order_Dict
[F
].sort(key
=lambda i
: self
.BuildRuleOrder
.index(i
))
3280 for Ext
in Order_Dict
[F
][1:]:
3281 RemoveList
.append(F
+ Ext
)
3283 for item
in RemoveList
:
3284 FileList
.remove(item
)
3288 ## Return the list of unicode files
3289 def _GetUnicodeFileList(self
):
3290 if self
._UnicodeFileList
is None:
3291 if TAB_UNICODE_FILE
in self
.FileTypes
:
3292 self
._UnicodeFileList
= self
.FileTypes
[TAB_UNICODE_FILE
]
3294 self
._UnicodeFileList
= []
3295 return self
._UnicodeFileList
3297 ## Return the list of vfr files
3298 def _GetVfrFileList(self
):
3299 if self
._VfrFileList
is None:
3300 if TAB_VFR_FILE
in self
.FileTypes
:
3301 self
._VfrFileList
= self
.FileTypes
[TAB_VFR_FILE
]
3303 self
._VfrFileList
= []
3304 return self
._VfrFileList
3306 ## Return the list of Image Definition files
3307 def _GetIdfFileList(self
):
3308 if self
._IdfFileList
is None:
3309 if TAB_IMAGE_FILE
in self
.FileTypes
:
3310 self
._IdfFileList
= self
.FileTypes
[TAB_IMAGE_FILE
]
3312 self
._IdfFileList
= []
3313 return self
._IdfFileList
3315 ## Return a list of files which can be built from binary
3317 # "Build" binary files are just to copy them to build directory.
3319 # @retval list The list of files which can be built later
3321 def _GetBinaryFiles(self
):
3322 if self
._BinaryFileList
is None:
3323 self
._BinaryFileList
= []
3324 for F
in self
.Module
.Binaries
:
3325 if F
.Target
not in [TAB_ARCH_COMMON
, '*'] and F
.Target
!= self
.BuildTarget
:
3327 self
._BinaryFileList
.append(F
)
3328 self
._ApplyBuildRule
(F
, F
.Type
)
3329 return self
._BinaryFileList
3331 def _GetBuildRules(self
):
3332 if self
._BuildRules
is None:
3334 BuildRuleDatabase
= self
.PlatformInfo
.BuildRule
3335 for Type
in BuildRuleDatabase
.FileTypeList
:
3336 #first try getting build rule by BuildRuleFamily
3337 RuleObject
= BuildRuleDatabase
[Type
, self
.BuildType
, self
.Arch
, self
.BuildRuleFamily
]
3339 # build type is always module type, but ...
3340 if self
.ModuleType
!= self
.BuildType
:
3341 RuleObject
= BuildRuleDatabase
[Type
, self
.ModuleType
, self
.Arch
, self
.BuildRuleFamily
]
3342 #second try getting build rule by ToolChainFamily
3344 RuleObject
= BuildRuleDatabase
[Type
, self
.BuildType
, self
.Arch
, self
.ToolChainFamily
]
3346 # build type is always module type, but ...
3347 if self
.ModuleType
!= self
.BuildType
:
3348 RuleObject
= BuildRuleDatabase
[Type
, self
.ModuleType
, self
.Arch
, self
.ToolChainFamily
]
3351 RuleObject
= RuleObject
.Instantiate(self
.Macros
)
3352 BuildRules
[Type
] = RuleObject
3353 for Ext
in RuleObject
.SourceFileExtList
:
3354 BuildRules
[Ext
] = RuleObject
3355 self
._BuildRules
= BuildRules
3356 return self
._BuildRules
3358 def _ApplyBuildRule(self
, File
, FileType
):
3359 if self
._BuildTargets
is None:
3360 self
._IntroBuildTargetList
= set()
3361 self
._FinalBuildTargetList
= set()
3362 self
._BuildTargets
= defaultdict(set)
3363 self
._FileTypes
= defaultdict(set)
3365 SubDirectory
= os
.path
.join(self
.OutputDir
, File
.SubDir
)
3366 if not os
.path
.exists(SubDirectory
):
3367 CreateDirectory(SubDirectory
)
3373 # Make sure to get build rule order value
3375 self
._GetModuleBuildOption
()
3377 while Index
< len(SourceList
):
3378 Source
= SourceList
[Index
]
3382 CreateDirectory(Source
.Dir
)
3384 if File
.IsBinary
and File
== Source
and self
._BinaryFileList
is not None and File
in self
._BinaryFileList
:
3385 # Skip all files that are not binary libraries
3386 if not self
.IsLibrary
:
3388 RuleObject
= self
.BuildRules
[TAB_DEFAULT_BINARY_FILE
]
3389 elif FileType
in self
.BuildRules
:
3390 RuleObject
= self
.BuildRules
[FileType
]
3391 elif Source
.Ext
in self
.BuildRules
:
3392 RuleObject
= self
.BuildRules
[Source
.Ext
]
3394 # stop at no more rules
3396 self
._FinalBuildTargetList
.add(LastTarget
)
3399 FileType
= RuleObject
.SourceFileType
3400 self
._FileTypes
[FileType
].add(Source
)
3402 # stop at STATIC_LIBRARY for library
3403 if self
.IsLibrary
and FileType
== TAB_STATIC_LIBRARY
:
3405 self
._FinalBuildTargetList
.add(LastTarget
)
3408 Target
= RuleObject
.Apply(Source
, self
.BuildRuleOrder
)
3411 self
._FinalBuildTargetList
.add(LastTarget
)
3413 elif not Target
.Outputs
:
3414 # Only do build for target with outputs
3415 self
._FinalBuildTargetList
.add(Target
)
3417 self
._BuildTargets
[FileType
].add(Target
)
3419 if not Source
.IsBinary
and Source
== File
:
3420 self
._IntroBuildTargetList
.add(Target
)
3422 # to avoid cyclic rule
3423 if FileType
in RuleChain
:
3426 RuleChain
.add(FileType
)
3427 SourceList
.extend(Target
.Outputs
)
3429 FileType
= TAB_UNKNOWN_FILE
3431 def _GetTargets(self
):
3432 if self
._BuildTargets
is None:
3433 self
._IntroBuildTargetList
= set()
3434 self
._FinalBuildTargetList
= set()
3435 self
._BuildTargets
= defaultdict(set)
3436 self
._FileTypes
= defaultdict(set)
3438 #TRICK: call _GetSourceFileList to apply build rule for source files
3439 if self
.SourceFileList
:
3442 #TRICK: call _GetBinaryFileList to apply build rule for binary files
3443 if self
.BinaryFileList
:
3446 return self
._BuildTargets
3448 def _GetIntroTargetList(self
):
3450 return self
._IntroBuildTargetList
3452 def _GetFinalTargetList(self
):
3454 return self
._FinalBuildTargetList
3456 def _GetFileTypes(self
):
3458 return self
._FileTypes
3460 ## Get the list of package object the module depends on
3462 # @retval list The package object list
3464 def _GetDependentPackageList(self
):
3465 return self
.Module
.Packages
3467 ## Return the list of auto-generated code file
3469 # @retval list The list of auto-generated file
3471 def _GetAutoGenFileList(self
):
3472 UniStringAutoGenC
= True
3473 IdfStringAutoGenC
= True
3474 UniStringBinBuffer
= BytesIO()
3475 IdfGenBinBuffer
= BytesIO()
3476 if self
.BuildType
== 'UEFI_HII':
3477 UniStringAutoGenC
= False
3478 IdfStringAutoGenC
= False
3479 if self
._AutoGenFileList
is None:
3480 self
._AutoGenFileList
= {}
3481 AutoGenC
= TemplateString()
3482 AutoGenH
= TemplateString()
3483 StringH
= TemplateString()
3484 StringIdf
= TemplateString()
3485 GenC
.CreateCode(self
, AutoGenC
, AutoGenH
, StringH
, UniStringAutoGenC
, UniStringBinBuffer
, StringIdf
, IdfStringAutoGenC
, IdfGenBinBuffer
)
3487 # AutoGen.c is generated if there are library classes in inf, or there are object files
3489 if str(AutoGenC
) != "" and (len(self
.Module
.LibraryClasses
) > 0
3490 or TAB_OBJECT_FILE
in self
.FileTypes
):
3491 AutoFile
= PathClass(gAutoGenCodeFileName
, self
.DebugDir
)
3492 self
._AutoGenFileList
[AutoFile
] = str(AutoGenC
)
3493 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3494 if str(AutoGenH
) != "":
3495 AutoFile
= PathClass(gAutoGenHeaderFileName
, self
.DebugDir
)
3496 self
._AutoGenFileList
[AutoFile
] = str(AutoGenH
)
3497 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3498 if str(StringH
) != "":
3499 AutoFile
= PathClass(gAutoGenStringFileName
% {"module_name":self
.Name
}, self
.DebugDir
)
3500 self
._AutoGenFileList
[AutoFile
] = str(StringH
)
3501 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3502 if UniStringBinBuffer
is not None and UniStringBinBuffer
.getvalue() != "":
3503 AutoFile
= PathClass(gAutoGenStringFormFileName
% {"module_name":self
.Name
}, self
.OutputDir
)
3504 self
._AutoGenFileList
[AutoFile
] = UniStringBinBuffer
.getvalue()
3505 AutoFile
.IsBinary
= True
3506 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3507 if UniStringBinBuffer
is not None:
3508 UniStringBinBuffer
.close()
3509 if str(StringIdf
) != "":
3510 AutoFile
= PathClass(gAutoGenImageDefFileName
% {"module_name":self
.Name
}, self
.DebugDir
)
3511 self
._AutoGenFileList
[AutoFile
] = str(StringIdf
)
3512 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3513 if IdfGenBinBuffer
is not None and IdfGenBinBuffer
.getvalue() != "":
3514 AutoFile
= PathClass(gAutoGenIdfFileName
% {"module_name":self
.Name
}, self
.OutputDir
)
3515 self
._AutoGenFileList
[AutoFile
] = IdfGenBinBuffer
.getvalue()
3516 AutoFile
.IsBinary
= True
3517 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3518 if IdfGenBinBuffer
is not None:
3519 IdfGenBinBuffer
.close()
3520 return self
._AutoGenFileList
3522 ## Return the list of library modules explicitly or implicityly used by this module
3523 def _GetLibraryList(self
):
3524 if self
._DependentLibraryList
is None:
3525 # only merge library classes and PCD for non-library module
3527 self
._DependentLibraryList
= []
3529 if self
.AutoGenVersion
< 0x00010005:
3530 self
._DependentLibraryList
= self
.PlatformInfo
.ResolveLibraryReference(self
.Module
)
3532 self
._DependentLibraryList
= self
.PlatformInfo
.ApplyLibraryInstance(self
.Module
)
3533 return self
._DependentLibraryList
3535 ## Get the list of PCDs from current module
3537 # @retval list The list of PCD
3539 def _GetModulePcdList(self
):
3540 if self
._ModulePcdList
is None:
3541 # apply PCD settings from platform
3542 self
._ModulePcdList
= self
.PlatformInfo
.ApplyPcdSetting(self
.Module
, self
.Module
.Pcds
)
3543 ExtendCopyDictionaryLists(self
._PcdComments
, self
.Module
.PcdComments
)
3544 return self
._ModulePcdList
3546 ## Get the list of PCDs from dependent libraries
3548 # @retval list The list of PCD
3550 def _GetLibraryPcdList(self
):
3551 if self
._LibraryPcdList
is None:
3552 Pcds
= OrderedDict()
3553 if not self
.IsLibrary
:
3554 # get PCDs from dependent libraries
3555 self
._LibraryPcdList
= []
3556 for Library
in self
.DependentLibraryList
:
3557 PcdsInLibrary
= OrderedDict()
3558 ExtendCopyDictionaryLists(self
._PcdComments
, Library
.PcdComments
)
3559 for Key
in Library
.Pcds
:
3560 # skip duplicated PCDs
3561 if Key
in self
.Module
.Pcds
or Key
in Pcds
:
3563 Pcds
[Key
] = copy
.copy(Library
.Pcds
[Key
])
3564 PcdsInLibrary
[Key
] = Pcds
[Key
]
3565 self
._LibraryPcdList
.extend(self
.PlatformInfo
.ApplyPcdSetting(self
.Module
, PcdsInLibrary
, Library
=Library
))
3567 self
._LibraryPcdList
= []
3568 return self
._LibraryPcdList
3570 ## Get the GUID value mapping
3572 # @retval dict The mapping between GUID cname and its value
3574 def _GetGuidList(self
):
3575 if self
._GuidList
is None:
3576 self
._GuidList
= OrderedDict()
3577 self
._GuidList
.update(self
.Module
.Guids
)
3578 for Library
in self
.DependentLibraryList
:
3579 self
._GuidList
.update(Library
.Guids
)
3580 ExtendCopyDictionaryLists(self
._GuidComments
, Library
.GuidComments
)
3581 ExtendCopyDictionaryLists(self
._GuidComments
, self
.Module
.GuidComments
)
3582 return self
._GuidList
3584 def GetGuidsUsedByPcd(self
):
3585 if self
._GuidsUsedByPcd
is None:
3586 self
._GuidsUsedByPcd
= OrderedDict()
3587 self
._GuidsUsedByPcd
.update(self
.Module
.GetGuidsUsedByPcd())
3588 for Library
in self
.DependentLibraryList
:
3589 self
._GuidsUsedByPcd
.update(Library
.GetGuidsUsedByPcd())
3590 return self
._GuidsUsedByPcd
3591 ## Get the protocol value mapping
3593 # @retval dict The mapping between protocol cname and its value
3595 def _GetProtocolList(self
):
3596 if self
._ProtocolList
is None:
3597 self
._ProtocolList
= OrderedDict()
3598 self
._ProtocolList
.update(self
.Module
.Protocols
)
3599 for Library
in self
.DependentLibraryList
:
3600 self
._ProtocolList
.update(Library
.Protocols
)
3601 ExtendCopyDictionaryLists(self
._ProtocolComments
, Library
.ProtocolComments
)
3602 ExtendCopyDictionaryLists(self
._ProtocolComments
, self
.Module
.ProtocolComments
)
3603 return self
._ProtocolList
3605 ## Get the PPI value mapping
3607 # @retval dict The mapping between PPI cname and its value
3609 def _GetPpiList(self
):
3610 if self
._PpiList
is None:
3611 self
._PpiList
= OrderedDict()
3612 self
._PpiList
.update(self
.Module
.Ppis
)
3613 for Library
in self
.DependentLibraryList
:
3614 self
._PpiList
.update(Library
.Ppis
)
3615 ExtendCopyDictionaryLists(self
._PpiComments
, Library
.PpiComments
)
3616 ExtendCopyDictionaryLists(self
._PpiComments
, self
.Module
.PpiComments
)
3617 return self
._PpiList
3619 ## Get the list of include search path
3621 # @retval list The list path
3623 def _GetIncludePathList(self
):
3624 if self
._IncludePathList
is None:
3625 self
._IncludePathList
= []
3626 if self
.AutoGenVersion
< 0x00010005:
3627 for Inc
in self
.Module
.Includes
:
3628 if Inc
not in self
._IncludePathList
:
3629 self
._IncludePathList
.append(Inc
)
3631 Inc
= path
.join(Inc
, self
.Arch
.capitalize())
3632 if os
.path
.exists(Inc
) and Inc
not in self
._IncludePathList
:
3633 self
._IncludePathList
.append(Inc
)
3634 # Edk module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time
3635 self
._IncludePathList
.append(self
.DebugDir
)
3637 self
._IncludePathList
.append(self
.MetaFile
.Dir
)
3638 self
._IncludePathList
.append(self
.DebugDir
)
3640 for Package
in self
.Module
.Packages
:
3641 PackageDir
= mws
.join(self
.WorkspaceDir
, Package
.MetaFile
.Dir
)
3642 if PackageDir
not in self
._IncludePathList
:
3643 self
._IncludePathList
.append(PackageDir
)
3644 IncludesList
= Package
.Includes
3645 if Package
._PrivateIncludes
:
3646 if not self
.MetaFile
.Path
.startswith(PackageDir
):
3647 IncludesList
= list(set(Package
.Includes
).difference(set(Package
._PrivateIncludes
)))
3648 for Inc
in IncludesList
:
3649 if Inc
not in self
._IncludePathList
:
3650 self
._IncludePathList
.append(str(Inc
))
3651 return self
._IncludePathList
3653 def _GetIncludePathLength(self
):
3654 return sum(len(inc
)+1 for inc
in self
._IncludePathList
)
3656 ## Get HII EX PCDs which maybe used by VFR
3658 # efivarstore used by VFR may relate with HII EX PCDs
3659 # Get the variable name and GUID from efivarstore and HII EX PCD
3660 # List the HII EX PCDs in As Built INF if both name and GUID match.
3662 # @retval list HII EX PCDs
3664 def _GetPcdsMaybeUsedByVfr(self
):
3665 if not self
.SourceFileList
:
3669 for SrcFile
in self
.SourceFileList
:
3670 if SrcFile
.Ext
.lower() != '.vfr':
3672 Vfri
= os
.path
.join(self
.OutputDir
, SrcFile
.BaseName
+ '.i')
3673 if not os
.path
.exists(Vfri
):
3675 VfriFile
= open(Vfri
, 'r')
3676 Content
= VfriFile
.read()
3678 Pos
= Content
.find('efivarstore')
3681 # Make sure 'efivarstore' is the start of efivarstore statement
3682 # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'
3685 while Index
>= 0 and Content
[Index
] in ' \t\r\n':
3687 if Index
>= 0 and Content
[Index
] != ';':
3688 Pos
= Content
.find('efivarstore', Pos
+ len('efivarstore'))
3691 # 'efivarstore' must be followed by name and guid
3693 Name
= gEfiVarStoreNamePattern
.search(Content
, Pos
)
3696 Guid
= gEfiVarStoreGuidPattern
.search(Content
, Pos
)
3699 NameArray
= ConvertStringToByteArray('L"' + Name
.group(1) + '"')
3700 NameGuids
.add((NameArray
, GuidStructureStringToGuidString(Guid
.group(1))))
3701 Pos
= Content
.find('efivarstore', Name
.end())
3705 for Pcd
in self
.PlatformInfo
.Platform
.Pcds
.values():
3706 if Pcd
.Type
!= TAB_PCDS_DYNAMIC_EX_HII
:
3708 for SkuInfo
in Pcd
.SkuInfoList
.values():
3709 Value
= GuidValue(SkuInfo
.VariableGuid
, self
.PlatformInfo
.PackageList
, self
.MetaFile
.Path
)
3712 Name
= ConvertStringToByteArray(SkuInfo
.VariableName
)
3713 Guid
= GuidStructureStringToGuidString(Value
)
3714 if (Name
, Guid
) in NameGuids
and Pcd
not in HiiExPcds
:
3715 HiiExPcds
.append(Pcd
)
3720 def _GenOffsetBin(self
):
3722 for SourceFile
in self
.Module
.Sources
:
3723 if SourceFile
.Type
.upper() == ".VFR" :
3725 # search the .map file to find the offset of vfr binary in the PE32+/TE file.
3727 VfrUniBaseName
[SourceFile
.BaseName
] = (SourceFile
.BaseName
+ "Bin")
3728 elif SourceFile
.Type
.upper() == ".UNI" :
3730 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.
3732 VfrUniBaseName
["UniOffsetName"] = (self
.Name
+ "Strings")
3734 if not VfrUniBaseName
:
3736 MapFileName
= os
.path
.join(self
.OutputDir
, self
.Name
+ ".map")
3737 EfiFileName
= os
.path
.join(self
.OutputDir
, self
.Name
+ ".efi")
3738 VfrUniOffsetList
= GetVariableOffset(MapFileName
, EfiFileName
, VfrUniBaseName
.values())
3739 if not VfrUniOffsetList
:
3742 OutputName
= '%sOffset.bin' % self
.Name
3743 UniVfrOffsetFileName
= os
.path
.join( self
.OutputDir
, OutputName
)
3746 fInputfile
= open(UniVfrOffsetFileName
, "wb+", 0)
3748 EdkLogger
.error("build", FILE_OPEN_FAILURE
, "File open failed for %s" % UniVfrOffsetFileName
, None)
3750 # Use a instance of BytesIO to cache data
3751 fStringIO
= BytesIO('')
3753 for Item
in VfrUniOffsetList
:
3754 if (Item
[0].find("Strings") != -1):
3756 # UNI offset in image.
3758 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }
3760 UniGuid
= [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]
3761 UniGuid
= [chr(ItemGuid
) for ItemGuid
in UniGuid
]
3762 fStringIO
.write(''.join(UniGuid
))
3763 UniValue
= pack ('Q', int (Item
[1], 16))
3764 fStringIO
.write (UniValue
)
3767 # VFR binary offset in image.
3769 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };
3771 VfrGuid
= [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]
3772 VfrGuid
= [chr(ItemGuid
) for ItemGuid
in VfrGuid
]
3773 fStringIO
.write(''.join(VfrGuid
))
3774 VfrValue
= pack ('Q', int (Item
[1], 16))
3775 fStringIO
.write (VfrValue
)
3777 # write data into file.
3780 fInputfile
.write (fStringIO
.getvalue())
3782 EdkLogger
.error("build", FILE_WRITE_FAILURE
, "Write data to file %s failed, please check whether the "
3783 "file been locked or using by other applications." %UniVfrOffsetFileName
, None)
3789 ## Create AsBuilt INF file the module
3791 def CreateAsBuiltInf(self
, IsOnlyCopy
= False):
3792 self
.OutputFile
= set()
3793 if IsOnlyCopy
and GlobalData
.gBinCacheDest
:
3794 self
.CopyModuleToCache()
3797 if self
.IsAsBuiltInfCreated
:
3800 # Skip the following code for EDK I inf
3801 if self
.AutoGenVersion
< 0x00010005:
3804 # Skip the following code for libraries
3808 # Skip the following code for modules with no source files
3809 if not self
.SourceFileList
:
3812 # Skip the following code for modules without any binary files
3813 if self
.BinaryFileList
:
3816 ### TODO: How to handles mixed source and binary modules
3818 # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries
3819 # Also find all packages that the DynamicEx PCDs depend on
3824 PcdTokenSpaceList
= []
3825 for Pcd
in self
.ModulePcdList
+ self
.LibraryPcdList
:
3826 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
:
3827 PatchablePcds
.append(Pcd
)
3828 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_PATCHABLE_IN_MODULE
))
3829 elif Pcd
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
3832 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC_EX
))
3833 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC
))
3834 PcdTokenSpaceList
.append(Pcd
.TokenSpaceGuidCName
)
3835 GuidList
= OrderedDict()
3836 GuidList
.update(self
.GuidList
)
3837 for TokenSpace
in self
.GetGuidsUsedByPcd():
3838 # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list
3839 # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs
3840 if TokenSpace
not in PcdTokenSpaceList
and TokenSpace
in GuidList
:
3841 GuidList
.pop(TokenSpace
)
3842 CheckList
= (GuidList
, self
.PpiList
, self
.ProtocolList
, PcdCheckList
)
3843 for Package
in self
.DerivedPackageList
:
3844 if Package
in Packages
:
3846 BeChecked
= (Package
.Guids
, Package
.Ppis
, Package
.Protocols
, Package
.Pcds
)
3848 for Index
in range(len(BeChecked
)):
3849 for Item
in CheckList
[Index
]:
3850 if Item
in BeChecked
[Index
]:
3851 Packages
.append(Package
)
3857 VfrPcds
= self
._GetPcdsMaybeUsedByVfr
()
3858 for Pkg
in self
.PlatformInfo
.PackageList
:
3861 for VfrPcd
in VfrPcds
:
3862 if ((VfrPcd
.TokenCName
, VfrPcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC_EX
) in Pkg
.Pcds
or
3863 (VfrPcd
.TokenCName
, VfrPcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC
) in Pkg
.Pcds
):
3864 Packages
.append(Pkg
)
3867 ModuleType
= SUP_MODULE_DXE_DRIVER
if self
.ModuleType
== SUP_MODULE_UEFI_DRIVER
and self
.DepexGenerated
else self
.ModuleType
3868 DriverType
= self
.PcdIsDriver
if self
.PcdIsDriver
else ''
3870 MDefs
= self
.Module
.Defines
3873 'module_name' : self
.Name
,
3874 'module_guid' : Guid
,
3875 'module_module_type' : ModuleType
,
3876 'module_version_string' : [MDefs
['VERSION_STRING']] if 'VERSION_STRING' in MDefs
else [],
3877 'pcd_is_driver_string' : [],
3878 'module_uefi_specification_version' : [],
3879 'module_pi_specification_version' : [],
3880 'module_entry_point' : self
.Module
.ModuleEntryPointList
,
3881 'module_unload_image' : self
.Module
.ModuleUnloadImageList
,
3882 'module_constructor' : self
.Module
.ConstructorList
,
3883 'module_destructor' : self
.Module
.DestructorList
,
3884 'module_shadow' : [MDefs
['SHADOW']] if 'SHADOW' in MDefs
else [],
3885 'module_pci_vendor_id' : [MDefs
['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs
else [],
3886 'module_pci_device_id' : [MDefs
['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs
else [],
3887 'module_pci_class_code' : [MDefs
['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs
else [],
3888 'module_pci_revision' : [MDefs
['PCI_REVISION']] if 'PCI_REVISION' in MDefs
else [],
3889 'module_build_number' : [MDefs
['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs
else [],
3890 'module_spec' : [MDefs
['SPEC']] if 'SPEC' in MDefs
else [],
3891 'module_uefi_hii_resource_section' : [MDefs
['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs
else [],
3892 'module_uni_file' : [MDefs
['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs
else [],
3893 'module_arch' : self
.Arch
,
3894 'package_item' : [Package
.MetaFile
.File
.replace('\\', '/') for Package
in Packages
],
3896 'patchablepcd_item' : [],
3898 'protocol_item' : [],
3902 'libraryclasses_item' : []
3905 if 'MODULE_UNI_FILE' in MDefs
:
3906 UNIFile
= os
.path
.join(self
.MetaFile
.Dir
, MDefs
['MODULE_UNI_FILE'])
3907 if os
.path
.isfile(UNIFile
):
3908 shutil
.copy2(UNIFile
, self
.OutputDir
)
3910 if self
.AutoGenVersion
> int(gInfSpecVersion
, 0):
3911 AsBuiltInfDict
['module_inf_version'] = '0x%08x' % self
.AutoGenVersion
3913 AsBuiltInfDict
['module_inf_version'] = gInfSpecVersion
3916 AsBuiltInfDict
['pcd_is_driver_string'].append(DriverType
)
3918 if 'UEFI_SPECIFICATION_VERSION' in self
.Specification
:
3919 AsBuiltInfDict
['module_uefi_specification_version'].append(self
.Specification
['UEFI_SPECIFICATION_VERSION'])
3920 if 'PI_SPECIFICATION_VERSION' in self
.Specification
:
3921 AsBuiltInfDict
['module_pi_specification_version'].append(self
.Specification
['PI_SPECIFICATION_VERSION'])
3923 OutputDir
= self
.OutputDir
.replace('\\', '/').strip('/')
3924 DebugDir
= self
.DebugDir
.replace('\\', '/').strip('/')
3925 for Item
in self
.CodaTargetList
:
3926 File
= Item
.Target
.Path
.replace('\\', '/').strip('/').replace(DebugDir
, '').replace(OutputDir
, '').strip('/')
3927 self
.OutputFile
.add(File
)
3928 if os
.path
.isabs(File
):
3929 File
= File
.replace('\\', '/').strip('/').replace(OutputDir
, '').strip('/')
3930 if Item
.Target
.Ext
.lower() == '.aml':
3931 AsBuiltInfDict
['binary_item'].append('ASL|' + File
)
3932 elif Item
.Target
.Ext
.lower() == '.acpi':
3933 AsBuiltInfDict
['binary_item'].append('ACPI|' + File
)
3934 elif Item
.Target
.Ext
.lower() == '.efi':
3935 AsBuiltInfDict
['binary_item'].append('PE32|' + self
.Name
+ '.efi')
3937 AsBuiltInfDict
['binary_item'].append('BIN|' + File
)
3938 if self
.DepexGenerated
:
3939 self
.OutputFile
.add(self
.Name
+ '.depex')
3940 if self
.ModuleType
in [SUP_MODULE_PEIM
]:
3941 AsBuiltInfDict
['binary_item'].append('PEI_DEPEX|' + self
.Name
+ '.depex')
3942 elif self
.ModuleType
in [SUP_MODULE_DXE_DRIVER
, SUP_MODULE_DXE_RUNTIME_DRIVER
, SUP_MODULE_DXE_SAL_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
3943 AsBuiltInfDict
['binary_item'].append('DXE_DEPEX|' + self
.Name
+ '.depex')
3944 elif self
.ModuleType
in [SUP_MODULE_DXE_SMM_DRIVER
]:
3945 AsBuiltInfDict
['binary_item'].append('SMM_DEPEX|' + self
.Name
+ '.depex')
3947 Bin
= self
._GenOffsetBin
()
3949 AsBuiltInfDict
['binary_item'].append('BIN|%s' % Bin
)
3950 self
.OutputFile
.add(Bin
)
3952 for Root
, Dirs
, Files
in os
.walk(OutputDir
):
3954 if File
.lower().endswith('.pdb'):
3955 AsBuiltInfDict
['binary_item'].append('DISPOSABLE|' + File
)
3956 self
.OutputFile
.add(File
)
3957 HeaderComments
= self
.Module
.HeaderComments
3959 for Index
in range(len(HeaderComments
)):
3960 if HeaderComments
[Index
].find('@BinaryHeader') != -1:
3961 HeaderComments
[Index
] = HeaderComments
[Index
].replace('@BinaryHeader', '@file')
3964 AsBuiltInfDict
['header_comments'] = '\n'.join(HeaderComments
[StartPos
:]).replace(':#', '://')
3965 AsBuiltInfDict
['tail_comments'] = '\n'.join(self
.Module
.TailComments
)
3968 (self
.ProtocolList
, self
._ProtocolComments
, 'protocol_item'),
3969 (self
.PpiList
, self
._PpiComments
, 'ppi_item'),
3970 (GuidList
, self
._GuidComments
, 'guid_item')
3972 for Item
in GenList
:
3973 for CName
in Item
[0]:
3974 Comments
= '\n '.join(Item
[1][CName
]) if CName
in Item
[1] else ''
3975 Entry
= Comments
+ '\n ' + CName
if Comments
else CName
3976 AsBuiltInfDict
[Item
[2]].append(Entry
)
3977 PatchList
= parsePcdInfoFromMapFile(
3978 os
.path
.join(self
.OutputDir
, self
.Name
+ '.map'),
3979 os
.path
.join(self
.OutputDir
, self
.Name
+ '.efi')
3982 for Pcd
in PatchablePcds
:
3983 TokenCName
= Pcd
.TokenCName
3984 for PcdItem
in GlobalData
.MixedPcd
:
3985 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
3986 TokenCName
= PcdItem
[0]
3988 for PatchPcd
in PatchList
:
3989 if TokenCName
== PatchPcd
[0]:
3994 if Pcd
.DatumType
== 'BOOLEAN':
3995 BoolValue
= Pcd
.DefaultValue
.upper()
3996 if BoolValue
== 'TRUE':
3997 Pcd
.DefaultValue
= '1'
3998 elif BoolValue
== 'FALSE':
3999 Pcd
.DefaultValue
= '0'
4001 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
4002 HexFormat
= '0x%02x'
4003 if Pcd
.DatumType
== TAB_UINT16
:
4004 HexFormat
= '0x%04x'
4005 elif Pcd
.DatumType
== TAB_UINT32
:
4006 HexFormat
= '0x%08x'
4007 elif Pcd
.DatumType
== TAB_UINT64
:
4008 HexFormat
= '0x%016x'
4009 PcdValue
= HexFormat
% int(Pcd
.DefaultValue
, 0)
4011 if Pcd
.MaxDatumSize
is None or Pcd
.MaxDatumSize
== '':
4012 EdkLogger
.error("build", AUTOGEN_ERROR
,
4013 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
4015 ArraySize
= int(Pcd
.MaxDatumSize
, 0)
4016 PcdValue
= Pcd
.DefaultValue
4017 if PcdValue
[0] != '{':
4019 if PcdValue
[0] == 'L':
4021 PcdValue
= PcdValue
.lstrip('L')
4022 PcdValue
= eval(PcdValue
)
4024 for Index
in range(0, len(PcdValue
)):
4026 CharVal
= ord(PcdValue
[Index
])
4027 NewValue
= NewValue
+ '0x%02x' % (CharVal
& 0x00FF) + ', ' \
4028 + '0x%02x' % (CharVal
>> 8) + ', '
4030 NewValue
= NewValue
+ '0x%02x' % (ord(PcdValue
[Index
]) % 0x100) + ', '
4033 Padding
= Padding
* 2
4034 ArraySize
= ArraySize
/ 2
4035 if ArraySize
< (len(PcdValue
) + 1):
4036 if Pcd
.MaxSizeUserSet
:
4037 EdkLogger
.error("build", AUTOGEN_ERROR
,
4038 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
4041 ArraySize
= len(PcdValue
) + 1
4042 if ArraySize
> len(PcdValue
) + 1:
4043 NewValue
= NewValue
+ Padding
* (ArraySize
- len(PcdValue
) - 1)
4044 PcdValue
= NewValue
+ Padding
.strip().rstrip(',') + '}'
4045 elif len(PcdValue
.split(',')) <= ArraySize
:
4046 PcdValue
= PcdValue
.rstrip('}') + ', 0x00' * (ArraySize
- len(PcdValue
.split(',')))
4049 if Pcd
.MaxSizeUserSet
:
4050 EdkLogger
.error("build", AUTOGEN_ERROR
,
4051 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
4054 ArraySize
= len(PcdValue
) + 1
4055 PcdItem
= '%s.%s|%s|0x%X' % \
4056 (Pcd
.TokenSpaceGuidCName
, TokenCName
, PcdValue
, PatchPcd
[1])
4058 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) in self
._PcdComments
:
4059 PcdComments
= '\n '.join(self
._PcdComments
[Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
])
4061 PcdItem
= PcdComments
+ '\n ' + PcdItem
4062 AsBuiltInfDict
['patchablepcd_item'].append(PcdItem
)
4064 for Pcd
in Pcds
+ VfrPcds
:
4067 TokenCName
= Pcd
.TokenCName
4068 for PcdItem
in GlobalData
.MixedPcd
:
4069 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
4070 TokenCName
= PcdItem
[0]
4072 if Pcd
.Type
== TAB_PCDS_DYNAMIC_EX_HII
:
4073 for SkuName
in Pcd
.SkuInfoList
:
4074 SkuInfo
= Pcd
.SkuInfoList
[SkuName
]
4075 HiiInfo
= '## %s|%s|%s' % (SkuInfo
.VariableName
, SkuInfo
.VariableGuid
, SkuInfo
.VariableOffset
)
4077 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) in self
._PcdComments
:
4078 PcdCommentList
= self
._PcdComments
[Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
][:]
4082 for Index
, Comment
in enumerate(PcdCommentList
):
4083 for Usage
in UsageList
:
4084 if Comment
.find(Usage
) != -1:
4088 if UsageIndex
!= -1:
4089 PcdCommentList
[UsageIndex
] = '## %s %s %s' % (UsageStr
, HiiInfo
, PcdCommentList
[UsageIndex
].replace(UsageStr
, ''))
4091 PcdCommentList
.append('## UNDEFINED ' + HiiInfo
)
4092 PcdComments
= '\n '.join(PcdCommentList
)
4093 PcdEntry
= Pcd
.TokenSpaceGuidCName
+ '.' + TokenCName
4095 PcdEntry
= PcdComments
+ '\n ' + PcdEntry
4096 AsBuiltInfDict
['pcd_item'].append(PcdEntry
)
4097 for Item
in self
.BuildOption
:
4098 if 'FLAGS' in self
.BuildOption
[Item
]:
4099 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()))
4101 # Generated LibraryClasses section in comments.
4102 for Library
in self
.LibraryAutoGenList
:
4103 AsBuiltInfDict
['libraryclasses_item'].append(Library
.MetaFile
.File
.replace('\\', '/'))
4105 # Generated UserExtensions TianoCore section.
4106 # All tianocore user extensions are copied.
4108 for TianoCore
in self
._GetTianoCoreUserExtensionList
():
4109 UserExtStr
+= '\n'.join(TianoCore
)
4110 ExtensionFile
= os
.path
.join(self
.MetaFile
.Dir
, TianoCore
[1])
4111 if os
.path
.isfile(ExtensionFile
):
4112 shutil
.copy2(ExtensionFile
, self
.OutputDir
)
4113 AsBuiltInfDict
['userextension_tianocore_item'] = UserExtStr
4115 # Generated depex expression section in comments.
4116 DepexExpresion
= self
._GetDepexExpresionString
()
4117 AsBuiltInfDict
['depexsection_item'] = DepexExpresion
if DepexExpresion
else ''
4119 AsBuiltInf
= TemplateString()
4120 AsBuiltInf
.Append(gAsBuiltInfHeaderString
.Replace(AsBuiltInfDict
))
4122 SaveFileOnChange(os
.path
.join(self
.OutputDir
, self
.Name
+ '.inf'), str(AsBuiltInf
), False)
4124 self
.IsAsBuiltInfCreated
= True
4125 if GlobalData
.gBinCacheDest
:
4126 self
.CopyModuleToCache()
4128 def CopyModuleToCache(self
):
4129 FileDir
= path
.join(GlobalData
.gBinCacheDest
, self
.Arch
, self
.SourceDir
, self
.MetaFile
.BaseName
)
4130 CreateDirectory (FileDir
)
4131 HashFile
= path
.join(self
.BuildDir
, self
.Name
+ '.hash')
4132 ModuleFile
= path
.join(self
.OutputDir
, self
.Name
+ '.inf')
4133 if os
.path
.exists(HashFile
):
4134 shutil
.copy2(HashFile
, FileDir
)
4135 if os
.path
.exists(ModuleFile
):
4136 shutil
.copy2(ModuleFile
, FileDir
)
4137 if not self
.OutputFile
:
4138 Ma
= self
.Workspace
.BuildDatabase
[PathClass(ModuleFile
), self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
4139 self
.OutputFile
= Ma
.Binaries
4141 for File
in self
.OutputFile
:
4143 if not os
.path
.isabs(File
):
4144 File
= os
.path
.join(self
.OutputDir
, File
)
4145 if os
.path
.exists(File
):
4146 shutil
.copy2(File
, FileDir
)
4148 def AttemptModuleCacheCopy(self
):
4149 if self
.IsBinaryModule
:
4151 FileDir
= path
.join(GlobalData
.gBinCacheSource
, self
.Arch
, self
.SourceDir
, self
.MetaFile
.BaseName
)
4152 HashFile
= path
.join(FileDir
, self
.Name
+ '.hash')
4153 if os
.path
.exists(HashFile
):
4154 f
= open(HashFile
, 'r')
4155 CacheHash
= f
.read()
4157 if GlobalData
.gModuleHash
[self
.Arch
][self
.Name
]:
4158 if CacheHash
== GlobalData
.gModuleHash
[self
.Arch
][self
.Name
]:
4159 for root
, dir, files
in os
.walk(FileDir
):
4161 if self
.Name
+ '.hash' in f
:
4162 shutil
.copy2(HashFile
, self
.BuildDir
)
4164 File
= path
.join(root
, f
)
4165 shutil
.copy2(File
, self
.OutputDir
)
4166 if self
.Name
== "PcdPeim" or self
.Name
== "PcdDxe":
4167 CreatePcdDatabaseCode(self
, TemplateString(), TemplateString())
4171 ## Create makefile for the module and its dependent libraries
4173 # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of
4174 # dependent libraries will be created
4176 def CreateMakeFile(self
, CreateLibraryMakeFile
=True, GenFfsList
= []):
4177 # Ignore generating makefile when it is a binary module
4178 if self
.IsBinaryModule
:
4181 if self
.IsMakeFileCreated
:
4183 self
.GenFfsList
= GenFfsList
4184 if not self
.IsLibrary
and CreateLibraryMakeFile
:
4185 for LibraryAutoGen
in self
.LibraryAutoGenList
:
4186 LibraryAutoGen
.CreateMakeFile()
4191 if len(self
.CustomMakefile
) == 0:
4192 Makefile
= GenMake
.ModuleMakefile(self
)
4194 Makefile
= GenMake
.CustomMakefile(self
)
4195 if Makefile
.Generate():
4196 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated makefile for module %s [%s]" %
4197 (self
.Name
, self
.Arch
))
4199 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Skipped the generation of makefile for module %s [%s]" %
4200 (self
.Name
, self
.Arch
))
4202 self
.CreateTimeStamp(Makefile
)
4203 self
.IsMakeFileCreated
= True
4205 def CopyBinaryFiles(self
):
4206 for File
in self
.Module
.Binaries
:
4208 DstPath
= os
.path
.join(self
.OutputDir
, os
.path
.basename(SrcPath
))
4209 CopyLongFilePath(SrcPath
, DstPath
)
4210 ## Create autogen code for the module and its dependent libraries
4212 # @param CreateLibraryCodeFile Flag indicating if or not the code of
4213 # dependent libraries will be created
4215 def CreateCodeFile(self
, CreateLibraryCodeFile
=True):
4216 if self
.IsCodeFileCreated
:
4219 # Need to generate PcdDatabase even PcdDriver is binarymodule
4220 if self
.IsBinaryModule
and self
.PcdIsDriver
!= '':
4221 CreatePcdDatabaseCode(self
, TemplateString(), TemplateString())
4223 if self
.IsBinaryModule
:
4225 self
.CopyBinaryFiles()
4228 if not self
.IsLibrary
and CreateLibraryCodeFile
:
4229 for LibraryAutoGen
in self
.LibraryAutoGenList
:
4230 LibraryAutoGen
.CreateCodeFile()
4236 IgoredAutoGenList
= []
4238 for File
in self
.AutoGenFileList
:
4239 if GenC
.Generate(File
.Path
, self
.AutoGenFileList
[File
], File
.IsBinary
):
4240 #Ignore Edk AutoGen.c
4241 if self
.AutoGenVersion
< 0x00010005 and File
.Name
== 'AutoGen.c':
4244 AutoGenList
.append(str(File
))
4246 IgoredAutoGenList
.append(str(File
))
4248 # Skip the following code for EDK I inf
4249 if self
.AutoGenVersion
< 0x00010005:
4252 for ModuleType
in self
.DepexList
:
4253 # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module
4254 if len(self
.DepexList
[ModuleType
]) == 0 or ModuleType
== SUP_MODULE_USER_DEFINED
:
4257 Dpx
= GenDepex
.DependencyExpression(self
.DepexList
[ModuleType
], ModuleType
, True)
4258 DpxFile
= gAutoGenDepexFileName
% {"module_name" : self
.Name
}
4260 if len(Dpx
.PostfixNotation
) != 0:
4261 self
.DepexGenerated
= True
4263 if Dpx
.Generate(path
.join(self
.OutputDir
, DpxFile
)):
4264 AutoGenList
.append(str(DpxFile
))
4266 IgoredAutoGenList
.append(str(DpxFile
))
4268 if IgoredAutoGenList
== []:
4269 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated [%s] files for module %s [%s]" %
4270 (" ".join(AutoGenList
), self
.Name
, self
.Arch
))
4271 elif AutoGenList
== []:
4272 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Skipped the generation of [%s] files for module %s [%s]" %
4273 (" ".join(IgoredAutoGenList
), self
.Name
, self
.Arch
))
4275 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated [%s] (skipped %s) files for module %s [%s]" %
4276 (" ".join(AutoGenList
), " ".join(IgoredAutoGenList
), self
.Name
, self
.Arch
))
4278 self
.IsCodeFileCreated
= True
4281 ## Summarize the ModuleAutoGen objects of all libraries used by this module
4282 def _GetLibraryAutoGenList(self
):
4283 if self
._LibraryAutoGenList
is None:
4284 self
._LibraryAutoGenList
= []
4285 for Library
in self
.DependentLibraryList
:
4292 self
.PlatformInfo
.MetaFile
4294 if La
not in self
._LibraryAutoGenList
:
4295 self
._LibraryAutoGenList
.append(La
)
4296 for Lib
in La
.CodaTargetList
:
4297 self
._ApplyBuildRule
(Lib
.Target
, TAB_UNKNOWN_FILE
)
4298 return self
._LibraryAutoGenList
4300 def GenModuleHash(self
):
4301 if self
.Arch
not in GlobalData
.gModuleHash
:
4302 GlobalData
.gModuleHash
[self
.Arch
] = {}
4304 # Add Platform level hash
4305 m
.update(GlobalData
.gPlatformHash
)
4306 # Add Package level hash
4307 if self
.DependentPackageList
:
4308 for Pkg
in sorted(self
.DependentPackageList
, key
=lambda x
: x
.PackageName
):
4309 if Pkg
.PackageName
in GlobalData
.gPackageHash
[self
.Arch
]:
4310 m
.update(GlobalData
.gPackageHash
[self
.Arch
][Pkg
.PackageName
])
4313 if self
.LibraryAutoGenList
:
4314 for Lib
in sorted(self
.LibraryAutoGenList
, key
=lambda x
: x
.Name
):
4315 if Lib
.Name
not in GlobalData
.gModuleHash
[self
.Arch
]:
4317 m
.update(GlobalData
.gModuleHash
[self
.Arch
][Lib
.Name
])
4320 f
= open(str(self
.MetaFile
), 'r')
4324 # Add Module's source files
4325 if self
.SourceFileList
:
4326 for File
in sorted(self
.SourceFileList
, key
=lambda x
: str(x
)):
4327 f
= open(str(File
), 'r')
4332 ModuleHashFile
= path
.join(self
.BuildDir
, self
.Name
+ ".hash")
4333 if self
.Name
not in GlobalData
.gModuleHash
[self
.Arch
]:
4334 GlobalData
.gModuleHash
[self
.Arch
][self
.Name
] = m
.hexdigest()
4335 if GlobalData
.gBinCacheSource
:
4336 if self
.AttemptModuleCacheCopy():
4338 return SaveFileOnChange(ModuleHashFile
, m
.hexdigest(), True)
4340 ## Decide whether we can skip the ModuleAutoGen process
4341 def CanSkipbyHash(self
):
4342 if GlobalData
.gUseHashCache
:
4343 return not self
.GenModuleHash()
4346 ## Decide whether we can skip the ModuleAutoGen process
4347 # If any source file is newer than the module than we cannot skip
4350 if self
.MakeFileDir
in GlobalData
.gSikpAutoGenCache
:
4352 if not os
.path
.exists(self
.GetTimeStampPath()):
4354 #last creation time of the module
4355 DstTimeStamp
= os
.stat(self
.GetTimeStampPath())[8]
4357 SrcTimeStamp
= self
.Workspace
._SrcTimeStamp
4358 if SrcTimeStamp
> DstTimeStamp
:
4361 with
open(self
.GetTimeStampPath(), 'r') as f
:
4363 source
= source
.rstrip('\n')
4364 if not os
.path
.exists(source
):
4366 if source
not in ModuleAutoGen
.TimeDict
:
4367 ModuleAutoGen
.TimeDict
[source
] = os
.stat(source
)[8]
4368 if ModuleAutoGen
.TimeDict
[source
] > DstTimeStamp
:
4370 GlobalData
.gSikpAutoGenCache
.add(self
.MakeFileDir
)
4373 def GetTimeStampPath(self
):
4374 if self
._TimeStampPath
is None:
4375 self
._TimeStampPath
= os
.path
.join(self
.MakeFileDir
, 'AutoGenTimeStamp')
4376 return self
._TimeStampPath
4377 def CreateTimeStamp(self
, Makefile
):
4379 FileSet
= {self
.MetaFile
.Path
}
4381 for SourceFile
in self
.Module
.Sources
:
4382 FileSet
.add (SourceFile
.Path
)
4384 for Lib
in self
.DependentLibraryList
:
4385 FileSet
.add (Lib
.MetaFile
.Path
)
4387 for f
in self
.AutoGenDepSet
:
4388 FileSet
.add (f
.Path
)
4390 if os
.path
.exists (self
.GetTimeStampPath()):
4391 os
.remove (self
.GetTimeStampPath())
4392 with
open(self
.GetTimeStampPath(), 'w+') as file:
4396 Module
= property(_GetModule
)
4397 Name
= property(_GetBaseName
)
4398 Guid
= property(_GetGuid
)
4399 Version
= property(_GetVersion
)
4400 ModuleType
= property(_GetModuleType
)
4401 ComponentType
= property(_GetComponentType
)
4402 BuildType
= property(_GetBuildType
)
4403 PcdIsDriver
= property(_GetPcdIsDriver
)
4404 AutoGenVersion
= property(_GetAutoGenVersion
)
4405 Macros
= property(_GetMacros
)
4406 Specification
= property(_GetSpecification
)
4408 IsLibrary
= property(_IsLibrary
)
4409 IsBinaryModule
= property(_IsBinaryModule
)
4410 BuildDir
= property(_GetBuildDir
)
4411 OutputDir
= property(_GetOutputDir
)
4412 FfsOutputDir
= property(_GetFfsOutputDir
)
4413 DebugDir
= property(_GetDebugDir
)
4414 MakeFileDir
= property(_GetMakeFileDir
)
4415 CustomMakefile
= property(_GetCustomMakefile
)
4417 IncludePathList
= property(_GetIncludePathList
)
4418 IncludePathLength
= property(_GetIncludePathLength
)
4419 AutoGenFileList
= property(_GetAutoGenFileList
)
4420 UnicodeFileList
= property(_GetUnicodeFileList
)
4421 VfrFileList
= property(_GetVfrFileList
)
4422 SourceFileList
= property(_GetSourceFileList
)
4423 BinaryFileList
= property(_GetBinaryFiles
) # FileType : [File List]
4424 Targets
= property(_GetTargets
)
4425 IntroTargetList
= property(_GetIntroTargetList
)
4426 CodaTargetList
= property(_GetFinalTargetList
)
4427 FileTypes
= property(_GetFileTypes
)
4428 BuildRules
= property(_GetBuildRules
)
4429 IdfFileList
= property(_GetIdfFileList
)
4431 DependentPackageList
= property(_GetDependentPackageList
)
4432 DependentLibraryList
= property(_GetLibraryList
)
4433 LibraryAutoGenList
= property(_GetLibraryAutoGenList
)
4434 DerivedPackageList
= property(_GetDerivedPackageList
)
4436 ModulePcdList
= property(_GetModulePcdList
)
4437 LibraryPcdList
= property(_GetLibraryPcdList
)
4438 GuidList
= property(_GetGuidList
)
4439 ProtocolList
= property(_GetProtocolList
)
4440 PpiList
= property(_GetPpiList
)
4441 DepexList
= property(_GetDepexTokenList
)
4442 DxsFile
= property(_GetDxsFile
)
4443 DepexExpressionDict
= property(_GetDepexExpressionTokenList
)
4444 BuildOption
= property(_GetModuleBuildOption
)
4445 BuildOptionIncPathList
= property(_GetBuildOptionIncPathList
)
4446 BuildCommand
= property(_GetBuildCommand
)
4448 FixedAtBuildPcds
= property(_GetFixedAtBuildPcds
)
4449 UniqueBaseName
= property(_GetUniqueBaseName
)
4450 FixedVoidTypePcds
= property(_GetFixedAtBuildVoidTypePcds
)
4452 # This acts like the main() function for the script, unless it is 'import'ed into another script.
4453 if __name__
== '__main__':