2 # Generate AutoGen.h, AutoGen.c and *.depex files
4 # Copyright (c) 2007 - 2019, Intel Corporation. All rights reserved.<BR>
5 # Copyright (c) 2018, Hewlett Packard Enterprise Development, L.P.<BR>
6 # Copyright (c) 2019, American Megatrends, Inc. All rights reserved.<BR>
8 # SPDX-License-Identifier: BSD-2-Clause-Patent
13 from __future__
import print_function
14 from __future__
import absolute_import
15 import Common
.LongFilePathOs
as os
17 import os
.path
as path
23 from . import GenDepex
24 from io
import BytesIO
26 from .StrGather
import *
27 from .BuildEngine
import BuildRule
29 from Common
.LongFilePathSupport
import CopyLongFilePath
30 from Common
.BuildToolError
import *
31 from Common
.DataType
import *
32 from Common
.Misc
import *
33 from Common
.StringUtils
import *
34 import Common
.GlobalData
as GlobalData
35 from GenFds
.FdfParser
import *
36 from CommonDataClass
.CommonClass
import SkuInfoClass
37 from GenPatchPcdTable
.GenPatchPcdTable
import parsePcdInfoFromMapFile
38 import Common
.VpdInfoFile
as VpdInfoFile
39 from .GenPcdDb
import CreatePcdDatabaseCode
40 from Workspace
.MetaFileCommentParser
import UsageList
41 from Workspace
.WorkspaceCommon
import GetModuleLibInstances
42 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
43 from . import InfSectionParser
46 from .GenVar
import VariableMgr
, var_info
47 from collections
import OrderedDict
48 from collections
import defaultdict
49 from Workspace
.WorkspaceCommon
import OrderedListDict
50 from Common
.ToolDefClassObject
import gDefaultToolsDefFile
52 from Common
.caching
import cached_property
, cached_class_function
54 ## Regular expression for splitting Dependency Expression string into tokens
55 gDepexTokenPattern
= re
.compile("(\(|\)|\w+| \S+\.inf)")
57 ## Regular expression for match: PCD(xxxx.yyy)
58 gPCDAsGuidPattern
= re
.compile(r
"^PCD\(.+\..+\)$")
61 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
62 # is the former use /I , the Latter used -I to specify include directories
64 gBuildOptIncludePatternMsft
= re
.compile(r
"(?:.*?)/I[ \t]*([^ ]*)", re
.MULTILINE | re
.DOTALL
)
65 gBuildOptIncludePatternOther
= re
.compile(r
"(?:.*?)-I[ \t]*([^ ]*)", re
.MULTILINE | re
.DOTALL
)
68 # Match name = variable
70 gEfiVarStoreNamePattern
= re
.compile("\s*name\s*=\s*(\w+)")
72 # The format of guid in efivarstore statement likes following and must be correct:
73 # guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}
75 gEfiVarStoreGuidPattern
= re
.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")
77 ## Mapping Makefile type
78 gMakeTypeMap
= {TAB_COMPILER_MSFT
:"nmake", "GCC":"gmake"}
81 ## Build rule configuration file
82 gDefaultBuildRuleFile
= 'build_rule.txt'
84 ## Build rule default version
85 AutoGenReqBuildRuleVerNum
= "0.1"
87 ## default file name for AutoGen
88 gAutoGenCodeFileName
= "AutoGen.c"
89 gAutoGenHeaderFileName
= "AutoGen.h"
90 gAutoGenStringFileName
= "%(module_name)sStrDefs.h"
91 gAutoGenStringFormFileName
= "%(module_name)sStrDefs.hpk"
92 gAutoGenDepexFileName
= "%(module_name)s.depex"
93 gAutoGenImageDefFileName
= "%(module_name)sImgDefs.h"
94 gAutoGenIdfFileName
= "%(module_name)sIdf.hpk"
95 gInfSpecVersion
= "0x00010017"
98 # Template string to generic AsBuilt INF
100 gAsBuiltInfHeaderString
= TemplateString("""${header_comments}
103 # FILE auto-generated
106 INF_VERSION = ${module_inf_version}
107 BASE_NAME = ${module_name}
108 FILE_GUID = ${module_guid}
109 MODULE_TYPE = ${module_module_type}${BEGIN}
110 VERSION_STRING = ${module_version_string}${END}${BEGIN}
111 PCD_IS_DRIVER = ${pcd_is_driver_string}${END}${BEGIN}
112 UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}
113 PI_SPECIFICATION_VERSION = ${module_pi_specification_version}${END}${BEGIN}
114 ENTRY_POINT = ${module_entry_point}${END}${BEGIN}
115 UNLOAD_IMAGE = ${module_unload_image}${END}${BEGIN}
116 CONSTRUCTOR = ${module_constructor}${END}${BEGIN}
117 DESTRUCTOR = ${module_destructor}${END}${BEGIN}
118 SHADOW = ${module_shadow}${END}${BEGIN}
119 PCI_VENDOR_ID = ${module_pci_vendor_id}${END}${BEGIN}
120 PCI_DEVICE_ID = ${module_pci_device_id}${END}${BEGIN}
121 PCI_CLASS_CODE = ${module_pci_class_code}${END}${BEGIN}
122 PCI_REVISION = ${module_pci_revision}${END}${BEGIN}
123 BUILD_NUMBER = ${module_build_number}${END}${BEGIN}
124 SPEC = ${module_spec}${END}${BEGIN}
125 UEFI_HII_RESOURCE_SECTION = ${module_uefi_hii_resource_section}${END}${BEGIN}
126 MODULE_UNI_FILE = ${module_uni_file}${END}
128 [Packages.${module_arch}]${BEGIN}
129 ${package_item}${END}
131 [Binaries.${module_arch}]${BEGIN}
134 [PatchPcd.${module_arch}]${BEGIN}
138 [Protocols.${module_arch}]${BEGIN}
142 [Ppis.${module_arch}]${BEGIN}
146 [Guids.${module_arch}]${BEGIN}
150 [PcdEx.${module_arch}]${BEGIN}
154 [LibraryClasses.${module_arch}]
155 ## @LIB_INSTANCES${BEGIN}
156 # ${libraryclasses_item}${END}
160 ${userextension_tianocore_item}
164 [BuildOptions.${module_arch}]
166 ## ${flags_item}${END}
168 ## Split command line option string to list
170 # subprocess.Popen needs the args to be a sequence. Otherwise there's problem
171 # in non-windows platform to launch command
173 def _SplitOption(OptionString
):
178 for Index
in range(0, len(OptionString
)):
179 CurrentChar
= OptionString
[Index
]
180 if CurrentChar
in ['"', "'"]:
181 if QuotationMark
== CurrentChar
:
183 elif QuotationMark
== "":
184 QuotationMark
= CurrentChar
189 if CurrentChar
in ["/", "-"] and LastChar
in [" ", "\t", "\r", "\n"]:
190 if Index
> OptionStart
:
191 OptionList
.append(OptionString
[OptionStart
:Index
- 1])
193 LastChar
= CurrentChar
194 OptionList
.append(OptionString
[OptionStart
:])
198 # Convert string to C format array
200 def _ConvertStringToByteArray(Value
):
201 Value
= Value
.strip()
205 if not Value
.endswith('}'):
207 Value
= Value
.replace(' ', '').replace('{', '').replace('}', '')
208 ValFields
= Value
.split(',')
210 for Index
in range(len(ValFields
)):
211 ValFields
[Index
] = str(int(ValFields
[Index
], 0))
214 Value
= '{' + ','.join(ValFields
) + '}'
218 if Value
.startswith('L"'):
219 if not Value
.endswith('"'):
223 elif not Value
.startswith('"') or not Value
.endswith('"'):
226 Value
= eval(Value
) # translate escape character
228 for Index
in range(0, len(Value
)):
230 NewValue
= NewValue
+ str(ord(Value
[Index
]) % 0x10000) + ','
232 NewValue
= NewValue
+ str(ord(Value
[Index
]) % 0x100) + ','
233 Value
= NewValue
+ '0}'
236 ## Base class for AutoGen
238 # This class just implements the cache mechanism of AutoGen objects.
240 class AutoGen(object):
241 # database to maintain the objects in each child class
242 __ObjectCache
= {} # (BuildTarget, ToolChain, ARCH, platform file): AutoGen object
246 # @param Class class object of real AutoGen class
247 # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)
248 # @param Workspace Workspace directory or WorkspaceAutoGen object
249 # @param MetaFile The path of meta file
250 # @param Target Build target
251 # @param Toolchain Tool chain name
252 # @param Arch Target arch
253 # @param *args The specific class related parameters
254 # @param **kwargs The specific class related dict parameters
256 def __new__(cls
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
257 # check if the object has been created
258 Key
= (Target
, Toolchain
, Arch
, MetaFile
)
259 if Key
in cls
.__ObjectCache
:
260 # if it exists, just return it directly
261 return cls
.__ObjectCache
[Key
]
262 # it didnt exist. create it, cache it, then return it
263 RetVal
= cls
.__ObjectCache
[Key
] = super(AutoGen
, cls
).__new
__(cls
)
269 # The file path of platform file will be used to represent hash value of this object
271 # @retval int Hash value of the file path of platform file
274 return hash(self
.MetaFile
)
278 # The file path of platform file will be used to represent this object
280 # @retval string String of platform file path
283 return str(self
.MetaFile
)
286 def __eq__(self
, Other
):
287 return Other
and self
.MetaFile
== Other
289 ## Workspace AutoGen class
291 # This class is used mainly to control the whole platform build for different
292 # architecture. This class will generate top level makefile.
294 class WorkspaceAutoGen(AutoGen
):
295 # call super().__init__ then call the worker function with different parameter count
296 def __init__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
297 if not hasattr(self
, "_Init"):
298 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
301 ## Initialize WorkspaceAutoGen
303 # @param WorkspaceDir Root directory of workspace
304 # @param ActivePlatform Meta-file of active platform
305 # @param Target Build target
306 # @param Toolchain Tool chain name
307 # @param ArchList List of architecture of current build
308 # @param MetaFileDb Database containing meta-files
309 # @param BuildConfig Configuration of build
310 # @param ToolDefinition Tool chain definitions
311 # @param FlashDefinitionFile File of flash definition
312 # @param Fds FD list to be generated
313 # @param Fvs FV list to be generated
314 # @param Caps Capsule list to be generated
315 # @param SkuId SKU id from command line
317 def _InitWorker(self
, WorkspaceDir
, ActivePlatform
, Target
, Toolchain
, ArchList
, MetaFileDb
,
318 BuildConfig
, ToolDefinition
, FlashDefinitionFile
='', Fds
=None, Fvs
=None, Caps
=None, SkuId
='', UniFlag
=None,
319 Progress
=None, BuildModule
=None):
320 self
.BuildDatabase
= MetaFileDb
321 self
.MetaFile
= ActivePlatform
322 self
.WorkspaceDir
= WorkspaceDir
323 self
.Platform
= self
.BuildDatabase
[self
.MetaFile
, TAB_ARCH_COMMON
, Target
, Toolchain
]
324 GlobalData
.gActivePlatform
= self
.Platform
325 self
.BuildTarget
= Target
326 self
.ToolChain
= Toolchain
327 self
.ArchList
= ArchList
329 self
.UniFlag
= UniFlag
331 self
.TargetTxt
= BuildConfig
332 self
.ToolDef
= ToolDefinition
333 self
.FdfFile
= FlashDefinitionFile
334 self
.FdTargetList
= Fds
if Fds
else []
335 self
.FvTargetList
= Fvs
if Fvs
else []
336 self
.CapTargetList
= Caps
if Caps
else []
337 self
.AutoGenObjectList
= []
340 # there's many relative directory operations, so ...
341 os
.chdir(self
.WorkspaceDir
)
346 if not self
.ArchList
:
347 ArchList
= set(self
.Platform
.SupArchList
)
349 ArchList
= set(self
.ArchList
) & set(self
.Platform
.SupArchList
)
351 EdkLogger
.error("build", PARAMETER_INVALID
,
352 ExtraData
= "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self
.Platform
.SupArchList
)))
353 elif self
.ArchList
and len(ArchList
) != len(self
.ArchList
):
354 SkippedArchList
= set(self
.ArchList
).symmetric_difference(set(self
.Platform
.SupArchList
))
355 EdkLogger
.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"
356 % (" ".join(SkippedArchList
), " ".join(self
.Platform
.SupArchList
)))
357 self
.ArchList
= tuple(ArchList
)
359 # Validate build target
360 if self
.BuildTarget
not in self
.Platform
.BuildTargets
:
361 EdkLogger
.error("build", PARAMETER_INVALID
,
362 ExtraData
="Build target [%s] is not supported by the platform. [Valid target: %s]"
363 % (self
.BuildTarget
, " ".join(self
.Platform
.BuildTargets
)))
366 # parse FDF file to get PCDs in it, if any
368 self
.FdfFile
= self
.Platform
.FlashDefinition
372 EdkLogger
.info('%-16s = %s' % ("Architecture(s)", ' '.join(self
.ArchList
)))
373 EdkLogger
.info('%-16s = %s' % ("Build target", self
.BuildTarget
))
374 EdkLogger
.info('%-16s = %s' % ("Toolchain", self
.ToolChain
))
376 EdkLogger
.info('\n%-24s = %s' % ("Active Platform", self
.Platform
))
378 EdkLogger
.info('%-24s = %s' % ("Active Module", BuildModule
))
381 EdkLogger
.info('%-24s = %s' % ("Flash Image Definition", self
.FdfFile
))
383 EdkLogger
.verbose("\nFLASH_DEFINITION = %s" % self
.FdfFile
)
386 Progress
.Start("\nProcessing meta-data")
390 # Mark now build in AutoGen Phase
392 GlobalData
.gAutoGenPhase
= True
393 Fdf
= FdfParser(self
.FdfFile
.Path
)
395 GlobalData
.gFdfParser
= Fdf
396 GlobalData
.gAutoGenPhase
= False
397 PcdSet
= Fdf
.Profile
.PcdDict
398 if Fdf
.CurrentFdName
and Fdf
.CurrentFdName
in Fdf
.Profile
.FdDict
:
399 FdDict
= Fdf
.Profile
.FdDict
[Fdf
.CurrentFdName
]
400 for FdRegion
in FdDict
.RegionList
:
401 if str(FdRegion
.RegionType
) is 'FILE' and self
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
402 if int(FdRegion
.Offset
) % 8 != 0:
403 EdkLogger
.error("build", FORMAT_INVALID
, 'The VPD Base Address %s must be 8-byte aligned.' % (FdRegion
.Offset
))
404 ModuleList
= Fdf
.Profile
.InfList
405 self
.FdfProfile
= Fdf
.Profile
406 for fvname
in self
.FvTargetList
:
407 if fvname
.upper() not in self
.FdfProfile
.FvDict
:
408 EdkLogger
.error("build", OPTION_VALUE_INVALID
,
409 "No such an FV in FDF file: %s" % fvname
)
411 # In DSC file may use FILE_GUID to override the module, then in the Platform.Modules use FILE_GUIDmodule.inf as key,
412 # but the path (self.MetaFile.Path) is the real path
413 for key
in self
.FdfProfile
.InfDict
:
415 MetaFile_cache
= defaultdict(set)
416 for Arch
in self
.ArchList
:
417 Current_Platform_cache
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
418 for Pkey
in Current_Platform_cache
.Modules
:
419 MetaFile_cache
[Arch
].add(Current_Platform_cache
.Modules
[Pkey
].MetaFile
)
420 for Inf
in self
.FdfProfile
.InfDict
[key
]:
421 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
422 for Arch
in self
.ArchList
:
423 if ModuleFile
in MetaFile_cache
[Arch
]:
426 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
427 if not ModuleData
.IsBinaryModule
:
428 EdkLogger
.error('build', PARSER_ERROR
, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile
)
431 for Arch
in self
.ArchList
:
433 Platform
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
435 for Pkey
in Platform
.Modules
:
436 MetaFileList
.add(Platform
.Modules
[Pkey
].MetaFile
)
437 for Inf
in self
.FdfProfile
.InfDict
[key
]:
438 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
439 if ModuleFile
in MetaFileList
:
441 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
442 if not ModuleData
.IsBinaryModule
:
443 EdkLogger
.error('build', PARSER_ERROR
, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile
)
448 self
.FdfProfile
= None
449 if self
.FdTargetList
:
450 EdkLogger
.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self
.FdTargetList
))
451 self
.FdTargetList
= []
452 if self
.FvTargetList
:
453 EdkLogger
.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self
.FvTargetList
))
454 self
.FvTargetList
= []
455 if self
.CapTargetList
:
456 EdkLogger
.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self
.CapTargetList
))
457 self
.CapTargetList
= []
459 # apply SKU and inject PCDs from Flash Definition file
460 for Arch
in self
.ArchList
:
461 Platform
= self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]
462 PlatformPcds
= Platform
.Pcds
463 self
._GuidDict
= Platform
._GuidDict
464 SourcePcdDict
= {TAB_PCDS_DYNAMIC_EX
:set(), TAB_PCDS_PATCHABLE_IN_MODULE
:set(),TAB_PCDS_DYNAMIC
:set(),TAB_PCDS_FIXED_AT_BUILD
:set()}
465 BinaryPcdDict
= {TAB_PCDS_DYNAMIC_EX
:set(), TAB_PCDS_PATCHABLE_IN_MODULE
:set()}
466 SourcePcdDict_Keys
= SourcePcdDict
.keys()
467 BinaryPcdDict_Keys
= BinaryPcdDict
.keys()
469 # generate the SourcePcdDict and BinaryPcdDict
470 PGen
= PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
)
471 for BuildData
in list(PGen
.BuildDatabase
._CACHE
_.values()):
472 if BuildData
.Arch
!= Arch
:
474 if BuildData
.MetaFile
.Ext
== '.inf':
475 for key
in BuildData
.Pcds
:
476 if BuildData
.Pcds
[key
].Pending
:
477 if key
in Platform
.Pcds
:
478 PcdInPlatform
= Platform
.Pcds
[key
]
479 if PcdInPlatform
.Type
:
480 BuildData
.Pcds
[key
].Type
= PcdInPlatform
.Type
481 BuildData
.Pcds
[key
].Pending
= False
483 if BuildData
.MetaFile
in Platform
.Modules
:
484 PlatformModule
= Platform
.Modules
[str(BuildData
.MetaFile
)]
485 if key
in PlatformModule
.Pcds
:
486 PcdInPlatform
= PlatformModule
.Pcds
[key
]
487 if PcdInPlatform
.Type
:
488 BuildData
.Pcds
[key
].Type
= PcdInPlatform
.Type
489 BuildData
.Pcds
[key
].Pending
= False
491 #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending
492 if BuildData
.Pcds
[key
].Pending
:
493 MGen
= ModuleAutoGen(self
, BuildData
.MetaFile
, Target
, Toolchain
, Arch
, self
.MetaFile
)
494 if MGen
and MGen
.IsLibrary
:
495 if MGen
in PGen
.LibraryAutoGenList
:
496 ReferenceModules
= MGen
.ReferenceModules
497 for ReferenceModule
in ReferenceModules
:
498 if ReferenceModule
.MetaFile
in Platform
.Modules
:
499 RefPlatformModule
= Platform
.Modules
[str(ReferenceModule
.MetaFile
)]
500 if key
in RefPlatformModule
.Pcds
:
501 PcdInReferenceModule
= RefPlatformModule
.Pcds
[key
]
502 if PcdInReferenceModule
.Type
:
503 BuildData
.Pcds
[key
].Type
= PcdInReferenceModule
.Type
504 BuildData
.Pcds
[key
].Pending
= False
507 if TAB_PCDS_DYNAMIC_EX
in BuildData
.Pcds
[key
].Type
:
508 if BuildData
.IsBinaryModule
:
509 BinaryPcdDict
[TAB_PCDS_DYNAMIC_EX
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
511 SourcePcdDict
[TAB_PCDS_DYNAMIC_EX
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
513 elif TAB_PCDS_PATCHABLE_IN_MODULE
in BuildData
.Pcds
[key
].Type
:
514 if BuildData
.MetaFile
.Ext
== '.inf':
515 if BuildData
.IsBinaryModule
:
516 BinaryPcdDict
[TAB_PCDS_PATCHABLE_IN_MODULE
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
518 SourcePcdDict
[TAB_PCDS_PATCHABLE_IN_MODULE
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
520 elif TAB_PCDS_DYNAMIC
in BuildData
.Pcds
[key
].Type
:
521 SourcePcdDict
[TAB_PCDS_DYNAMIC
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
522 elif TAB_PCDS_FIXED_AT_BUILD
in BuildData
.Pcds
[key
].Type
:
523 SourcePcdDict
[TAB_PCDS_FIXED_AT_BUILD
].add((BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
))
527 # A PCD can only use one type for all source modules
529 for i
in SourcePcdDict_Keys
:
530 for j
in SourcePcdDict_Keys
:
532 Intersections
= SourcePcdDict
[i
].intersection(SourcePcdDict
[j
])
533 if len(Intersections
) > 0:
537 "Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i
, j
),
538 ExtraData
='\n\t'.join(str(P
[1]+'.'+P
[0]) for P
in Intersections
)
542 # intersection the BinaryPCD for Mixed PCD
544 for i
in BinaryPcdDict_Keys
:
545 for j
in BinaryPcdDict_Keys
:
547 Intersections
= BinaryPcdDict
[i
].intersection(BinaryPcdDict
[j
])
548 for item
in Intersections
:
549 NewPcd1
= (item
[0] + '_' + i
, item
[1])
550 NewPcd2
= (item
[0] + '_' + j
, item
[1])
551 if item
not in GlobalData
.MixedPcd
:
552 GlobalData
.MixedPcd
[item
] = [NewPcd1
, NewPcd2
]
554 if NewPcd1
not in GlobalData
.MixedPcd
[item
]:
555 GlobalData
.MixedPcd
[item
].append(NewPcd1
)
556 if NewPcd2
not in GlobalData
.MixedPcd
[item
]:
557 GlobalData
.MixedPcd
[item
].append(NewPcd2
)
560 # intersection the SourcePCD and BinaryPCD for Mixed PCD
562 for i
in SourcePcdDict_Keys
:
563 for j
in BinaryPcdDict_Keys
:
565 Intersections
= SourcePcdDict
[i
].intersection(BinaryPcdDict
[j
])
566 for item
in Intersections
:
567 NewPcd1
= (item
[0] + '_' + i
, item
[1])
568 NewPcd2
= (item
[0] + '_' + j
, item
[1])
569 if item
not in GlobalData
.MixedPcd
:
570 GlobalData
.MixedPcd
[item
] = [NewPcd1
, NewPcd2
]
572 if NewPcd1
not in GlobalData
.MixedPcd
[item
]:
573 GlobalData
.MixedPcd
[item
].append(NewPcd1
)
574 if NewPcd2
not in GlobalData
.MixedPcd
[item
]:
575 GlobalData
.MixedPcd
[item
].append(NewPcd2
)
577 for BuildData
in list(PGen
.BuildDatabase
._CACHE
_.values()):
578 if BuildData
.Arch
!= Arch
:
580 for key
in BuildData
.Pcds
:
581 for SinglePcd
in GlobalData
.MixedPcd
:
582 if (BuildData
.Pcds
[key
].TokenCName
, BuildData
.Pcds
[key
].TokenSpaceGuidCName
) == SinglePcd
:
583 for item
in GlobalData
.MixedPcd
[SinglePcd
]:
584 Pcd_Type
= item
[0].split('_')[-1]
585 if (Pcd_Type
== BuildData
.Pcds
[key
].Type
) or (Pcd_Type
== TAB_PCDS_DYNAMIC_EX
and BuildData
.Pcds
[key
].Type
in PCD_DYNAMIC_EX_TYPE_SET
) or \
586 (Pcd_Type
== TAB_PCDS_DYNAMIC
and BuildData
.Pcds
[key
].Type
in PCD_DYNAMIC_TYPE_SET
):
587 Value
= BuildData
.Pcds
[key
]
588 Value
.TokenCName
= BuildData
.Pcds
[key
].TokenCName
+ '_' + Pcd_Type
590 newkey
= (Value
.TokenCName
, key
[1])
592 newkey
= (Value
.TokenCName
, key
[1], key
[2])
593 del BuildData
.Pcds
[key
]
594 BuildData
.Pcds
[newkey
] = Value
598 # handle the mixed pcd in FDF file
600 if key
in GlobalData
.MixedPcd
:
603 for item
in GlobalData
.MixedPcd
[key
]:
606 #Collect package set information from INF of FDF
608 for Inf
in ModuleList
:
609 ModuleFile
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, Arch
)
610 if ModuleFile
in Platform
.Modules
:
612 ModuleData
= self
.BuildDatabase
[ModuleFile
, Arch
, Target
, Toolchain
]
613 PkgSet
.update(ModuleData
.Packages
)
614 Pkgs
= list(PkgSet
) + list(PGen
.PackageList
)
619 DecPcds
.add((Pcd
[0], Pcd
[1]))
620 DecPcdsKey
.add((Pcd
[0], Pcd
[1], Pcd
[2]))
622 Platform
.SkuName
= self
.SkuId
623 for Name
, Guid
,Fileds
in PcdSet
:
624 if (Name
, Guid
) not in DecPcds
:
628 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid
, Name
),
629 File
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
, Fileds
][0],
630 Line
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
, Fileds
][1]
633 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.
634 if (Name
, Guid
, TAB_PCDS_FIXED_AT_BUILD
) in DecPcdsKey \
635 or (Name
, Guid
, TAB_PCDS_PATCHABLE_IN_MODULE
) in DecPcdsKey \
636 or (Name
, Guid
, TAB_PCDS_FEATURE_FLAG
) in DecPcdsKey
:
638 elif (Name
, Guid
, TAB_PCDS_DYNAMIC
) in DecPcdsKey
or (Name
, Guid
, TAB_PCDS_DYNAMIC_EX
) in DecPcdsKey
:
642 "Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid
, Name
),
643 File
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
, Fileds
][0],
644 Line
= self
.FdfProfile
.PcdFileLineDict
[Name
, Guid
, Fileds
][1]
647 Pa
= PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
)
649 # Explicitly collect platform's dynamic PCDs
651 Pa
.CollectPlatformDynamicPcds()
652 Pa
.CollectFixedAtBuildPcds()
653 self
.AutoGenObjectList
.append(Pa
)
656 # Generate Package level hash value
658 GlobalData
.gPackageHash
= {}
659 if GlobalData
.gUseHashCache
:
661 self
._GenPkgLevelHash
(Pkg
)
664 # Check PCDs token value conflict in each DEC file.
666 self
._CheckAllPcdsTokenValueConflict
()
669 # Check PCD type and definition between DSC and DEC
671 self
._CheckPcdDefineAndType
()
674 # Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.
676 content
= 'gCommandLineDefines: '
677 content
+= str(GlobalData
.gCommandLineDefines
)
678 content
+= TAB_LINE_BREAK
679 content
+= 'BuildOptionPcd: '
680 content
+= str(GlobalData
.BuildOptionPcd
)
681 content
+= TAB_LINE_BREAK
682 content
+= 'Active Platform: '
683 content
+= str(self
.Platform
)
684 content
+= TAB_LINE_BREAK
686 content
+= 'Flash Image Definition: '
687 content
+= str(self
.FdfFile
)
688 content
+= TAB_LINE_BREAK
689 SaveFileOnChange(os
.path
.join(self
.BuildDir
, 'BuildOptions'), content
, False)
692 # Create PcdToken Number file for Dynamic/DynamicEx Pcd.
694 PcdTokenNumber
= 'PcdTokenNumber: '
695 if Pa
.PcdTokenNumber
:
696 if Pa
.DynamicPcdList
:
697 for Pcd
in Pa
.DynamicPcdList
:
698 PcdTokenNumber
+= TAB_LINE_BREAK
699 PcdTokenNumber
+= str((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
700 PcdTokenNumber
+= ' : '
701 PcdTokenNumber
+= str(Pa
.PcdTokenNumber
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
])
702 SaveFileOnChange(os
.path
.join(self
.BuildDir
, 'PcdTokenNumber'), PcdTokenNumber
, False)
705 # Get set of workspace metafiles
707 AllWorkSpaceMetaFiles
= self
._GetMetaFiles
(Target
, Toolchain
, Arch
)
710 # Retrieve latest modified time of all metafiles
713 for f
in AllWorkSpaceMetaFiles
:
714 if os
.stat(f
)[8] > SrcTimeStamp
:
715 SrcTimeStamp
= os
.stat(f
)[8]
716 self
._SrcTimeStamp
= SrcTimeStamp
718 if GlobalData
.gUseHashCache
:
720 for files
in AllWorkSpaceMetaFiles
:
721 if files
.endswith('.dec'):
723 f
= open(files
, 'rb')
727 SaveFileOnChange(os
.path
.join(self
.BuildDir
, 'AutoGen.hash'), m
.hexdigest(), False)
728 GlobalData
.gPlatformHash
= m
.hexdigest()
731 # Write metafile list to build directory
733 AutoGenFilePath
= os
.path
.join(self
.BuildDir
, 'AutoGen')
734 if os
.path
.exists (AutoGenFilePath
):
735 os
.remove(AutoGenFilePath
)
736 if not os
.path
.exists(self
.BuildDir
):
737 os
.makedirs(self
.BuildDir
)
738 with
open(os
.path
.join(self
.BuildDir
, 'AutoGen'), 'w+') as file:
739 for f
in AllWorkSpaceMetaFiles
:
743 def _GenPkgLevelHash(self
, Pkg
):
744 if Pkg
.PackageName
in GlobalData
.gPackageHash
:
747 PkgDir
= os
.path
.join(self
.BuildDir
, Pkg
.Arch
, Pkg
.PackageName
)
748 CreateDirectory(PkgDir
)
749 HashFile
= os
.path
.join(PkgDir
, Pkg
.PackageName
+ '.hash')
751 # Get .dec file's hash value
752 f
= open(Pkg
.MetaFile
.Path
, 'rb')
756 # Get include files hash value
758 for inc
in sorted(Pkg
.Includes
, key
=lambda x
: str(x
)):
759 for Root
, Dirs
, Files
in os
.walk(str(inc
)):
760 for File
in sorted(Files
):
761 File_Path
= os
.path
.join(Root
, File
)
762 f
= open(File_Path
, 'rb')
766 SaveFileOnChange(HashFile
, m
.hexdigest(), False)
767 GlobalData
.gPackageHash
[Pkg
.PackageName
] = m
.hexdigest()
769 def _GetMetaFiles(self
, Target
, Toolchain
, Arch
):
770 AllWorkSpaceMetaFiles
= set()
775 AllWorkSpaceMetaFiles
.add (self
.FdfFile
.Path
)
776 for f
in GlobalData
.gFdfParser
.GetAllIncludedFile():
777 AllWorkSpaceMetaFiles
.add (f
.FileName
)
781 AllWorkSpaceMetaFiles
.add(self
.MetaFile
.Path
)
784 # add build_rule.txt & tools_def.txt
786 AllWorkSpaceMetaFiles
.add(os
.path
.join(GlobalData
.gConfDirectory
, gDefaultBuildRuleFile
))
787 AllWorkSpaceMetaFiles
.add(os
.path
.join(GlobalData
.gConfDirectory
, gDefaultToolsDefFile
))
789 # add BuildOption metafile
791 AllWorkSpaceMetaFiles
.add(os
.path
.join(self
.BuildDir
, 'BuildOptions'))
793 # add PcdToken Number file for Dynamic/DynamicEx Pcd
795 AllWorkSpaceMetaFiles
.add(os
.path
.join(self
.BuildDir
, 'PcdTokenNumber'))
797 for Arch
in self
.ArchList
:
801 for Package
in PlatformAutoGen(self
, self
.MetaFile
, Target
, Toolchain
, Arch
).PackageList
:
802 AllWorkSpaceMetaFiles
.add(Package
.MetaFile
.Path
)
807 for filePath
in self
.BuildDatabase
[self
.MetaFile
, Arch
, Target
, Toolchain
]._RawData
.IncludedFiles
:
808 AllWorkSpaceMetaFiles
.add(filePath
.Path
)
810 return AllWorkSpaceMetaFiles
812 def _CheckPcdDefineAndType(self
):
813 PcdTypeSet
= {TAB_PCDS_FIXED_AT_BUILD
,
814 TAB_PCDS_PATCHABLE_IN_MODULE
,
815 TAB_PCDS_FEATURE_FLAG
,
819 # This dict store PCDs which are not used by any modules with specified arches
820 UnusedPcd
= OrderedDict()
821 for Pa
in self
.AutoGenObjectList
:
822 # Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid
823 for Pcd
in Pa
.Platform
.Pcds
:
824 PcdType
= Pa
.Platform
.Pcds
[Pcd
].Type
826 # If no PCD type, this PCD comes from FDF
830 # Try to remove Hii and Vpd suffix
831 if PcdType
.startswith(TAB_PCDS_DYNAMIC_EX
):
832 PcdType
= TAB_PCDS_DYNAMIC_EX
833 elif PcdType
.startswith(TAB_PCDS_DYNAMIC
):
834 PcdType
= TAB_PCDS_DYNAMIC
836 for Package
in Pa
.PackageList
:
837 # Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType
838 if (Pcd
[0], Pcd
[1], PcdType
) in Package
.Pcds
:
840 for Type
in PcdTypeSet
:
841 if (Pcd
[0], Pcd
[1], Type
) in Package
.Pcds
:
845 "Type [%s] of PCD [%s.%s] in DSC file doesn't match the type [%s] defined in DEC file." \
846 % (Pa
.Platform
.Pcds
[Pcd
].Type
, Pcd
[1], Pcd
[0], Type
),
851 UnusedPcd
.setdefault(Pcd
, []).append(Pa
.Arch
)
853 for Pcd
in UnusedPcd
:
856 "The PCD was not specified by any INF module in the platform for the given architecture.\n"
857 "\tPCD: [%s.%s]\n\tPlatform: [%s]\n\tArch: %s"
858 % (Pcd
[1], Pcd
[0], os
.path
.basename(str(self
.MetaFile
)), str(UnusedPcd
[Pcd
])),
863 return "%s [%s]" % (self
.MetaFile
, ", ".join(self
.ArchList
))
865 ## Return the directory to store FV files
868 return path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
)
870 ## Return the directory to store all intermediate and final files built
873 return self
.AutoGenObjectList
[0].BuildDir
875 ## Return the build output directory platform specifies
878 return self
.Platform
.OutputDirectory
880 ## Return platform name
883 return self
.Platform
.PlatformName
885 ## Return meta-file GUID
888 return self
.Platform
.Guid
890 ## Return platform version
893 return self
.Platform
.Version
895 ## Return paths of tools
897 def ToolDefinition(self
):
898 return self
.AutoGenObjectList
[0].ToolDefinition
900 ## Return directory of platform makefile
902 # @retval string Makefile directory
905 def MakeFileDir(self
):
908 ## Return build command string
910 # @retval string Build command string
913 def BuildCommand(self
):
914 # BuildCommand should be all the same. So just get one from platform AutoGen
915 return self
.AutoGenObjectList
[0].BuildCommand
917 ## Check the PCDs token value conflict in each DEC file.
919 # Will cause build break and raise error message while two PCDs conflict.
923 def _CheckAllPcdsTokenValueConflict(self
):
924 for Pa
in self
.AutoGenObjectList
:
925 for Package
in Pa
.PackageList
:
926 PcdList
= list(Package
.Pcds
.values())
927 PcdList
.sort(key
=lambda x
: int(x
.TokenValue
, 0))
929 while (Count
< len(PcdList
) - 1) :
930 Item
= PcdList
[Count
]
931 ItemNext
= PcdList
[Count
+ 1]
933 # Make sure in the same token space the TokenValue should be unique
935 if (int(Item
.TokenValue
, 0) == int(ItemNext
.TokenValue
, 0)):
936 SameTokenValuePcdList
= []
937 SameTokenValuePcdList
.append(Item
)
938 SameTokenValuePcdList
.append(ItemNext
)
939 RemainPcdListLength
= len(PcdList
) - Count
- 2
940 for ValueSameCount
in range(RemainPcdListLength
):
941 if int(PcdList
[len(PcdList
) - RemainPcdListLength
+ ValueSameCount
].TokenValue
, 0) == int(Item
.TokenValue
, 0):
942 SameTokenValuePcdList
.append(PcdList
[len(PcdList
) - RemainPcdListLength
+ ValueSameCount
])
946 # Sort same token value PCD list with TokenGuid and TokenCName
948 SameTokenValuePcdList
.sort(key
=lambda x
: "%s.%s" % (x
.TokenSpaceGuidCName
, x
.TokenCName
))
949 SameTokenValuePcdListCount
= 0
950 while (SameTokenValuePcdListCount
< len(SameTokenValuePcdList
) - 1):
952 TemListItem
= SameTokenValuePcdList
[SameTokenValuePcdListCount
]
953 TemListItemNext
= SameTokenValuePcdList
[SameTokenValuePcdListCount
+ 1]
955 if (TemListItem
.TokenSpaceGuidCName
== TemListItemNext
.TokenSpaceGuidCName
) and (TemListItem
.TokenCName
!= TemListItemNext
.TokenCName
):
956 for PcdItem
in GlobalData
.MixedPcd
:
957 if (TemListItem
.TokenCName
, TemListItem
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
] or \
958 (TemListItemNext
.TokenCName
, TemListItemNext
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
964 "The TokenValue [%s] of PCD [%s.%s] is conflict with: [%s.%s] in %s"\
965 % (TemListItem
.TokenValue
, TemListItem
.TokenSpaceGuidCName
, TemListItem
.TokenCName
, TemListItemNext
.TokenSpaceGuidCName
, TemListItemNext
.TokenCName
, Package
),
968 SameTokenValuePcdListCount
+= 1
969 Count
+= SameTokenValuePcdListCount
972 PcdList
= list(Package
.Pcds
.values())
973 PcdList
.sort(key
=lambda x
: "%s.%s" % (x
.TokenSpaceGuidCName
, x
.TokenCName
))
975 while (Count
< len(PcdList
) - 1) :
976 Item
= PcdList
[Count
]
977 ItemNext
= PcdList
[Count
+ 1]
979 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.
981 if (Item
.TokenSpaceGuidCName
== ItemNext
.TokenSpaceGuidCName
) and (Item
.TokenCName
== ItemNext
.TokenCName
) and (int(Item
.TokenValue
, 0) != int(ItemNext
.TokenValue
, 0)):
985 "The TokenValue [%s] of PCD [%s.%s] in %s defined in two places should be same as well."\
986 % (Item
.TokenValue
, Item
.TokenSpaceGuidCName
, Item
.TokenCName
, Package
),
990 ## Generate fds command
992 def GenFdsCommand(self
):
993 return (GenMake
.TopLevelMakefile(self
)._TEMPLATE
_.Replace(GenMake
.TopLevelMakefile(self
)._TemplateDict
)).strip()
996 def GenFdsCommandDict(self
):
998 LogLevel
= EdkLogger
.GetLevel()
999 if LogLevel
== EdkLogger
.VERBOSE
:
1000 FdsCommandDict
["verbose"] = True
1001 elif LogLevel
<= EdkLogger
.DEBUG_9
:
1002 FdsCommandDict
["debug"] = LogLevel
- 1
1003 elif LogLevel
== EdkLogger
.QUIET
:
1004 FdsCommandDict
["quiet"] = True
1006 if GlobalData
.gEnableGenfdsMultiThread
:
1007 FdsCommandDict
["GenfdsMultiThread"] = True
1008 if GlobalData
.gIgnoreSource
:
1009 FdsCommandDict
["IgnoreSources"] = True
1011 FdsCommandDict
["OptionPcd"] = []
1012 for pcd
in GlobalData
.BuildOptionPcd
:
1014 pcdname
= '.'.join(pcd
[0:3])
1016 pcdname
= '.'.join(pcd
[0:2])
1017 if pcd
[3].startswith('{'):
1018 FdsCommandDict
["OptionPcd"].append(pcdname
+ '=' + 'H' + '"' + pcd
[3] + '"')
1020 FdsCommandDict
["OptionPcd"].append(pcdname
+ '=' + pcd
[3])
1023 # macros passed to GenFds
1025 MacroDict
.update(GlobalData
.gGlobalDefines
)
1026 MacroDict
.update(GlobalData
.gCommandLineDefines
)
1027 for MacroName
in MacroDict
:
1028 if MacroDict
[MacroName
] != "":
1029 MacroList
.append('"%s=%s"' % (MacroName
, MacroDict
[MacroName
].replace('\\', '\\\\')))
1031 MacroList
.append('"%s"' % MacroName
)
1032 FdsCommandDict
["macro"] = MacroList
1034 FdsCommandDict
["fdf_file"] = [self
.FdfFile
]
1035 FdsCommandDict
["build_target"] = self
.BuildTarget
1036 FdsCommandDict
["toolchain_tag"] = self
.ToolChain
1037 FdsCommandDict
["active_platform"] = str(self
)
1039 FdsCommandDict
["conf_directory"] = GlobalData
.gConfDirectory
1040 FdsCommandDict
["build_architecture_list"] = ','.join(self
.ArchList
)
1041 FdsCommandDict
["platform_build_directory"] = self
.BuildDir
1043 FdsCommandDict
["fd"] = self
.FdTargetList
1044 FdsCommandDict
["fv"] = self
.FvTargetList
1045 FdsCommandDict
["cap"] = self
.CapTargetList
1046 return FdsCommandDict
1048 ## Create makefile for the platform and modules in it
1050 # @param CreateDepsMakeFile Flag indicating if the makefile for
1051 # modules will be created as well
1053 def CreateMakeFile(self
, CreateDepsMakeFile
=False):
1054 if not CreateDepsMakeFile
:
1056 for Pa
in self
.AutoGenObjectList
:
1057 Pa
.CreateMakeFile(True)
1059 ## Create autogen code for platform and modules
1061 # Since there's no autogen code for platform, this method will do nothing
1062 # if CreateModuleCodeFile is set to False.
1064 # @param CreateDepsCodeFile Flag indicating if creating module's
1065 # autogen code file or not
1067 def CreateCodeFile(self
, CreateDepsCodeFile
=False):
1068 if not CreateDepsCodeFile
:
1070 for Pa
in self
.AutoGenObjectList
:
1071 Pa
.CreateCodeFile(True)
1073 ## Create AsBuilt INF file the platform
1075 def CreateAsBuiltInf(self
):
1079 ## AutoGen class for platform
1081 # PlatformAutoGen class will process the original information in platform
1082 # file in order to generate makefile for platform.
1084 class PlatformAutoGen(AutoGen
):
1085 # call super().__init__ then call the worker function with different parameter count
1086 def __init__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
1087 if not hasattr(self
, "_Init"):
1088 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
)
1091 # Used to store all PCDs for both PEI and DXE phase, in order to generate
1092 # correct PCD database
1095 _NonDynaPcdList_
= []
1099 # The priority list while override build option
1101 PrioList
= {"0x11111" : 16, # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE (Highest)
1102 "0x01111" : 15, # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
1103 "0x10111" : 14, # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE
1104 "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE
1105 "0x11011" : 12, # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE
1106 "0x01011" : 11, # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE
1107 "0x10011" : 10, # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE
1108 "0x00011" : 9, # ******_*********_****_COMMANDTYPE_ATTRIBUTE
1109 "0x11101" : 8, # TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE
1110 "0x01101" : 7, # ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE
1111 "0x10101" : 6, # TARGET_*********_ARCH_***********_ATTRIBUTE
1112 "0x00101" : 5, # ******_*********_ARCH_***********_ATTRIBUTE
1113 "0x11001" : 4, # TARGET_TOOLCHAIN_****_***********_ATTRIBUTE
1114 "0x01001" : 3, # ******_TOOLCHAIN_****_***********_ATTRIBUTE
1115 "0x10001" : 2, # TARGET_*********_****_***********_ATTRIBUTE
1116 "0x00001" : 1} # ******_*********_****_***********_ATTRIBUTE (Lowest)
1118 ## Initialize PlatformAutoGen
1121 # @param Workspace WorkspaceAutoGen object
1122 # @param PlatformFile Platform file (DSC file)
1123 # @param Target Build target (DEBUG, RELEASE)
1124 # @param Toolchain Name of tool chain
1125 # @param Arch arch of the platform supports
1127 def _InitWorker(self
, Workspace
, PlatformFile
, Target
, Toolchain
, Arch
):
1128 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "AutoGen platform [%s] [%s]" % (PlatformFile
, Arch
))
1129 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (PlatformFile
, Arch
, Toolchain
, Target
)
1131 self
.MetaFile
= PlatformFile
1132 self
.Workspace
= Workspace
1133 self
.WorkspaceDir
= Workspace
.WorkspaceDir
1134 self
.ToolChain
= Toolchain
1135 self
.BuildTarget
= Target
1137 self
.SourceDir
= PlatformFile
.SubDir
1138 self
.FdTargetList
= self
.Workspace
.FdTargetList
1139 self
.FvTargetList
= self
.Workspace
.FvTargetList
1140 # get the original module/package/platform objects
1141 self
.BuildDatabase
= Workspace
.BuildDatabase
1142 self
.DscBuildDataObj
= Workspace
.Platform
1144 # flag indicating if the makefile/C-code file has been created or not
1145 self
.IsMakeFileCreated
= False
1147 self
._DynamicPcdList
= None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1148 self
._NonDynamicPcdList
= None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1150 self
._AsBuildInfList
= []
1151 self
._AsBuildModuleList
= []
1153 self
.VariableInfo
= None
1155 if GlobalData
.gFdfParser
is not None:
1156 self
._AsBuildInfList
= GlobalData
.gFdfParser
.Profile
.InfList
1157 for Inf
in self
._AsBuildInfList
:
1158 InfClass
= PathClass(NormPath(Inf
), GlobalData
.gWorkspace
, self
.Arch
)
1159 M
= self
.BuildDatabase
[InfClass
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
1160 if not M
.IsBinaryModule
:
1162 self
._AsBuildModuleList
.append(InfClass
)
1163 # get library/modules for build
1164 self
.LibraryBuildDirectoryList
= []
1165 self
.ModuleBuildDirectoryList
= []
1169 @cached_class_function
1171 return "%s [%s]" % (self
.MetaFile
, self
.Arch
)
1173 ## Create autogen code for platform and modules
1175 # Since there's no autogen code for platform, this method will do nothing
1176 # if CreateModuleCodeFile is set to False.
1178 # @param CreateModuleCodeFile Flag indicating if creating module's
1179 # autogen code file or not
1181 @cached_class_function
1182 def CreateCodeFile(self
, CreateModuleCodeFile
=False):
1183 # only module has code to be created, so do nothing if CreateModuleCodeFile is False
1184 if not CreateModuleCodeFile
:
1187 for Ma
in self
.ModuleAutoGenList
:
1188 Ma
.CreateCodeFile(True)
1190 ## Generate Fds Command
1192 def GenFdsCommand(self
):
1193 return self
.Workspace
.GenFdsCommand
1195 ## Create makefile for the platform and modules in it
1197 # @param CreateModuleMakeFile Flag indicating if the makefile for
1198 # modules will be created as well
1200 def CreateMakeFile(self
, CreateModuleMakeFile
=False, FfsCommand
= {}):
1201 if CreateModuleMakeFile
:
1202 for Ma
in self
._MaList
:
1203 key
= (Ma
.MetaFile
.File
, self
.Arch
)
1204 if key
in FfsCommand
:
1205 Ma
.CreateMakeFile(True, FfsCommand
[key
])
1207 Ma
.CreateMakeFile(True)
1209 # no need to create makefile for the platform more than once
1210 if self
.IsMakeFileCreated
:
1213 # create library/module build dirs for platform
1214 Makefile
= GenMake
.PlatformMakefile(self
)
1215 self
.LibraryBuildDirectoryList
= Makefile
.GetLibraryBuildDirectoryList()
1216 self
.ModuleBuildDirectoryList
= Makefile
.GetModuleBuildDirectoryList()
1218 self
.IsMakeFileCreated
= True
1221 def AllPcdList(self
):
1222 return self
.DynamicPcdList
+ self
.NonDynamicPcdList
1223 ## Deal with Shared FixedAtBuild Pcds
1225 def CollectFixedAtBuildPcds(self
):
1226 for LibAuto
in self
.LibraryAutoGenList
:
1227 FixedAtBuildPcds
= {}
1228 ShareFixedAtBuildPcdsSameValue
= {}
1229 for Module
in LibAuto
.ReferenceModules
:
1230 for Pcd
in set(Module
.FixedAtBuildPcds
+ LibAuto
.FixedAtBuildPcds
):
1231 DefaultValue
= Pcd
.DefaultValue
1232 # Cover the case: DSC component override the Pcd value and the Pcd only used in one Lib
1233 if Pcd
in Module
.LibraryPcdList
:
1234 Index
= Module
.LibraryPcdList
.index(Pcd
)
1235 DefaultValue
= Module
.LibraryPcdList
[Index
].DefaultValue
1236 key
= ".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
1237 if key
not in FixedAtBuildPcds
:
1238 ShareFixedAtBuildPcdsSameValue
[key
] = True
1239 FixedAtBuildPcds
[key
] = DefaultValue
1241 if FixedAtBuildPcds
[key
] != DefaultValue
:
1242 ShareFixedAtBuildPcdsSameValue
[key
] = False
1243 for Pcd
in LibAuto
.FixedAtBuildPcds
:
1244 key
= ".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
1245 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) not in self
.NonDynamicPcdDict
:
1248 DscPcd
= self
.NonDynamicPcdDict
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1249 if DscPcd
.Type
!= TAB_PCDS_FIXED_AT_BUILD
:
1251 if key
in ShareFixedAtBuildPcdsSameValue
and ShareFixedAtBuildPcdsSameValue
[key
]:
1252 LibAuto
.ConstPcd
[key
] = FixedAtBuildPcds
[key
]
1254 def CollectVariables(self
, DynamicPcdSet
):
1257 if self
.Workspace
.FdfFile
:
1258 FdDict
= self
.Workspace
.FdfProfile
.FdDict
[GlobalData
.gFdfParser
.CurrentFdName
]
1259 for FdRegion
in FdDict
.RegionList
:
1260 for item
in FdRegion
.RegionDataList
:
1261 if self
.Platform
.VpdToolGuid
.strip() and self
.Platform
.VpdToolGuid
in item
:
1262 VpdRegionSize
= FdRegion
.Size
1263 VpdRegionBase
= FdRegion
.Offset
1266 VariableInfo
= VariableMgr(self
.DscBuildDataObj
._GetDefaultStores
(), self
.DscBuildDataObj
.SkuIds
)
1267 VariableInfo
.SetVpdRegionMaxSize(VpdRegionSize
)
1268 VariableInfo
.SetVpdRegionOffset(VpdRegionBase
)
1270 for Pcd
in DynamicPcdSet
:
1271 pcdname
= ".".join((Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
1272 for SkuName
in Pcd
.SkuInfoList
:
1273 Sku
= Pcd
.SkuInfoList
[SkuName
]
1275 if SkuId
is None or SkuId
== '':
1277 if len(Sku
.VariableName
) > 0:
1278 if Sku
.VariableAttribute
and 'NV' not in Sku
.VariableAttribute
:
1280 VariableGuidStructure
= Sku
.VariableGuidValue
1281 VariableGuid
= GuidStructureStringToGuidString(VariableGuidStructure
)
1282 for StorageName
in Sku
.DefaultStoreDict
:
1283 VariableInfo
.append_variable(var_info(Index
, pcdname
, StorageName
, SkuName
, StringToArray(Sku
.VariableName
), VariableGuid
, Sku
.VariableOffset
, Sku
.VariableAttribute
, Sku
.HiiDefaultValue
, Sku
.DefaultStoreDict
[StorageName
] if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
else StringToArray(Sku
.DefaultStoreDict
[StorageName
]), Pcd
.DatumType
, Pcd
.CustomAttribute
['DscPosition'], Pcd
.CustomAttribute
.get('IsStru',False)))
1287 def UpdateNVStoreMaxSize(self
, OrgVpdFile
):
1288 if self
.VariableInfo
:
1289 VpdMapFilePath
= os
.path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
, "%s.map" % self
.Platform
.VpdToolGuid
)
1290 PcdNvStoreDfBuffer
= [item
for item
in self
._DynamicPcdList
if item
.TokenCName
== "PcdNvStoreDefaultValueBuffer" and item
.TokenSpaceGuidCName
== "gEfiMdeModulePkgTokenSpaceGuid"]
1292 if PcdNvStoreDfBuffer
:
1293 if os
.path
.exists(VpdMapFilePath
):
1294 OrgVpdFile
.Read(VpdMapFilePath
)
1295 PcdItems
= OrgVpdFile
.GetOffset(PcdNvStoreDfBuffer
[0])
1296 NvStoreOffset
= list(PcdItems
.values())[0].strip() if PcdItems
else '0'
1298 EdkLogger
.error("build", FILE_READ_FAILURE
, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath
)
1300 NvStoreOffset
= int(NvStoreOffset
, 16) if NvStoreOffset
.upper().startswith("0X") else int(NvStoreOffset
)
1301 default_skuobj
= PcdNvStoreDfBuffer
[0].SkuInfoList
.get(TAB_DEFAULT
)
1302 maxsize
= self
.VariableInfo
.VpdRegionSize
- NvStoreOffset
if self
.VariableInfo
.VpdRegionSize
else len(default_skuobj
.DefaultValue
.split(","))
1303 var_data
= self
.VariableInfo
.PatchNVStoreDefaultMaxSize(maxsize
)
1305 if var_data
and default_skuobj
:
1306 default_skuobj
.DefaultValue
= var_data
1307 PcdNvStoreDfBuffer
[0].DefaultValue
= var_data
1308 PcdNvStoreDfBuffer
[0].SkuInfoList
.clear()
1309 PcdNvStoreDfBuffer
[0].SkuInfoList
[TAB_DEFAULT
] = default_skuobj
1310 PcdNvStoreDfBuffer
[0].MaxDatumSize
= str(len(default_skuobj
.DefaultValue
.split(",")))
1314 ## Collect dynamic PCDs
1316 # Gather dynamic PCDs list from each module and their settings from platform
1317 # This interface should be invoked explicitly when platform action is created.
1319 def CollectPlatformDynamicPcds(self
):
1320 for key
in self
.Platform
.Pcds
:
1321 for SinglePcd
in GlobalData
.MixedPcd
:
1322 if (self
.Platform
.Pcds
[key
].TokenCName
, self
.Platform
.Pcds
[key
].TokenSpaceGuidCName
) == SinglePcd
:
1323 for item
in GlobalData
.MixedPcd
[SinglePcd
]:
1324 Pcd_Type
= item
[0].split('_')[-1]
1325 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 \
1326 (Pcd_Type
== TAB_PCDS_DYNAMIC
and self
.Platform
.Pcds
[key
].Type
in PCD_DYNAMIC_TYPE_SET
):
1327 Value
= self
.Platform
.Pcds
[key
]
1328 Value
.TokenCName
= self
.Platform
.Pcds
[key
].TokenCName
+ '_' + Pcd_Type
1330 newkey
= (Value
.TokenCName
, key
[1])
1332 newkey
= (Value
.TokenCName
, key
[1], key
[2])
1333 del self
.Platform
.Pcds
[key
]
1334 self
.Platform
.Pcds
[newkey
] = Value
1338 # for gathering error information
1339 NoDatumTypePcdList
= set()
1341 for InfName
in self
._AsBuildInfList
:
1342 InfName
= mws
.join(self
.WorkspaceDir
, InfName
)
1343 FdfModuleList
.append(os
.path
.normpath(InfName
))
1344 for M
in self
._MaList
:
1345 # F is the Module for which M is the module autogen
1346 for PcdFromModule
in M
.ModulePcdList
+ M
.LibraryPcdList
:
1347 # make sure that the "VOID*" kind of datum has MaxDatumSize set
1348 if PcdFromModule
.DatumType
== TAB_VOID
and not PcdFromModule
.MaxDatumSize
:
1349 NoDatumTypePcdList
.add("%s.%s [%s]" % (PcdFromModule
.TokenSpaceGuidCName
, PcdFromModule
.TokenCName
, M
.MetaFile
))
1351 # Check the PCD from Binary INF or Source INF
1352 if M
.IsBinaryModule
== True:
1353 PcdFromModule
.IsFromBinaryInf
= True
1355 # Check the PCD from DSC or not
1356 PcdFromModule
.IsFromDsc
= (PcdFromModule
.TokenCName
, PcdFromModule
.TokenSpaceGuidCName
) in self
.Platform
.Pcds
1358 if PcdFromModule
.Type
in PCD_DYNAMIC_TYPE_SET
or PcdFromModule
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
1359 if M
.MetaFile
.Path
not in FdfModuleList
:
1360 # If one of the Source built modules listed in the DSC is not listed
1361 # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic
1362 # access method (it is only listed in the DEC file that declares the
1363 # PCD as PcdsDynamic), then build tool will report warning message
1364 # notify the PI that they are attempting to build a module that must
1365 # be included in a flash image in order to be functional. These Dynamic
1366 # PCD will not be added into the Database unless it is used by other
1367 # modules that are included in the FDF file.
1368 if PcdFromModule
.Type
in PCD_DYNAMIC_TYPE_SET
and \
1369 PcdFromModule
.IsFromBinaryInf
== False:
1370 # Print warning message to let the developer make a determine.
1372 # If one of the Source built modules listed in the DSC is not listed in
1373 # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx
1374 # access method (it is only listed in the DEC file that declares the
1375 # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the
1376 # PCD to the Platform's PCD Database.
1377 if PcdFromModule
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
1380 # If a dynamic PCD used by a PEM module/PEI module & DXE module,
1381 # it should be stored in Pcd PEI database, If a dynamic only
1382 # used by DXE module, it should be stored in DXE PCD database.
1383 # The default Phase is DXE
1385 if M
.ModuleType
in SUP_MODULE_SET_PEI
:
1386 PcdFromModule
.Phase
= "PEI"
1387 if PcdFromModule
not in self
._DynaPcdList
_:
1388 self
._DynaPcdList
_.append(PcdFromModule
)
1389 elif PcdFromModule
.Phase
== 'PEI':
1390 # overwrite any the same PCD existing, if Phase is PEI
1391 Index
= self
._DynaPcdList
_.index(PcdFromModule
)
1392 self
._DynaPcdList
_[Index
] = PcdFromModule
1393 elif PcdFromModule
not in self
._NonDynaPcdList
_:
1394 self
._NonDynaPcdList
_.append(PcdFromModule
)
1395 elif PcdFromModule
in self
._NonDynaPcdList
_ and PcdFromModule
.IsFromBinaryInf
== True:
1396 Index
= self
._NonDynaPcdList
_.index(PcdFromModule
)
1397 if self
._NonDynaPcdList
_[Index
].IsFromBinaryInf
== False:
1398 #The PCD from Binary INF will override the same one from source INF
1399 self
._NonDynaPcdList
_.remove (self
._NonDynaPcdList
_[Index
])
1400 PcdFromModule
.Pending
= False
1401 self
._NonDynaPcdList
_.append (PcdFromModule
)
1402 DscModuleSet
= {os
.path
.normpath(ModuleInf
.Path
) for ModuleInf
in self
.Platform
.Modules
}
1403 # add the PCD from modules that listed in FDF but not in DSC to Database
1404 for InfName
in FdfModuleList
:
1405 if InfName
not in DscModuleSet
:
1406 InfClass
= PathClass(InfName
)
1407 M
= self
.BuildDatabase
[InfClass
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
1408 # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source)
1409 # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here.
1410 # For binary module, if in current arch, we need to list the PCDs into database.
1411 if not M
.IsBinaryModule
:
1413 # Override the module PCD setting by platform setting
1414 ModulePcdList
= self
.ApplyPcdSetting(M
, M
.Pcds
)
1415 for PcdFromModule
in ModulePcdList
:
1416 PcdFromModule
.IsFromBinaryInf
= True
1417 PcdFromModule
.IsFromDsc
= False
1418 # Only allow the DynamicEx and Patchable PCD in AsBuild INF
1419 if PcdFromModule
.Type
not in PCD_DYNAMIC_EX_TYPE_SET
and PcdFromModule
.Type
not in TAB_PCDS_PATCHABLE_IN_MODULE
:
1420 EdkLogger
.error("build", AUTOGEN_ERROR
, "PCD setting error",
1422 ExtraData
="\n\tExisted %s PCD %s in:\n\t\t%s\n"
1423 % (PcdFromModule
.Type
, PcdFromModule
.TokenCName
, InfName
))
1424 # make sure that the "VOID*" kind of datum has MaxDatumSize set
1425 if PcdFromModule
.DatumType
== TAB_VOID
and not PcdFromModule
.MaxDatumSize
:
1426 NoDatumTypePcdList
.add("%s.%s [%s]" % (PcdFromModule
.TokenSpaceGuidCName
, PcdFromModule
.TokenCName
, InfName
))
1427 if M
.ModuleType
in SUP_MODULE_SET_PEI
:
1428 PcdFromModule
.Phase
= "PEI"
1429 if PcdFromModule
not in self
._DynaPcdList
_ and PcdFromModule
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
1430 self
._DynaPcdList
_.append(PcdFromModule
)
1431 elif PcdFromModule
not in self
._NonDynaPcdList
_ and PcdFromModule
.Type
in TAB_PCDS_PATCHABLE_IN_MODULE
:
1432 self
._NonDynaPcdList
_.append(PcdFromModule
)
1433 if PcdFromModule
in self
._DynaPcdList
_ and PcdFromModule
.Phase
== 'PEI' and PcdFromModule
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
1434 # Overwrite the phase of any the same PCD existing, if Phase is PEI.
1435 # It is to solve the case that a dynamic PCD used by a PEM module/PEI
1436 # module & DXE module at a same time.
1437 # Overwrite the type of the PCDs in source INF by the type of AsBuild
1438 # INF file as DynamicEx.
1439 Index
= self
._DynaPcdList
_.index(PcdFromModule
)
1440 self
._DynaPcdList
_[Index
].Phase
= PcdFromModule
.Phase
1441 self
._DynaPcdList
_[Index
].Type
= PcdFromModule
.Type
1442 for PcdFromModule
in self
._NonDynaPcdList
_:
1443 # If a PCD is not listed in the DSC file, but binary INF files used by
1444 # this platform all (that use this PCD) list the PCD in a [PatchPcds]
1445 # section, AND all source INF files used by this platform the build
1446 # that use the PCD list the PCD in either a [Pcds] or [PatchPcds]
1447 # section, then the tools must NOT add the PCD to the Platform's PCD
1448 # Database; the build must assign the access method for this PCD as
1449 # PcdsPatchableInModule.
1450 if PcdFromModule
not in self
._DynaPcdList
_:
1452 Index
= self
._DynaPcdList
_.index(PcdFromModule
)
1453 if PcdFromModule
.IsFromDsc
== False and \
1454 PcdFromModule
.Type
in TAB_PCDS_PATCHABLE_IN_MODULE
and \
1455 PcdFromModule
.IsFromBinaryInf
== True and \
1456 self
._DynaPcdList
_[Index
].IsFromBinaryInf
== False:
1457 Index
= self
._DynaPcdList
_.index(PcdFromModule
)
1458 self
._DynaPcdList
_.remove (self
._DynaPcdList
_[Index
])
1460 # print out error information and break the build, if error found
1461 if len(NoDatumTypePcdList
) > 0:
1462 NoDatumTypePcdListString
= "\n\t\t".join(NoDatumTypePcdList
)
1463 EdkLogger
.error("build", AUTOGEN_ERROR
, "PCD setting error",
1465 ExtraData
="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
1466 % NoDatumTypePcdListString
)
1467 self
._NonDynamicPcdList
= self
._NonDynaPcdList
_
1468 self
._DynamicPcdList
= self
._DynaPcdList
_
1470 # Sort dynamic PCD list to:
1471 # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should
1472 # try to be put header of dynamicd List
1473 # 2) If PCD is HII type, the PCD item should be put after unicode type PCD
1475 # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
1477 UnicodePcdArray
= set()
1479 OtherPcdArray
= set()
1481 VpdFile
= VpdInfoFile
.VpdInfoFile()
1482 NeedProcessVpdMapFile
= False
1484 for pcd
in self
.Platform
.Pcds
:
1485 if pcd
not in self
._PlatformPcds
:
1486 self
._PlatformPcds
[pcd
] = self
.Platform
.Pcds
[pcd
]
1488 for item
in self
._PlatformPcds
:
1489 if self
._PlatformPcds
[item
].DatumType
and self
._PlatformPcds
[item
].DatumType
not in [TAB_UINT8
, TAB_UINT16
, TAB_UINT32
, TAB_UINT64
, TAB_VOID
, "BOOLEAN"]:
1490 self
._PlatformPcds
[item
].DatumType
= TAB_VOID
1492 if (self
.Workspace
.ArchList
[-1] == self
.Arch
):
1493 for Pcd
in self
._DynamicPcdList
:
1494 # just pick the a value to determine whether is unicode string type
1495 Sku
= Pcd
.SkuInfoList
.get(TAB_DEFAULT
)
1496 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1498 if Pcd
.DatumType
not in [TAB_UINT8
, TAB_UINT16
, TAB_UINT32
, TAB_UINT64
, TAB_VOID
, "BOOLEAN"]:
1499 Pcd
.DatumType
= TAB_VOID
1501 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
1502 # if found HII type PCD then insert to right of UnicodeIndex
1503 if Pcd
.Type
in [TAB_PCDS_DYNAMIC_VPD
, TAB_PCDS_DYNAMIC_EX_VPD
]:
1504 VpdPcdDict
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)] = Pcd
1506 #Collect DynamicHii PCD values and assign it to DynamicExVpd PCD gEfiMdeModulePkgTokenSpaceGuid.PcdNvStoreDefaultValueBuffer
1507 PcdNvStoreDfBuffer
= VpdPcdDict
.get(("PcdNvStoreDefaultValueBuffer", "gEfiMdeModulePkgTokenSpaceGuid"))
1508 if PcdNvStoreDfBuffer
:
1509 self
.VariableInfo
= self
.CollectVariables(self
._DynamicPcdList
)
1510 vardump
= self
.VariableInfo
.dump()
1513 #According to PCD_DATABASE_INIT in edk2\MdeModulePkg\Include\Guid\PcdDataBaseSignatureGuid.h,
1514 #the max size for string PCD should not exceed USHRT_MAX 65535(0xffff).
1515 #typedef UINT16 SIZE_INFO;
1516 #//SIZE_INFO SizeTable[];
1517 if len(vardump
.split(",")) > 0xffff:
1518 EdkLogger
.error("build", RESOURCE_OVERFLOW
, 'The current length of PCD %s value is %d, it exceeds to the max size of String PCD.' %(".".join([PcdNvStoreDfBuffer
.TokenSpaceGuidCName
,PcdNvStoreDfBuffer
.TokenCName
]) ,len(vardump
.split(","))))
1519 PcdNvStoreDfBuffer
.DefaultValue
= vardump
1520 for skuname
in PcdNvStoreDfBuffer
.SkuInfoList
:
1521 PcdNvStoreDfBuffer
.SkuInfoList
[skuname
].DefaultValue
= vardump
1522 PcdNvStoreDfBuffer
.MaxDatumSize
= str(len(vardump
.split(",")))
1524 #If the end user define [DefaultStores] and [XXX.Menufacturing] in DSC, but forget to configure PcdNvStoreDefaultValueBuffer to PcdsDynamicVpd
1525 if [Pcd
for Pcd
in self
._DynamicPcdList
if Pcd
.UserDefinedDefaultStoresFlag
]:
1526 EdkLogger
.warn("build", "PcdNvStoreDefaultValueBuffer should be defined as PcdsDynamicExVpd in dsc file since the DefaultStores is enabled for this platform.\n%s" %self
.Platform
.MetaFile
.Path
)
1527 PlatformPcds
= sorted(self
._PlatformPcds
.keys())
1529 # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.
1532 for PcdKey
in PlatformPcds
:
1533 Pcd
= self
._PlatformPcds
[PcdKey
]
1534 if Pcd
.Type
in [TAB_PCDS_DYNAMIC_VPD
, TAB_PCDS_DYNAMIC_EX_VPD
] and \
1535 PcdKey
in VpdPcdDict
:
1536 Pcd
= VpdPcdDict
[PcdKey
]
1538 DefaultSku
= Pcd
.SkuInfoList
.get(TAB_DEFAULT
)
1540 PcdValue
= DefaultSku
.DefaultValue
1541 if PcdValue
not in SkuValueMap
:
1542 SkuValueMap
[PcdValue
] = []
1543 VpdFile
.Add(Pcd
, TAB_DEFAULT
, DefaultSku
.VpdOffset
)
1544 SkuValueMap
[PcdValue
].append(DefaultSku
)
1546 for (SkuName
, Sku
) in Pcd
.SkuInfoList
.items():
1547 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1548 PcdValue
= Sku
.DefaultValue
1550 PcdValue
= Pcd
.DefaultValue
1551 if Sku
.VpdOffset
!= TAB_STAR
:
1552 if PcdValue
.startswith("{"):
1554 elif PcdValue
.startswith("L"):
1559 VpdOffset
= int(Sku
.VpdOffset
)
1562 VpdOffset
= int(Sku
.VpdOffset
, 16)
1564 EdkLogger
.error("build", FORMAT_INVALID
, "Invalid offset value %s for PCD %s.%s." % (Sku
.VpdOffset
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
1565 if VpdOffset
% Alignment
!= 0:
1566 if PcdValue
.startswith("{"):
1567 EdkLogger
.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
), File
=self
.MetaFile
)
1569 EdkLogger
.error("build", FORMAT_INVALID
, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Alignment
))
1570 if PcdValue
not in SkuValueMap
:
1571 SkuValueMap
[PcdValue
] = []
1572 VpdFile
.Add(Pcd
, SkuName
, Sku
.VpdOffset
)
1573 SkuValueMap
[PcdValue
].append(Sku
)
1574 # if the offset of a VPD is *, then it need to be fixed up by third party tool.
1575 if not NeedProcessVpdMapFile
and Sku
.VpdOffset
== TAB_STAR
:
1576 NeedProcessVpdMapFile
= True
1577 if self
.Platform
.VpdToolGuid
is None or self
.Platform
.VpdToolGuid
== '':
1578 EdkLogger
.error("Build", FILE_NOT_FOUND
, \
1579 "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.")
1581 VpdSkuMap
[PcdKey
] = SkuValueMap
1583 # Fix the PCDs define in VPD PCD section that never referenced by module.
1584 # An example is PCD for signature usage.
1586 for DscPcd
in PlatformPcds
:
1587 DscPcdEntry
= self
._PlatformPcds
[DscPcd
]
1588 if DscPcdEntry
.Type
in [TAB_PCDS_DYNAMIC_VPD
, TAB_PCDS_DYNAMIC_EX_VPD
]:
1589 if not (self
.Platform
.VpdToolGuid
is None or self
.Platform
.VpdToolGuid
== ''):
1591 for VpdPcd
in VpdFile
._VpdArray
:
1592 # This PCD has been referenced by module
1593 if (VpdPcd
.TokenSpaceGuidCName
== DscPcdEntry
.TokenSpaceGuidCName
) and \
1594 (VpdPcd
.TokenCName
== DscPcdEntry
.TokenCName
):
1597 # Not found, it should be signature
1599 # just pick the a value to determine whether is unicode string type
1601 SkuObjList
= list(DscPcdEntry
.SkuInfoList
.items())
1602 DefaultSku
= DscPcdEntry
.SkuInfoList
.get(TAB_DEFAULT
)
1604 defaultindex
= SkuObjList
.index((TAB_DEFAULT
, DefaultSku
))
1605 SkuObjList
[0], SkuObjList
[defaultindex
] = SkuObjList
[defaultindex
], SkuObjList
[0]
1606 for (SkuName
, Sku
) in SkuObjList
:
1607 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1609 # Need to iterate DEC pcd information to get the value & datumtype
1610 for eachDec
in self
.PackageList
:
1611 for DecPcd
in eachDec
.Pcds
:
1612 DecPcdEntry
= eachDec
.Pcds
[DecPcd
]
1613 if (DecPcdEntry
.TokenSpaceGuidCName
== DscPcdEntry
.TokenSpaceGuidCName
) and \
1614 (DecPcdEntry
.TokenCName
== DscPcdEntry
.TokenCName
):
1615 # Print warning message to let the developer make a determine.
1616 EdkLogger
.warn("build", "Unreferenced vpd pcd used!",
1617 File
=self
.MetaFile
, \
1618 ExtraData
= "PCD: %s.%s used in the DSC file %s is unreferenced." \
1619 %(DscPcdEntry
.TokenSpaceGuidCName
, DscPcdEntry
.TokenCName
, self
.Platform
.MetaFile
.Path
))
1621 DscPcdEntry
.DatumType
= DecPcdEntry
.DatumType
1622 DscPcdEntry
.DefaultValue
= DecPcdEntry
.DefaultValue
1623 DscPcdEntry
.TokenValue
= DecPcdEntry
.TokenValue
1624 DscPcdEntry
.TokenSpaceGuidValue
= eachDec
.Guids
[DecPcdEntry
.TokenSpaceGuidCName
]
1625 # Only fix the value while no value provided in DSC file.
1626 if not Sku
.DefaultValue
:
1627 DscPcdEntry
.SkuInfoList
[list(DscPcdEntry
.SkuInfoList
.keys())[0]].DefaultValue
= DecPcdEntry
.DefaultValue
1629 if DscPcdEntry
not in self
._DynamicPcdList
:
1630 self
._DynamicPcdList
.append(DscPcdEntry
)
1631 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1632 PcdValue
= Sku
.DefaultValue
1634 PcdValue
= DscPcdEntry
.DefaultValue
1635 if Sku
.VpdOffset
!= TAB_STAR
:
1636 if PcdValue
.startswith("{"):
1638 elif PcdValue
.startswith("L"):
1643 VpdOffset
= int(Sku
.VpdOffset
)
1646 VpdOffset
= int(Sku
.VpdOffset
, 16)
1648 EdkLogger
.error("build", FORMAT_INVALID
, "Invalid offset value %s for PCD %s.%s." % (Sku
.VpdOffset
, DscPcdEntry
.TokenSpaceGuidCName
, DscPcdEntry
.TokenCName
))
1649 if VpdOffset
% Alignment
!= 0:
1650 if PcdValue
.startswith("{"):
1651 EdkLogger
.warn("build", "The offset value of PCD %s.%s is not 8-byte aligned!" %(DscPcdEntry
.TokenSpaceGuidCName
, DscPcdEntry
.TokenCName
), File
=self
.MetaFile
)
1653 EdkLogger
.error("build", FORMAT_INVALID
, 'The offset value of PCD %s.%s should be %s-byte aligned.' % (DscPcdEntry
.TokenSpaceGuidCName
, DscPcdEntry
.TokenCName
, Alignment
))
1654 if PcdValue
not in SkuValueMap
:
1655 SkuValueMap
[PcdValue
] = []
1656 VpdFile
.Add(DscPcdEntry
, SkuName
, Sku
.VpdOffset
)
1657 SkuValueMap
[PcdValue
].append(Sku
)
1658 if not NeedProcessVpdMapFile
and Sku
.VpdOffset
== TAB_STAR
:
1659 NeedProcessVpdMapFile
= True
1660 if DscPcdEntry
.DatumType
== TAB_VOID
and PcdValue
.startswith("L"):
1661 UnicodePcdArray
.add(DscPcdEntry
)
1662 elif len(Sku
.VariableName
) > 0:
1663 HiiPcdArray
.add(DscPcdEntry
)
1665 OtherPcdArray
.add(DscPcdEntry
)
1667 # if the offset of a VPD is *, then it need to be fixed up by third party tool.
1668 VpdSkuMap
[DscPcd
] = SkuValueMap
1669 if (self
.Platform
.FlashDefinition
is None or self
.Platform
.FlashDefinition
== '') and \
1670 VpdFile
.GetCount() != 0:
1671 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
,
1672 "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self
.Platform
.MetaFile
))
1674 if VpdFile
.GetCount() != 0:
1676 self
.FixVpdOffset(VpdFile
)
1678 self
.FixVpdOffset(self
.UpdateNVStoreMaxSize(VpdFile
))
1679 PcdNvStoreDfBuffer
= [item
for item
in self
._DynamicPcdList
if item
.TokenCName
== "PcdNvStoreDefaultValueBuffer" and item
.TokenSpaceGuidCName
== "gEfiMdeModulePkgTokenSpaceGuid"]
1680 if PcdNvStoreDfBuffer
:
1681 PcdName
,PcdGuid
= PcdNvStoreDfBuffer
[0].TokenCName
, PcdNvStoreDfBuffer
[0].TokenSpaceGuidCName
1682 if (PcdName
,PcdGuid
) in VpdSkuMap
:
1683 DefaultSku
= PcdNvStoreDfBuffer
[0].SkuInfoList
.get(TAB_DEFAULT
)
1684 VpdSkuMap
[(PcdName
,PcdGuid
)] = {DefaultSku
.DefaultValue
:[SkuObj
for SkuObj
in PcdNvStoreDfBuffer
[0].SkuInfoList
.values() ]}
1686 # Process VPD map file generated by third party BPDG tool
1687 if NeedProcessVpdMapFile
:
1688 VpdMapFilePath
= os
.path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
, "%s.map" % self
.Platform
.VpdToolGuid
)
1689 if os
.path
.exists(VpdMapFilePath
):
1690 VpdFile
.Read(VpdMapFilePath
)
1692 # Fixup TAB_STAR offset
1693 for pcd
in VpdSkuMap
:
1694 vpdinfo
= VpdFile
.GetVpdInfo(pcd
)
1696 # just pick the a value to determine whether is unicode string type
1698 for pcdvalue
in VpdSkuMap
[pcd
]:
1699 for sku
in VpdSkuMap
[pcd
][pcdvalue
]:
1700 for item
in vpdinfo
:
1701 if item
[2] == pcdvalue
:
1702 sku
.VpdOffset
= item
[1]
1704 EdkLogger
.error("build", FILE_READ_FAILURE
, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath
)
1706 # Delete the DynamicPcdList At the last time enter into this function
1707 for Pcd
in self
._DynamicPcdList
:
1708 # just pick the a value to determine whether is unicode string type
1709 Sku
= Pcd
.SkuInfoList
.get(TAB_DEFAULT
)
1710 Sku
.VpdOffset
= Sku
.VpdOffset
.strip()
1712 if Pcd
.DatumType
not in [TAB_UINT8
, TAB_UINT16
, TAB_UINT32
, TAB_UINT64
, TAB_VOID
, "BOOLEAN"]:
1713 Pcd
.DatumType
= TAB_VOID
1715 PcdValue
= Sku
.DefaultValue
1716 if Pcd
.DatumType
== TAB_VOID
and PcdValue
.startswith("L"):
1717 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
1718 UnicodePcdArray
.add(Pcd
)
1719 elif len(Sku
.VariableName
) > 0:
1720 # if found HII type PCD then insert to right of UnicodeIndex
1721 HiiPcdArray
.add(Pcd
)
1723 OtherPcdArray
.add(Pcd
)
1724 del self
._DynamicPcdList
[:]
1725 self
._DynamicPcdList
.extend(list(UnicodePcdArray
))
1726 self
._DynamicPcdList
.extend(list(HiiPcdArray
))
1727 self
._DynamicPcdList
.extend(list(OtherPcdArray
))
1728 allskuset
= [(SkuName
, Sku
.SkuId
) for pcd
in self
._DynamicPcdList
for (SkuName
, Sku
) in pcd
.SkuInfoList
.items()]
1729 for pcd
in self
._DynamicPcdList
:
1730 if len(pcd
.SkuInfoList
) == 1:
1731 for (SkuName
, SkuId
) in allskuset
:
1732 if isinstance(SkuId
, str) and eval(SkuId
) == 0 or SkuId
== 0:
1734 pcd
.SkuInfoList
[SkuName
] = copy
.deepcopy(pcd
.SkuInfoList
[TAB_DEFAULT
])
1735 pcd
.SkuInfoList
[SkuName
].SkuId
= SkuId
1736 pcd
.SkuInfoList
[SkuName
].SkuIdName
= SkuName
1738 def FixVpdOffset(self
, VpdFile
):
1739 FvPath
= os
.path
.join(self
.BuildDir
, TAB_FV_DIRECTORY
)
1740 if not os
.path
.exists(FvPath
):
1744 EdkLogger
.error("build", FILE_WRITE_FAILURE
, "Fail to create FV folder under %s" % self
.BuildDir
)
1746 VpdFilePath
= os
.path
.join(FvPath
, "%s.txt" % self
.Platform
.VpdToolGuid
)
1748 if VpdFile
.Write(VpdFilePath
):
1749 # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.
1751 for ToolDef
in self
.ToolDefinition
.values():
1752 if TAB_GUID
in ToolDef
and ToolDef
[TAB_GUID
] == self
.Platform
.VpdToolGuid
:
1753 if "PATH" not in ToolDef
:
1754 EdkLogger
.error("build", ATTRIBUTE_NOT_AVAILABLE
, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self
.Platform
.VpdToolGuid
)
1755 BPDGToolName
= ToolDef
["PATH"]
1757 # Call third party GUID BPDG tool.
1758 if BPDGToolName
is not None:
1759 VpdInfoFile
.CallExtenalBPDGTool(BPDGToolName
, VpdFilePath
)
1761 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.")
1763 ## Return the platform build data object
1766 return self
.BuildDatabase
[self
.MetaFile
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
1768 ## Return platform name
1771 return self
.Platform
.PlatformName
1773 ## Return the meta file GUID
1776 return self
.Platform
.Guid
1778 ## Return the platform version
1781 return self
.Platform
.Version
1783 ## Return the FDF file name
1786 if self
.Workspace
.FdfFile
:
1787 RetVal
= mws
.join(self
.WorkspaceDir
, self
.Workspace
.FdfFile
)
1792 ## Return the build output directory platform specifies
1794 def OutputDir(self
):
1795 return self
.Platform
.OutputDirectory
1797 ## Return the directory to store all intermediate and final files built
1800 if os
.path
.isabs(self
.OutputDir
):
1801 GlobalData
.gBuildDirectory
= RetVal
= path
.join(
1802 path
.abspath(self
.OutputDir
),
1803 self
.BuildTarget
+ "_" + self
.ToolChain
,
1806 GlobalData
.gBuildDirectory
= RetVal
= path
.join(
1809 self
.BuildTarget
+ "_" + self
.ToolChain
,
1813 ## Return directory of platform makefile
1815 # @retval string Makefile directory
1818 def MakeFileDir(self
):
1819 return path
.join(self
.BuildDir
, self
.Arch
)
1821 ## Return build command string
1823 # @retval string Build command string
1826 def BuildCommand(self
):
1828 if "MAKE" in self
.ToolDefinition
and "PATH" in self
.ToolDefinition
["MAKE"]:
1829 RetVal
+= _SplitOption(self
.ToolDefinition
["MAKE"]["PATH"])
1830 if "FLAGS" in self
.ToolDefinition
["MAKE"]:
1831 NewOption
= self
.ToolDefinition
["MAKE"]["FLAGS"].strip()
1833 RetVal
+= _SplitOption(NewOption
)
1834 if "MAKE" in self
.EdkIIBuildOption
:
1835 if "FLAGS" in self
.EdkIIBuildOption
["MAKE"]:
1836 Flags
= self
.EdkIIBuildOption
["MAKE"]["FLAGS"]
1837 if Flags
.startswith('='):
1838 RetVal
= [RetVal
[0]] + [Flags
[1:]]
1840 RetVal
.append(Flags
)
1843 ## Get tool chain definition
1845 # Get each tool definition for given tool chain from tools_def.txt and platform
1848 def ToolDefinition(self
):
1849 ToolDefinition
= self
.Workspace
.ToolDef
.ToolsDefTxtDictionary
1850 if TAB_TOD_DEFINES_COMMAND_TYPE
not in self
.Workspace
.ToolDef
.ToolsDefTxtDatabase
:
1851 EdkLogger
.error('build', RESOURCE_NOT_AVAILABLE
, "No tools found in configuration",
1852 ExtraData
="[%s]" % self
.MetaFile
)
1855 for Def
in ToolDefinition
:
1856 Target
, Tag
, Arch
, Tool
, Attr
= Def
.split("_")
1857 if Target
!= self
.BuildTarget
or Tag
!= self
.ToolChain
or Arch
!= self
.Arch
:
1860 Value
= ToolDefinition
[Def
]
1861 # don't record the DLL
1863 DllPathList
.add(Value
)
1866 if Tool
not in RetVal
:
1868 RetVal
[Tool
][Attr
] = Value
1871 if GlobalData
.gOptions
.SilentMode
and "MAKE" in RetVal
:
1872 if "FLAGS" not in RetVal
["MAKE"]:
1873 RetVal
["MAKE"]["FLAGS"] = ""
1874 RetVal
["MAKE"]["FLAGS"] += " -s"
1877 for Attr
in RetVal
[Tool
]:
1878 Value
= RetVal
[Tool
][Attr
]
1879 if Tool
in self
._BuildOptionWithToolDef
(RetVal
) and Attr
in self
._BuildOptionWithToolDef
(RetVal
)[Tool
]:
1880 # check if override is indicated
1881 if self
._BuildOptionWithToolDef
(RetVal
)[Tool
][Attr
].startswith('='):
1882 Value
= self
._BuildOptionWithToolDef
(RetVal
)[Tool
][Attr
][1:]
1885 Value
+= " " + self
._BuildOptionWithToolDef
(RetVal
)[Tool
][Attr
]
1887 Value
= self
._BuildOptionWithToolDef
(RetVal
)[Tool
][Attr
]
1890 # Don't put MAKE definition in the file
1892 ToolsDef
+= "%s = %s\n" % (Tool
, Value
)
1894 # Don't put MAKE definition in the file
1899 ToolsDef
+= "%s_%s = %s\n" % (Tool
, Attr
, Value
)
1902 SaveFileOnChange(self
.ToolDefinitionFile
, ToolsDef
, False)
1903 for DllPath
in DllPathList
:
1904 os
.environ
["PATH"] = DllPath
+ os
.pathsep
+ os
.environ
["PATH"]
1905 os
.environ
["MAKE_FLAGS"] = MakeFlags
1909 ## Return the paths of tools
1911 def ToolDefinitionFile(self
):
1912 return os
.path
.join(self
.MakeFileDir
, "TOOLS_DEF." + self
.Arch
)
1914 ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.
1916 def ToolChainFamily(self
):
1917 ToolDefinition
= self
.Workspace
.ToolDef
.ToolsDefTxtDatabase
1918 if TAB_TOD_DEFINES_FAMILY
not in ToolDefinition \
1919 or self
.ToolChain
not in ToolDefinition
[TAB_TOD_DEFINES_FAMILY
] \
1920 or not ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
.ToolChain
]:
1921 EdkLogger
.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
1923 RetVal
= TAB_COMPILER_MSFT
1925 RetVal
= ToolDefinition
[TAB_TOD_DEFINES_FAMILY
][self
.ToolChain
]
1929 def BuildRuleFamily(self
):
1930 ToolDefinition
= self
.Workspace
.ToolDef
.ToolsDefTxtDatabase
1931 if TAB_TOD_DEFINES_BUILDRULEFAMILY
not in ToolDefinition \
1932 or self
.ToolChain
not in ToolDefinition
[TAB_TOD_DEFINES_BUILDRULEFAMILY
] \
1933 or not ToolDefinition
[TAB_TOD_DEFINES_BUILDRULEFAMILY
][self
.ToolChain
]:
1934 EdkLogger
.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
1936 return TAB_COMPILER_MSFT
1938 return ToolDefinition
[TAB_TOD_DEFINES_BUILDRULEFAMILY
][self
.ToolChain
]
1940 ## Return the build options specific for all modules in this platform
1942 def BuildOption(self
):
1943 return self
._ExpandBuildOption
(self
.Platform
.BuildOptions
)
1945 def _BuildOptionWithToolDef(self
, ToolDef
):
1946 return self
._ExpandBuildOption
(self
.Platform
.BuildOptions
, ToolDef
=ToolDef
)
1948 ## Return the build options specific for EDK modules in this platform
1950 def EdkBuildOption(self
):
1951 return self
._ExpandBuildOption
(self
.Platform
.BuildOptions
, EDK_NAME
)
1953 ## Return the build options specific for EDKII modules in this platform
1955 def EdkIIBuildOption(self
):
1956 return self
._ExpandBuildOption
(self
.Platform
.BuildOptions
, EDKII_NAME
)
1958 ## Parse build_rule.txt in Conf Directory.
1960 # @retval BuildRule object
1963 def BuildRule(self
):
1964 BuildRuleFile
= None
1965 if TAB_TAT_DEFINES_BUILD_RULE_CONF
in self
.Workspace
.TargetTxt
.TargetTxtDictionary
:
1966 BuildRuleFile
= self
.Workspace
.TargetTxt
.TargetTxtDictionary
[TAB_TAT_DEFINES_BUILD_RULE_CONF
]
1967 if not BuildRuleFile
:
1968 BuildRuleFile
= gDefaultBuildRuleFile
1969 RetVal
= BuildRule(BuildRuleFile
)
1970 if RetVal
._FileVersion
== "":
1971 RetVal
._FileVersion
= AutoGenReqBuildRuleVerNum
1973 if RetVal
._FileVersion
< AutoGenReqBuildRuleVerNum
:
1974 # If Build Rule's version is less than the version number required by the tools, halting the build.
1975 EdkLogger
.error("build", AUTOGEN_ERROR
,
1976 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])"\
1977 % (RetVal
._FileVersion
, AutoGenReqBuildRuleVerNum
))
1980 ## Summarize the packages used by modules in this platform
1982 def PackageList(self
):
1984 for La
in self
.LibraryAutoGenList
:
1985 RetVal
.update(La
.DependentPackageList
)
1986 for Ma
in self
.ModuleAutoGenList
:
1987 RetVal
.update(Ma
.DependentPackageList
)
1988 #Collect package set information from INF of FDF
1989 for ModuleFile
in self
._AsBuildModuleList
:
1990 if ModuleFile
in self
.Platform
.Modules
:
1992 ModuleData
= self
.BuildDatabase
[ModuleFile
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
1993 RetVal
.update(ModuleData
.Packages
)
1997 def NonDynamicPcdDict(self
):
1998 return {(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
):Pcd
for Pcd
in self
.NonDynamicPcdList
}
2000 ## Get list of non-dynamic PCDs
2002 def NonDynamicPcdList(self
):
2003 if not self
._NonDynamicPcdList
:
2004 self
.CollectPlatformDynamicPcds()
2005 return self
._NonDynamicPcdList
2007 ## Get list of dynamic PCDs
2009 def DynamicPcdList(self
):
2010 if not self
._DynamicPcdList
:
2011 self
.CollectPlatformDynamicPcds()
2012 return self
._DynamicPcdList
2014 ## Generate Token Number for all PCD
2016 def PcdTokenNumber(self
):
2017 RetVal
= OrderedDict()
2020 # Make the Dynamic and DynamicEx PCD use within different TokenNumber area.
2024 # TokenNumber 0 ~ 10
2026 # TokeNumber 11 ~ 20
2028 for Pcd
in self
.DynamicPcdList
:
2029 if Pcd
.Phase
== "PEI" and Pcd
.Type
in PCD_DYNAMIC_TYPE_SET
:
2030 EdkLogger
.debug(EdkLogger
.DEBUG_5
, "%s %s (%s) -> %d" % (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Phase
, TokenNumber
))
2031 RetVal
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2034 for Pcd
in self
.DynamicPcdList
:
2035 if Pcd
.Phase
== "PEI" and Pcd
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
2036 EdkLogger
.debug(EdkLogger
.DEBUG_5
, "%s %s (%s) -> %d" % (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Phase
, TokenNumber
))
2037 RetVal
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2040 for Pcd
in self
.DynamicPcdList
:
2041 if Pcd
.Phase
== "DXE" and Pcd
.Type
in PCD_DYNAMIC_TYPE_SET
:
2042 EdkLogger
.debug(EdkLogger
.DEBUG_5
, "%s %s (%s) -> %d" % (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Phase
, TokenNumber
))
2043 RetVal
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2046 for Pcd
in self
.DynamicPcdList
:
2047 if Pcd
.Phase
== "DXE" and Pcd
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
2048 EdkLogger
.debug(EdkLogger
.DEBUG_5
, "%s %s (%s) -> %d" % (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Phase
, TokenNumber
))
2049 RetVal
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2052 for Pcd
in self
.NonDynamicPcdList
:
2053 RetVal
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
] = TokenNumber
2059 for ModuleFile
in self
.Platform
.Modules
:
2068 self
.Platform
.Modules
[ModuleFile
].M
= Ma
2069 return [x
.M
for x
in self
.Platform
.Modules
.values()]
2071 ## Summarize ModuleAutoGen objects of all modules to be built for this platform
2073 def ModuleAutoGenList(self
):
2075 for Ma
in self
._MaList
:
2076 if Ma
not in RetVal
:
2080 ## Summarize ModuleAutoGen objects of all libraries to be built for this platform
2082 def LibraryAutoGenList(self
):
2084 for Ma
in self
._MaList
:
2085 for La
in Ma
.LibraryAutoGenList
:
2086 if La
not in RetVal
:
2088 if Ma
not in La
.ReferenceModules
:
2089 La
.ReferenceModules
.append(Ma
)
2092 ## Test if a module is supported by the platform
2094 # An error will be raised directly if the module or its arch is not supported
2095 # by the platform or current configuration
2097 def ValidModule(self
, Module
):
2098 return Module
in self
.Platform
.Modules
or Module
in self
.Platform
.LibraryInstances \
2099 or Module
in self
._AsBuildModuleList
2101 ## Resolve the library classes in a module to library instances
2103 # This method will not only resolve library classes but also sort the library
2104 # instances according to the dependency-ship.
2106 # @param Module The module from which the library classes will be resolved
2108 # @retval library_list List of library instances sorted
2110 def ApplyLibraryInstance(self
, Module
):
2111 # Cover the case that the binary INF file is list in the FDF file but not DSC file, return empty list directly
2112 if str(Module
) not in self
.Platform
.Modules
:
2115 return GetModuleLibInstances(Module
,
2124 ## Override PCD setting (type, value, ...)
2126 # @param ToPcd The PCD to be overridden
2127 # @param FromPcd The PCD overriding from
2129 def _OverridePcd(self
, ToPcd
, FromPcd
, Module
="", Msg
="", Library
=""):
2131 # in case there's PCDs coming from FDF file, which have no type given.
2132 # at this point, ToPcd.Type has the type found from dependent
2135 TokenCName
= ToPcd
.TokenCName
2136 for PcdItem
in GlobalData
.MixedPcd
:
2137 if (ToPcd
.TokenCName
, ToPcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
2138 TokenCName
= PcdItem
[0]
2140 if FromPcd
is not None:
2141 if ToPcd
.Pending
and FromPcd
.Type
:
2142 ToPcd
.Type
= FromPcd
.Type
2143 elif ToPcd
.Type
and FromPcd
.Type\
2144 and ToPcd
.Type
!= FromPcd
.Type
and ToPcd
.Type
in FromPcd
.Type
:
2145 if ToPcd
.Type
.strip() == TAB_PCDS_DYNAMIC_EX
:
2146 ToPcd
.Type
= FromPcd
.Type
2147 elif ToPcd
.Type
and FromPcd
.Type \
2148 and ToPcd
.Type
!= FromPcd
.Type
:
2150 Module
= str(Module
) + " 's library file (" + str(Library
) + ")"
2151 EdkLogger
.error("build", OPTION_CONFLICT
, "Mismatched PCD type",
2152 ExtraData
="%s.%s is used as [%s] in module %s, but as [%s] in %s."\
2153 % (ToPcd
.TokenSpaceGuidCName
, TokenCName
,
2154 ToPcd
.Type
, Module
, FromPcd
.Type
, Msg
),
2157 if FromPcd
.MaxDatumSize
:
2158 ToPcd
.MaxDatumSize
= FromPcd
.MaxDatumSize
2159 ToPcd
.MaxSizeUserSet
= FromPcd
.MaxDatumSize
2160 if FromPcd
.DefaultValue
:
2161 ToPcd
.DefaultValue
= FromPcd
.DefaultValue
2162 if FromPcd
.TokenValue
:
2163 ToPcd
.TokenValue
= FromPcd
.TokenValue
2164 if FromPcd
.DatumType
:
2165 ToPcd
.DatumType
= FromPcd
.DatumType
2166 if FromPcd
.SkuInfoList
:
2167 ToPcd
.SkuInfoList
= FromPcd
.SkuInfoList
2168 if FromPcd
.UserDefinedDefaultStoresFlag
:
2169 ToPcd
.UserDefinedDefaultStoresFlag
= FromPcd
.UserDefinedDefaultStoresFlag
2170 # Add Flexible PCD format parse
2171 if ToPcd
.DefaultValue
:
2173 ToPcd
.DefaultValue
= ValueExpressionEx(ToPcd
.DefaultValue
, ToPcd
.DatumType
, self
.Workspace
._GuidDict
)(True)
2174 except BadExpression
as Value
:
2175 EdkLogger
.error('Parser', FORMAT_INVALID
, 'PCD [%s.%s] Value "%s", %s' %(ToPcd
.TokenSpaceGuidCName
, ToPcd
.TokenCName
, ToPcd
.DefaultValue
, Value
),
2178 # check the validation of datum
2179 IsValid
, Cause
= CheckPcdDatum(ToPcd
.DatumType
, ToPcd
.DefaultValue
)
2181 EdkLogger
.error('build', FORMAT_INVALID
, Cause
, File
=self
.MetaFile
,
2182 ExtraData
="%s.%s" % (ToPcd
.TokenSpaceGuidCName
, TokenCName
))
2183 ToPcd
.validateranges
= FromPcd
.validateranges
2184 ToPcd
.validlists
= FromPcd
.validlists
2185 ToPcd
.expressions
= FromPcd
.expressions
2186 ToPcd
.CustomAttribute
= FromPcd
.CustomAttribute
2188 if FromPcd
is not None and ToPcd
.DatumType
== TAB_VOID
and not ToPcd
.MaxDatumSize
:
2189 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "No MaxDatumSize specified for PCD %s.%s" \
2190 % (ToPcd
.TokenSpaceGuidCName
, TokenCName
))
2191 Value
= ToPcd
.DefaultValue
2193 ToPcd
.MaxDatumSize
= '1'
2194 elif Value
[0] == 'L':
2195 ToPcd
.MaxDatumSize
= str((len(Value
) - 2) * 2)
2196 elif Value
[0] == '{':
2197 ToPcd
.MaxDatumSize
= str(len(Value
.split(',')))
2199 ToPcd
.MaxDatumSize
= str(len(Value
) - 1)
2201 # apply default SKU for dynamic PCDS if specified one is not available
2202 if (ToPcd
.Type
in PCD_DYNAMIC_TYPE_SET
or ToPcd
.Type
in PCD_DYNAMIC_EX_TYPE_SET
) \
2203 and not ToPcd
.SkuInfoList
:
2204 if self
.Platform
.SkuName
in self
.Platform
.SkuIds
:
2205 SkuName
= self
.Platform
.SkuName
2207 SkuName
= TAB_DEFAULT
2208 ToPcd
.SkuInfoList
= {
2209 SkuName
: SkuInfoClass(SkuName
, self
.Platform
.SkuIds
[SkuName
][0], '', '', '', '', '', ToPcd
.DefaultValue
)
2212 ## Apply PCD setting defined platform to a module
2214 # @param Module The module from which the PCD setting will be overridden
2216 # @retval PCD_list The list PCDs with settings from platform
2218 def ApplyPcdSetting(self
, Module
, Pcds
, Library
=""):
2219 # for each PCD in module
2220 for Name
, Guid
in Pcds
:
2221 PcdInModule
= Pcds
[Name
, Guid
]
2222 # find out the PCD setting in platform
2223 if (Name
, Guid
) in self
.Platform
.Pcds
:
2224 PcdInPlatform
= self
.Platform
.Pcds
[Name
, Guid
]
2226 PcdInPlatform
= None
2227 # then override the settings if any
2228 self
._OverridePcd
(PcdInModule
, PcdInPlatform
, Module
, Msg
="DSC PCD sections", Library
=Library
)
2229 # resolve the VariableGuid value
2230 for SkuId
in PcdInModule
.SkuInfoList
:
2231 Sku
= PcdInModule
.SkuInfoList
[SkuId
]
2232 if Sku
.VariableGuid
== '': continue
2233 Sku
.VariableGuidValue
= GuidValue(Sku
.VariableGuid
, self
.PackageList
, self
.MetaFile
.Path
)
2234 if Sku
.VariableGuidValue
is None:
2235 PackageList
= "\n\t".join(str(P
) for P
in self
.PackageList
)
2238 RESOURCE_NOT_AVAILABLE
,
2239 "Value of GUID [%s] is not found in" % Sku
.VariableGuid
,
2240 ExtraData
=PackageList
+ "\n\t(used with %s.%s from module %s)" \
2241 % (Guid
, Name
, str(Module
)),
2245 # override PCD settings with module specific setting
2246 if Module
in self
.Platform
.Modules
:
2247 PlatformModule
= self
.Platform
.Modules
[str(Module
)]
2248 for Key
in PlatformModule
.Pcds
:
2249 if GlobalData
.BuildOptionPcd
:
2250 for pcd
in GlobalData
.BuildOptionPcd
:
2251 (TokenSpaceGuidCName
, TokenCName
, FieldName
, pcdvalue
, _
) = pcd
2252 if (TokenCName
, TokenSpaceGuidCName
) == Key
and FieldName
=="":
2253 PlatformModule
.Pcds
[Key
].DefaultValue
= pcdvalue
2254 PlatformModule
.Pcds
[Key
].PcdValueFromComm
= pcdvalue
2260 elif Key
in GlobalData
.MixedPcd
:
2261 for PcdItem
in GlobalData
.MixedPcd
[Key
]:
2263 ToPcd
= Pcds
[PcdItem
]
2267 self
._OverridePcd
(ToPcd
, PlatformModule
.Pcds
[Key
], Module
, Msg
="DSC Components Module scoped PCD section", Library
=Library
)
2268 # use PCD value to calculate the MaxDatumSize when it is not specified
2269 for Name
, Guid
in Pcds
:
2270 Pcd
= Pcds
[Name
, Guid
]
2271 if Pcd
.DatumType
== TAB_VOID
and not Pcd
.MaxDatumSize
:
2272 Pcd
.MaxSizeUserSet
= None
2273 Value
= Pcd
.DefaultValue
2275 Pcd
.MaxDatumSize
= '1'
2276 elif Value
[0] == 'L':
2277 Pcd
.MaxDatumSize
= str((len(Value
) - 2) * 2)
2278 elif Value
[0] == '{':
2279 Pcd
.MaxDatumSize
= str(len(Value
.split(',')))
2281 Pcd
.MaxDatumSize
= str(len(Value
) - 1)
2282 return list(Pcds
.values())
2286 ## Calculate the priority value of the build option
2288 # @param Key Build option definition contain: TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
2290 # @retval Value Priority value based on the priority list.
2292 def CalculatePriorityValue(self
, Key
):
2293 Target
, ToolChain
, Arch
, CommandType
, Attr
= Key
.split('_')
2294 PriorityValue
= 0x11111
2295 if Target
== TAB_STAR
:
2296 PriorityValue
&= 0x01111
2297 if ToolChain
== TAB_STAR
:
2298 PriorityValue
&= 0x10111
2299 if Arch
== TAB_STAR
:
2300 PriorityValue
&= 0x11011
2301 if CommandType
== TAB_STAR
:
2302 PriorityValue
&= 0x11101
2303 if Attr
== TAB_STAR
:
2304 PriorityValue
&= 0x11110
2306 return self
.PrioList
["0x%0.5x" % PriorityValue
]
2309 ## Expand * in build option key
2311 # @param Options Options to be expanded
2312 # @param ToolDef Use specified ToolDef instead of full version.
2313 # This is needed during initialization to prevent
2314 # infinite recursion betweeh BuildOptions,
2315 # ToolDefinition, and this function.
2317 # @retval options Options expanded
2319 def _ExpandBuildOption(self
, Options
, ModuleStyle
=None, ToolDef
=None):
2321 ToolDef
= self
.ToolDefinition
2328 # Construct a list contain the build options which need override.
2332 # Key[0] -- tool family
2333 # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE
2335 if (Key
[0] == self
.BuildRuleFamily
and
2336 (ModuleStyle
is None or len(Key
) < 3 or (len(Key
) > 2 and Key
[2] == ModuleStyle
))):
2337 Target
, ToolChain
, Arch
, CommandType
, Attr
= Key
[1].split('_')
2338 if (Target
== self
.BuildTarget
or Target
== TAB_STAR
) and\
2339 (ToolChain
== self
.ToolChain
or ToolChain
== TAB_STAR
) and\
2340 (Arch
== self
.Arch
or Arch
== TAB_STAR
) and\
2341 Options
[Key
].startswith("="):
2343 if OverrideList
.get(Key
[1]) is not None:
2344 OverrideList
.pop(Key
[1])
2345 OverrideList
[Key
[1]] = Options
[Key
]
2348 # Use the highest priority value.
2350 if (len(OverrideList
) >= 2):
2351 KeyList
= list(OverrideList
.keys())
2352 for Index
in range(len(KeyList
)):
2353 NowKey
= KeyList
[Index
]
2354 Target1
, ToolChain1
, Arch1
, CommandType1
, Attr1
= NowKey
.split("_")
2355 for Index1
in range(len(KeyList
) - Index
- 1):
2356 NextKey
= KeyList
[Index1
+ Index
+ 1]
2358 # Compare two Key, if one is included by another, choose the higher priority one
2360 Target2
, ToolChain2
, Arch2
, CommandType2
, Attr2
= NextKey
.split("_")
2361 if (Target1
== Target2
or Target1
== TAB_STAR
or Target2
== TAB_STAR
) and\
2362 (ToolChain1
== ToolChain2
or ToolChain1
== TAB_STAR
or ToolChain2
== TAB_STAR
) and\
2363 (Arch1
== Arch2
or Arch1
== TAB_STAR
or Arch2
== TAB_STAR
) and\
2364 (CommandType1
== CommandType2
or CommandType1
== TAB_STAR
or CommandType2
== TAB_STAR
) and\
2365 (Attr1
== Attr2
or Attr1
== TAB_STAR
or Attr2
== TAB_STAR
):
2367 if self
.CalculatePriorityValue(NowKey
) > self
.CalculatePriorityValue(NextKey
):
2368 if Options
.get((self
.BuildRuleFamily
, NextKey
)) is not None:
2369 Options
.pop((self
.BuildRuleFamily
, NextKey
))
2371 if Options
.get((self
.BuildRuleFamily
, NowKey
)) is not None:
2372 Options
.pop((self
.BuildRuleFamily
, NowKey
))
2375 if ModuleStyle
is not None and len (Key
) > 2:
2376 # Check Module style is EDK or EDKII.
2377 # Only append build option for the matched style module.
2378 if ModuleStyle
== EDK_NAME
and Key
[2] != EDK_NAME
:
2380 elif ModuleStyle
== EDKII_NAME
and Key
[2] != EDKII_NAME
:
2383 Target
, Tag
, Arch
, Tool
, Attr
= Key
[1].split("_")
2384 # if tool chain family doesn't match, skip it
2385 if Tool
in ToolDef
and Family
!= "":
2386 FamilyIsNull
= False
2387 if ToolDef
[Tool
].get(TAB_TOD_DEFINES_BUILDRULEFAMILY
, "") != "":
2388 if Family
!= ToolDef
[Tool
][TAB_TOD_DEFINES_BUILDRULEFAMILY
]:
2390 elif Family
!= ToolDef
[Tool
][TAB_TOD_DEFINES_FAMILY
]:
2393 # expand any wildcard
2394 if Target
== TAB_STAR
or Target
== self
.BuildTarget
:
2395 if Tag
== TAB_STAR
or Tag
== self
.ToolChain
:
2396 if Arch
== TAB_STAR
or Arch
== self
.Arch
:
2397 if Tool
not in BuildOptions
:
2398 BuildOptions
[Tool
] = {}
2399 if Attr
!= "FLAGS" or Attr
not in BuildOptions
[Tool
] or Options
[Key
].startswith('='):
2400 BuildOptions
[Tool
][Attr
] = Options
[Key
]
2402 # append options for the same tool except PATH
2404 BuildOptions
[Tool
][Attr
] += " " + Options
[Key
]
2406 BuildOptions
[Tool
][Attr
] = Options
[Key
]
2407 # Build Option Family has been checked, which need't to be checked again for family.
2408 if FamilyMatch
or FamilyIsNull
:
2412 if ModuleStyle
is not None and len (Key
) > 2:
2413 # Check Module style is EDK or EDKII.
2414 # Only append build option for the matched style module.
2415 if ModuleStyle
== EDK_NAME
and Key
[2] != EDK_NAME
:
2417 elif ModuleStyle
== EDKII_NAME
and Key
[2] != EDKII_NAME
:
2420 Target
, Tag
, Arch
, Tool
, Attr
= Key
[1].split("_")
2421 # if tool chain family doesn't match, skip it
2422 if Tool
not in ToolDef
or Family
== "":
2424 # option has been added before
2425 if Family
!= ToolDef
[Tool
][TAB_TOD_DEFINES_FAMILY
]:
2428 # expand any wildcard
2429 if Target
== TAB_STAR
or Target
== self
.BuildTarget
:
2430 if Tag
== TAB_STAR
or Tag
== self
.ToolChain
:
2431 if Arch
== TAB_STAR
or Arch
== self
.Arch
:
2432 if Tool
not in BuildOptions
:
2433 BuildOptions
[Tool
] = {}
2434 if Attr
!= "FLAGS" or Attr
not in BuildOptions
[Tool
] or Options
[Key
].startswith('='):
2435 BuildOptions
[Tool
][Attr
] = Options
[Key
]
2437 # append options for the same tool except PATH
2439 BuildOptions
[Tool
][Attr
] += " " + Options
[Key
]
2441 BuildOptions
[Tool
][Attr
] = Options
[Key
]
2444 ## Append build options in platform to a module
2446 # @param Module The module to which the build options will be appended
2448 # @retval options The options appended with build options in platform
2450 def ApplyBuildOption(self
, Module
):
2451 # Get the different options for the different style module
2452 PlatformOptions
= self
.EdkIIBuildOption
2453 ModuleTypeOptions
= self
.Platform
.GetBuildOptionsByModuleType(EDKII_NAME
, Module
.ModuleType
)
2454 ModuleTypeOptions
= self
._ExpandBuildOption
(ModuleTypeOptions
)
2455 ModuleOptions
= self
._ExpandBuildOption
(Module
.BuildOptions
)
2456 if Module
in self
.Platform
.Modules
:
2457 PlatformModule
= self
.Platform
.Modules
[str(Module
)]
2458 PlatformModuleOptions
= self
._ExpandBuildOption
(PlatformModule
.BuildOptions
)
2460 PlatformModuleOptions
= {}
2462 BuildRuleOrder
= None
2463 for Options
in [self
.ToolDefinition
, ModuleOptions
, PlatformOptions
, ModuleTypeOptions
, PlatformModuleOptions
]:
2464 for Tool
in Options
:
2465 for Attr
in Options
[Tool
]:
2466 if Attr
== TAB_TOD_DEFINES_BUILDRULEORDER
:
2467 BuildRuleOrder
= Options
[Tool
][Attr
]
2469 AllTools
= set(list(ModuleOptions
.keys()) + list(PlatformOptions
.keys()) +
2470 list(PlatformModuleOptions
.keys()) + list(ModuleTypeOptions
.keys()) +
2471 list(self
.ToolDefinition
.keys()))
2472 BuildOptions
= defaultdict(lambda: defaultdict(str))
2473 for Tool
in AllTools
:
2474 for Options
in [self
.ToolDefinition
, ModuleOptions
, PlatformOptions
, ModuleTypeOptions
, PlatformModuleOptions
]:
2475 if Tool
not in Options
:
2477 for Attr
in Options
[Tool
]:
2479 # Do not generate it in Makefile
2481 if Attr
== TAB_TOD_DEFINES_BUILDRULEORDER
:
2483 Value
= Options
[Tool
][Attr
]
2484 # check if override is indicated
2485 if Value
.startswith('='):
2486 BuildOptions
[Tool
][Attr
] = mws
.handleWsMacro(Value
[1:])
2489 BuildOptions
[Tool
][Attr
] += " " + mws
.handleWsMacro(Value
)
2491 BuildOptions
[Tool
][Attr
] = mws
.handleWsMacro(Value
)
2493 return BuildOptions
, BuildRuleOrder
2496 # extend lists contained in a dictionary with lists stored in another dictionary
2497 # if CopyToDict is not derived from DefaultDict(list) then this may raise exception
2499 def ExtendCopyDictionaryLists(CopyToDict
, CopyFromDict
):
2500 for Key
in CopyFromDict
:
2501 CopyToDict
[Key
].extend(CopyFromDict
[Key
])
2503 # Create a directory specified by a set of path elements and return the full path
2504 def _MakeDir(PathList
):
2505 RetVal
= path
.join(*PathList
)
2506 CreateDirectory(RetVal
)
2509 ## ModuleAutoGen class
2511 # This class encapsules the AutoGen behaviors for the build tools. In addition to
2512 # the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according
2513 # to the [depex] section in module's inf file.
2515 class ModuleAutoGen(AutoGen
):
2516 # call super().__init__ then call the worker function with different parameter count
2517 def __init__(self
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
2518 if not hasattr(self
, "_Init"):
2519 self
._InitWorker
(Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
)
2522 ## Cache the timestamps of metafiles of every module in a class attribute
2526 def __new__(cls
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
):
2527 # check if this module is employed by active platform
2528 if not PlatformAutoGen(Workspace
, args
[0], Target
, Toolchain
, Arch
).ValidModule(MetaFile
):
2529 EdkLogger
.verbose("Module [%s] for [%s] is not employed by active platform\n" \
2532 return super(ModuleAutoGen
, cls
).__new
__(cls
, Workspace
, MetaFile
, Target
, Toolchain
, Arch
, *args
, **kwargs
)
2534 ## Initialize ModuleAutoGen
2536 # @param Workspace EdkIIWorkspaceBuild object
2537 # @param ModuleFile The path of module file
2538 # @param Target Build target (DEBUG, RELEASE)
2539 # @param Toolchain Name of tool chain
2540 # @param Arch The arch the module supports
2541 # @param PlatformFile Platform meta-file
2543 def _InitWorker(self
, Workspace
, ModuleFile
, Target
, Toolchain
, Arch
, PlatformFile
):
2544 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "AutoGen module [%s] [%s]" % (ModuleFile
, Arch
))
2545 GlobalData
.gProcessingFile
= "%s [%s, %s, %s]" % (ModuleFile
, Arch
, Toolchain
, Target
)
2547 self
.Workspace
= Workspace
2548 self
.WorkspaceDir
= Workspace
.WorkspaceDir
2549 self
.MetaFile
= ModuleFile
2550 self
.PlatformInfo
= PlatformAutoGen(Workspace
, PlatformFile
, Target
, Toolchain
, Arch
)
2552 self
.SourceDir
= self
.MetaFile
.SubDir
2553 self
.SourceDir
= mws
.relpath(self
.SourceDir
, self
.WorkspaceDir
)
2555 self
.ToolChain
= Toolchain
2556 self
.BuildTarget
= Target
2558 self
.ToolChainFamily
= self
.PlatformInfo
.ToolChainFamily
2559 self
.BuildRuleFamily
= self
.PlatformInfo
.BuildRuleFamily
2561 self
.IsCodeFileCreated
= False
2562 self
.IsAsBuiltInfCreated
= False
2563 self
.DepexGenerated
= False
2565 self
.BuildDatabase
= self
.Workspace
.BuildDatabase
2566 self
.BuildRuleOrder
= None
2569 self
._PcdComments
= OrderedListDict()
2570 self
._GuidComments
= OrderedListDict()
2571 self
._ProtocolComments
= OrderedListDict()
2572 self
._PpiComments
= OrderedListDict()
2573 self
._BuildTargets
= None
2574 self
._IntroBuildTargetList
= None
2575 self
._FinalBuildTargetList
= None
2576 self
._FileTypes
= None
2578 self
.AutoGenDepSet
= set()
2579 self
.ReferenceModules
= []
2584 return "%s [%s]" % (self
.MetaFile
, self
.Arch
)
2586 # Get FixedAtBuild Pcds of this Module
2588 def FixedAtBuildPcds(self
):
2590 for Pcd
in self
.ModulePcdList
:
2591 if Pcd
.Type
!= TAB_PCDS_FIXED_AT_BUILD
:
2593 if Pcd
not in RetVal
:
2598 def FixedVoidTypePcds(self
):
2600 for Pcd
in self
.FixedAtBuildPcds
:
2601 if Pcd
.DatumType
== TAB_VOID
:
2602 if '{}.{}'.format(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) not in RetVal
:
2603 RetVal
['{}.{}'.format(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
)] = Pcd
.DefaultValue
2607 def UniqueBaseName(self
):
2608 BaseName
= self
.Name
2609 for Module
in self
.PlatformInfo
.ModuleAutoGenList
:
2610 if Module
.MetaFile
== self
.MetaFile
:
2612 if Module
.Name
== self
.Name
:
2613 if uuid
.UUID(Module
.Guid
) == uuid
.UUID(self
.Guid
):
2614 EdkLogger
.error("build", FILE_DUPLICATED
, 'Modules have same BaseName and FILE_GUID:\n'
2615 ' %s\n %s' % (Module
.MetaFile
, self
.MetaFile
))
2616 BaseName
= '%s_%s' % (self
.Name
, self
.Guid
)
2619 # Macros could be used in build_rule.txt (also Makefile)
2622 return OrderedDict((
2623 ("WORKSPACE" ,self
.WorkspaceDir
),
2624 ("MODULE_NAME" ,self
.Name
),
2625 ("MODULE_NAME_GUID" ,self
.UniqueBaseName
),
2626 ("MODULE_GUID" ,self
.Guid
),
2627 ("MODULE_VERSION" ,self
.Version
),
2628 ("MODULE_TYPE" ,self
.ModuleType
),
2629 ("MODULE_FILE" ,str(self
.MetaFile
)),
2630 ("MODULE_FILE_BASE_NAME" ,self
.MetaFile
.BaseName
),
2631 ("MODULE_RELATIVE_DIR" ,self
.SourceDir
),
2632 ("MODULE_DIR" ,self
.SourceDir
),
2633 ("BASE_NAME" ,self
.Name
),
2634 ("ARCH" ,self
.Arch
),
2635 ("TOOLCHAIN" ,self
.ToolChain
),
2636 ("TOOLCHAIN_TAG" ,self
.ToolChain
),
2637 ("TOOL_CHAIN_TAG" ,self
.ToolChain
),
2638 ("TARGET" ,self
.BuildTarget
),
2639 ("BUILD_DIR" ,self
.PlatformInfo
.BuildDir
),
2640 ("BIN_DIR" ,os
.path
.join(self
.PlatformInfo
.BuildDir
, self
.Arch
)),
2641 ("LIB_DIR" ,os
.path
.join(self
.PlatformInfo
.BuildDir
, self
.Arch
)),
2642 ("MODULE_BUILD_DIR" ,self
.BuildDir
),
2643 ("OUTPUT_DIR" ,self
.OutputDir
),
2644 ("DEBUG_DIR" ,self
.DebugDir
),
2645 ("DEST_DIR_OUTPUT" ,self
.OutputDir
),
2646 ("DEST_DIR_DEBUG" ,self
.DebugDir
),
2647 ("PLATFORM_NAME" ,self
.PlatformInfo
.Name
),
2648 ("PLATFORM_GUID" ,self
.PlatformInfo
.Guid
),
2649 ("PLATFORM_VERSION" ,self
.PlatformInfo
.Version
),
2650 ("PLATFORM_RELATIVE_DIR" ,self
.PlatformInfo
.SourceDir
),
2651 ("PLATFORM_DIR" ,mws
.join(self
.WorkspaceDir
, self
.PlatformInfo
.SourceDir
)),
2652 ("PLATFORM_OUTPUT_DIR" ,self
.PlatformInfo
.OutputDir
),
2653 ("FFS_OUTPUT_DIR" ,self
.FfsOutputDir
)
2656 ## Return the module build data object
2659 return self
.BuildDatabase
[self
.MetaFile
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
2661 ## Return the module name
2664 return self
.Module
.BaseName
2666 ## Return the module DxsFile if exist
2669 return self
.Module
.DxsFile
2671 ## Return the module meta-file GUID
2675 # To build same module more than once, the module path with FILE_GUID overridden has
2676 # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the real path
2677 # in DSC. The overridden GUID can be retrieved from file name
2679 if os
.path
.basename(self
.MetaFile
.File
) != os
.path
.basename(self
.MetaFile
.Path
):
2681 # Length of GUID is 36
2683 return os
.path
.basename(self
.MetaFile
.Path
)[:36]
2684 return self
.Module
.Guid
2686 ## Return the module version
2689 return self
.Module
.Version
2691 ## Return the module type
2693 def ModuleType(self
):
2694 return self
.Module
.ModuleType
2696 ## Return the component type (for Edk.x style of module)
2698 def ComponentType(self
):
2699 return self
.Module
.ComponentType
2701 ## Return the build type
2703 def BuildType(self
):
2704 return self
.Module
.BuildType
2706 ## Return the PCD_IS_DRIVER setting
2708 def PcdIsDriver(self
):
2709 return self
.Module
.PcdIsDriver
2711 ## Return the autogen version, i.e. module meta-file version
2713 def AutoGenVersion(self
):
2714 return self
.Module
.AutoGenVersion
2716 ## Check if the module is library or not
2718 def IsLibrary(self
):
2719 return bool(self
.Module
.LibraryClass
)
2721 ## Check if the module is binary module or not
2723 def IsBinaryModule(self
):
2724 return self
.Module
.IsBinaryModule
2726 ## Return the directory to store intermediate files of the module
2730 self
.PlatformInfo
.BuildDir
,
2733 self
.MetaFile
.BaseName
2736 ## Return the directory to store the intermediate object files of the module
2738 def OutputDir(self
):
2739 return _MakeDir((self
.BuildDir
, "OUTPUT"))
2741 ## Return the directory path to store ffs file
2743 def FfsOutputDir(self
):
2744 if GlobalData
.gFdfParser
:
2745 return path
.join(self
.PlatformInfo
.BuildDir
, TAB_FV_DIRECTORY
, "Ffs", self
.Guid
+ self
.Name
)
2748 ## Return the directory to store auto-gened source files of the module
2751 return _MakeDir((self
.BuildDir
, "DEBUG"))
2753 ## Return the path of custom file
2755 def CustomMakefile(self
):
2757 for Type
in self
.Module
.CustomMakefile
:
2758 MakeType
= gMakeTypeMap
[Type
] if Type
in gMakeTypeMap
else 'nmake'
2759 File
= os
.path
.join(self
.SourceDir
, self
.Module
.CustomMakefile
[Type
])
2760 RetVal
[MakeType
] = File
2763 ## Return the directory of the makefile
2765 # @retval string The directory string of module's makefile
2768 def MakeFileDir(self
):
2769 return self
.BuildDir
2771 ## Return build command string
2773 # @retval string Build command string
2776 def BuildCommand(self
):
2777 return self
.PlatformInfo
.BuildCommand
2779 ## Get object list of all packages the module and its dependent libraries belong to
2781 # @retval list The list of package object
2784 def DerivedPackageList(self
):
2786 for M
in [self
.Module
] + self
.DependentLibraryList
:
2787 for Package
in M
.Packages
:
2788 if Package
in PackageList
:
2790 PackageList
.append(Package
)
2793 ## Get the depex string
2795 # @return : a string contain all depex expression.
2796 def _GetDepexExpresionString(self
):
2799 ## DPX_SOURCE IN Define section.
2800 if self
.Module
.DxsFile
:
2802 for M
in [self
.Module
] + self
.DependentLibraryList
:
2803 Filename
= M
.MetaFile
.Path
2804 InfObj
= InfSectionParser
.InfSectionParser(Filename
)
2805 DepexExpressionList
= InfObj
.GetDepexExpresionList()
2806 for DepexExpression
in DepexExpressionList
:
2807 for key
in DepexExpression
:
2808 Arch
, ModuleType
= key
2809 DepexExpr
= [x
for x
in DepexExpression
[key
] if not str(x
).startswith('#')]
2810 # the type of build module is USER_DEFINED.
2811 # All different DEPEX section tags would be copied into the As Built INF file
2812 # and there would be separate DEPEX section tags
2813 if self
.ModuleType
.upper() == SUP_MODULE_USER_DEFINED
:
2814 if (Arch
.upper() == self
.Arch
.upper()) and (ModuleType
.upper() != TAB_ARCH_COMMON
):
2815 DepexList
.append({(Arch
, ModuleType
): DepexExpr
})
2817 if Arch
.upper() == TAB_ARCH_COMMON
or \
2818 (Arch
.upper() == self
.Arch
.upper() and \
2819 ModuleType
.upper() in [TAB_ARCH_COMMON
, self
.ModuleType
.upper()]):
2820 DepexList
.append({(Arch
, ModuleType
): DepexExpr
})
2822 #the type of build module is USER_DEFINED.
2823 if self
.ModuleType
.upper() == SUP_MODULE_USER_DEFINED
:
2824 for Depex
in DepexList
:
2826 DepexStr
+= '[Depex.%s.%s]\n' % key
2827 DepexStr
+= '\n'.join('# '+ val
for val
in Depex
[key
])
2830 return '[Depex.%s]\n' % self
.Arch
2833 #the type of build module not is USER_DEFINED.
2835 for Depex
in DepexList
:
2840 for D
in Depex
.values():
2841 DepexStr
+= ' '.join(val
for val
in D
)
2842 Index
= DepexStr
.find('END')
2843 if Index
> -1 and Index
== len(DepexStr
) - 3:
2844 DepexStr
= DepexStr
[:-3]
2845 DepexStr
= DepexStr
.strip()
2848 DepexStr
= DepexStr
.lstrip('(').rstrip(')').strip()
2850 return '[Depex.%s]\n' % self
.Arch
2851 return '[Depex.%s]\n# ' % self
.Arch
+ DepexStr
2853 ## Merge dependency expression
2855 # @retval list The token list of the dependency expression after parsed
2858 def DepexList(self
):
2859 if self
.DxsFile
or self
.IsLibrary
or TAB_DEPENDENCY_EXPRESSION_FILE
in self
.FileTypes
:
2864 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expression
2866 for M
in [self
.Module
] + self
.DependentLibraryList
:
2868 for D
in M
.Depex
[self
.Arch
, self
.ModuleType
]:
2870 DepexList
.append('AND')
2871 DepexList
.append('(')
2872 #replace D with value if D is FixedAtBuild PCD
2876 NewList
.append(item
)
2878 FixedVoidTypePcds
= {}
2879 if item
in self
.FixedVoidTypePcds
:
2880 FixedVoidTypePcds
= self
.FixedVoidTypePcds
2881 elif M
in self
.PlatformInfo
.LibraryAutoGenList
:
2882 Index
= self
.PlatformInfo
.LibraryAutoGenList
.index(M
)
2883 FixedVoidTypePcds
= self
.PlatformInfo
.LibraryAutoGenList
[Index
].FixedVoidTypePcds
2884 if item
not in FixedVoidTypePcds
:
2885 EdkLogger
.error("build", FORMAT_INVALID
, "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type in the module.".format(item
))
2887 Value
= FixedVoidTypePcds
[item
]
2888 if len(Value
.split(',')) != 16:
2889 EdkLogger
.error("build", FORMAT_INVALID
,
2890 "{} used in [Depex] section should be used as FixedAtBuild type and VOID* datum type and 16 bytes in the module.".format(item
))
2891 NewList
.append(Value
)
2892 DepexList
.extend(NewList
)
2893 if DepexList
[-1] == 'END': # no need of a END at this time
2895 DepexList
.append(')')
2898 EdkLogger
.verbose("DEPEX[%s] (+%s) = %s" % (self
.Name
, M
.BaseName
, DepexList
))
2899 if 'BEFORE' in DepexList
or 'AFTER' in DepexList
:
2901 if len(DepexList
) > 0:
2902 EdkLogger
.verbose('')
2903 return {self
.ModuleType
:DepexList
}
2905 ## Merge dependency expression
2907 # @retval list The token list of the dependency expression after parsed
2910 def DepexExpressionDict(self
):
2911 if self
.DxsFile
or self
.IsLibrary
or TAB_DEPENDENCY_EXPRESSION_FILE
in self
.FileTypes
:
2914 DepexExpressionString
= ''
2916 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
2918 for M
in [self
.Module
] + self
.DependentLibraryList
:
2920 for D
in M
.DepexExpression
[self
.Arch
, self
.ModuleType
]:
2921 if DepexExpressionString
!= '':
2922 DepexExpressionString
+= ' AND '
2923 DepexExpressionString
+= '('
2924 DepexExpressionString
+= D
2925 DepexExpressionString
= DepexExpressionString
.rstrip('END').strip()
2926 DepexExpressionString
+= ')'
2929 EdkLogger
.verbose("DEPEX[%s] (+%s) = %s" % (self
.Name
, M
.BaseName
, DepexExpressionString
))
2930 if 'BEFORE' in DepexExpressionString
or 'AFTER' in DepexExpressionString
:
2932 if len(DepexExpressionString
) > 0:
2933 EdkLogger
.verbose('')
2935 return {self
.ModuleType
:DepexExpressionString
}
2937 # Get the tiano core user extension, it is contain dependent library.
2938 # @retval: a list contain tiano core userextension.
2940 def _GetTianoCoreUserExtensionList(self
):
2941 TianoCoreUserExtentionList
= []
2942 for M
in [self
.Module
] + self
.DependentLibraryList
:
2943 Filename
= M
.MetaFile
.Path
2944 InfObj
= InfSectionParser
.InfSectionParser(Filename
)
2945 TianoCoreUserExtenList
= InfObj
.GetUserExtensionTianoCore()
2946 for TianoCoreUserExtent
in TianoCoreUserExtenList
:
2947 for Section
in TianoCoreUserExtent
:
2948 ItemList
= Section
.split(TAB_SPLIT
)
2950 if len(ItemList
) == 4:
2952 if Arch
.upper() == TAB_ARCH_COMMON
or Arch
.upper() == self
.Arch
.upper():
2954 TianoCoreList
.extend([TAB_SECTION_START
+ Section
+ TAB_SECTION_END
])
2955 TianoCoreList
.extend(TianoCoreUserExtent
[Section
][:])
2956 TianoCoreList
.append('\n')
2957 TianoCoreUserExtentionList
.append(TianoCoreList
)
2959 return TianoCoreUserExtentionList
2961 ## Return the list of specification version required for the module
2963 # @retval list The list of specification defined in module file
2966 def Specification(self
):
2967 return self
.Module
.Specification
2969 ## Tool option for the module build
2971 # @param PlatformInfo The object of PlatformBuildInfo
2972 # @retval dict The dict containing valid options
2975 def BuildOption(self
):
2976 RetVal
, self
.BuildRuleOrder
= self
.PlatformInfo
.ApplyBuildOption(self
.Module
)
2977 if self
.BuildRuleOrder
:
2978 self
.BuildRuleOrder
= ['.%s' % Ext
for Ext
in self
.BuildRuleOrder
.split()]
2981 ## Get include path list from tool option for the module build
2983 # @retval list The include path list
2986 def BuildOptionIncPathList(self
):
2988 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT
2989 # is the former use /I , the Latter used -I to specify include directories
2991 if self
.PlatformInfo
.ToolChainFamily
in (TAB_COMPILER_MSFT
):
2992 BuildOptIncludeRegEx
= gBuildOptIncludePatternMsft
2993 elif self
.PlatformInfo
.ToolChainFamily
in ('INTEL', 'GCC', 'RVCT'):
2994 BuildOptIncludeRegEx
= gBuildOptIncludePatternOther
2997 # New ToolChainFamily, don't known whether there is option to specify include directories
3002 for Tool
in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):
3004 FlagOption
= self
.BuildOption
[Tool
]['FLAGS']
3008 if self
.ToolChainFamily
!= 'RVCT':
3009 IncPathList
= [NormPath(Path
, self
.Macros
) for Path
in BuildOptIncludeRegEx
.findall(FlagOption
)]
3012 # RVCT may specify a list of directory seperated by commas
3015 for Path
in BuildOptIncludeRegEx
.findall(FlagOption
):
3016 PathList
= GetSplitList(Path
, TAB_COMMA_SPLIT
)
3017 IncPathList
.extend(NormPath(PathEntry
, self
.Macros
) for PathEntry
in PathList
)
3020 # EDK II modules must not reference header files outside of the packages they depend on or
3021 # within the module's directory tree. Report error if violation.
3023 if GlobalData
.gDisableIncludePathCheck
== False:
3024 for Path
in IncPathList
:
3025 if (Path
not in self
.IncludePathList
) and (CommonPath([Path
, self
.MetaFile
.Dir
]) != self
.MetaFile
.Dir
):
3026 ErrMsg
= "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path
, Tool
, FlagOption
)
3027 EdkLogger
.error("build",
3030 File
=str(self
.MetaFile
))
3031 RetVal
+= IncPathList
3034 ## Return a list of files which can be built from source
3036 # What kind of files can be built is determined by build rules in
3037 # $(CONF_DIRECTORY)/build_rule.txt and toolchain family.
3040 def SourceFileList(self
):
3042 ToolChainTagSet
= {"", TAB_STAR
, self
.ToolChain
}
3043 ToolChainFamilySet
= {"", TAB_STAR
, self
.ToolChainFamily
, self
.BuildRuleFamily
}
3044 for F
in self
.Module
.Sources
:
3046 if F
.TagName
not in ToolChainTagSet
:
3047 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "The toolchain [%s] for processing file [%s] is found, "
3048 "but [%s] is currently used" % (F
.TagName
, str(F
), self
.ToolChain
))
3050 # match tool chain family or build rule family
3051 if F
.ToolChainFamily
not in ToolChainFamilySet
:
3054 "The file [%s] must be built by tools of [%s], " \
3055 "but current toolchain family is [%s], buildrule family is [%s]" \
3056 % (str(F
), F
.ToolChainFamily
, self
.ToolChainFamily
, self
.BuildRuleFamily
))
3059 # add the file path into search path list for file including
3060 if F
.Dir
not in self
.IncludePathList
:
3061 self
.IncludePathList
.insert(0, F
.Dir
)
3064 self
._MatchBuildRuleOrder
(RetVal
)
3067 self
._ApplyBuildRule
(F
, TAB_UNKNOWN_FILE
)
3070 def _MatchBuildRuleOrder(self
, FileList
):
3073 for SingleFile
in FileList
:
3074 if self
.BuildRuleOrder
and SingleFile
.Ext
in self
.BuildRuleOrder
and SingleFile
.Ext
in self
.BuildRules
:
3075 key
= SingleFile
.Path
.rsplit(SingleFile
.Ext
,1)[0]
3076 if key
in Order_Dict
:
3077 Order_Dict
[key
].append(SingleFile
.Ext
)
3079 Order_Dict
[key
] = [SingleFile
.Ext
]
3082 for F
in Order_Dict
:
3083 if len(Order_Dict
[F
]) > 1:
3084 Order_Dict
[F
].sort(key
=lambda i
: self
.BuildRuleOrder
.index(i
))
3085 for Ext
in Order_Dict
[F
][1:]:
3086 RemoveList
.append(F
+ Ext
)
3088 for item
in RemoveList
:
3089 FileList
.remove(item
)
3093 ## Return the list of unicode files
3095 def UnicodeFileList(self
):
3096 return self
.FileTypes
.get(TAB_UNICODE_FILE
,[])
3098 ## Return the list of vfr files
3100 def VfrFileList(self
):
3101 return self
.FileTypes
.get(TAB_VFR_FILE
, [])
3103 ## Return the list of Image Definition files
3105 def IdfFileList(self
):
3106 return self
.FileTypes
.get(TAB_IMAGE_FILE
,[])
3108 ## Return a list of files which can be built from binary
3110 # "Build" binary files are just to copy them to build directory.
3112 # @retval list The list of files which can be built later
3115 def BinaryFileList(self
):
3117 for F
in self
.Module
.Binaries
:
3118 if F
.Target
not in [TAB_ARCH_COMMON
, TAB_STAR
] and F
.Target
!= self
.BuildTarget
:
3121 self
._ApplyBuildRule
(F
, F
.Type
, BinaryFileList
=RetVal
)
3125 def BuildRules(self
):
3127 BuildRuleDatabase
= self
.PlatformInfo
.BuildRule
3128 for Type
in BuildRuleDatabase
.FileTypeList
:
3129 #first try getting build rule by BuildRuleFamily
3130 RuleObject
= BuildRuleDatabase
[Type
, self
.BuildType
, self
.Arch
, self
.BuildRuleFamily
]
3132 # build type is always module type, but ...
3133 if self
.ModuleType
!= self
.BuildType
:
3134 RuleObject
= BuildRuleDatabase
[Type
, self
.ModuleType
, self
.Arch
, self
.BuildRuleFamily
]
3135 #second try getting build rule by ToolChainFamily
3137 RuleObject
= BuildRuleDatabase
[Type
, self
.BuildType
, self
.Arch
, self
.ToolChainFamily
]
3139 # build type is always module type, but ...
3140 if self
.ModuleType
!= self
.BuildType
:
3141 RuleObject
= BuildRuleDatabase
[Type
, self
.ModuleType
, self
.Arch
, self
.ToolChainFamily
]
3144 RuleObject
= RuleObject
.Instantiate(self
.Macros
)
3145 RetVal
[Type
] = RuleObject
3146 for Ext
in RuleObject
.SourceFileExtList
:
3147 RetVal
[Ext
] = RuleObject
3150 def _ApplyBuildRule(self
, File
, FileType
, BinaryFileList
=None):
3151 if self
._BuildTargets
is None:
3152 self
._IntroBuildTargetList
= set()
3153 self
._FinalBuildTargetList
= set()
3154 self
._BuildTargets
= defaultdict(set)
3155 self
._FileTypes
= defaultdict(set)
3157 if not BinaryFileList
:
3158 BinaryFileList
= self
.BinaryFileList
3160 SubDirectory
= os
.path
.join(self
.OutputDir
, File
.SubDir
)
3161 if not os
.path
.exists(SubDirectory
):
3162 CreateDirectory(SubDirectory
)
3168 # Make sure to get build rule order value
3172 while Index
< len(SourceList
):
3173 Source
= SourceList
[Index
]
3177 CreateDirectory(Source
.Dir
)
3179 if File
.IsBinary
and File
== Source
and File
in BinaryFileList
:
3180 # Skip all files that are not binary libraries
3181 if not self
.IsLibrary
:
3183 RuleObject
= self
.BuildRules
[TAB_DEFAULT_BINARY_FILE
]
3184 elif FileType
in self
.BuildRules
:
3185 RuleObject
= self
.BuildRules
[FileType
]
3186 elif Source
.Ext
in self
.BuildRules
:
3187 RuleObject
= self
.BuildRules
[Source
.Ext
]
3189 # stop at no more rules
3191 self
._FinalBuildTargetList
.add(LastTarget
)
3194 FileType
= RuleObject
.SourceFileType
3195 self
._FileTypes
[FileType
].add(Source
)
3197 # stop at STATIC_LIBRARY for library
3198 if self
.IsLibrary
and FileType
== TAB_STATIC_LIBRARY
:
3200 self
._FinalBuildTargetList
.add(LastTarget
)
3203 Target
= RuleObject
.Apply(Source
, self
.BuildRuleOrder
)
3206 self
._FinalBuildTargetList
.add(LastTarget
)
3208 elif not Target
.Outputs
:
3209 # Only do build for target with outputs
3210 self
._FinalBuildTargetList
.add(Target
)
3212 self
._BuildTargets
[FileType
].add(Target
)
3214 if not Source
.IsBinary
and Source
== File
:
3215 self
._IntroBuildTargetList
.add(Target
)
3217 # to avoid cyclic rule
3218 if FileType
in RuleChain
:
3221 RuleChain
.add(FileType
)
3222 SourceList
.extend(Target
.Outputs
)
3224 FileType
= TAB_UNKNOWN_FILE
3228 if self
._BuildTargets
is None:
3229 self
._IntroBuildTargetList
= set()
3230 self
._FinalBuildTargetList
= set()
3231 self
._BuildTargets
= defaultdict(set)
3232 self
._FileTypes
= defaultdict(set)
3234 #TRICK: call SourceFileList property to apply build rule for source files
3237 #TRICK: call _GetBinaryFileList to apply build rule for binary files
3240 return self
._BuildTargets
3243 def IntroTargetList(self
):
3245 return self
._IntroBuildTargetList
3248 def CodaTargetList(self
):
3250 return self
._FinalBuildTargetList
3253 def FileTypes(self
):
3255 return self
._FileTypes
3257 ## Get the list of package object the module depends on
3259 # @retval list The package object list
3262 def DependentPackageList(self
):
3263 return self
.Module
.Packages
3265 ## Return the list of auto-generated code file
3267 # @retval list The list of auto-generated file
3270 def AutoGenFileList(self
):
3271 AutoGenUniIdf
= self
.BuildType
!= 'UEFI_HII'
3272 UniStringBinBuffer
= BytesIO()
3273 IdfGenBinBuffer
= BytesIO()
3275 AutoGenC
= TemplateString()
3276 AutoGenH
= TemplateString()
3277 StringH
= TemplateString()
3278 StringIdf
= TemplateString()
3279 GenC
.CreateCode(self
, AutoGenC
, AutoGenH
, StringH
, AutoGenUniIdf
, UniStringBinBuffer
, StringIdf
, AutoGenUniIdf
, IdfGenBinBuffer
)
3281 # AutoGen.c is generated if there are library classes in inf, or there are object files
3283 if str(AutoGenC
) != "" and (len(self
.Module
.LibraryClasses
) > 0
3284 or TAB_OBJECT_FILE
in self
.FileTypes
):
3285 AutoFile
= PathClass(gAutoGenCodeFileName
, self
.DebugDir
)
3286 RetVal
[AutoFile
] = str(AutoGenC
)
3287 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3288 if str(AutoGenH
) != "":
3289 AutoFile
= PathClass(gAutoGenHeaderFileName
, self
.DebugDir
)
3290 RetVal
[AutoFile
] = str(AutoGenH
)
3291 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3292 if str(StringH
) != "":
3293 AutoFile
= PathClass(gAutoGenStringFileName
% {"module_name":self
.Name
}, self
.DebugDir
)
3294 RetVal
[AutoFile
] = str(StringH
)
3295 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3296 if UniStringBinBuffer
is not None and UniStringBinBuffer
.getvalue() != b
"":
3297 AutoFile
= PathClass(gAutoGenStringFormFileName
% {"module_name":self
.Name
}, self
.OutputDir
)
3298 RetVal
[AutoFile
] = UniStringBinBuffer
.getvalue()
3299 AutoFile
.IsBinary
= True
3300 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3301 if UniStringBinBuffer
is not None:
3302 UniStringBinBuffer
.close()
3303 if str(StringIdf
) != "":
3304 AutoFile
= PathClass(gAutoGenImageDefFileName
% {"module_name":self
.Name
}, self
.DebugDir
)
3305 RetVal
[AutoFile
] = str(StringIdf
)
3306 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3307 if IdfGenBinBuffer
is not None and IdfGenBinBuffer
.getvalue() != b
"":
3308 AutoFile
= PathClass(gAutoGenIdfFileName
% {"module_name":self
.Name
}, self
.OutputDir
)
3309 RetVal
[AutoFile
] = IdfGenBinBuffer
.getvalue()
3310 AutoFile
.IsBinary
= True
3311 self
._ApplyBuildRule
(AutoFile
, TAB_UNKNOWN_FILE
)
3312 if IdfGenBinBuffer
is not None:
3313 IdfGenBinBuffer
.close()
3316 ## Return the list of library modules explicitly or implicitly used by this module
3318 def DependentLibraryList(self
):
3319 # only merge library classes and PCD for non-library module
3322 return self
.PlatformInfo
.ApplyLibraryInstance(self
.Module
)
3324 ## Get the list of PCDs from current module
3326 # @retval list The list of PCD
3329 def ModulePcdList(self
):
3330 # apply PCD settings from platform
3331 RetVal
= self
.PlatformInfo
.ApplyPcdSetting(self
.Module
, self
.Module
.Pcds
)
3332 ExtendCopyDictionaryLists(self
._PcdComments
, self
.Module
.PcdComments
)
3335 ## Get the list of PCDs from dependent libraries
3337 # @retval list The list of PCD
3340 def LibraryPcdList(self
):
3345 # get PCDs from dependent libraries
3346 for Library
in self
.DependentLibraryList
:
3347 PcdsInLibrary
= OrderedDict()
3348 ExtendCopyDictionaryLists(self
._PcdComments
, Library
.PcdComments
)
3349 for Key
in Library
.Pcds
:
3350 # skip duplicated PCDs
3351 if Key
in self
.Module
.Pcds
or Key
in Pcds
:
3354 PcdsInLibrary
[Key
] = copy
.copy(Library
.Pcds
[Key
])
3355 RetVal
.extend(self
.PlatformInfo
.ApplyPcdSetting(self
.Module
, PcdsInLibrary
, Library
=Library
))
3358 ## Get the GUID value mapping
3360 # @retval dict The mapping between GUID cname and its value
3364 RetVal
= OrderedDict(self
.Module
.Guids
)
3365 for Library
in self
.DependentLibraryList
:
3366 RetVal
.update(Library
.Guids
)
3367 ExtendCopyDictionaryLists(self
._GuidComments
, Library
.GuidComments
)
3368 ExtendCopyDictionaryLists(self
._GuidComments
, self
.Module
.GuidComments
)
3372 def GetGuidsUsedByPcd(self
):
3373 RetVal
= OrderedDict(self
.Module
.GetGuidsUsedByPcd())
3374 for Library
in self
.DependentLibraryList
:
3375 RetVal
.update(Library
.GetGuidsUsedByPcd())
3377 ## Get the protocol value mapping
3379 # @retval dict The mapping between protocol cname and its value
3382 def ProtocolList(self
):
3383 RetVal
= OrderedDict(self
.Module
.Protocols
)
3384 for Library
in self
.DependentLibraryList
:
3385 RetVal
.update(Library
.Protocols
)
3386 ExtendCopyDictionaryLists(self
._ProtocolComments
, Library
.ProtocolComments
)
3387 ExtendCopyDictionaryLists(self
._ProtocolComments
, self
.Module
.ProtocolComments
)
3390 ## Get the PPI value mapping
3392 # @retval dict The mapping between PPI cname and its value
3396 RetVal
= OrderedDict(self
.Module
.Ppis
)
3397 for Library
in self
.DependentLibraryList
:
3398 RetVal
.update(Library
.Ppis
)
3399 ExtendCopyDictionaryLists(self
._PpiComments
, Library
.PpiComments
)
3400 ExtendCopyDictionaryLists(self
._PpiComments
, self
.Module
.PpiComments
)
3403 ## Get the list of include search path
3405 # @retval list The list path
3408 def IncludePathList(self
):
3410 RetVal
.append(self
.MetaFile
.Dir
)
3411 RetVal
.append(self
.DebugDir
)
3413 for Package
in self
.Module
.Packages
:
3414 PackageDir
= mws
.join(self
.WorkspaceDir
, Package
.MetaFile
.Dir
)
3415 if PackageDir
not in RetVal
:
3416 RetVal
.append(PackageDir
)
3417 IncludesList
= Package
.Includes
3418 if Package
._PrivateIncludes
:
3419 if not self
.MetaFile
.OriginalPath
.Path
.startswith(PackageDir
):
3420 IncludesList
= list(set(Package
.Includes
).difference(set(Package
._PrivateIncludes
)))
3421 for Inc
in IncludesList
:
3422 if Inc
not in RetVal
:
3423 RetVal
.append(str(Inc
))
3427 def IncludePathLength(self
):
3428 return sum(len(inc
)+1 for inc
in self
.IncludePathList
)
3430 ## Get HII EX PCDs which maybe used by VFR
3432 # efivarstore used by VFR may relate with HII EX PCDs
3433 # Get the variable name and GUID from efivarstore and HII EX PCD
3434 # List the HII EX PCDs in As Built INF if both name and GUID match.
3436 # @retval list HII EX PCDs
3438 def _GetPcdsMaybeUsedByVfr(self
):
3439 if not self
.SourceFileList
:
3443 for SrcFile
in self
.SourceFileList
:
3444 if SrcFile
.Ext
.lower() != '.vfr':
3446 Vfri
= os
.path
.join(self
.OutputDir
, SrcFile
.BaseName
+ '.i')
3447 if not os
.path
.exists(Vfri
):
3449 VfriFile
= open(Vfri
, 'r')
3450 Content
= VfriFile
.read()
3452 Pos
= Content
.find('efivarstore')
3455 # Make sure 'efivarstore' is the start of efivarstore statement
3456 # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'
3459 while Index
>= 0 and Content
[Index
] in ' \t\r\n':
3461 if Index
>= 0 and Content
[Index
] != ';':
3462 Pos
= Content
.find('efivarstore', Pos
+ len('efivarstore'))
3465 # 'efivarstore' must be followed by name and guid
3467 Name
= gEfiVarStoreNamePattern
.search(Content
, Pos
)
3470 Guid
= gEfiVarStoreGuidPattern
.search(Content
, Pos
)
3473 NameArray
= _ConvertStringToByteArray('L"' + Name
.group(1) + '"')
3474 NameGuids
.add((NameArray
, GuidStructureStringToGuidString(Guid
.group(1))))
3475 Pos
= Content
.find('efivarstore', Name
.end())
3479 for Pcd
in self
.PlatformInfo
.Platform
.Pcds
.values():
3480 if Pcd
.Type
!= TAB_PCDS_DYNAMIC_EX_HII
:
3482 for SkuInfo
in Pcd
.SkuInfoList
.values():
3483 Value
= GuidValue(SkuInfo
.VariableGuid
, self
.PlatformInfo
.PackageList
, self
.MetaFile
.Path
)
3486 Name
= _ConvertStringToByteArray(SkuInfo
.VariableName
)
3487 Guid
= GuidStructureStringToGuidString(Value
)
3488 if (Name
, Guid
) in NameGuids
and Pcd
not in HiiExPcds
:
3489 HiiExPcds
.append(Pcd
)
3494 def _GenOffsetBin(self
):
3496 for SourceFile
in self
.Module
.Sources
:
3497 if SourceFile
.Type
.upper() == ".VFR" :
3499 # search the .map file to find the offset of vfr binary in the PE32+/TE file.
3501 VfrUniBaseName
[SourceFile
.BaseName
] = (SourceFile
.BaseName
+ "Bin")
3502 elif SourceFile
.Type
.upper() == ".UNI" :
3504 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.
3506 VfrUniBaseName
["UniOffsetName"] = (self
.Name
+ "Strings")
3508 if not VfrUniBaseName
:
3510 MapFileName
= os
.path
.join(self
.OutputDir
, self
.Name
+ ".map")
3511 EfiFileName
= os
.path
.join(self
.OutputDir
, self
.Name
+ ".efi")
3512 VfrUniOffsetList
= GetVariableOffset(MapFileName
, EfiFileName
, list(VfrUniBaseName
.values()))
3513 if not VfrUniOffsetList
:
3516 OutputName
= '%sOffset.bin' % self
.Name
3517 UniVfrOffsetFileName
= os
.path
.join( self
.OutputDir
, OutputName
)
3520 fInputfile
= open(UniVfrOffsetFileName
, "wb+", 0)
3522 EdkLogger
.error("build", FILE_OPEN_FAILURE
, "File open failed for %s" % UniVfrOffsetFileName
, None)
3524 # Use a instance of BytesIO to cache data
3525 fStringIO
= BytesIO()
3527 for Item
in VfrUniOffsetList
:
3528 if (Item
[0].find("Strings") != -1):
3530 # UNI offset in image.
3532 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }
3534 UniGuid
= b
'\xe0\xc5\x13\x89\xf63\x86M\x9b\xf1C\xef\x89\xfc\x06f'
3535 fStringIO
.write(UniGuid
)
3536 UniValue
= pack ('Q', int (Item
[1], 16))
3537 fStringIO
.write (UniValue
)
3540 # VFR binary offset in image.
3542 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };
3544 VfrGuid
= b
'\xb4|\xbc\xd0Gj_I\xaa\x11q\x07F\xda\x06\xa2'
3545 fStringIO
.write(VfrGuid
)
3546 VfrValue
= pack ('Q', int (Item
[1], 16))
3547 fStringIO
.write (VfrValue
)
3549 # write data into file.
3552 fInputfile
.write (fStringIO
.getvalue())
3554 EdkLogger
.error("build", FILE_WRITE_FAILURE
, "Write data to file %s failed, please check whether the "
3555 "file been locked or using by other applications." %UniVfrOffsetFileName
, None)
3561 ## Create AsBuilt INF file the module
3563 def CreateAsBuiltInf(self
, IsOnlyCopy
= False):
3564 self
.OutputFile
= set()
3565 if IsOnlyCopy
and GlobalData
.gBinCacheDest
:
3566 self
.CopyModuleToCache()
3569 if self
.IsAsBuiltInfCreated
:
3572 # Skip the following code for libraries
3576 # Skip the following code for modules with no source files
3577 if not self
.SourceFileList
:
3580 # Skip the following code for modules without any binary files
3581 if self
.BinaryFileList
:
3584 ### TODO: How to handles mixed source and binary modules
3586 # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries
3587 # Also find all packages that the DynamicEx PCDs depend on
3592 PcdTokenSpaceList
= []
3593 for Pcd
in self
.ModulePcdList
+ self
.LibraryPcdList
:
3594 if Pcd
.Type
== TAB_PCDS_PATCHABLE_IN_MODULE
:
3595 PatchablePcds
.append(Pcd
)
3596 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_PATCHABLE_IN_MODULE
))
3597 elif Pcd
.Type
in PCD_DYNAMIC_EX_TYPE_SET
:
3600 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC_EX
))
3601 PcdCheckList
.append((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC
))
3602 PcdTokenSpaceList
.append(Pcd
.TokenSpaceGuidCName
)
3603 GuidList
= OrderedDict(self
.GuidList
)
3604 for TokenSpace
in self
.GetGuidsUsedByPcd
:
3605 # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list
3606 # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs
3607 if TokenSpace
not in PcdTokenSpaceList
and TokenSpace
in GuidList
:
3608 GuidList
.pop(TokenSpace
)
3609 CheckList
= (GuidList
, self
.PpiList
, self
.ProtocolList
, PcdCheckList
)
3610 for Package
in self
.DerivedPackageList
:
3611 if Package
in Packages
:
3613 BeChecked
= (Package
.Guids
, Package
.Ppis
, Package
.Protocols
, Package
.Pcds
)
3615 for Index
in range(len(BeChecked
)):
3616 for Item
in CheckList
[Index
]:
3617 if Item
in BeChecked
[Index
]:
3618 Packages
.append(Package
)
3624 VfrPcds
= self
._GetPcdsMaybeUsedByVfr
()
3625 for Pkg
in self
.PlatformInfo
.PackageList
:
3628 for VfrPcd
in VfrPcds
:
3629 if ((VfrPcd
.TokenCName
, VfrPcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC_EX
) in Pkg
.Pcds
or
3630 (VfrPcd
.TokenCName
, VfrPcd
.TokenSpaceGuidCName
, TAB_PCDS_DYNAMIC
) in Pkg
.Pcds
):
3631 Packages
.append(Pkg
)
3634 ModuleType
= SUP_MODULE_DXE_DRIVER
if self
.ModuleType
== SUP_MODULE_UEFI_DRIVER
and self
.DepexGenerated
else self
.ModuleType
3635 DriverType
= self
.PcdIsDriver
if self
.PcdIsDriver
else ''
3637 MDefs
= self
.Module
.Defines
3640 'module_name' : self
.Name
,
3641 'module_guid' : Guid
,
3642 'module_module_type' : ModuleType
,
3643 'module_version_string' : [MDefs
['VERSION_STRING']] if 'VERSION_STRING' in MDefs
else [],
3644 'pcd_is_driver_string' : [],
3645 'module_uefi_specification_version' : [],
3646 'module_pi_specification_version' : [],
3647 'module_entry_point' : self
.Module
.ModuleEntryPointList
,
3648 'module_unload_image' : self
.Module
.ModuleUnloadImageList
,
3649 'module_constructor' : self
.Module
.ConstructorList
,
3650 'module_destructor' : self
.Module
.DestructorList
,
3651 'module_shadow' : [MDefs
['SHADOW']] if 'SHADOW' in MDefs
else [],
3652 'module_pci_vendor_id' : [MDefs
['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs
else [],
3653 'module_pci_device_id' : [MDefs
['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs
else [],
3654 'module_pci_class_code' : [MDefs
['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs
else [],
3655 'module_pci_revision' : [MDefs
['PCI_REVISION']] if 'PCI_REVISION' in MDefs
else [],
3656 'module_build_number' : [MDefs
['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs
else [],
3657 'module_spec' : [MDefs
['SPEC']] if 'SPEC' in MDefs
else [],
3658 'module_uefi_hii_resource_section' : [MDefs
['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs
else [],
3659 'module_uni_file' : [MDefs
['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs
else [],
3660 'module_arch' : self
.Arch
,
3661 'package_item' : [Package
.MetaFile
.File
.replace('\\', '/') for Package
in Packages
],
3663 'patchablepcd_item' : [],
3665 'protocol_item' : [],
3669 'libraryclasses_item' : []
3672 if 'MODULE_UNI_FILE' in MDefs
:
3673 UNIFile
= os
.path
.join(self
.MetaFile
.Dir
, MDefs
['MODULE_UNI_FILE'])
3674 if os
.path
.isfile(UNIFile
):
3675 shutil
.copy2(UNIFile
, self
.OutputDir
)
3677 if self
.AutoGenVersion
> int(gInfSpecVersion
, 0):
3678 AsBuiltInfDict
['module_inf_version'] = '0x%08x' % self
.AutoGenVersion
3680 AsBuiltInfDict
['module_inf_version'] = gInfSpecVersion
3683 AsBuiltInfDict
['pcd_is_driver_string'].append(DriverType
)
3685 if 'UEFI_SPECIFICATION_VERSION' in self
.Specification
:
3686 AsBuiltInfDict
['module_uefi_specification_version'].append(self
.Specification
['UEFI_SPECIFICATION_VERSION'])
3687 if 'PI_SPECIFICATION_VERSION' in self
.Specification
:
3688 AsBuiltInfDict
['module_pi_specification_version'].append(self
.Specification
['PI_SPECIFICATION_VERSION'])
3690 OutputDir
= self
.OutputDir
.replace('\\', '/').strip('/')
3691 DebugDir
= self
.DebugDir
.replace('\\', '/').strip('/')
3692 for Item
in self
.CodaTargetList
:
3693 File
= Item
.Target
.Path
.replace('\\', '/').strip('/').replace(DebugDir
, '').replace(OutputDir
, '').strip('/')
3694 self
.OutputFile
.add(File
)
3695 if os
.path
.isabs(File
):
3696 File
= File
.replace('\\', '/').strip('/').replace(OutputDir
, '').strip('/')
3697 if Item
.Target
.Ext
.lower() == '.aml':
3698 AsBuiltInfDict
['binary_item'].append('ASL|' + File
)
3699 elif Item
.Target
.Ext
.lower() == '.acpi':
3700 AsBuiltInfDict
['binary_item'].append('ACPI|' + File
)
3701 elif Item
.Target
.Ext
.lower() == '.efi':
3702 AsBuiltInfDict
['binary_item'].append('PE32|' + self
.Name
+ '.efi')
3704 AsBuiltInfDict
['binary_item'].append('BIN|' + File
)
3705 if not self
.DepexGenerated
:
3706 DepexFile
= os
.path
.join(self
.OutputDir
, self
.Name
+ '.depex')
3707 if os
.path
.exists(DepexFile
):
3708 self
.DepexGenerated
= True
3709 if self
.DepexGenerated
:
3710 self
.OutputFile
.add(self
.Name
+ '.depex')
3711 if self
.ModuleType
in [SUP_MODULE_PEIM
]:
3712 AsBuiltInfDict
['binary_item'].append('PEI_DEPEX|' + self
.Name
+ '.depex')
3713 elif self
.ModuleType
in [SUP_MODULE_DXE_DRIVER
, SUP_MODULE_DXE_RUNTIME_DRIVER
, SUP_MODULE_DXE_SAL_DRIVER
, SUP_MODULE_UEFI_DRIVER
]:
3714 AsBuiltInfDict
['binary_item'].append('DXE_DEPEX|' + self
.Name
+ '.depex')
3715 elif self
.ModuleType
in [SUP_MODULE_DXE_SMM_DRIVER
]:
3716 AsBuiltInfDict
['binary_item'].append('SMM_DEPEX|' + self
.Name
+ '.depex')
3718 Bin
= self
._GenOffsetBin
()
3720 AsBuiltInfDict
['binary_item'].append('BIN|%s' % Bin
)
3721 self
.OutputFile
.add(Bin
)
3723 for Root
, Dirs
, Files
in os
.walk(OutputDir
):
3725 if File
.lower().endswith('.pdb'):
3726 AsBuiltInfDict
['binary_item'].append('DISPOSABLE|' + File
)
3727 self
.OutputFile
.add(File
)
3728 HeaderComments
= self
.Module
.HeaderComments
3730 for Index
in range(len(HeaderComments
)):
3731 if HeaderComments
[Index
].find('@BinaryHeader') != -1:
3732 HeaderComments
[Index
] = HeaderComments
[Index
].replace('@BinaryHeader', '@file')
3735 AsBuiltInfDict
['header_comments'] = '\n'.join(HeaderComments
[StartPos
:]).replace(':#', '://')
3736 AsBuiltInfDict
['tail_comments'] = '\n'.join(self
.Module
.TailComments
)
3739 (self
.ProtocolList
, self
._ProtocolComments
, 'protocol_item'),
3740 (self
.PpiList
, self
._PpiComments
, 'ppi_item'),
3741 (GuidList
, self
._GuidComments
, 'guid_item')
3743 for Item
in GenList
:
3744 for CName
in Item
[0]:
3745 Comments
= '\n '.join(Item
[1][CName
]) if CName
in Item
[1] else ''
3746 Entry
= Comments
+ '\n ' + CName
if Comments
else CName
3747 AsBuiltInfDict
[Item
[2]].append(Entry
)
3748 PatchList
= parsePcdInfoFromMapFile(
3749 os
.path
.join(self
.OutputDir
, self
.Name
+ '.map'),
3750 os
.path
.join(self
.OutputDir
, self
.Name
+ '.efi')
3753 for Pcd
in PatchablePcds
:
3754 TokenCName
= Pcd
.TokenCName
3755 for PcdItem
in GlobalData
.MixedPcd
:
3756 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
3757 TokenCName
= PcdItem
[0]
3759 for PatchPcd
in PatchList
:
3760 if TokenCName
== PatchPcd
[0]:
3765 if Pcd
.DatumType
== 'BOOLEAN':
3766 BoolValue
= Pcd
.DefaultValue
.upper()
3767 if BoolValue
== 'TRUE':
3768 Pcd
.DefaultValue
= '1'
3769 elif BoolValue
== 'FALSE':
3770 Pcd
.DefaultValue
= '0'
3772 if Pcd
.DatumType
in TAB_PCD_NUMERIC_TYPES
:
3773 HexFormat
= '0x%02x'
3774 if Pcd
.DatumType
== TAB_UINT16
:
3775 HexFormat
= '0x%04x'
3776 elif Pcd
.DatumType
== TAB_UINT32
:
3777 HexFormat
= '0x%08x'
3778 elif Pcd
.DatumType
== TAB_UINT64
:
3779 HexFormat
= '0x%016x'
3780 PcdValue
= HexFormat
% int(Pcd
.DefaultValue
, 0)
3782 if Pcd
.MaxDatumSize
is None or Pcd
.MaxDatumSize
== '':
3783 EdkLogger
.error("build", AUTOGEN_ERROR
,
3784 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
3786 ArraySize
= int(Pcd
.MaxDatumSize
, 0)
3787 PcdValue
= Pcd
.DefaultValue
3788 if PcdValue
[0] != '{':
3790 if PcdValue
[0] == 'L':
3792 PcdValue
= PcdValue
.lstrip('L')
3793 PcdValue
= eval(PcdValue
)
3795 for Index
in range(0, len(PcdValue
)):
3797 CharVal
= ord(PcdValue
[Index
])
3798 NewValue
= NewValue
+ '0x%02x' % (CharVal
& 0x00FF) + ', ' \
3799 + '0x%02x' % (CharVal
>> 8) + ', '
3801 NewValue
= NewValue
+ '0x%02x' % (ord(PcdValue
[Index
]) % 0x100) + ', '
3804 Padding
= Padding
* 2
3805 ArraySize
= ArraySize
// 2
3806 if ArraySize
< (len(PcdValue
) + 1):
3807 if Pcd
.MaxSizeUserSet
:
3808 EdkLogger
.error("build", AUTOGEN_ERROR
,
3809 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
3812 ArraySize
= len(PcdValue
) + 1
3813 if ArraySize
> len(PcdValue
) + 1:
3814 NewValue
= NewValue
+ Padding
* (ArraySize
- len(PcdValue
) - 1)
3815 PcdValue
= NewValue
+ Padding
.strip().rstrip(',') + '}'
3816 elif len(PcdValue
.split(',')) <= ArraySize
:
3817 PcdValue
= PcdValue
.rstrip('}') + ', 0x00' * (ArraySize
- len(PcdValue
.split(',')))
3820 if Pcd
.MaxSizeUserSet
:
3821 EdkLogger
.error("build", AUTOGEN_ERROR
,
3822 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd
.TokenSpaceGuidCName
, TokenCName
)
3825 ArraySize
= len(PcdValue
) + 1
3826 PcdItem
= '%s.%s|%s|0x%X' % \
3827 (Pcd
.TokenSpaceGuidCName
, TokenCName
, PcdValue
, PatchPcd
[1])
3829 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) in self
._PcdComments
:
3830 PcdComments
= '\n '.join(self
._PcdComments
[Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
])
3832 PcdItem
= PcdComments
+ '\n ' + PcdItem
3833 AsBuiltInfDict
['patchablepcd_item'].append(PcdItem
)
3835 for Pcd
in Pcds
+ VfrPcds
:
3838 TokenCName
= Pcd
.TokenCName
3839 for PcdItem
in GlobalData
.MixedPcd
:
3840 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdItem
]:
3841 TokenCName
= PcdItem
[0]
3843 if Pcd
.Type
== TAB_PCDS_DYNAMIC_EX_HII
:
3844 for SkuName
in Pcd
.SkuInfoList
:
3845 SkuInfo
= Pcd
.SkuInfoList
[SkuName
]
3846 HiiInfo
= '## %s|%s|%s' % (SkuInfo
.VariableName
, SkuInfo
.VariableGuid
, SkuInfo
.VariableOffset
)
3848 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) in self
._PcdComments
:
3849 PcdCommentList
= self
._PcdComments
[Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
][:]
3853 for Index
, Comment
in enumerate(PcdCommentList
):
3854 for Usage
in UsageList
:
3855 if Comment
.find(Usage
) != -1:
3859 if UsageIndex
!= -1:
3860 PcdCommentList
[UsageIndex
] = '## %s %s %s' % (UsageStr
, HiiInfo
, PcdCommentList
[UsageIndex
].replace(UsageStr
, ''))
3862 PcdCommentList
.append('## UNDEFINED ' + HiiInfo
)
3863 PcdComments
= '\n '.join(PcdCommentList
)
3864 PcdEntry
= Pcd
.TokenSpaceGuidCName
+ '.' + TokenCName
3866 PcdEntry
= PcdComments
+ '\n ' + PcdEntry
3867 AsBuiltInfDict
['pcd_item'].append(PcdEntry
)
3868 for Item
in self
.BuildOption
:
3869 if 'FLAGS' in self
.BuildOption
[Item
]:
3870 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()))
3872 # Generated LibraryClasses section in comments.
3873 for Library
in self
.LibraryAutoGenList
:
3874 AsBuiltInfDict
['libraryclasses_item'].append(Library
.MetaFile
.File
.replace('\\', '/'))
3876 # Generated UserExtensions TianoCore section.
3877 # All tianocore user extensions are copied.
3879 for TianoCore
in self
._GetTianoCoreUserExtensionList
():
3880 UserExtStr
+= '\n'.join(TianoCore
)
3881 ExtensionFile
= os
.path
.join(self
.MetaFile
.Dir
, TianoCore
[1])
3882 if os
.path
.isfile(ExtensionFile
):
3883 shutil
.copy2(ExtensionFile
, self
.OutputDir
)
3884 AsBuiltInfDict
['userextension_tianocore_item'] = UserExtStr
3886 # Generated depex expression section in comments.
3887 DepexExpression
= self
._GetDepexExpresionString
()
3888 AsBuiltInfDict
['depexsection_item'] = DepexExpression
if DepexExpression
else ''
3890 AsBuiltInf
= TemplateString()
3891 AsBuiltInf
.Append(gAsBuiltInfHeaderString
.Replace(AsBuiltInfDict
))
3893 SaveFileOnChange(os
.path
.join(self
.OutputDir
, self
.Name
+ '.inf'), str(AsBuiltInf
), False)
3895 self
.IsAsBuiltInfCreated
= True
3896 if GlobalData
.gBinCacheDest
:
3897 self
.CopyModuleToCache()
3899 def CopyModuleToCache(self
):
3900 FileDir
= path
.join(GlobalData
.gBinCacheDest
, self
.PlatformInfo
.Name
, self
.BuildTarget
+ "_" + self
.ToolChain
, self
.Arch
, self
.SourceDir
, self
.MetaFile
.BaseName
)
3901 CreateDirectory (FileDir
)
3902 HashFile
= path
.join(self
.BuildDir
, self
.Name
+ '.hash')
3903 if os
.path
.exists(HashFile
):
3904 shutil
.copy2(HashFile
, FileDir
)
3905 if not self
.IsLibrary
:
3906 ModuleFile
= path
.join(self
.OutputDir
, self
.Name
+ '.inf')
3907 if os
.path
.exists(ModuleFile
):
3908 shutil
.copy2(ModuleFile
, FileDir
)
3909 if not self
.OutputFile
:
3910 Ma
= self
.BuildDatabase
[self
.MetaFile
, self
.Arch
, self
.BuildTarget
, self
.ToolChain
]
3911 self
.OutputFile
= Ma
.Binaries
3913 for File
in self
.OutputFile
:
3915 if not os
.path
.isabs(File
):
3916 File
= os
.path
.join(self
.OutputDir
, File
)
3917 if os
.path
.exists(File
):
3918 sub_dir
= os
.path
.relpath(File
, self
.OutputDir
)
3919 destination_file
= os
.path
.join(FileDir
, sub_dir
)
3920 destination_dir
= os
.path
.dirname(destination_file
)
3921 CreateDirectory(destination_dir
)
3922 shutil
.copy2(File
, destination_dir
)
3924 def AttemptModuleCacheCopy(self
):
3925 # If library or Module is binary do not skip by hash
3926 if self
.IsBinaryModule
:
3928 # .inc is contains binary information so do not skip by hash as well
3929 for f_ext
in self
.SourceFileList
:
3930 if '.inc' in str(f_ext
):
3932 FileDir
= path
.join(GlobalData
.gBinCacheSource
, self
.PlatformInfo
.Name
, self
.BuildTarget
+ "_" + self
.ToolChain
, self
.Arch
, self
.SourceDir
, self
.MetaFile
.BaseName
)
3933 HashFile
= path
.join(FileDir
, self
.Name
+ '.hash')
3934 if os
.path
.exists(HashFile
):
3935 f
= open(HashFile
, 'r')
3936 CacheHash
= f
.read()
3938 if GlobalData
.gModuleHash
[self
.Arch
][self
.Name
]:
3939 if CacheHash
== GlobalData
.gModuleHash
[self
.Arch
][self
.Name
]:
3940 for root
, dir, files
in os
.walk(FileDir
):
3942 if self
.Name
+ '.hash' in f
:
3943 shutil
.copy2(HashFile
, self
.BuildDir
)
3945 File
= path
.join(root
, f
)
3946 sub_dir
= os
.path
.relpath(File
, FileDir
)
3947 destination_file
= os
.path
.join(self
.OutputDir
, sub_dir
)
3948 destination_dir
= os
.path
.dirname(destination_file
)
3949 CreateDirectory(destination_dir
)
3950 shutil
.copy2(File
, destination_dir
)
3951 if self
.Name
== "PcdPeim" or self
.Name
== "PcdDxe":
3952 CreatePcdDatabaseCode(self
, TemplateString(), TemplateString())
3956 ## Create makefile for the module and its dependent libraries
3958 # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of
3959 # dependent libraries will be created
3961 @cached_class_function
3962 def CreateMakeFile(self
, CreateLibraryMakeFile
=True, GenFfsList
= []):
3963 # nest this function inside it's only caller.
3964 def CreateTimeStamp():
3965 FileSet
= {self
.MetaFile
.Path
}
3967 for SourceFile
in self
.Module
.Sources
:
3968 FileSet
.add (SourceFile
.Path
)
3970 for Lib
in self
.DependentLibraryList
:
3971 FileSet
.add (Lib
.MetaFile
.Path
)
3973 for f
in self
.AutoGenDepSet
:
3974 FileSet
.add (f
.Path
)
3976 if os
.path
.exists (self
.TimeStampPath
):
3977 os
.remove (self
.TimeStampPath
)
3978 with
open(self
.TimeStampPath
, 'w+') as file:
3982 # Ignore generating makefile when it is a binary module
3983 if self
.IsBinaryModule
:
3986 self
.GenFfsList
= GenFfsList
3987 if not self
.IsLibrary
and CreateLibraryMakeFile
:
3988 for LibraryAutoGen
in self
.LibraryAutoGenList
:
3989 LibraryAutoGen
.CreateMakeFile()
3994 if len(self
.CustomMakefile
) == 0:
3995 Makefile
= GenMake
.ModuleMakefile(self
)
3997 Makefile
= GenMake
.CustomMakefile(self
)
3998 if Makefile
.Generate():
3999 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated makefile for module %s [%s]" %
4000 (self
.Name
, self
.Arch
))
4002 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Skipped the generation of makefile for module %s [%s]" %
4003 (self
.Name
, self
.Arch
))
4007 def CopyBinaryFiles(self
):
4008 for File
in self
.Module
.Binaries
:
4010 DstPath
= os
.path
.join(self
.OutputDir
, os
.path
.basename(SrcPath
))
4011 CopyLongFilePath(SrcPath
, DstPath
)
4012 ## Create autogen code for the module and its dependent libraries
4014 # @param CreateLibraryCodeFile Flag indicating if or not the code of
4015 # dependent libraries will be created
4017 def CreateCodeFile(self
, CreateLibraryCodeFile
=True):
4018 if self
.IsCodeFileCreated
:
4021 # Need to generate PcdDatabase even PcdDriver is binarymodule
4022 if self
.IsBinaryModule
and self
.PcdIsDriver
!= '':
4023 CreatePcdDatabaseCode(self
, TemplateString(), TemplateString())
4025 if self
.IsBinaryModule
:
4027 self
.CopyBinaryFiles()
4030 if not self
.IsLibrary
and CreateLibraryCodeFile
:
4031 for LibraryAutoGen
in self
.LibraryAutoGenList
:
4032 LibraryAutoGen
.CreateCodeFile()
4038 IgoredAutoGenList
= []
4040 for File
in self
.AutoGenFileList
:
4041 if GenC
.Generate(File
.Path
, self
.AutoGenFileList
[File
], File
.IsBinary
):
4042 AutoGenList
.append(str(File
))
4044 IgoredAutoGenList
.append(str(File
))
4047 for ModuleType
in self
.DepexList
:
4048 # Ignore empty [depex] section or [depex] section for SUP_MODULE_USER_DEFINED module
4049 if len(self
.DepexList
[ModuleType
]) == 0 or ModuleType
== SUP_MODULE_USER_DEFINED
:
4052 Dpx
= GenDepex
.DependencyExpression(self
.DepexList
[ModuleType
], ModuleType
, True)
4053 DpxFile
= gAutoGenDepexFileName
% {"module_name" : self
.Name
}
4055 if len(Dpx
.PostfixNotation
) != 0:
4056 self
.DepexGenerated
= True
4058 if Dpx
.Generate(path
.join(self
.OutputDir
, DpxFile
)):
4059 AutoGenList
.append(str(DpxFile
))
4061 IgoredAutoGenList
.append(str(DpxFile
))
4063 if IgoredAutoGenList
== []:
4064 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated [%s] files for module %s [%s]" %
4065 (" ".join(AutoGenList
), self
.Name
, self
.Arch
))
4066 elif AutoGenList
== []:
4067 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Skipped the generation of [%s] files for module %s [%s]" %
4068 (" ".join(IgoredAutoGenList
), self
.Name
, self
.Arch
))
4070 EdkLogger
.debug(EdkLogger
.DEBUG_9
, "Generated [%s] (skipped %s) files for module %s [%s]" %
4071 (" ".join(AutoGenList
), " ".join(IgoredAutoGenList
), self
.Name
, self
.Arch
))
4073 self
.IsCodeFileCreated
= True
4076 ## Summarize the ModuleAutoGen objects of all libraries used by this module
4078 def LibraryAutoGenList(self
):
4080 for Library
in self
.DependentLibraryList
:
4087 self
.PlatformInfo
.MetaFile
4089 if La
not in RetVal
:
4091 for Lib
in La
.CodaTargetList
:
4092 self
._ApplyBuildRule
(Lib
.Target
, TAB_UNKNOWN_FILE
)
4095 def GenModuleHash(self
):
4096 if self
.Arch
not in GlobalData
.gModuleHash
:
4097 GlobalData
.gModuleHash
[self
.Arch
] = {}
4098 if self
.Name
in GlobalData
.gModuleHash
[self
.Arch
] and GlobalData
.gBinCacheSource
and self
.AttemptModuleCacheCopy():
4101 # Add Platform level hash
4102 m
.update(GlobalData
.gPlatformHash
.encode('utf-8'))
4103 # Add Package level hash
4104 if self
.DependentPackageList
:
4105 for Pkg
in sorted(self
.DependentPackageList
, key
=lambda x
: x
.PackageName
):
4106 if Pkg
.PackageName
in GlobalData
.gPackageHash
:
4107 m
.update(GlobalData
.gPackageHash
[Pkg
.PackageName
].encode('utf-8'))
4110 if self
.LibraryAutoGenList
:
4111 for Lib
in sorted(self
.LibraryAutoGenList
, key
=lambda x
: x
.Name
):
4112 if Lib
.Name
not in GlobalData
.gModuleHash
[self
.Arch
]:
4114 m
.update(GlobalData
.gModuleHash
[self
.Arch
][Lib
.Name
].encode('utf-8'))
4117 f
= open(str(self
.MetaFile
), 'rb')
4121 # Add Module's source files
4122 if self
.SourceFileList
:
4123 for File
in sorted(self
.SourceFileList
, key
=lambda x
: str(x
)):
4124 f
= open(str(File
), 'rb')
4129 ModuleHashFile
= path
.join(self
.BuildDir
, self
.Name
+ ".hash")
4130 if self
.Name
not in GlobalData
.gModuleHash
[self
.Arch
]:
4131 GlobalData
.gModuleHash
[self
.Arch
][self
.Name
] = m
.hexdigest()
4132 if GlobalData
.gBinCacheSource
and self
.AttemptModuleCacheCopy():
4134 return SaveFileOnChange(ModuleHashFile
, m
.hexdigest(), False)
4136 ## Decide whether we can skip the ModuleAutoGen process
4137 def CanSkipbyHash(self
):
4138 # If library or Module is binary do not skip by hash
4139 if self
.IsBinaryModule
:
4141 # .inc is contains binary information so do not skip by hash as well
4142 for f_ext
in self
.SourceFileList
:
4143 if '.inc' in str(f_ext
):
4145 if GlobalData
.gUseHashCache
:
4146 # If there is a valid hash or function generated a valid hash; function will return False
4147 # and the statement below will return True
4148 return not self
.GenModuleHash()
4151 ## Decide whether we can skip the ModuleAutoGen process
4152 # If any source file is newer than the module than we cannot skip
4155 if self
.MakeFileDir
in GlobalData
.gSikpAutoGenCache
:
4157 if not os
.path
.exists(self
.TimeStampPath
):
4159 #last creation time of the module
4160 DstTimeStamp
= os
.stat(self
.TimeStampPath
)[8]
4162 SrcTimeStamp
= self
.Workspace
._SrcTimeStamp
4163 if SrcTimeStamp
> DstTimeStamp
:
4166 with
open(self
.TimeStampPath
,'r') as f
:
4168 source
= source
.rstrip('\n')
4169 if not os
.path
.exists(source
):
4171 if source
not in ModuleAutoGen
.TimeDict
:
4172 ModuleAutoGen
.TimeDict
[source
] = os
.stat(source
)[8]
4173 if ModuleAutoGen
.TimeDict
[source
] > DstTimeStamp
:
4175 GlobalData
.gSikpAutoGenCache
.add(self
.MakeFileDir
)
4179 def TimeStampPath(self
):
4180 return os
.path
.join(self
.MakeFileDir
, 'AutoGenTimeStamp')