]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/AutoGen/AutoGen.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BaseTools: Implement BUILDRULEORDER for tools_def
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / AutoGen.py
CommitLineData
52302d4d
LG		 1## @file\r
2# Generate AutoGen.h, AutoGen.c and *.depex files\r
3#\r
82a6a960 4# Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>\r
40d841f6 5# This program and the accompanying materials\r
52302d4d
LG		 6# are licensed and made available under the terms and conditions of the BSD License\r
7# which accompanies this distribution. The full text of the license may be found at\r
8# http://opensource.org/licenses/bsd-license.php\r
9#\r
10# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12#\r
13\r
14## Import Modules\r
15#\r
1be2ed90 16import Common.LongFilePathOs as os\r
52302d4d
LG		 17import re\r
18import os.path as path\r
19import copy\r
20\r
21import GenC\r
22import GenMake\r
23import GenDepex\r
24from StringIO import StringIO\r
25\r
26from StrGather import *\r
27from BuildEngine import BuildRule\r
28\r
1be2ed90 29from Common.LongFilePathSupport import CopyLongFilePath\r
52302d4d
LG		 30from Common.BuildToolError import *\r
31from Common.DataType import *\r
32from Common.Misc import *\r
33from Common.String import *\r
34import Common.GlobalData as GlobalData\r
35from GenFds.FdfParser import *\r
36from CommonDataClass.CommonClass import SkuInfoClass\r
37from Workspace.BuildClassObject import *\r
e8a47801 38from GenPatchPcdTable.GenPatchPcdTable import parsePcdInfoFromMapFile\r
e56468c0 39import Common.VpdInfoFile as VpdInfoFile\r
e8a47801
LG		 40from GenPcdDb import CreatePcdDatabaseCode\r
41from Workspace.MetaFileCommentParser import UsageList\r
52302d4d 42\r
97fa0ee9
YL		 43import InfSectionParser\r
44\r
e8a47801 45## Regular expression for splitting Dependency Expression string into tokens\r
52302d4d
LG		 46gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
47\r
97fa0ee9
YL		 48#\r
49# Match name = variable\r
50#\r
51gEfiVarStoreNamePattern = re.compile("\s*name\s*=\s*(\w+)")\r
52#\r
53# The format of guid in efivarstore statement likes following and must be correct:\r
54# guid = {0xA04A27f4, 0xDF00, 0x4D42, {0xB5, 0x52, 0x39, 0x51, 0x13, 0x02, 0x11, 0x3D}}\r
55#\r
56gEfiVarStoreGuidPattern = re.compile("\s*guid\s*=\s*({.*?{.*?}\s*})")\r
57\r
52302d4d
LG		 58## Mapping Makefile type\r
59gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}\r
60\r
61\r
62## Build rule configuration file\r
97fa0ee9 63gDefaultBuildRuleFile = 'Conf/build_rule.txt'\r
52302d4d 64\r
64b2609f
LG		 65## Build rule default version\r
66AutoGenReqBuildRuleVerNum = "0.1"\r
67\r
52302d4d
LG		 68## default file name for AutoGen\r
69gAutoGenCodeFileName = "AutoGen.c"\r
70gAutoGenHeaderFileName = "AutoGen.h"\r
71gAutoGenStringFileName = "%(module_name)sStrDefs.h"\r
72gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"\r
73gAutoGenDepexFileName = "%(module_name)s.depex"\r
74\r
97fa0ee9
YL		 75gInfSpecVersion = "0x00010017"\r
76\r
da92f276
LG		 77#\r
78# Template string to generic AsBuilt INF\r
79#\r
e8a47801 80gAsBuiltInfHeaderString = TemplateString("""${header_comments}\r
da92f276 81\r
97fa0ee9
YL		 82# DO NOT EDIT\r
83# FILE auto-generated\r
84\r
da92f276 85[Defines]\r
97fa0ee9 86 INF_VERSION = ${module_inf_version}\r
da92f276
LG		 87 BASE_NAME = ${module_name}\r
88 FILE_GUID = ${module_guid}\r
97fa0ee9
YL		 89 MODULE_TYPE = ${module_module_type}${BEGIN}\r
90 VERSION_STRING = ${module_version_string}${END}${BEGIN}\r
e8a47801 91 PCD_IS_DRIVER = ${pcd_is_driver_string}${END}${BEGIN}\r
da92f276 92 UEFI_SPECIFICATION_VERSION = ${module_uefi_specification_version}${END}${BEGIN}\r
97fa0ee9
YL		 93 PI_SPECIFICATION_VERSION = ${module_pi_specification_version}${END}${BEGIN}\r
94 ENTRY_POINT = ${module_entry_point}${END}${BEGIN}\r
95 UNLOAD_IMAGE = ${module_unload_image}${END}${BEGIN}\r
96 CONSTRUCTOR = ${module_constructor}${END}${BEGIN}\r
97 DESTRUCTOR = ${module_destructor}${END}${BEGIN}\r
98 SHADOW = ${module_shadow}${END}${BEGIN}\r
99 PCI_VENDOR_ID = ${module_pci_vendor_id}${END}${BEGIN}\r
100 PCI_DEVICE_ID = ${module_pci_device_id}${END}${BEGIN}\r
101 PCI_CLASS_CODE = ${module_pci_class_code}${END}${BEGIN}\r
102 PCI_REVISION = ${module_pci_revision}${END}${BEGIN}\r
103 BUILD_NUMBER = ${module_build_number}${END}${BEGIN}\r
104 SPEC = ${module_spec}${END}${BEGIN}\r
105 UEFI_HII_RESOURCE_SECTION = ${module_uefi_hii_resource_section}${END}${BEGIN}\r
106 MODULE_UNI_FILE = ${module_uni_file}${END}\r
107\r
108[Packages.${module_arch}]${BEGIN}\r
da92f276
LG		 109 ${package_item}${END}\r
110\r
111[Binaries.${module_arch}]${BEGIN}\r
112 ${binary_item}${END}\r
113\r
e8a47801
LG		 114[PatchPcd.${module_arch}]${BEGIN}\r
115 ${patchablepcd_item}\r
116${END}\r
97fa0ee9 117\r
e8a47801
LG		 118[Protocols.${module_arch}]${BEGIN}\r
119 ${protocol_item}\r
120${END}\r
97fa0ee9 121\r
e8a47801
LG		 122[Ppis.${module_arch}]${BEGIN}\r
123 ${ppi_item}\r
124${END}\r
97fa0ee9 125\r
e8a47801
LG		 126[Guids.${module_arch}]${BEGIN}\r
127 ${guid_item}\r
128${END}\r
97fa0ee9 129\r
e8a47801
LG		 130[PcdEx.${module_arch}]${BEGIN}\r
131 ${pcd_item}\r
132${END}\r
da92f276 133\r
97fa0ee9
YL		 134[LibraryClasses.${module_arch}]\r
135## @LIB_INSTANCES${BEGIN}\r
136# ${libraryclasses_item}${END}\r
137\r
138${depexsection_item}\r
139\r
140${tail_comments}\r
141\r
142[BuildOptions.${module_arch}]\r
da92f276
LG		 143## @AsBuilt${BEGIN}\r
144## ${flags_item}${END}\r
145""")\r
146\r
52302d4d
LG		 147## Base class for AutoGen\r
148#\r
149# This class just implements the cache mechanism of AutoGen objects.\r
150#\r
151class AutoGen(object):\r
152 # database to maintain the objects of xxxAutoGen\r
153 _CACHE_ = {} # (BuildTarget, ToolChain) : {ARCH : {platform file: AutoGen object}}}\r
154\r
155 ## Factory method\r
156 #\r
157 # @param Class class object of real AutoGen class\r
158 # (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)\r
159 # @param Workspace Workspace directory or WorkspaceAutoGen object\r
160 # @param MetaFile The path of meta file\r
161 # @param Target Build target\r
162 # @param Toolchain Tool chain name\r
163 # @param Arch Target arch\r
164 # @param *args The specific class related parameters\r
165 # @param **kwargs The specific class related dict parameters\r
166 #\r
167 def __new__(Class, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
168 # check if the object has been created\r
169 Key = (Target, Toolchain)\r
170 if Key not in Class._CACHE_ or Arch not in Class._CACHE_[Key] \\r
171 or MetaFile not in Class._CACHE_[Key][Arch]:\r
172 AutoGenObject = super(AutoGen, Class).__new__(Class)\r
173 # call real constructor\r
174 if not AutoGenObject._Init(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
175 return None\r
176 if Key not in Class._CACHE_:\r
177 Class._CACHE_[Key] = {}\r
178 if Arch not in Class._CACHE_[Key]:\r
179 Class._CACHE_[Key][Arch] = {}\r
180 Class._CACHE_[Key][Arch][MetaFile] = AutoGenObject\r
181 else:\r
182 AutoGenObject = Class._CACHE_[Key][Arch][MetaFile]\r
183\r
184 return AutoGenObject\r
185\r
186 ## hash() operator\r
187 #\r
188 # The file path of platform file will be used to represent hash value of this object\r
189 #\r
190 # @retval int Hash value of the file path of platform file\r
191 #\r
192 def __hash__(self):\r
193 return hash(self.MetaFile)\r
194\r
195 ## str() operator\r
196 #\r
197 # The file path of platform file will be used to represent this object\r
198 #\r
199 # @retval string String of platform file path\r
200 #\r
201 def __str__(self):\r
202 return str(self.MetaFile)\r
203\r
204 ## "==" operator\r
205 def __eq__(self, Other):\r
206 return Other and self.MetaFile == Other\r
207\r
208## Workspace AutoGen class\r
209#\r
210# This class is used mainly to control the whole platform build for different\r
211# architecture. This class will generate top level makefile.\r
212#\r
213class WorkspaceAutoGen(AutoGen):\r
214 ## Real constructor of WorkspaceAutoGen\r
215 #\r
79b74a03 216 # This method behaves the same as __init__ except that it needs explicit invoke\r
52302d4d
LG		 217 # (in super class's __new__ method)\r
218 #\r
219 # @param WorkspaceDir Root directory of workspace\r
220 # @param ActivePlatform Meta-file of active platform\r
221 # @param Target Build target\r
222 # @param Toolchain Tool chain name\r
223 # @param ArchList List of architecture of current build\r
224 # @param MetaFileDb Database containing meta-files\r
225 # @param BuildConfig Configuration of build\r
226 # @param ToolDefinition Tool chain definitions\r
227 # @param FlashDefinitionFile File of flash definition\r
228 # @param Fds FD list to be generated\r
229 # @param Fvs FV list to be generated\r
4234283c 230 # @param Caps Capsule list to be generated\r
52302d4d
LG		 231 # @param SkuId SKU id from command line\r
232 #\r
233 def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
9508d0fa
LG		 234 BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None, \r
235 Progress=None, BuildModule=None):\r
4234283c
LG		 236 if Fds is None:\r
237 Fds = []\r
238 if Fvs is None:\r
239 Fvs = []\r
240 if Caps is None:\r
241 Caps = []\r
0d2711a6
LG		 242 self.BuildDatabase = MetaFileDb\r
243 self.MetaFile = ActivePlatform\r
52302d4d 244 self.WorkspaceDir = WorkspaceDir\r
0d2711a6 245 self.Platform = self.BuildDatabase[self.MetaFile, 'COMMON', Target, Toolchain]\r
d0acc87a 246 GlobalData.gActivePlatform = self.Platform\r
52302d4d
LG		 247 self.BuildTarget = Target\r
248 self.ToolChain = Toolchain\r
249 self.ArchList = ArchList\r
250 self.SkuId = SkuId\r
f3decdc3 251 self.UniFlag = UniFlag\r
52302d4d 252\r
52302d4d
LG		 253 self.TargetTxt = BuildConfig\r
254 self.ToolDef = ToolDefinition\r
255 self.FdfFile = FlashDefinitionFile\r
256 self.FdTargetList = Fds\r
257 self.FvTargetList = Fvs\r
4234283c 258 self.CapTargetList = Caps\r
52302d4d
LG		 259 self.AutoGenObjectList = []\r
260\r
261 # there's many relative directory operations, so ...\r
262 os.chdir(self.WorkspaceDir)\r
263\r
0d2711a6
LG		 264 #\r
265 # Merge Arch\r
266 #\r
267 if not self.ArchList:\r
268 ArchList = set(self.Platform.SupArchList)\r
269 else:\r
270 ArchList = set(self.ArchList) & set(self.Platform.SupArchList)\r
271 if not ArchList:\r
272 EdkLogger.error("build", PARAMETER_INVALID,\r
273 ExtraData = "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self.Platform.SupArchList)))\r
274 elif self.ArchList and len(ArchList) != len(self.ArchList):\r
275 SkippedArchList = set(self.ArchList).symmetric_difference(set(self.Platform.SupArchList))\r
276 EdkLogger.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"\r
277 % (" ".join(SkippedArchList), " ".join(self.Platform.SupArchList)))\r
278 self.ArchList = tuple(ArchList)\r
279\r
280 # Validate build target\r
281 if self.BuildTarget not in self.Platform.BuildTargets:\r
282 EdkLogger.error("build", PARAMETER_INVALID, \r
283 ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
284 % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
285\r
12d37ace 286 \r
52302d4d 287 # parse FDF file to get PCDs in it, if any\r
0d2711a6
LG		 288 if not self.FdfFile:\r
289 self.FdfFile = self.Platform.FlashDefinition\r
9508d0fa
LG		 290 \r
291 EdkLogger.info("")\r
292 if self.ArchList:\r
293 EdkLogger.info('%-16s = %s' % ("Architecture(s)", ' '.join(self.ArchList)))\r
294 EdkLogger.info('%-16s = %s' % ("Build target", self.BuildTarget))\r
295 EdkLogger.info('%-16s = %s' % ("Toolchain",self.ToolChain)) \r
296 \r
297 EdkLogger.info('\n%-24s = %s' % ("Active Platform", self.Platform))\r
298 if BuildModule:\r
299 EdkLogger.info('%-24s = %s' % ("Active Module", BuildModule))\r
300 \r
301 if self.FdfFile:\r
302 EdkLogger.info('%-24s = %s' % ("Flash Image Definition", self.FdfFile))\r
0d2711a6 303\r
9508d0fa
LG		 304 EdkLogger.verbose("\nFLASH_DEFINITION = %s" % self.FdfFile)\r
305 \r
306 if Progress:\r
307 Progress.Start("\nProcessing meta-data")\r
308 \r
0d2711a6 309 if self.FdfFile:\r
df692f02
LG		 310 #\r
311 # Mark now build in AutoGen Phase\r
312 #\r
0d2711a6 313 GlobalData.gAutoGenPhase = True \r
52302d4d
LG		 314 Fdf = FdfParser(self.FdfFile.Path)\r
315 Fdf.ParseFile()\r
a0a2cd1e 316 GlobalData.gFdfParser = Fdf\r
0d2711a6 317 GlobalData.gAutoGenPhase = False\r
52302d4d
LG		 318 PcdSet = Fdf.Profile.PcdDict\r
319 ModuleList = Fdf.Profile.InfList\r
320 self.FdfProfile = Fdf.Profile\r
0d2711a6
LG		 321 for fvname in self.FvTargetList:\r
322 if fvname.upper() not in self.FdfProfile.FvDict:\r
323 EdkLogger.error("build", OPTION_VALUE_INVALID,\r
324 "No such an FV in FDF file: %s" % fvname)\r
52302d4d
LG		 325 else:\r
326 PcdSet = {}\r
327 ModuleList = []\r
328 self.FdfProfile = None\r
0d2711a6
LG		 329 if self.FdTargetList:\r
330 EdkLogger.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self.FdTargetList))\r
331 self.FdTargetList = []\r
332 if self.FvTargetList:\r
333 EdkLogger.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self.FvTargetList))\r
334 self.FvTargetList = []\r
335 if self.CapTargetList:\r
336 EdkLogger.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self.CapTargetList))\r
337 self.CapTargetList = []\r
52302d4d
LG		 338 \r
339 # apply SKU and inject PCDs from Flash Definition file\r
340 for Arch in self.ArchList:\r
0d2711a6 341 Platform = self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]\r
64b2609f 342\r
25918452 343 DecPcds = {}\r
4afd3d04 344 DecPcdsKey = set()\r
64b2609f 345 PGen = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
97fa0ee9 346 #Collect package set information from INF of FDF\r
a0a2cd1e
FB		 347 PkgSet = set()\r
348 for Inf in ModuleList:\r
349 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
350 if ModuleFile in Platform.Modules:\r
351 continue\r
352 ModuleData = self.BuildDatabase[ModuleFile, Arch, Target, Toolchain]\r
353 PkgSet.update(ModuleData.Packages)\r
354 Pkgs = list(PkgSet) + list(PGen.PackageList)\r
64b2609f 355 for Pkg in Pkgs:\r
25918452
LG		 356 for Pcd in Pkg.Pcds:\r
357 DecPcds[Pcd[0], Pcd[1]] = Pkg.Pcds[Pcd]\r
4afd3d04 358 DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))\r
64b2609f 359\r
52302d4d
LG		 360 Platform.SkuName = self.SkuId\r
361 for Name, Guid in PcdSet:\r
64b2609f
LG		 362 if (Name, Guid) not in DecPcds:\r
363 EdkLogger.error(\r
364 'build',\r
365 PARSER_ERROR,\r
366 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid, Name),\r
367 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
368 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
369 )\r
4afd3d04
LG		 370 else:\r
371 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.\r
372 if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \\r
373 or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \\r
374 or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:\r
375 Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])\r
376 continue\r
377 elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:\r
378 EdkLogger.error(\r
379 'build',\r
380 PARSER_ERROR,\r
381 "Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid, Name),\r
382 File = self.FdfProfile.PcdFileLineDict[Name, Guid][0],\r
383 Line = self.FdfProfile.PcdFileLineDict[Name, Guid][1]\r
384 )\r
52302d4d
LG		 385\r
386 Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)\r
387 #\r
388 # Explicitly collect platform's dynamic PCDs\r
389 #\r
390 Pa.CollectPlatformDynamicPcds()\r
2bc3256c 391 Pa.CollectFixedAtBuildPcds()\r
52302d4d 392 self.AutoGenObjectList.append(Pa)\r
6780eef1
LG		 393 \r
394 #\r
395 # Check PCDs token value conflict in each DEC file.\r
396 #\r
397 self._CheckAllPcdsTokenValueConflict()\r
398 \r
4234283c
LG		 399 #\r
400 # Check PCD type and definition between DSC and DEC\r
401 #\r
402 self._CheckPcdDefineAndType()\r
97fa0ee9
YL		 403\r
404# if self.FdfFile:\r
405# self._CheckDuplicateInFV(Fdf)\r
406\r
52302d4d
LG		 407 self._BuildDir = None\r
408 self._FvDir = None\r
409 self._MakeFileDir = None\r
410 self._BuildCommand = None\r
411\r
412 return True\r
413\r
79b74a03
LG		 414 ## _CheckDuplicateInFV() method\r
415 #\r
416 # Check whether there is duplicate modules/files exist in FV section. \r
417 # The check base on the file GUID;\r
418 #\r
419 def _CheckDuplicateInFV(self, Fdf):\r
420 for Fv in Fdf.Profile.FvDict:\r
421 _GuidDict = {}\r
422 for FfsFile in Fdf.Profile.FvDict[Fv].FfsList:\r
423 if FfsFile.InfFileName and FfsFile.NameGuid == None:\r
424 #\r
425 # Get INF file GUID\r
426 #\r
427 InfFoundFlag = False \r
428 for Pa in self.AutoGenObjectList:\r
64b2609f
LG		 429 if InfFoundFlag:\r
430 break\r
79b74a03
LG		 431 for Module in Pa.ModuleAutoGenList:\r
432 if path.normpath(Module.MetaFile.File) == path.normpath(FfsFile.InfFileName):\r
433 InfFoundFlag = True\r
434 if not Module.Guid.upper() in _GuidDict.keys():\r
435 _GuidDict[Module.Guid.upper()] = FfsFile\r
64b2609f 436 break\r
79b74a03
LG		 437 else:\r
438 EdkLogger.error("build", \r
439 FORMAT_INVALID,\r
440 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
441 FfsFile.CurrentLineContent,\r
442 _GuidDict[Module.Guid.upper()].CurrentLineNum,\r
443 _GuidDict[Module.Guid.upper()].CurrentLineContent,\r
444 Module.Guid.upper()),\r
445 ExtraData=self.FdfFile)\r
446 #\r
447 # Some INF files not have entity in DSC file. \r
448 #\r
449 if not InfFoundFlag:\r
450 if FfsFile.InfFileName.find('$') == -1:\r
451 InfPath = NormPath(FfsFile.InfFileName)\r
452 if not os.path.exists(InfPath):\r
453 EdkLogger.error('build', GENFDS_ERROR, "Non-existant Module %s !" % (FfsFile.InfFileName))\r
454 \r
455 PathClassObj = PathClass(FfsFile.InfFileName, self.WorkspaceDir)\r
456 #\r
457 # Here we just need to get FILE_GUID from INF file, use 'COMMON' as ARCH attribute. and use \r
458 # BuildObject from one of AutoGenObjectList is enough.\r
459 #\r
460 InfObj = self.AutoGenObjectList[0].BuildDatabase.WorkspaceDb.BuildObject[PathClassObj, 'COMMON', self.BuildTarget, self.ToolChain]\r
461 if not InfObj.Guid.upper() in _GuidDict.keys():\r
462 _GuidDict[InfObj.Guid.upper()] = FfsFile\r
463 else:\r
464 EdkLogger.error("build", \r
465 FORMAT_INVALID,\r
466 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
467 FfsFile.CurrentLineContent,\r
468 _GuidDict[InfObj.Guid.upper()].CurrentLineNum,\r
469 _GuidDict[InfObj.Guid.upper()].CurrentLineContent,\r
470 InfObj.Guid.upper()),\r
471 ExtraData=self.FdfFile)\r
472 InfFoundFlag = False\r
473 \r
474 if FfsFile.NameGuid != None:\r
475 _CheckPCDAsGuidPattern = re.compile("^PCD\(.+\..+\)$")\r
476 \r
477 #\r
478 # If the NameGuid reference a PCD name. \r
479 # The style must match: PCD(xxxx.yyy)\r
480 #\r
481 if _CheckPCDAsGuidPattern.match(FfsFile.NameGuid):\r
482 #\r
483 # Replace the PCD value.\r
484 #\r
485 _PcdName = FfsFile.NameGuid.lstrip("PCD(").rstrip(")")\r
486 PcdFoundFlag = False\r
487 for Pa in self.AutoGenObjectList:\r
488 if not PcdFoundFlag:\r
489 for PcdItem in Pa.AllPcdList:\r
490 if (PcdItem.TokenSpaceGuidCName + "." + PcdItem.TokenCName) == _PcdName:\r
491 #\r
492 # First convert from CFormatGuid to GUID string\r
493 #\r
494 _PcdGuidString = GuidStructureStringToGuidString(PcdItem.DefaultValue)\r
495 \r
496 if not _PcdGuidString:\r
497 #\r
498 # Then try Byte array.\r
499 #\r
500 _PcdGuidString = GuidStructureByteArrayToGuidString(PcdItem.DefaultValue)\r
501 \r
502 if not _PcdGuidString:\r
503 #\r
504 # Not Byte array or CFormat GUID, raise error.\r
505 #\r
506 EdkLogger.error("build",\r
507 FORMAT_INVALID,\r
508 "The format of PCD value is incorrect. PCD: %s , Value: %s\n"%(_PcdName, PcdItem.DefaultValue),\r
509 ExtraData=self.FdfFile)\r
510 \r
511 if not _PcdGuidString.upper() in _GuidDict.keys(): \r
512 _GuidDict[_PcdGuidString.upper()] = FfsFile\r
513 PcdFoundFlag = True\r
514 break\r
515 else:\r
516 EdkLogger.error("build", \r
517 FORMAT_INVALID,\r
518 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
519 FfsFile.CurrentLineContent,\r
520 _GuidDict[_PcdGuidString.upper()].CurrentLineNum,\r
521 _GuidDict[_PcdGuidString.upper()].CurrentLineContent,\r
522 FfsFile.NameGuid.upper()),\r
523 ExtraData=self.FdfFile) \r
524 \r
525 if not FfsFile.NameGuid.upper() in _GuidDict.keys():\r
526 _GuidDict[FfsFile.NameGuid.upper()] = FfsFile\r
527 else:\r
528 #\r
529 # Two raw file GUID conflict.\r
530 #\r
531 EdkLogger.error("build", \r
532 FORMAT_INVALID,\r
533 "Duplicate GUID found for these lines: Line %d: %s and Line %d: %s. GUID: %s"%(FfsFile.CurrentLineNum,\r
534 FfsFile.CurrentLineContent,\r
535 _GuidDict[FfsFile.NameGuid.upper()].CurrentLineNum,\r
536 _GuidDict[FfsFile.NameGuid.upper()].CurrentLineContent,\r
537 FfsFile.NameGuid.upper()),\r
538 ExtraData=self.FdfFile)\r
539 \r
540\r
4234283c
LG		 541 def _CheckPcdDefineAndType(self):\r
542 PcdTypeList = [\r
543 "FixedAtBuild", "PatchableInModule", "FeatureFlag",\r
544 "Dynamic", #"DynamicHii", "DynamicVpd",\r
545 "DynamicEx", # "DynamicExHii", "DynamicExVpd"\r
546 ]\r
547\r
548 # This dict store PCDs which are not used by any modules with specified arches\r
549 UnusedPcd = sdict()\r
550 for Pa in self.AutoGenObjectList:\r
551 # Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid\r
552 for Pcd in Pa.Platform.Pcds:\r
553 PcdType = Pa.Platform.Pcds[Pcd].Type\r
554 \r
555 # If no PCD type, this PCD comes from FDF \r
556 if not PcdType:\r
557 continue\r
558 \r
559 # Try to remove Hii and Vpd suffix\r
560 if PcdType.startswith("DynamicEx"):\r
561 PcdType = "DynamicEx"\r
562 elif PcdType.startswith("Dynamic"):\r
563 PcdType = "Dynamic"\r
564 \r
565 for Package in Pa.PackageList:\r
566 # Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
567 if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
568 break\r
569 for Type in PcdTypeList:\r
570 if (Pcd[0], Pcd[1], Type) in Package.Pcds:\r
571 EdkLogger.error(\r
572 'build',\r
573 FORMAT_INVALID,\r
574 "Type [%s] of PCD [%s.%s] in DSC file doesn't match the type [%s] defined in DEC file." \\r
575 % (Pa.Platform.Pcds[Pcd].Type, Pcd[1], Pcd[0], Type),\r
576 ExtraData=None\r
577 )\r
578 return\r
579 else:\r
580 UnusedPcd.setdefault(Pcd, []).append(Pa.Arch)\r
581\r
582 for Pcd in UnusedPcd:\r
583 EdkLogger.warn(\r
584 'build',\r
585 "The PCD was not specified by any INF module in the platform for the given architecture.\n"\r
586 "\tPCD: [%s.%s]\n\tPlatform: [%s]\n\tArch: %s"\r
587 % (Pcd[1], Pcd[0], os.path.basename(str(self.MetaFile)), str(UnusedPcd[Pcd])),\r
588 ExtraData=None\r
589 )\r
590\r
52302d4d
LG		 591 def __repr__(self):\r
592 return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))\r
593\r
594 ## Return the directory to store FV files\r
595 def _GetFvDir(self):\r
596 if self._FvDir == None:\r
597 self._FvDir = path.join(self.BuildDir, 'FV')\r
598 return self._FvDir\r
599\r
600 ## Return the directory to store all intermediate and final files built\r
601 def _GetBuildDir(self):\r
602 return self.AutoGenObjectList[0].BuildDir\r
603\r
604 ## Return the build output directory platform specifies\r
605 def _GetOutputDir(self):\r
606 return self.Platform.OutputDirectory\r
607\r
608 ## Return platform name\r
609 def _GetName(self):\r
610 return self.Platform.PlatformName\r
611\r
612 ## Return meta-file GUID\r
613 def _GetGuid(self):\r
614 return self.Platform.Guid\r
615\r
616 ## Return platform version\r
617 def _GetVersion(self):\r
618 return self.Platform.Version\r
619\r
620 ## Return paths of tools\r
621 def _GetToolDefinition(self):\r
622 return self.AutoGenObjectList[0].ToolDefinition\r
623\r
624 ## Return directory of platform makefile\r
625 #\r
626 # @retval string Makefile directory\r
627 #\r
628 def _GetMakeFileDir(self):\r
629 if self._MakeFileDir == None:\r
630 self._MakeFileDir = self.BuildDir\r
631 return self._MakeFileDir\r
632\r
633 ## Return build command string\r
634 #\r
635 # @retval string Build command string\r
636 #\r
637 def _GetBuildCommand(self):\r
638 if self._BuildCommand == None:\r
639 # BuildCommand should be all the same. So just get one from platform AutoGen\r
640 self._BuildCommand = self.AutoGenObjectList[0].BuildCommand\r
641 return self._BuildCommand\r
6780eef1
LG		 642 \r
643 ## Check the PCDs token value conflict in each DEC file.\r
644 #\r
645 # Will cause build break and raise error message while two PCDs conflict.\r
646 # \r
647 # @return None\r
648 #\r
649 def _CheckAllPcdsTokenValueConflict(self):\r
b36d134f
LG		 650 for Pa in self.AutoGenObjectList:\r
651 for Package in Pa.PackageList:\r
6780eef1
LG		 652 PcdList = Package.Pcds.values()\r
653 PcdList.sort(lambda x, y: cmp(x.TokenValue, y.TokenValue)) \r
654 Count = 0\r
655 while (Count < len(PcdList) - 1) :\r
656 Item = PcdList[Count]\r
657 ItemNext = PcdList[Count + 1]\r
658 #\r
659 # Make sure in the same token space the TokenValue should be unique\r
660 #\r
661 if (Item.TokenValue == ItemNext.TokenValue):\r
662 SameTokenValuePcdList = []\r
663 SameTokenValuePcdList.append(Item)\r
664 SameTokenValuePcdList.append(ItemNext)\r
665 RemainPcdListLength = len(PcdList) - Count - 2\r
666 for ValueSameCount in range(RemainPcdListLength):\r
667 if PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue == Item.TokenValue:\r
668 SameTokenValuePcdList.append(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount])\r
669 else:\r
670 break;\r
671 #\r
672 # Sort same token value PCD list with TokenGuid and TokenCName\r
673 #\r
674 SameTokenValuePcdList.sort(lambda x, y: cmp("%s.%s"%(x.TokenSpaceGuidCName, x.TokenCName), "%s.%s"%(y.TokenSpaceGuidCName, y.TokenCName))) \r
675 SameTokenValuePcdListCount = 0 \r
676 while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):\r
677 TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]\r
678 TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1] \r
679 \r
680 if (TemListItem.TokenSpaceGuidCName == TemListItemNext.TokenSpaceGuidCName) and (TemListItem.TokenCName != TemListItemNext.TokenCName):\r
681 EdkLogger.error(\r
682 'build',\r
683 FORMAT_INVALID,\r
684 "The TokenValue [%s] of PCD [%s.%s] is conflict with: [%s.%s] in %s"\\r
685 % (TemListItem.TokenValue, TemListItem.TokenSpaceGuidCName, TemListItem.TokenCName, TemListItemNext.TokenSpaceGuidCName, TemListItemNext.TokenCName, Package),\r
686 ExtraData=None\r
687 )\r
688 SameTokenValuePcdListCount += 1\r
689 Count += SameTokenValuePcdListCount\r
690 Count += 1\r
691 \r
692 PcdList = Package.Pcds.values()\r
693 PcdList.sort(lambda x, y: cmp("%s.%s"%(x.TokenSpaceGuidCName, x.TokenCName), "%s.%s"%(y.TokenSpaceGuidCName, y.TokenCName)))\r
694 Count = 0\r
695 while (Count < len(PcdList) - 1) :\r
696 Item = PcdList[Count]\r
697 ItemNext = PcdList[Count + 1] \r
698 #\r
699 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.\r
700 #\r
701 if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (Item.TokenValue != ItemNext.TokenValue):\r
702 EdkLogger.error(\r
703 'build',\r
704 FORMAT_INVALID,\r
705 "The TokenValue [%s] of PCD [%s.%s] in %s defined in two places should be same as well."\\r
706 % (Item.TokenValue, Item.TokenSpaceGuidCName, Item.TokenCName, Package),\r
707 ExtraData=None\r
708 )\r
709 Count += 1\r
97fa0ee9 710 ## Generate fds command\r
03af2753
HC		 711 def _GenFdsCommand(self):\r
712 return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()\r
52302d4d 713\r
e56468c0 714 ## Create makefile for the platform and modules in it\r
52302d4d
LG		 715 #\r
716 # @param CreateDepsMakeFile Flag indicating if the makefile for\r
717 # modules will be created as well\r
718 #\r
719 def CreateMakeFile(self, CreateDepsMakeFile=False):\r
52302d4d
LG		 720 if CreateDepsMakeFile:\r
721 for Pa in self.AutoGenObjectList:\r
722 Pa.CreateMakeFile(CreateDepsMakeFile)\r
723\r
724 ## Create autogen code for platform and modules\r
725 #\r
726 # Since there's no autogen code for platform, this method will do nothing\r
727 # if CreateModuleCodeFile is set to False.\r
728 #\r
729 # @param CreateDepsCodeFile Flag indicating if creating module's\r
730 # autogen code file or not\r
731 #\r
732 def CreateCodeFile(self, CreateDepsCodeFile=False):\r
733 if not CreateDepsCodeFile:\r
734 return\r
735 for Pa in self.AutoGenObjectList:\r
736 Pa.CreateCodeFile(CreateDepsCodeFile)\r
737\r
7c1fd323
LG		 738 ## Create AsBuilt INF file the platform\r
739 #\r
740 def CreateAsBuiltInf(self):\r
741 return\r
742\r
52302d4d
LG		 743 Name = property(_GetName)\r
744 Guid = property(_GetGuid)\r
745 Version = property(_GetVersion)\r
746 OutputDir = property(_GetOutputDir)\r
747\r
748 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
749\r
750 BuildDir = property(_GetBuildDir)\r
751 FvDir = property(_GetFvDir)\r
752 MakeFileDir = property(_GetMakeFileDir)\r
753 BuildCommand = property(_GetBuildCommand)\r
03af2753 754 GenFdsCommand = property(_GenFdsCommand)\r
52302d4d
LG		 755\r
756## AutoGen class for platform\r
757#\r
758# PlatformAutoGen class will process the original information in platform\r
759# file in order to generate makefile for platform.\r
760#\r
761class PlatformAutoGen(AutoGen):\r
762 #\r
763 # Used to store all PCDs for both PEI and DXE phase, in order to generate \r
764 # correct PCD database\r
765 # \r
766 _DynaPcdList_ = []\r
767 _NonDynaPcdList_ = []\r
6780eef1
LG		 768 \r
769 #\r
770 # The priority list while override build option \r
771 #\r
772 PrioList = {"0x11111" : 16, # TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE (Highest)\r
773 "0x01111" : 15, # ******_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
774 "0x10111" : 14, # TARGET_*********_ARCH_COMMANDTYPE_ATTRIBUTE\r
775 "0x00111" : 13, # ******_*********_ARCH_COMMANDTYPE_ATTRIBUTE \r
776 "0x11011" : 12, # TARGET_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
777 "0x01011" : 11, # ******_TOOLCHAIN_****_COMMANDTYPE_ATTRIBUTE\r
778 "0x10011" : 10, # TARGET_*********_****_COMMANDTYPE_ATTRIBUTE\r
779 "0x00011" : 9, # ******_*********_****_COMMANDTYPE_ATTRIBUTE\r
780 "0x11101" : 8, # TARGET_TOOLCHAIN_ARCH_***********_ATTRIBUTE\r
781 "0x01101" : 7, # ******_TOOLCHAIN_ARCH_***********_ATTRIBUTE\r
782 "0x10101" : 6, # TARGET_*********_ARCH_***********_ATTRIBUTE\r
783 "0x00101" : 5, # ******_*********_ARCH_***********_ATTRIBUTE\r
784 "0x11001" : 4, # TARGET_TOOLCHAIN_****_***********_ATTRIBUTE\r
785 "0x01001" : 3, # ******_TOOLCHAIN_****_***********_ATTRIBUTE\r
786 "0x10001" : 2, # TARGET_*********_****_***********_ATTRIBUTE\r
787 "0x00001" : 1} # ******_*********_****_***********_ATTRIBUTE (Lowest)\r
788 \r
52302d4d
LG		 789 ## The real constructor of PlatformAutoGen\r
790 #\r
791 # This method is not supposed to be called by users of PlatformAutoGen. It's\r
792 # only used by factory method __new__() to do real initialization work for an\r
793 # object of PlatformAutoGen\r
794 #\r
795 # @param Workspace WorkspaceAutoGen object\r
796 # @param PlatformFile Platform file (DSC file)\r
797 # @param Target Build target (DEBUG, RELEASE)\r
798 # @param Toolchain Name of tool chain\r
799 # @param Arch arch of the platform supports\r
800 #\r
801 def _Init(self, Workspace, PlatformFile, Target, Toolchain, Arch):\r
802 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))\r
803 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)\r
804\r
805 self.MetaFile = PlatformFile\r
806 self.Workspace = Workspace\r
807 self.WorkspaceDir = Workspace.WorkspaceDir\r
808 self.ToolChain = Toolchain\r
809 self.BuildTarget = Target\r
810 self.Arch = Arch\r
811 self.SourceDir = PlatformFile.SubDir\r
812 self.SourceOverrideDir = None\r
813 self.FdTargetList = self.Workspace.FdTargetList\r
814 self.FvTargetList = self.Workspace.FvTargetList\r
815 self.AllPcdList = []\r
a0a2cd1e
FB		 816 # get the original module/package/platform objects\r
817 self.BuildDatabase = Workspace.BuildDatabase\r
52302d4d
LG		 818\r
819 # flag indicating if the makefile/C-code file has been created or not\r
820 self.IsMakeFileCreated = False\r
821 self.IsCodeFileCreated = False\r
822\r
823 self._Platform = None\r
824 self._Name = None\r
825 self._Guid = None\r
826 self._Version = None\r
827\r
828 self._BuildRule = None\r
829 self._SourceDir = None\r
830 self._BuildDir = None\r
831 self._OutputDir = None\r
832 self._FvDir = None\r
833 self._MakeFileDir = None\r
834 self._FdfFile = None\r
835\r
836 self._PcdTokenNumber = None # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
837 self._DynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
838 self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
2bc3256c 839 self._NonDynamicPcdDict = {}\r
52302d4d
LG		 840\r
841 self._ToolDefinitions = None\r
842 self._ToolDefFile = None # toolcode : tool path\r
843 self._ToolChainFamily = None\r
844 self._BuildRuleFamily = None\r
845 self._BuildOption = None # toolcode : option\r
846 self._EdkBuildOption = None # edktoolcode : option\r
847 self._EdkIIBuildOption = None # edkiitoolcode : option\r
848 self._PackageList = None\r
849 self._ModuleAutoGenList = None\r
850 self._LibraryAutoGenList = None\r
851 self._BuildCommand = None\r
a0a2cd1e
FB		 852 self._AsBuildInfList = []\r
853 self._AsBuildModuleList = []\r
854 if GlobalData.gFdfParser != None:\r
855 self._AsBuildInfList = GlobalData.gFdfParser.Profile.InfList\r
856 for Inf in self._AsBuildInfList:\r
857 InfClass = PathClass(NormPath(Inf), GlobalData.gWorkspace, self.Arch)\r
858 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
859 if not M.IsSupportedArch:\r
860 continue\r
861 self._AsBuildModuleList.append(InfClass)\r
03af2753
HC		 862 # get library/modules for build\r
863 self.LibraryBuildDirectoryList = []\r
864 self.ModuleBuildDirectoryList = []\r
52302d4d
LG		 865 return True\r
866\r
867 def __repr__(self):\r
868 return "%s [%s]" % (self.MetaFile, self.Arch)\r
869\r
870 ## Create autogen code for platform and modules\r
871 #\r
872 # Since there's no autogen code for platform, this method will do nothing\r
873 # if CreateModuleCodeFile is set to False.\r
874 #\r
875 # @param CreateModuleCodeFile Flag indicating if creating module's\r
876 # autogen code file or not\r
877 #\r
878 def CreateCodeFile(self, CreateModuleCodeFile=False):\r
879 # only module has code to be greated, so do nothing if CreateModuleCodeFile is False\r
880 if self.IsCodeFileCreated or not CreateModuleCodeFile:\r
881 return\r
882\r
883 for Ma in self.ModuleAutoGenList:\r
884 Ma.CreateCodeFile(True)\r
885\r
886 # don't do this twice\r
887 self.IsCodeFileCreated = True\r
888\r
03af2753
HC		 889 ## Generate Fds Command\r
890 def _GenFdsCommand(self):\r
891 return self.Workspace.GenFdsCommand\r
892 \r
52302d4d
LG		 893 ## Create makefile for the platform and mdoules in it\r
894 #\r
895 # @param CreateModuleMakeFile Flag indicating if the makefile for\r
896 # modules will be created as well\r
897 #\r
898 def CreateMakeFile(self, CreateModuleMakeFile=False):\r
899 if CreateModuleMakeFile:\r
900 for ModuleFile in self.Platform.Modules:\r
901 Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,\r
902 self.ToolChain, self.Arch, self.MetaFile)\r
903 Ma.CreateMakeFile(True)\r
97fa0ee9 904 #Ma.CreateAsBuiltInf()\r
52302d4d
LG		 905\r
906 # no need to create makefile for the platform more than once\r
907 if self.IsMakeFileCreated:\r
908 return\r
909\r
03af2753 910 # create library/module build dirs for platform\r
52302d4d 911 Makefile = GenMake.PlatformMakefile(self)\r
03af2753
HC		 912 self.LibraryBuildDirectoryList = Makefile.GetLibraryBuildDirectoryList()\r
913 self.ModuleBuildDirectoryList = Makefile.GetModuleBuildDirectoryList()\r
914\r
52302d4d
LG		 915 self.IsMakeFileCreated = True\r
916\r
2bc3256c
LG		 917 ## Deal with Shared FixedAtBuild Pcds\r
918 #\r
919 def CollectFixedAtBuildPcds(self):\r
920 for LibAuto in self.LibraryAutoGenList:\r
921 FixedAtBuildPcds = {} \r
922 ShareFixedAtBuildPcdsSameValue = {} \r
923 for Module in LibAuto._ReferenceModules: \r
924 for Pcd in Module.FixedAtBuildPcds + LibAuto.FixedAtBuildPcds:\r
925 key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName)) \r
926 if key not in FixedAtBuildPcds:\r
927 ShareFixedAtBuildPcdsSameValue[key] = True\r
928 FixedAtBuildPcds[key] = Pcd.DefaultValue\r
929 else:\r
930 if FixedAtBuildPcds[key] != Pcd.DefaultValue:\r
931 ShareFixedAtBuildPcdsSameValue[key] = False \r
932 for Pcd in LibAuto.FixedAtBuildPcds:\r
933 key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))\r
934 if (Pcd.TokenCName,Pcd.TokenSpaceGuidCName) not in self.NonDynamicPcdDict:\r
935 continue\r
936 else:\r
937 DscPcd = self.NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)]\r
938 if DscPcd.Type != "FixedAtBuild":\r
939 continue\r
940 if key in ShareFixedAtBuildPcdsSameValue and ShareFixedAtBuildPcdsSameValue[key]: \r
941 LibAuto.ConstPcd[key] = Pcd.DefaultValue\r
942\r
52302d4d
LG		 943 ## Collect dynamic PCDs\r
944 #\r
945 # Gather dynamic PCDs list from each module and their settings from platform\r
946 # This interface should be invoked explicitly when platform action is created.\r
947 #\r
948 def CollectPlatformDynamicPcds(self):\r
949 # for gathering error information\r
950 NoDatumTypePcdList = set()\r
a0a2cd1e 951 PcdNotInDb = []\r
52302d4d 952 self._GuidValue = {}\r
a0a2cd1e
FB		 953 FdfModuleList = []\r
954 for InfName in self._AsBuildInfList:\r
955 InfName = os.path.join(self.WorkspaceDir, InfName)\r
956 FdfModuleList.append(os.path.normpath(InfName))\r
52302d4d
LG		 957 for F in self.Platform.Modules.keys():\r
958 M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)\r
959 #GuidValue.update(M.Guids)\r
960 \r
961 self.Platform.Modules[F].M = M\r
962 \r
963 for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:\r
964 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
e8a47801 965 if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
52302d4d
LG		 966 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))\r
967\r
97fa0ee9 968 # Check the PCD from Binary INF or Source INF\r
a0a2cd1e
FB		 969 if M.IsBinaryModule == True:\r
970 PcdFromModule.IsFromBinaryInf = True\r
97fa0ee9
YL		 971\r
972 # Check the PCD from DSC or not \r
a0a2cd1e
FB		 973 if (PcdFromModule.TokenCName, PcdFromModule.TokenSpaceGuidCName) in self.Platform.Pcds.keys():\r
974 PcdFromModule.IsFromDsc = True\r
975 else:\r
976 PcdFromModule.IsFromDsc = False\r
52302d4d 977 if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:\r
a0a2cd1e
FB		 978 if F.Path not in FdfModuleList:\r
979 # If one of the Source built modules listed in the DSC is not listed \r
980 # in FDF modules, and the INF lists a PCD can only use the PcdsDynamic \r
981 # access method (it is only listed in the DEC file that declares the \r
982 # PCD as PcdsDynamic), then build tool will report warning message\r
983 # notify the PI that they are attempting to build a module that must \r
984 # be included in a flash image in order to be functional. These Dynamic \r
985 # PCD will not be added into the Database unless it is used by other \r
986 # modules that are included in the FDF file.\r
987 if PcdFromModule.Type in GenC.gDynamicPcd and \\r
988 PcdFromModule.IsFromBinaryInf == False:\r
989 # Print warning message to let the developer make a determine.\r
990 if PcdFromModule not in PcdNotInDb:\r
a0a2cd1e
FB		 991 PcdNotInDb.append(PcdFromModule)\r
992 continue\r
993 # If one of the Source built modules listed in the DSC is not listed in \r
994 # FDF modules, and the INF lists a PCD can only use the PcdsDynamicEx \r
995 # access method (it is only listed in the DEC file that declares the \r
996 # PCD as PcdsDynamicEx), then DO NOT break the build; DO NOT add the \r
997 # PCD to the Platform's PCD Database.\r
998 if PcdFromModule.Type in GenC.gDynamicExPcd:\r
999 if PcdFromModule not in PcdNotInDb:\r
1000 PcdNotInDb.append(PcdFromModule)\r
1001 continue\r
52302d4d
LG		 1002 #\r
1003 # If a dynamic PCD used by a PEM module/PEI module & DXE module,\r
1004 # it should be stored in Pcd PEI database, If a dynamic only\r
1005 # used by DXE module, it should be stored in DXE PCD database.\r
1006 # The default Phase is DXE\r
1007 #\r
1008 if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
1009 PcdFromModule.Phase = "PEI"\r
1010 if PcdFromModule not in self._DynaPcdList_:\r
1011 self._DynaPcdList_.append(PcdFromModule)\r
1012 elif PcdFromModule.Phase == 'PEI':\r
1013 # overwrite any the same PCD existing, if Phase is PEI\r
1014 Index = self._DynaPcdList_.index(PcdFromModule)\r
1015 self._DynaPcdList_[Index] = PcdFromModule\r
1016 elif PcdFromModule not in self._NonDynaPcdList_:\r
1017 self._NonDynaPcdList_.append(PcdFromModule)\r
a0a2cd1e
FB		 1018 elif PcdFromModule in self._NonDynaPcdList_ and PcdFromModule.IsFromBinaryInf == True:\r
1019 Index = self._NonDynaPcdList_.index(PcdFromModule)\r
1020 if self._NonDynaPcdList_[Index].IsFromBinaryInf == False:\r
1021 #The PCD from Binary INF will override the same one from source INF\r
1022 self._NonDynaPcdList_.remove (self._NonDynaPcdList_[Index])\r
1023 PcdFromModule.Pending = False\r
1024 self._NonDynaPcdList_.append (PcdFromModule)\r
1025 # Parse the DynamicEx PCD from the AsBuild INF module list of FDF.\r
1026 DscModuleList = []\r
1027 for ModuleInf in self.Platform.Modules.keys():\r
1028 DscModuleList.append (os.path.normpath(ModuleInf.Path))\r
1029 # add the PCD from modules that listed in FDF but not in DSC to Database \r
1030 for InfName in FdfModuleList:\r
1031 if InfName not in DscModuleList:\r
1032 InfClass = PathClass(InfName)\r
1033 M = self.BuildDatabase[InfClass, self.Arch, self.BuildTarget, self.ToolChain]\r
1034 # If a module INF in FDF but not in current arch's DSC module list, it must be module (either binary or source) \r
1035 # for different Arch. PCDs in source module for different Arch is already added before, so skip the source module here. \r
1036 # For binary module, if in current arch, we need to list the PCDs into database. \r
1037 if not M.IsSupportedArch:\r
1038 continue\r
1039 # Override the module PCD setting by platform setting\r
1040 ModulePcdList = self.ApplyPcdSetting(M, M.Pcds)\r
1041 for PcdFromModule in ModulePcdList:\r
1042 PcdFromModule.IsFromBinaryInf = True\r
1043 PcdFromModule.IsFromDsc = False\r
1044 # Only allow the DynamicEx and Patchable PCD in AsBuild INF\r
1045 if PcdFromModule.Type not in GenC.gDynamicExPcd and PcdFromModule.Type not in TAB_PCDS_PATCHABLE_IN_MODULE:\r
1046 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
1047 File=self.MetaFile,\r
1048 ExtraData="\n\tExisted %s PCD %s in:\n\t\t%s\n"\r
1049 % (PcdFromModule.Type, PcdFromModule.TokenCName, InfName))\r
1050 # make sure that the "VOID*" kind of datum has MaxDatumSize set\r
1051 if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize in [None, '']:\r
1052 NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, InfName))\r
1053 if M.ModuleType in ["PEIM", "PEI_CORE"]:\r
1054 PcdFromModule.Phase = "PEI"\r
1055 if PcdFromModule not in self._DynaPcdList_ and PcdFromModule.Type in GenC.gDynamicExPcd:\r
1056 self._DynaPcdList_.append(PcdFromModule)\r
1057 elif PcdFromModule not in self._NonDynaPcdList_ and PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE:\r
1058 self._NonDynaPcdList_.append(PcdFromModule)\r
1059 if PcdFromModule in self._DynaPcdList_ and PcdFromModule.Phase == 'PEI' and PcdFromModule.Type in GenC.gDynamicExPcd:\r
97fa0ee9
YL		 1060 # Overwrite the phase of any the same PCD existing, if Phase is PEI.\r
1061 # It is to solve the case that a dynamic PCD used by a PEM module/PEI \r
1062 # module & DXE module at a same time.\r
1063 # Overwrite the type of the PCDs in source INF by the type of AsBuild\r
1064 # INF file as DynamicEx. \r
a0a2cd1e
FB		 1065 Index = self._DynaPcdList_.index(PcdFromModule)\r
1066 self._DynaPcdList_[Index].Phase = PcdFromModule.Phase\r
1067 self._DynaPcdList_[Index].Type = PcdFromModule.Type\r
1068 for PcdFromModule in self._NonDynaPcdList_:\r
1069 # If a PCD is not listed in the DSC file, but binary INF files used by \r
1070 # this platform all (that use this PCD) list the PCD in a [PatchPcds] \r
1071 # section, AND all source INF files used by this platform the build \r
1072 # that use the PCD list the PCD in either a [Pcds] or [PatchPcds] \r
1073 # section, then the tools must NOT add the PCD to the Platform's PCD\r
1074 # Database; the build must assign the access method for this PCD as \r
1075 # PcdsPatchableInModule.\r
1076 if PcdFromModule not in self._DynaPcdList_:\r
1077 continue\r
1078 Index = self._DynaPcdList_.index(PcdFromModule)\r
1079 if PcdFromModule.IsFromDsc == False and \\r
1080 PcdFromModule.Type in TAB_PCDS_PATCHABLE_IN_MODULE and \\r
1081 PcdFromModule.IsFromBinaryInf == True and \\r
1082 self._DynaPcdList_[Index].IsFromBinaryInf == False:\r
1083 Index = self._DynaPcdList_.index(PcdFromModule)\r
1084 self._DynaPcdList_.remove (self._DynaPcdList_[Index])\r
52302d4d
LG		 1085\r
1086 # print out error information and break the build, if error found\r
1087 if len(NoDatumTypePcdList) > 0:\r
1088 NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)\r
1089 EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",\r
1090 File=self.MetaFile,\r
1091 ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"\r
1092 % NoDatumTypePcdListString)\r
1093 self._NonDynamicPcdList = self._NonDynaPcdList_\r
1094 self._DynamicPcdList = self._DynaPcdList_\r
52302d4d
LG		 1095 #\r
1096 # Sort dynamic PCD list to:\r
1097 # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should \r
1098 # try to be put header of dynamicd List\r
1099 # 2) If PCD is HII type, the PCD item should be put after unicode type PCD\r
1100 #\r
1101 # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.\r
1102 #\r
1103 UnicodePcdArray = []\r
1104 HiiPcdArray = []\r
1105 OtherPcdArray = []\r
6780eef1 1106 VpdPcdDict = {}\r
e56468c0 1107 VpdFile = VpdInfoFile.VpdInfoFile()\r
1108 NeedProcessVpdMapFile = False \r
1109 \r
1110 if (self.Workspace.ArchList[-1] == self.Arch): \r
1111 for Pcd in self._DynamicPcdList:\r
e56468c0 1112 # just pick the a value to determine whether is unicode string type\r
1113 Sku = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]\r
1114 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1115 \r
1116 PcdValue = Sku.DefaultValue\r
1117 if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
1118 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex\r
1119 UnicodePcdArray.append(Pcd)\r
1120 elif len(Sku.VariableName) > 0:\r
1121 # if found HII type PCD then insert to right of UnicodeIndex\r
1122 HiiPcdArray.append(Pcd)\r
1123 else:\r
1124 OtherPcdArray.append(Pcd)\r
e56468c0 1125 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
6780eef1
LG		 1126 VpdPcdDict[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)] = Pcd \r
1127 \r
1128 PlatformPcds = self.Platform.Pcds.keys()\r
1129 PlatformPcds.sort() \r
1130 #\r
1131 # Add VPD type PCD into VpdFile and determine whether the VPD PCD need to be fixed up.\r
1132 #\r
1133 for PcdKey in PlatformPcds:\r
e8a47801
LG		 1134 Pcd = self.Platform.Pcds[PcdKey]\r
1135 if Pcd.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD] and \\r
1136 PcdKey in VpdPcdDict:\r
1137 Pcd = VpdPcdDict[PcdKey]\r
1138 for (SkuName,Sku) in Pcd.SkuInfoList.items():\r
1139 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1140 VpdFile.Add(Pcd, Sku.VpdOffset)\r
1141 # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
1142 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
1143 NeedProcessVpdMapFile = True\r
1144 if self.Platform.VpdToolGuid == None or self.Platform.VpdToolGuid == '':\r
1145 EdkLogger.error("Build", FILE_NOT_FOUND, \\r
1146 "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.")\r
6780eef1 1147 \r
e56468c0 1148 \r
1149 #\r
1150 # Fix the PCDs define in VPD PCD section that never referenced by module.\r
1151 # An example is PCD for signature usage.\r
6780eef1
LG		 1152 # \r
1153 for DscPcd in PlatformPcds:\r
e56468c0 1154 DscPcdEntry = self.Platform.Pcds[DscPcd]\r
1155 if DscPcdEntry.Type in [TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_EX_VPD]:\r
1156 if not (self.Platform.VpdToolGuid == None or self.Platform.VpdToolGuid == ''):\r
1157 FoundFlag = False\r
1158 for VpdPcd in VpdFile._VpdArray.keys():\r
1159 # This PCD has been referenced by module\r
1160 if (VpdPcd.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
1161 (VpdPcd.TokenCName == DscPcdEntry.TokenCName):\r
1162 FoundFlag = True\r
1163 \r
1164 # Not found, it should be signature\r
1165 if not FoundFlag :\r
1166 # just pick the a value to determine whether is unicode string type\r
e8a47801
LG		 1167 for (SkuName,Sku) in DscPcdEntry.SkuInfoList.items():\r
1168 Sku.VpdOffset = Sku.VpdOffset.strip() \r
1169 \r
1170 # Need to iterate DEC pcd information to get the value & datumtype\r
1171 for eachDec in self.PackageList:\r
1172 for DecPcd in eachDec.Pcds:\r
1173 DecPcdEntry = eachDec.Pcds[DecPcd]\r
1174 if (DecPcdEntry.TokenSpaceGuidCName == DscPcdEntry.TokenSpaceGuidCName) and \\r
1175 (DecPcdEntry.TokenCName == DscPcdEntry.TokenCName):\r
1176 # Print warning message to let the developer make a determine.\r
1177 EdkLogger.warn("build", "Unreferenced vpd pcd used!",\r
1178 File=self.MetaFile, \\r
1179 ExtraData = "PCD: %s.%s used in the DSC file %s is unreferenced." \\r
1180 %(DscPcdEntry.TokenSpaceGuidCName, DscPcdEntry.TokenCName, self.Platform.MetaFile.Path)) \r
1181 \r
1182 DscPcdEntry.DatumType = DecPcdEntry.DatumType\r
1183 DscPcdEntry.DefaultValue = DecPcdEntry.DefaultValue\r
1184 DscPcdEntry.TokenValue = DecPcdEntry.TokenValue\r
1185 DscPcdEntry.TokenSpaceGuidValue = eachDec.Guids[DecPcdEntry.TokenSpaceGuidCName]\r
1186 # Only fix the value while no value provided in DSC file.\r
1187 if (Sku.DefaultValue == "" or Sku.DefaultValue==None):\r
1188 DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]].DefaultValue = DecPcdEntry.DefaultValue\r
1189 \r
1190 if DscPcdEntry not in self._DynamicPcdList:\r
1191 self._DynamicPcdList.append(DscPcdEntry)\r
1192# Sku = DscPcdEntry.SkuInfoList[DscPcdEntry.SkuInfoList.keys()[0]]\r
1193 Sku.VpdOffset = Sku.VpdOffset.strip()\r
1194 PcdValue = Sku.DefaultValue\r
1195 VpdFile.Add(DscPcdEntry, Sku.VpdOffset)\r
1196 if not NeedProcessVpdMapFile and Sku.VpdOffset == "*":\r
1197 NeedProcessVpdMapFile = True \r
1198 if DscPcdEntry.DatumType == 'VOID*' and PcdValue.startswith("L"):\r
1199 UnicodePcdArray.append(DscPcdEntry)\r
1200 elif len(Sku.VariableName) > 0:\r
1201 HiiPcdArray.append(DscPcdEntry)\r
1202 else:\r
1203 OtherPcdArray.append(DscPcdEntry)\r
1204 \r
1205 # if the offset of a VPD is *, then it need to be fixed up by third party tool.\r
e56468c0 1206 \r
e56468c0 1207 \r
1208 \r
1209 if (self.Platform.FlashDefinition == None or self.Platform.FlashDefinition == '') and \\r
1210 VpdFile.GetCount() != 0:\r
1211 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, \r
1212 "Fail to get FLASH_DEFINITION definition in DSC file %s which is required when DSC contains VPD PCD." % str(self.Platform.MetaFile))\r
1213 \r
1214 if VpdFile.GetCount() != 0:\r
d0acc87a 1215 DscTimeStamp = self.Platform.MetaFile.TimeStamp\r
e56468c0 1216 FvPath = os.path.join(self.BuildDir, "FV")\r
1217 if not os.path.exists(FvPath):\r
1218 try:\r
1219 os.makedirs(FvPath)\r
1220 except:\r
1221 EdkLogger.error("build", FILE_WRITE_FAILURE, "Fail to create FV folder under %s" % self.BuildDir)\r
1222 \r
08dd311f
LG		 1223 \r
1224 VpdFilePath = os.path.join(FvPath, "%s.txt" % self.Platform.VpdToolGuid)\r
1225\r
e56468c0 1226 \r
1227 if not os.path.exists(VpdFilePath) or os.path.getmtime(VpdFilePath) < DscTimeStamp:\r
1228 VpdFile.Write(VpdFilePath)\r
1229 \r
1230 # retrieve BPDG tool's path from tool_def.txt according to VPD_TOOL_GUID defined in DSC file.\r
1231 BPDGToolName = None\r
1232 for ToolDef in self.ToolDefinition.values():\r
1233 if ToolDef.has_key("GUID") and ToolDef["GUID"] == self.Platform.VpdToolGuid:\r
1234 if not ToolDef.has_key("PATH"):\r
1235 EdkLogger.error("build", ATTRIBUTE_NOT_AVAILABLE, "PATH attribute was not provided for BPDG guid tool %s in tools_def.txt" % self.Platform.VpdToolGuid)\r
1236 BPDGToolName = ToolDef["PATH"]\r
1237 break\r
1238 # Call third party GUID BPDG tool.\r
1239 if BPDGToolName != None:\r
08dd311f 1240 VpdInfoFile.CallExtenalBPDGTool(BPDGToolName, VpdFilePath)\r
e56468c0 1241 else:\r
1242 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.")\r
1243 \r
1244 # Process VPD map file generated by third party BPDG tool\r
1245 if NeedProcessVpdMapFile:\r
08dd311f 1246 VpdMapFilePath = os.path.join(self.BuildDir, "FV", "%s.map" % self.Platform.VpdToolGuid)\r
e56468c0 1247 if os.path.exists(VpdMapFilePath):\r
1248 VpdFile.Read(VpdMapFilePath)\r
1249 \r
1250 # Fixup "*" offset\r
1251 for Pcd in self._DynamicPcdList:\r
1252 # just pick the a value to determine whether is unicode string type\r
e8a47801
LG		 1253 i = 0\r
1254 for (SkuName,Sku) in Pcd.SkuInfoList.items(): \r
1255 if Sku.VpdOffset == "*":\r
1256 Sku.VpdOffset = VpdFile.GetOffset(Pcd)[i].strip()\r
1257 i += 1\r
e56468c0 1258 else:\r
1259 EdkLogger.error("build", FILE_READ_FAILURE, "Can not find VPD map file %s to fix up VPD offset." % VpdMapFilePath)\r
1260 \r
1261 # Delete the DynamicPcdList At the last time enter into this function \r
1262 del self._DynamicPcdList[:] \r
52302d4d
LG		 1263 self._DynamicPcdList.extend(UnicodePcdArray)\r
1264 self._DynamicPcdList.extend(HiiPcdArray)\r
1265 self._DynamicPcdList.extend(OtherPcdArray)\r
a0a2cd1e 1266 self.AllPcdList = self._NonDynamicPcdList + self._DynamicPcdList\r
52302d4d
LG		 1267 \r
1268 ## Return the platform build data object\r
1269 def _GetPlatform(self):\r
1270 if self._Platform == None:\r
0d2711a6 1271 self._Platform = self.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
52302d4d
LG		 1272 return self._Platform\r
1273\r
1274 ## Return platform name\r
1275 def _GetName(self):\r
1276 return self.Platform.PlatformName\r
1277\r
1278 ## Return the meta file GUID\r
1279 def _GetGuid(self):\r
1280 return self.Platform.Guid\r
1281\r
1282 ## Return the platform version\r
1283 def _GetVersion(self):\r
1284 return self.Platform.Version\r
1285\r
1286 ## Return the FDF file name\r
1287 def _GetFdfFile(self):\r
1288 if self._FdfFile == None:\r
1289 if self.Workspace.FdfFile != "":\r
1290 self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile)\r
1291 else:\r
1292 self._FdfFile = ''\r
1293 return self._FdfFile\r
1294\r
1295 ## Return the build output directory platform specifies\r
1296 def _GetOutputDir(self):\r
1297 return self.Platform.OutputDirectory\r
1298\r
1299 ## Return the directory to store all intermediate and final files built\r
1300 def _GetBuildDir(self):\r
1301 if self._BuildDir == None:\r
1302 if os.path.isabs(self.OutputDir):\r
1303 self._BuildDir = path.join(\r
1304 path.abspath(self.OutputDir),\r
1305 self.BuildTarget + "_" + self.ToolChain,\r
1306 )\r
1307 else:\r
1308 self._BuildDir = path.join(\r
1309 self.WorkspaceDir,\r
1310 self.OutputDir,\r
1311 self.BuildTarget + "_" + self.ToolChain,\r
1312 )\r
1313 return self._BuildDir\r
1314\r
1315 ## Return directory of platform makefile\r
1316 #\r
1317 # @retval string Makefile directory\r
1318 #\r
1319 def _GetMakeFileDir(self):\r
1320 if self._MakeFileDir == None:\r
1321 self._MakeFileDir = path.join(self.BuildDir, self.Arch)\r
1322 return self._MakeFileDir\r
1323\r
1324 ## Return build command string\r
1325 #\r
1326 # @retval string Build command string\r
1327 #\r
1328 def _GetBuildCommand(self):\r
1329 if self._BuildCommand == None:\r
1330 self._BuildCommand = []\r
1331 if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:\r
1332 self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])\r
1333 if "FLAGS" in self.ToolDefinition["MAKE"]:\r
1334 NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()\r
1335 if NewOption != '':\r
6780eef1 1336 self._BuildCommand += SplitOption(NewOption)\r
52302d4d
LG		 1337 return self._BuildCommand\r
1338\r
1339 ## Get tool chain definition\r
1340 #\r
1341 # Get each tool defition for given tool chain from tools_def.txt and platform\r
1342 #\r
1343 def _GetToolDefinition(self):\r
1344 if self._ToolDefinitions == None:\r
1345 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary\r
1346 if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:\r
1347 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",\r
1348 ExtraData="[%s]" % self.MetaFile)\r
1349 self._ToolDefinitions = {}\r
1350 DllPathList = set()\r
1351 for Def in ToolDefinition:\r
1352 Target, Tag, Arch, Tool, Attr = Def.split("_")\r
1353 if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:\r
1354 continue\r
1355\r
1356 Value = ToolDefinition[Def]\r
1357 # don't record the DLL\r
1358 if Attr == "DLL":\r
1359 DllPathList.add(Value)\r
1360 continue\r
1361\r
1362 if Tool not in self._ToolDefinitions:\r
1363 self._ToolDefinitions[Tool] = {}\r
1364 self._ToolDefinitions[Tool][Attr] = Value\r
1365\r
1366 ToolsDef = ''\r
1367 MakePath = ''\r
1368 if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:\r
1369 if "FLAGS" not in self._ToolDefinitions["MAKE"]:\r
1370 self._ToolDefinitions["MAKE"]["FLAGS"] = ""\r
1371 self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"\r
1372 MakeFlags = ''\r
1373 for Tool in self._ToolDefinitions:\r
1374 for Attr in self._ToolDefinitions[Tool]:\r
1375 Value = self._ToolDefinitions[Tool][Attr]\r
1376 if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:\r
1377 # check if override is indicated\r
1378 if self.BuildOption[Tool][Attr].startswith('='):\r
1379 Value = self.BuildOption[Tool][Attr][1:]\r
1380 else:\r
1381 Value += " " + self.BuildOption[Tool][Attr]\r
1382\r
1383 if Attr == "PATH":\r
1384 # Don't put MAKE definition in the file\r
1385 if Tool == "MAKE":\r
1386 MakePath = Value\r
1387 else:\r
1388 ToolsDef += "%s = %s\n" % (Tool, Value)\r
1389 elif Attr != "DLL":\r
1390 # Don't put MAKE definition in the file\r
1391 if Tool == "MAKE":\r
1392 if Attr == "FLAGS":\r
1393 MakeFlags = Value\r
1394 else:\r
1395 ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)\r
1396 ToolsDef += "\n"\r
1397\r
1398 SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)\r
1399 for DllPath in DllPathList:\r
1400 os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]\r
1401 os.environ["MAKE_FLAGS"] = MakeFlags\r
1402\r
1403 return self._ToolDefinitions\r
1404\r
1405 ## Return the paths of tools\r
1406 def _GetToolDefFile(self):\r
1407 if self._ToolDefFile == None:\r
1408 self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)\r
1409 return self._ToolDefFile\r
1410\r
1411 ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.\r
1412 def _GetToolChainFamily(self):\r
1413 if self._ToolChainFamily == None:\r
1414 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
1415 if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \\r
1416 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \\r
1417 or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:\r
1418 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
1419 % self.ToolChain)\r
1420 self._ToolChainFamily = "MSFT"\r
1421 else:\r
1422 self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]\r
1423 return self._ToolChainFamily\r
1424\r
1425 def _GetBuildRuleFamily(self):\r
1426 if self._BuildRuleFamily == None:\r
1427 ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase\r
1428 if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \\r
1429 or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
1430 or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:\r
1431 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \\r
1432 % self.ToolChain)\r
1433 self._BuildRuleFamily = "MSFT"\r
1434 else:\r
1435 self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]\r
1436 return self._BuildRuleFamily\r
1437\r
1438 ## Return the build options specific for all modules in this platform\r
1439 def _GetBuildOptions(self):\r
1440 if self._BuildOption == None:\r
1441 self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)\r
1442 return self._BuildOption\r
1443\r
1444 ## Return the build options specific for EDK modules in this platform\r
1445 def _GetEdkBuildOptions(self):\r
1446 if self._EdkBuildOption == None:\r
1447 self._EdkBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDK_NAME)\r
1448 return self._EdkBuildOption\r
1449\r
1450 ## Return the build options specific for EDKII modules in this platform\r
1451 def _GetEdkIIBuildOptions(self):\r
1452 if self._EdkIIBuildOption == None:\r
1453 self._EdkIIBuildOption = self._ExpandBuildOption(self.Platform.BuildOptions, EDKII_NAME)\r
1454 return self._EdkIIBuildOption\r
1455\r
97fa0ee9 1456 ## Parse build_rule.txt in Conf Directory.\r
52302d4d
LG		 1457 #\r
1458 # @retval BuildRule object\r
1459 #\r
1460 def _GetBuildRule(self):\r
1461 if self._BuildRule == None:\r
1462 BuildRuleFile = None\r
1463 if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:\r
1464 BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
1465 if BuildRuleFile in [None, '']:\r
97fa0ee9 1466 BuildRuleFile = gDefaultBuildRuleFile\r
52302d4d 1467 self._BuildRule = BuildRule(BuildRuleFile)\r
64b2609f
LG		 1468 if self._BuildRule._FileVersion == "":\r
1469 self._BuildRule._FileVersion = AutoGenReqBuildRuleVerNum\r
1470 else:\r
1471 if self._BuildRule._FileVersion < AutoGenReqBuildRuleVerNum :\r
1472 # If Build Rule's version is less than the version number required by the tools, halting the build.\r
1473 EdkLogger.error("build", AUTOGEN_ERROR, \r
1474 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])"\\r
1475 % (self._BuildRule._FileVersion, AutoGenReqBuildRuleVerNum))\r
1476 \r
52302d4d
LG		 1477 return self._BuildRule\r
1478\r
1479 ## Summarize the packages used by modules in this platform\r
1480 def _GetPackageList(self):\r
1481 if self._PackageList == None:\r
1482 self._PackageList = set()\r
1483 for La in self.LibraryAutoGenList:\r
1484 self._PackageList.update(La.DependentPackageList)\r
1485 for Ma in self.ModuleAutoGenList:\r
1486 self._PackageList.update(Ma.DependentPackageList)\r
a0a2cd1e
FB		 1487 #Collect package set information from INF of FDF\r
1488 PkgSet = set()\r
1489 for ModuleFile in self._AsBuildModuleList:\r
1490 if ModuleFile in self.Platform.Modules:\r
1491 continue\r
1492 ModuleData = self.BuildDatabase[ModuleFile, self.Arch, self.BuildTarget, self.ToolChain]\r
1493 PkgSet.update(ModuleData.Packages)\r
1494 self._PackageList = list(self._PackageList) + list (PkgSet)\r
52302d4d
LG		 1495 return self._PackageList\r
1496\r
2bc3256c
LG		 1497 def _GetNonDynamicPcdDict(self):\r
1498 if self._NonDynamicPcdDict:\r
1499 return self._NonDynamicPcdDict\r
1500 for Pcd in self.NonDynamicPcdList:\r
1501 self._NonDynamicPcdDict[(Pcd.TokenCName,Pcd.TokenSpaceGuidCName)] = Pcd\r
1502 return self._NonDynamicPcdDict\r
1503\r
52302d4d
LG		 1504 ## Get list of non-dynamic PCDs\r
1505 def _GetNonDynamicPcdList(self):\r
e56468c0 1506 if self._NonDynamicPcdList == None:\r
1507 self.CollectPlatformDynamicPcds()\r
52302d4d
LG		 1508 return self._NonDynamicPcdList\r
1509\r
1510 ## Get list of dynamic PCDs\r
1511 def _GetDynamicPcdList(self):\r
e56468c0 1512 if self._DynamicPcdList == None:\r
1513 self.CollectPlatformDynamicPcds()\r
52302d4d
LG		 1514 return self._DynamicPcdList\r
1515\r
1516 ## Generate Token Number for all PCD\r
1517 def _GetPcdTokenNumbers(self):\r
1518 if self._PcdTokenNumber == None:\r
1519 self._PcdTokenNumber = sdict()\r
1520 TokenNumber = 1\r
d0acc87a
LG		 1521 #\r
1522 # Make the Dynamic and DynamicEx PCD use within different TokenNumber area. \r
1523 # Such as:\r
1524 # \r
1525 # Dynamic PCD:\r
1526 # TokenNumber 0 ~ 10\r
1527 # DynamicEx PCD:\r
1528 # TokeNumber 11 ~ 20\r
1529 #\r
52302d4d
LG		 1530 for Pcd in self.DynamicPcdList:\r
1531 if Pcd.Phase == "PEI":\r
d0acc87a
LG		 1532 if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\r
1533 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1534 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1535 TokenNumber += 1\r
1536 \r
1537 for Pcd in self.DynamicPcdList:\r
1538 if Pcd.Phase == "PEI":\r
1539 if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\r
1540 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1541 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1542 TokenNumber += 1\r
1543 \r
52302d4d
LG		 1544 for Pcd in self.DynamicPcdList:\r
1545 if Pcd.Phase == "DXE":\r
d0acc87a
LG		 1546 if Pcd.Type in ["Dynamic", "DynamicDefault", "DynamicVpd", "DynamicHii"]:\r
1547 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1548 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1549 TokenNumber += 1\r
1550 \r
1551 for Pcd in self.DynamicPcdList:\r
1552 if Pcd.Phase == "DXE":\r
1553 if Pcd.Type in ["DynamicEx", "DynamicExDefault", "DynamicExVpd", "DynamicExHii"]:\r
1554 EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))\r
1555 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1556 TokenNumber += 1\r
1557 \r
52302d4d
LG		 1558 for Pcd in self.NonDynamicPcdList:\r
1559 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber\r
1560 TokenNumber += 1\r
1561 return self._PcdTokenNumber\r
1562\r
1563 ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform\r
1564 def _GetAutoGenObjectList(self):\r
1565 self._ModuleAutoGenList = []\r
1566 self._LibraryAutoGenList = []\r
1567 for ModuleFile in self.Platform.Modules:\r
1568 Ma = ModuleAutoGen(\r
1569 self.Workspace,\r
1570 ModuleFile,\r
1571 self.BuildTarget,\r
1572 self.ToolChain,\r
1573 self.Arch,\r
1574 self.MetaFile\r
1575 )\r
1576 if Ma not in self._ModuleAutoGenList:\r
1577 self._ModuleAutoGenList.append(Ma)\r
1578 for La in Ma.LibraryAutoGenList:\r
1579 if La not in self._LibraryAutoGenList:\r
1580 self._LibraryAutoGenList.append(La)\r
2bc3256c
LG		 1581 if Ma not in La._ReferenceModules:\r
1582 La._ReferenceModules.append(Ma)\r
52302d4d
LG		 1583\r
1584 ## Summarize ModuleAutoGen objects of all modules to be built for this platform\r
1585 def _GetModuleAutoGenList(self):\r
1586 if self._ModuleAutoGenList == None:\r
1587 self._GetAutoGenObjectList()\r
1588 return self._ModuleAutoGenList\r
1589\r
1590 ## Summarize ModuleAutoGen objects of all libraries to be built for this platform\r
1591 def _GetLibraryAutoGenList(self):\r
1592 if self._LibraryAutoGenList == None:\r
1593 self._GetAutoGenObjectList()\r
1594 return self._LibraryAutoGenList\r
1595\r
1596 ## Test if a module is supported by the platform\r
1597 #\r
1598 # An error will be raised directly if the module or its arch is not supported\r
1599 # by the platform or current configuration\r
1600 #\r
1601 def ValidModule(self, Module):\r
a0a2cd1e
FB		 1602 return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances \\r
1603 or Module in self._AsBuildModuleList\r
52302d4d
LG		 1604\r
1605 ## Resolve the library classes in a module to library instances\r
1606 #\r
1607 # This method will not only resolve library classes but also sort the library\r
1608 # instances according to the dependency-ship.\r
1609 #\r
1610 # @param Module The module from which the library classes will be resolved\r
1611 #\r
1612 # @retval library_list List of library instances sorted\r
1613 #\r
1614 def ApplyLibraryInstance(self, Module):\r
1615 ModuleType = Module.ModuleType\r
1616\r
1617 # for overridding library instances with module specific setting\r
1618 PlatformModule = self.Platform.Modules[str(Module)]\r
1619\r
1620 # add forced library instances (specified under LibraryClasses sections)\r
da92f276
LG		 1621 #\r
1622 # If a module has a MODULE_TYPE of USER_DEFINED,\r
1623 # do not link in NULL library class instances from the global [LibraryClasses.*] sections.\r
1624 #\r
1625 if Module.ModuleType != SUP_MODULE_USER_DEFINED:\r
1626 for LibraryClass in self.Platform.LibraryClasses.GetKeys():\r
1627 if LibraryClass.startswith("NULL") and self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]:\r
1628 Module.LibraryClasses[LibraryClass] = self.Platform.LibraryClasses[LibraryClass, Module.ModuleType]\r
52302d4d
LG		 1629\r
1630 # add forced library instances (specified in module overrides)\r
1631 for LibraryClass in PlatformModule.LibraryClasses:\r
1632 if LibraryClass.startswith("NULL"):\r
1633 Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]\r
1634\r
b36d134f 1635 # EdkII module\r
52302d4d
LG		 1636 LibraryConsumerList = [Module]\r
1637 Constructor = []\r
1638 ConsumedByList = sdict()\r
1639 LibraryInstance = sdict()\r
1640\r
1641 EdkLogger.verbose("")\r
1642 EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
1643 while len(LibraryConsumerList) > 0:\r
1644 M = LibraryConsumerList.pop()\r
1645 for LibraryClassName in M.LibraryClasses:\r
1646 if LibraryClassName not in LibraryInstance:\r
1647 # override library instance for this module\r
1648 if LibraryClassName in PlatformModule.LibraryClasses:\r
1649 LibraryPath = PlatformModule.LibraryClasses[LibraryClassName]\r
1650 else:\r
1651 LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]\r
1652 if LibraryPath == None or LibraryPath == "":\r
1653 LibraryPath = M.LibraryClasses[LibraryClassName]\r
1654 if LibraryPath == None or LibraryPath == "":\r
1655 EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,\r
1656 "Instance of library class [%s] is not found" % LibraryClassName,\r
1657 File=self.MetaFile,\r
1658 ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module)))\r
1659\r
0d2711a6 1660 LibraryModule = self.BuildDatabase[LibraryPath, self.Arch, self.BuildTarget, self.ToolChain]\r
52302d4d
LG		 1661 # for those forced library instance (NULL library), add a fake library class\r
1662 if LibraryClassName.startswith("NULL"):\r
1663 LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))\r
1664 elif LibraryModule.LibraryClass == None \\r
1665 or len(LibraryModule.LibraryClass) == 0 \\r
1666 or (ModuleType != 'USER_DEFINED'\r
1667 and ModuleType not in LibraryModule.LibraryClass[0].SupModList):\r
1668 # only USER_DEFINED can link against any library instance despite of its SupModList\r
1669 EdkLogger.error("build", OPTION_MISSING,\r
1670 "Module type [%s] is not supported by library instance [%s]" \\r
1671 % (ModuleType, LibraryPath), File=self.MetaFile,\r
1672 ExtraData="consumed by [%s]" % str(Module))\r
1673\r
1674 LibraryInstance[LibraryClassName] = LibraryModule\r
1675 LibraryConsumerList.append(LibraryModule)\r
1676 EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))\r
1677 else:\r
1678 LibraryModule = LibraryInstance[LibraryClassName]\r
1679\r
1680 if LibraryModule == None:\r
1681 continue\r
1682\r
1683 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:\r
1684 Constructor.append(LibraryModule)\r
1685\r
1686 if LibraryModule not in ConsumedByList:\r
1687 ConsumedByList[LibraryModule] = []\r
1688 # don't add current module itself to consumer list\r
1689 if M != Module:\r
1690 if M in ConsumedByList[LibraryModule]:\r
1691 continue\r
1692 ConsumedByList[LibraryModule].append(M)\r
1693 #\r
1694 # Initialize the sorted output list to the empty set\r
1695 #\r
1696 SortedLibraryList = []\r
1697 #\r
1698 # Q <- Set of all nodes with no incoming edges\r
1699 #\r
1700 LibraryList = [] #LibraryInstance.values()\r
1701 Q = []\r
1702 for LibraryClassName in LibraryInstance:\r
1703 M = LibraryInstance[LibraryClassName]\r
1704 LibraryList.append(M)\r
1705 if ConsumedByList[M] == []:\r
1706 Q.append(M)\r
1707\r
1708 #\r
1709 # start the DAG algorithm\r
1710 #\r
1711 while True:\r
1712 EdgeRemoved = True\r
1713 while Q == [] and EdgeRemoved:\r
1714 EdgeRemoved = False\r
1715 # for each node Item with a Constructor\r
1716 for Item in LibraryList:\r
1717 if Item not in Constructor:\r
1718 continue\r
1719 # for each Node without a constructor with an edge e from Item to Node\r
1720 for Node in ConsumedByList[Item]:\r
1721 if Node in Constructor:\r
1722 continue\r
1723 # remove edge e from the graph if Node has no constructor\r
1724 ConsumedByList[Item].remove(Node)\r
1725 EdgeRemoved = True\r
1726 if ConsumedByList[Item] == []:\r
1727 # insert Item into Q\r
1728 Q.insert(0, Item)\r
1729 break\r
1730 if Q != []:\r
1731 break\r
1732 # DAG is done if there's no more incoming edge for all nodes\r
1733 if Q == []:\r
1734 break\r
1735\r
1736 # remove node from Q\r
1737 Node = Q.pop()\r
1738 # output Node\r
1739 SortedLibraryList.append(Node)\r
1740\r
1741 # for each node Item with an edge e from Node to Item do\r
1742 for Item in LibraryList:\r
1743 if Node not in ConsumedByList[Item]:\r
1744 continue\r
1745 # remove edge e from the graph\r
1746 ConsumedByList[Item].remove(Node)\r
1747\r
1748 if ConsumedByList[Item] != []:\r
1749 continue\r
1750 # insert Item into Q, if Item has no other incoming edges\r
1751 Q.insert(0, Item)\r
1752\r
1753 #\r
1754 # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle\r
1755 #\r
1756 for Item in LibraryList:\r
1757 if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:\r
1758 ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])\r
1759 EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),\r
1760 ExtraData=ErrorMessage, File=self.MetaFile)\r
1761 if Item not in SortedLibraryList:\r
1762 SortedLibraryList.append(Item)\r
1763\r
1764 #\r
1765 # Build the list of constructor and destructir names\r
1766 # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order\r
1767 #\r
1768 SortedLibraryList.reverse()\r
1769 return SortedLibraryList\r
1770\r
1771\r
1772 ## Override PCD setting (type, value, ...)\r
1773 #\r
1774 # @param ToPcd The PCD to be overrided\r
1775 # @param FromPcd The PCD overrideing from\r
1776 #\r
1777 def _OverridePcd(self, ToPcd, FromPcd, Module=""):\r
1778 #\r
1779 # in case there's PCDs coming from FDF file, which have no type given.\r
1780 # at this point, ToPcd.Type has the type found from dependent\r
1781 # package\r
1782 #\r
1783 if FromPcd != None:\r
1784 if ToPcd.Pending and FromPcd.Type not in [None, '']:\r
1785 ToPcd.Type = FromPcd.Type\r
e56468c0 1786 elif (ToPcd.Type not in [None, '']) and (FromPcd.Type not in [None, ''])\\r
1787 and (ToPcd.Type != FromPcd.Type) and (ToPcd.Type in FromPcd.Type):\r
1788 if ToPcd.Type.strip() == "DynamicEx":\r
1789 ToPcd.Type = FromPcd.Type \r
52302d4d
LG		 1790 elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \\r
1791 and ToPcd.Type != FromPcd.Type:\r
1792 EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",\r
1793 ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\\r
1794 % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName,\r
1795 ToPcd.Type, Module, FromPcd.Type),\r
1796 File=self.MetaFile)\r
1797\r
1798 if FromPcd.MaxDatumSize not in [None, '']:\r
1799 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize\r
1800 if FromPcd.DefaultValue not in [None, '']:\r
1801 ToPcd.DefaultValue = FromPcd.DefaultValue\r
1802 if FromPcd.TokenValue not in [None, '']:\r
1803 ToPcd.TokenValue = FromPcd.TokenValue\r
1804 if FromPcd.MaxDatumSize not in [None, '']:\r
1805 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize\r
1806 if FromPcd.DatumType not in [None, '']:\r
1807 ToPcd.DatumType = FromPcd.DatumType\r
1808 if FromPcd.SkuInfoList not in [None, '', []]:\r
1809 ToPcd.SkuInfoList = FromPcd.SkuInfoList\r
1810\r
1811 # check the validation of datum\r
1812 IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)\r
1813 if not IsValid:\r
1814 EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,\r
1815 ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))\r
82a6a960
BF		 1816 ToPcd.validateranges = FromPcd.validateranges\r
1817 ToPcd.validlists = FromPcd.validlists\r
1818 ToPcd.expressions = FromPcd.expressions\r
52302d4d
LG		 1819\r
1820 if ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:\r
1821 EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \\r
1822 % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))\r
1823 Value = ToPcd.DefaultValue\r
1824 if Value in [None, '']:\r
e8a47801 1825 ToPcd.MaxDatumSize = '1'\r
52302d4d 1826 elif Value[0] == 'L':\r
e8a47801 1827 ToPcd.MaxDatumSize = str((len(Value) - 2) * 2)\r
52302d4d
LG		 1828 elif Value[0] == '{':\r
1829 ToPcd.MaxDatumSize = str(len(Value.split(',')))\r
1830 else:\r
e8a47801 1831 ToPcd.MaxDatumSize = str(len(Value) - 1)\r
52302d4d
LG		 1832\r
1833 # apply default SKU for dynamic PCDS if specified one is not available\r
1834 if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \\r
1835 and ToPcd.SkuInfoList in [None, {}, '']:\r
1836 if self.Platform.SkuName in self.Platform.SkuIds:\r
1837 SkuName = self.Platform.SkuName\r
1838 else:\r
1839 SkuName = 'DEFAULT'\r
1840 ToPcd.SkuInfoList = {\r
1841 SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName], '', '', '', '', '', ToPcd.DefaultValue)\r
1842 }\r
1843\r
1844 ## Apply PCD setting defined platform to a module\r
1845 #\r
1846 # @param Module The module from which the PCD setting will be overrided\r
1847 #\r
1848 # @retval PCD_list The list PCDs with settings from platform\r
1849 #\r
1850 def ApplyPcdSetting(self, Module, Pcds):\r
1851 # for each PCD in module\r
1852 for Name,Guid in Pcds:\r
1853 PcdInModule = Pcds[Name,Guid]\r
1854 # find out the PCD setting in platform\r
1855 if (Name,Guid) in self.Platform.Pcds:\r
1856 PcdInPlatform = self.Platform.Pcds[Name,Guid]\r
1857 else:\r
1858 PcdInPlatform = None\r
1859 # then override the settings if any\r
1860 self._OverridePcd(PcdInModule, PcdInPlatform, Module)\r
1861 # resolve the VariableGuid value\r
1862 for SkuId in PcdInModule.SkuInfoList:\r
1863 Sku = PcdInModule.SkuInfoList[SkuId]\r
1864 if Sku.VariableGuid == '': continue\r
1865 Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList)\r
1866 if Sku.VariableGuidValue == None:\r
1867 PackageList = "\n\t".join([str(P) for P in self.PackageList])\r
1868 EdkLogger.error(\r
1869 'build',\r
1870 RESOURCE_NOT_AVAILABLE,\r
1871 "Value of GUID [%s] is not found in" % Sku.VariableGuid,\r
1872 ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \\r
1873 % (Guid, Name, str(Module)),\r
1874 File=self.MetaFile\r
1875 )\r
1876\r
1877 # override PCD settings with module specific setting\r
1878 if Module in self.Platform.Modules:\r
1879 PlatformModule = self.Platform.Modules[str(Module)]\r
1880 for Key in PlatformModule.Pcds:\r
1881 if Key in Pcds:\r
1882 self._OverridePcd(Pcds[Key], PlatformModule.Pcds[Key], Module)\r
1883 return Pcds.values()\r
1884\r
1885 ## Resolve library names to library modules\r
1886 #\r
b36d134f 1887 # (for Edk.x modules)\r
52302d4d
LG		 1888 #\r
1889 # @param Module The module from which the library names will be resolved\r
1890 #\r
1891 # @retval library_list The list of library modules\r
1892 #\r
1893 def ResolveLibraryReference(self, Module):\r
1894 EdkLogger.verbose("")\r
1895 EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))\r
1896 LibraryConsumerList = [Module]\r
1897\r
b36d134f 1898 # "CompilerStub" is a must for Edk modules\r
52302d4d
LG		 1899 if Module.Libraries:\r
1900 Module.Libraries.append("CompilerStub")\r
1901 LibraryList = []\r
1902 while len(LibraryConsumerList) > 0:\r
1903 M = LibraryConsumerList.pop()\r
1904 for LibraryName in M.Libraries:\r
1905 Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']\r
1906 if Library == None:\r
1907 for Key in self.Platform.LibraryClasses.data.keys():\r
1908 if LibraryName.upper() == Key.upper():\r
1909 Library = self.Platform.LibraryClasses[Key, ':dummy:']\r
1910 break\r
1911 if Library == None:\r
1912 EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),\r
1913 ExtraData="\t%s [%s]" % (str(Module), self.Arch))\r
1914 continue\r
1915\r
1916 if Library not in LibraryList:\r
1917 LibraryList.append(Library)\r
1918 LibraryConsumerList.append(Library)\r
1919 EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))\r
1920 return LibraryList\r
1921\r
6780eef1
LG		 1922 ## Calculate the priority value of the build option\r
1923 #\r
1924 # @param Key Build option definition contain: TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
1925 #\r
1926 # @retval Value Priority value based on the priority list.\r
1927 #\r
1928 def CalculatePriorityValue(self, Key):\r
1929 Target, ToolChain, Arch, CommandType, Attr = Key.split('_') \r
1930 PriorityValue = 0x11111 \r
1931 if Target == "*":\r
1932 PriorityValue &= 0x01111\r
1933 if ToolChain == "*":\r
1934 PriorityValue &= 0x10111\r
1935 if Arch == "*":\r
1936 PriorityValue &= 0x11011\r
1937 if CommandType == "*":\r
1938 PriorityValue &= 0x11101\r
1939 if Attr == "*":\r
1940 PriorityValue &= 0x11110\r
1941 \r
1942 return self.PrioList["0x%0.5x"%PriorityValue]\r
1943 \r
1944\r
52302d4d
LG		 1945 ## Expand * in build option key\r
1946 #\r
1947 # @param Options Options to be expanded\r
1948 #\r
1949 # @retval options Options expanded\r
6780eef1 1950 # \r
52302d4d
LG		 1951 def _ExpandBuildOption(self, Options, ModuleStyle=None):\r
1952 BuildOptions = {}\r
1953 FamilyMatch = False\r
1954 FamilyIsNull = True\r
6780eef1
LG		 1955 \r
1956 OverrideList = {}\r
1957 #\r
1958 # Construct a list contain the build options which need override.\r
1959 #\r
1960 for Key in Options:\r
1961 #\r
1962 # Key[0] -- tool family\r
1963 # Key[1] -- TARGET_TOOLCHAIN_ARCH_COMMANDTYPE_ATTRIBUTE\r
1964 #\r
1965 if Key[0] == self.BuildRuleFamily :\r
1966 Target, ToolChain, Arch, CommandType, Attr = Key[1].split('_')\r
1967 if Target == self.BuildTarget or Target == "*":\r
1968 if ToolChain == self.ToolChain or ToolChain == "*":\r
1969 if Arch == self.Arch or Arch == "*":\r
1970 if Options[Key].startswith("="):\r
1971 if OverrideList.get(Key[1]) != None: \r
1972 OverrideList.pop(Key[1])\r
1973 OverrideList[Key[1]] = Options[Key]\r
1974 \r
1975 #\r
1976 # Use the highest priority value. \r
1977 #\r
1978 if (len(OverrideList) >= 2):\r
1979 KeyList = OverrideList.keys()\r
1980 for Index in range(len(KeyList)):\r
1981 NowKey = KeyList[Index]\r
1982 Target1, ToolChain1, Arch1, CommandType1, Attr1 = NowKey.split("_")\r
1983 for Index1 in range(len(KeyList) - Index - 1):\r
1984 NextKey = KeyList[Index1 + Index + 1]\r
1985 #\r
1986 # Compare two Key, if one is included by another, choose the higher priority one\r
1987 # \r
1988 Target2, ToolChain2, Arch2, CommandType2, Attr2 = NextKey.split("_")\r
1989 if Target1 == Target2 or Target1 == "*" or Target2 == "*":\r
1990 if ToolChain1 == ToolChain2 or ToolChain1 == "*" or ToolChain2 == "*":\r
1991 if Arch1 == Arch2 or Arch1 == "*" or Arch2 == "*":\r
1992 if CommandType1 == CommandType2 or CommandType1 == "*" or CommandType2 == "*":\r
1993 if Attr1 == Attr2 or Attr1 == "*" or Attr2 == "*":\r
1994 if self.CalculatePriorityValue(NowKey) > self.CalculatePriorityValue(NextKey):\r
1995 if Options.get((self.BuildRuleFamily, NextKey)) != None: \r
1996 Options.pop((self.BuildRuleFamily, NextKey))\r
1997 else:\r
1998 if Options.get((self.BuildRuleFamily, NowKey)) != None: \r
1999 Options.pop((self.BuildRuleFamily, NowKey))\r
2000 \r
2001 \r
52302d4d
LG		 2002 for Key in Options:\r
2003 if ModuleStyle != None and len (Key) > 2:\r
2004 # Check Module style is EDK or EDKII.\r
2005 # Only append build option for the matched style module.\r
2006 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:\r
2007 continue\r
2008 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:\r
2009 continue\r
2010 Family = Key[0]\r
2011 Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
2012 # if tool chain family doesn't match, skip it\r
2013 if Tool in self.ToolDefinition and Family != "":\r
2014 FamilyIsNull = False\r
2015 if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":\r
2016 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:\r
2017 continue\r
2018 elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
2019 continue\r
2020 FamilyMatch = True\r
2021 # expand any wildcard\r
2022 if Target == "*" or Target == self.BuildTarget:\r
2023 if Tag == "*" or Tag == self.ToolChain:\r
2024 if Arch == "*" or Arch == self.Arch:\r
2025 if Tool not in BuildOptions:\r
2026 BuildOptions[Tool] = {}\r
2027 if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:\r
2028 BuildOptions[Tool][Attr] = Options[Key]\r
2029 else:\r
2030 # append options for the same tool\r
2031 BuildOptions[Tool][Attr] += " " + Options[Key]\r
2032 # Build Option Family has been checked, which need't to be checked again for family.\r
2033 if FamilyMatch or FamilyIsNull:\r
2034 return BuildOptions\r
2035 \r
2036 for Key in Options:\r
2037 if ModuleStyle != None and len (Key) > 2:\r
2038 # Check Module style is EDK or EDKII.\r
2039 # Only append build option for the matched style module.\r
2040 if ModuleStyle == EDK_NAME and Key[2] != EDK_NAME:\r
2041 continue\r
2042 elif ModuleStyle == EDKII_NAME and Key[2] != EDKII_NAME:\r
2043 continue\r
2044 Family = Key[0]\r
2045 Target, Tag, Arch, Tool, Attr = Key[1].split("_")\r
2046 # if tool chain family doesn't match, skip it\r
2047 if Tool not in self.ToolDefinition or Family =="":\r
2048 continue\r
2049 # option has been added before\r
2050 if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:\r
2051 continue\r
2052\r
2053 # expand any wildcard\r
2054 if Target == "*" or Target == self.BuildTarget:\r
2055 if Tag == "*" or Tag == self.ToolChain:\r
2056 if Arch == "*" or Arch == self.Arch:\r
2057 if Tool not in BuildOptions:\r
2058 BuildOptions[Tool] = {}\r
2059 if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:\r
2060 BuildOptions[Tool][Attr] = Options[Key]\r
2061 else:\r
2062 # append options for the same tool\r
2063 BuildOptions[Tool][Attr] += " " + Options[Key]\r
2064 return BuildOptions\r
2065\r
2066 ## Append build options in platform to a module\r
2067 #\r
2068 # @param Module The module to which the build options will be appened\r
2069 #\r
2070 # @retval options The options appended with build options in platform\r
2071 #\r
2072 def ApplyBuildOption(self, Module):\r
2073 # Get the different options for the different style module\r
2074 if Module.AutoGenVersion < 0x00010005:\r
2075 PlatformOptions = self.EdkBuildOption\r
2076 else:\r
2077 PlatformOptions = self.EdkIIBuildOption\r
2078 ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)\r
2079 if Module in self.Platform.Modules:\r
2080 PlatformModule = self.Platform.Modules[str(Module)]\r
2081 PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)\r
2082 else:\r
2083 PlatformModuleOptions = {}\r
2084\r
fe4bf2f9
YL		 2085 BuildRuleOrder = None\r
2086 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:\r
2087 for Tool in Options:\r
2088 for Attr in Options[Tool]:\r
2089 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
2090 BuildRuleOrder = Options[Tool][Attr]\r
2091\r
52302d4d
LG		 2092 AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() + PlatformModuleOptions.keys() + self.ToolDefinition.keys())\r
2093 BuildOptions = {}\r
2094 for Tool in AllTools:\r
2095 if Tool not in BuildOptions:\r
2096 BuildOptions[Tool] = {}\r
2097\r
2098 for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:\r
2099 if Tool not in Options:\r
2100 continue\r
2101 for Attr in Options[Tool]:\r
2102 Value = Options[Tool][Attr]\r
fe4bf2f9
YL		 2103 #\r
2104 # Do not generate it in Makefile\r
2105 #\r
2106 if Attr == TAB_TOD_DEFINES_BUILDRULEORDER:\r
2107 continue\r
52302d4d
LG		 2108 if Attr not in BuildOptions[Tool]:\r
2109 BuildOptions[Tool][Attr] = ""\r
2110 # check if override is indicated\r
2111 if Value.startswith('='):\r
2112 BuildOptions[Tool][Attr] = Value[1:]\r
2113 else:\r
2114 BuildOptions[Tool][Attr] += " " + Value\r
f3decdc3
LG		 2115 if Module.AutoGenVersion < 0x00010005 and self.Workspace.UniFlag != None:\r
2116 #\r
2117 # Override UNI flag only for EDK module.\r
2118 #\r
2119 if 'BUILD' not in BuildOptions:\r
2120 BuildOptions['BUILD'] = {}\r
2121 BuildOptions['BUILD']['FLAGS'] = self.Workspace.UniFlag\r
fe4bf2f9 2122 return BuildOptions, BuildRuleOrder\r
52302d4d
LG		 2123\r
2124 Platform = property(_GetPlatform)\r
2125 Name = property(_GetName)\r
2126 Guid = property(_GetGuid)\r
2127 Version = property(_GetVersion)\r
2128\r
2129 OutputDir = property(_GetOutputDir)\r
2130 BuildDir = property(_GetBuildDir)\r
2131 MakeFileDir = property(_GetMakeFileDir)\r
2132 FdfFile = property(_GetFdfFile)\r
2133\r
2134 PcdTokenNumber = property(_GetPcdTokenNumbers) # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber\r
2135 DynamicPcdList = property(_GetDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
2136 NonDynamicPcdList = property(_GetNonDynamicPcdList) # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]\r
2bc3256c 2137 NonDynamicPcdDict = property(_GetNonDynamicPcdDict)\r
52302d4d
LG		 2138 PackageList = property(_GetPackageList)\r
2139\r
2140 ToolDefinition = property(_GetToolDefinition) # toolcode : tool path\r
2141 ToolDefinitionFile = property(_GetToolDefFile) # toolcode : lib path\r
2142 ToolChainFamily = property(_GetToolChainFamily)\r
2143 BuildRuleFamily = property(_GetBuildRuleFamily)\r
2144 BuildOption = property(_GetBuildOptions) # toolcode : option\r
2145 EdkBuildOption = property(_GetEdkBuildOptions) # edktoolcode : option\r
2146 EdkIIBuildOption = property(_GetEdkIIBuildOptions) # edkiitoolcode : option\r
2147\r
2148 BuildCommand = property(_GetBuildCommand)\r
2149 BuildRule = property(_GetBuildRule)\r
2150 ModuleAutoGenList = property(_GetModuleAutoGenList)\r
2151 LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
0923aa1c 2152 GenFdsCommand = property(_GenFdsCommand)\r
52302d4d
LG		 2153\r
2154## ModuleAutoGen class\r
2155#\r
2156# This class encapsules the AutoGen behaviors for the build tools. In addition to\r
2157# the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according\r
2158# to the [depex] section in module's inf file.\r
2159#\r
2160class ModuleAutoGen(AutoGen):\r
2161 ## The real constructor of ModuleAutoGen\r
2162 #\r
2163 # This method is not supposed to be called by users of ModuleAutoGen. It's\r
2164 # only used by factory method __new__() to do real initialization work for an\r
2165 # object of ModuleAutoGen\r
2166 #\r
2167 # @param Workspace EdkIIWorkspaceBuild object\r
2168 # @param ModuleFile The path of module file\r
2169 # @param Target Build target (DEBUG, RELEASE)\r
2170 # @param Toolchain Name of tool chain\r
2171 # @param Arch The arch the module supports\r
2172 # @param PlatformFile Platform meta-file\r
2173 #\r
2174 def _Init(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):\r
2175 EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))\r
2176 GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)\r
2177\r
2178 self.Workspace = Workspace\r
2179 self.WorkspaceDir = Workspace.WorkspaceDir\r
2180\r
2181 self.MetaFile = ModuleFile\r
2182 self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)\r
2183 # check if this module is employed by active platform\r
2184 if not self.PlatformInfo.ValidModule(self.MetaFile):\r
2185 EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \\r
2186 % (self.MetaFile, Arch))\r
2187 return False\r
2188\r
2189 self.SourceDir = self.MetaFile.SubDir\r
97fa0ee9
YL		 2190 if self.SourceDir.upper().find(self.WorkspaceDir.upper()) == 0:\r
2191 self.SourceDir = self.SourceDir[len(self.WorkspaceDir) + 1:]\r
2192\r
52302d4d
LG		 2193 self.SourceOverrideDir = None\r
2194 # use overrided path defined in DSC file\r
2195 if self.MetaFile.Key in GlobalData.gOverrideDir:\r
2196 self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]\r
2197\r
2198 self.ToolChain = Toolchain\r
2199 self.BuildTarget = Target\r
2200 self.Arch = Arch\r
2201 self.ToolChainFamily = self.PlatformInfo.ToolChainFamily\r
2202 self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily\r
2203\r
2204 self.IsMakeFileCreated = False\r
2205 self.IsCodeFileCreated = False\r
da92f276
LG		 2206 self.IsAsBuiltInfCreated = False\r
2207 self.DepexGenerated = False\r
52302d4d
LG		 2208\r
2209 self.BuildDatabase = self.Workspace.BuildDatabase\r
fe4bf2f9 2210 self.BuildRuleOrder = None\r
52302d4d
LG		 2211\r
2212 self._Module = None\r
2213 self._Name = None\r
2214 self._Guid = None\r
2215 self._Version = None\r
2216 self._ModuleType = None\r
2217 self._ComponentType = None\r
2218 self._PcdIsDriver = None\r
2219 self._AutoGenVersion = None\r
2220 self._LibraryFlag = None\r
2221 self._CustomMakefile = None\r
2222 self._Macro = None\r
2223\r
2224 self._BuildDir = None\r
2225 self._OutputDir = None\r
2226 self._DebugDir = None\r
2227 self._MakeFileDir = None\r
2228\r
2229 self._IncludePathList = None\r
2230 self._AutoGenFileList = None\r
2231 self._UnicodeFileList = None\r
2232 self._SourceFileList = None\r
2233 self._ObjectFileList = None\r
2234 self._BinaryFileList = None\r
2235\r
2236 self._DependentPackageList = None\r
2237 self._DependentLibraryList = None\r
2238 self._LibraryAutoGenList = None\r
2239 self._DerivedPackageList = None\r
2240 self._ModulePcdList = None\r
2241 self._LibraryPcdList = None\r
e8a47801 2242 self._PcdComments = sdict()\r
52302d4d 2243 self._GuidList = None\r
e8a47801
LG		 2244 self._GuidsUsedByPcd = None\r
2245 self._GuidComments = sdict()\r
52302d4d 2246 self._ProtocolList = None\r
e8a47801 2247 self._ProtocolComments = sdict()\r
52302d4d 2248 self._PpiList = None\r
e8a47801 2249 self._PpiComments = sdict()\r
52302d4d
LG		 2250 self._DepexList = None\r
2251 self._DepexExpressionList = None\r
2252 self._BuildOption = None\r
79b74a03 2253 self._BuildOptionIncPathList = None\r
52302d4d
LG		 2254 self._BuildTargets = None\r
2255 self._IntroBuildTargetList = None\r
2256 self._FinalBuildTargetList = None\r
2257 self._FileTypes = None\r
2258 self._BuildRules = None\r
2bc3256c
LG		 2259 \r
2260 ## The Modules referenced to this Library\r
2261 # Only Library has this attribute\r
2262 self._ReferenceModules = [] \r
2263 \r
2264 ## Store the FixedAtBuild Pcds\r
2265 # \r
2266 self._FixedAtBuildPcds = []\r
2267 self.ConstPcd = {}\r
52302d4d
LG		 2268 return True\r
2269\r
2270 def __repr__(self):\r
2271 return "%s [%s]" % (self.MetaFile, self.Arch)\r
2272\r
2bc3256c
LG		 2273 # Get FixedAtBuild Pcds of this Module\r
2274 def _GetFixedAtBuildPcds(self):\r
2275 if self._FixedAtBuildPcds:\r
2276 return self._FixedAtBuildPcds\r
2277 for Pcd in self.ModulePcdList:\r
2278 if self.IsLibrary:\r
2279 if not (Pcd.Pending == False and Pcd.Type == "FixedAtBuild"):\r
2280 continue\r
2281 elif Pcd.Type != "FixedAtBuild":\r
2282 continue\r
2283 if Pcd not in self._FixedAtBuildPcds:\r
2284 self._FixedAtBuildPcds.append(Pcd)\r
2285 \r
2286 return self._FixedAtBuildPcds \r
2287\r
52302d4d
LG		 2288 # Macros could be used in build_rule.txt (also Makefile)\r
2289 def _GetMacros(self):\r
2290 if self._Macro == None:\r
2291 self._Macro = sdict()\r
2292 self._Macro["WORKSPACE" ] = self.WorkspaceDir\r
2293 self._Macro["MODULE_NAME" ] = self.Name\r
2294 self._Macro["MODULE_GUID" ] = self.Guid\r
2295 self._Macro["MODULE_VERSION" ] = self.Version\r
2296 self._Macro["MODULE_TYPE" ] = self.ModuleType\r
2297 self._Macro["MODULE_FILE" ] = str(self.MetaFile)\r
2298 self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName\r
2299 self._Macro["MODULE_RELATIVE_DIR" ] = self.SourceDir\r
2300 self._Macro["MODULE_DIR" ] = self.SourceDir\r
2301\r
2302 self._Macro["BASE_NAME" ] = self.Name\r
2303\r
2304 self._Macro["ARCH" ] = self.Arch\r
2305 self._Macro["TOOLCHAIN" ] = self.ToolChain\r
2306 self._Macro["TOOLCHAIN_TAG" ] = self.ToolChain\r
0d2711a6 2307 self._Macro["TOOL_CHAIN_TAG" ] = self.ToolChain\r
52302d4d
LG		 2308 self._Macro["TARGET" ] = self.BuildTarget\r
2309\r
2310 self._Macro["BUILD_DIR" ] = self.PlatformInfo.BuildDir\r
2311 self._Macro["BIN_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)\r
2312 self._Macro["LIB_DIR" ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)\r
2313 self._Macro["MODULE_BUILD_DIR" ] = self.BuildDir\r
2314 self._Macro["OUTPUT_DIR" ] = self.OutputDir\r
2315 self._Macro["DEBUG_DIR" ] = self.DebugDir\r
2316 return self._Macro\r
2317\r
2318 ## Return the module build data object\r
2319 def _GetModule(self):\r
2320 if self._Module == None:\r
0d2711a6 2321 self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch, self.BuildTarget, self.ToolChain]\r
52302d4d
LG		 2322 return self._Module\r
2323\r
2324 ## Return the module name\r
2325 def _GetBaseName(self):\r
2326 return self.Module.BaseName\r
2327\r
b36d134f
LG		 2328 ## Return the module DxsFile if exist\r
2329 def _GetDxsFile(self):\r
2330 return self.Module.DxsFile\r
2331\r
52302d4d
LG		 2332 ## Return the module SourceOverridePath\r
2333 def _GetSourceOverridePath(self):\r
2334 return self.Module.SourceOverridePath\r
2335\r
2336 ## Return the module meta-file GUID\r
2337 def _GetGuid(self):\r
97fa0ee9
YL		 2338 #\r
2339 # To build same module more than once, the module path with FILE_GUID overridden has\r
2340 # the file name FILE_GUIDmodule.inf, but the relative path (self.MetaFile.File) is the realy path\r
2341 # in DSC. The overridden GUID can be retrieved from file name\r
2342 #\r
2343 if os.path.basename(self.MetaFile.File) != os.path.basename(self.MetaFile.Path):\r
2344 #\r
2345 # Length of GUID is 36\r
2346 #\r
2347 return os.path.basename(self.MetaFile.Path)[:36]\r
52302d4d
LG		 2348 return self.Module.Guid\r
2349\r
2350 ## Return the module version\r
2351 def _GetVersion(self):\r
2352 return self.Module.Version\r
2353\r
2354 ## Return the module type\r
2355 def _GetModuleType(self):\r
2356 return self.Module.ModuleType\r
2357\r
b36d134f 2358 ## Return the component type (for Edk.x style of module)\r
52302d4d
LG		 2359 def _GetComponentType(self):\r
2360 return self.Module.ComponentType\r
2361\r
2362 ## Return the build type\r
2363 def _GetBuildType(self):\r
2364 return self.Module.BuildType\r
2365\r
2366 ## Return the PCD_IS_DRIVER setting\r
2367 def _GetPcdIsDriver(self):\r
2368 return self.Module.PcdIsDriver\r
2369\r
2370 ## Return the autogen version, i.e. module meta-file version\r
2371 def _GetAutoGenVersion(self):\r
2372 return self.Module.AutoGenVersion\r
2373\r
2374 ## Check if the module is library or not\r
2375 def _IsLibrary(self):\r
2376 if self._LibraryFlag == None:\r
2377 if self.Module.LibraryClass != None and self.Module.LibraryClass != []:\r
2378 self._LibraryFlag = True\r
2379 else:\r
2380 self._LibraryFlag = False\r
2381 return self._LibraryFlag\r
2382\r
e8a47801
LG		 2383 ## Check if the module is binary module or not\r
2384 def _IsBinaryModule(self):\r
2385 return self.Module.IsBinaryModule\r
2386\r
52302d4d
LG		 2387 ## Return the directory to store intermediate files of the module\r
2388 def _GetBuildDir(self):\r
2389 if self._BuildDir == None:\r
2390 self._BuildDir = path.join(\r
2391 self.PlatformInfo.BuildDir,\r
2392 self.Arch,\r
2393 self.SourceDir,\r
2394 self.MetaFile.BaseName\r
2395 )\r
2396 CreateDirectory(self._BuildDir)\r
2397 return self._BuildDir\r
2398\r
2399 ## Return the directory to store the intermediate object files of the mdoule\r
2400 def _GetOutputDir(self):\r
2401 if self._OutputDir == None:\r
2402 self._OutputDir = path.join(self.BuildDir, "OUTPUT")\r
2403 CreateDirectory(self._OutputDir)\r
2404 return self._OutputDir\r
2405\r
2406 ## Return the directory to store auto-gened source files of the mdoule\r
2407 def _GetDebugDir(self):\r
2408 if self._DebugDir == None:\r
2409 self._DebugDir = path.join(self.BuildDir, "DEBUG")\r
2410 CreateDirectory(self._DebugDir)\r
2411 return self._DebugDir\r
2412\r
2413 ## Return the path of custom file\r
2414 def _GetCustomMakefile(self):\r
2415 if self._CustomMakefile == None:\r
2416 self._CustomMakefile = {}\r
2417 for Type in self.Module.CustomMakefile:\r
2418 if Type in gMakeTypeMap:\r
2419 MakeType = gMakeTypeMap[Type]\r
2420 else:\r
2421 MakeType = 'nmake'\r
2422 if self.SourceOverrideDir != None:\r
2423 File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])\r
2424 if not os.path.exists(File):\r
2425 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
2426 else:\r
2427 File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])\r
2428 self._CustomMakefile[MakeType] = File\r
2429 return self._CustomMakefile\r
2430\r
2431 ## Return the directory of the makefile\r
2432 #\r
2433 # @retval string The directory string of module's makefile\r
2434 #\r
2435 def _GetMakeFileDir(self):\r
2436 return self.BuildDir\r
2437\r
2438 ## Return build command string\r
2439 #\r
2440 # @retval string Build command string\r
2441 #\r
2442 def _GetBuildCommand(self):\r
2443 return self.PlatformInfo.BuildCommand\r
2444\r
2445 ## Get object list of all packages the module and its dependent libraries belong to\r
2446 #\r
2447 # @retval list The list of package object\r
2448 #\r
2449 def _GetDerivedPackageList(self):\r
2450 PackageList = []\r
2451 for M in [self.Module] + self.DependentLibraryList:\r
2452 for Package in M.Packages:\r
2453 if Package in PackageList:\r
2454 continue\r
2455 PackageList.append(Package)\r
2456 return PackageList\r
97fa0ee9
YL		 2457 \r
2458 ## Get the depex string\r
2459 #\r
2460 # @return : a string contain all depex expresion.\r
2461 def _GetDepexExpresionString(self):\r
2462 DepexStr = ''\r
2463 DepexList = []\r
2464 ## DPX_SOURCE IN Define section.\r
2465 if self.Module.DxsFile:\r
2466 return DepexStr\r
2467 for M in [self.Module] + self.DependentLibraryList:\r
2468 Filename = M.MetaFile.Path\r
2469 InfObj = InfSectionParser.InfSectionParser(Filename)\r
2470 DepexExpresionList = InfObj.GetDepexExpresionList()\r
2471 for DepexExpresion in DepexExpresionList:\r
2472 for key in DepexExpresion.keys():\r
2473 Arch, ModuleType = key\r
2474 # the type of build module is USER_DEFINED.\r
2475 # All different DEPEX section tags would be copied into the As Built INF file\r
2476 # and there would be separate DEPEX section tags\r
2477 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
2478 if (Arch.upper() == self.Arch.upper()) and (ModuleType.upper() != TAB_ARCH_COMMON):\r
2479 DepexList.append({(Arch, ModuleType): DepexExpresion[key][:]})\r
2480 else:\r
2481 if Arch.upper() == TAB_ARCH_COMMON or \\r
2482 (Arch.upper() == self.Arch.upper() and \\r
2483 ModuleType.upper() in [TAB_ARCH_COMMON, self.ModuleType.upper()]):\r
2484 DepexList.append({(Arch, ModuleType): DepexExpresion[key][:]})\r
2485 \r
2486 #the type of build module is USER_DEFINED.\r
2487 if self.ModuleType.upper() == SUP_MODULE_USER_DEFINED:\r
2488 for Depex in DepexList:\r
2489 for key in Depex.keys():\r
2490 DepexStr += '[Depex.%s.%s]\n' % key\r
2491 DepexStr += '\n'.join(['# '+ val for val in Depex[key]])\r
2492 DepexStr += '\n\n'\r
2493 if not DepexStr:\r
2494 return '[Depex.%s]\n' % self.Arch\r
2495 return DepexStr\r
2496 \r
2497 #the type of build module not is USER_DEFINED.\r
2498 Count = 0\r
2499 for Depex in DepexList:\r
2500 Count += 1\r
2501 if DepexStr != '':\r
2502 DepexStr += ' AND '\r
2503 DepexStr += '('\r
2504 for D in Depex.values():\r
2505 DepexStr += ' '.join([val for val in D])\r
2506 Index = DepexStr.find('END')\r
2507 if Index > -1 and Index == len(DepexStr) - 3:\r
2508 DepexStr = DepexStr[:-3]\r
2509 DepexStr = DepexStr.strip()\r
2510 DepexStr += ')'\r
2511 if Count == 1:\r
2512 DepexStr = DepexStr.lstrip('(').rstrip(')').strip()\r
2513 if not DepexStr:\r
2514 return '[Depex.%s]\n' % self.Arch\r
2515 return '[Depex.%s]\n# ' % self.Arch + DepexStr\r
2516 \r
52302d4d
LG		 2517 ## Merge dependency expression\r
2518 #\r
2519 # @retval list The token list of the dependency expression after parsed\r
2520 #\r
2521 def _GetDepexTokenList(self):\r
2522 if self._DepexList == None:\r
2523 self._DepexList = {}\r
b36d134f 2524 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
52302d4d
LG		 2525 return self._DepexList\r
2526\r
2527 self._DepexList[self.ModuleType] = []\r
2528\r
2529 for ModuleType in self._DepexList:\r
2530 DepexList = self._DepexList[ModuleType]\r
2531 #\r
2532 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
2533 #\r
2534 for M in [self.Module] + self.DependentLibraryList:\r
2535 Inherited = False\r
2536 for D in M.Depex[self.Arch, ModuleType]:\r
2537 if DepexList != []:\r
2538 DepexList.append('AND')\r
2539 DepexList.append('(')\r
2540 DepexList.extend(D)\r
2541 if DepexList[-1] == 'END': # no need of a END at this time\r
2542 DepexList.pop()\r
2543 DepexList.append(')')\r
2544 Inherited = True\r
2545 if Inherited:\r
2546 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))\r
2547 if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
2548 break\r
2549 if len(DepexList) > 0:\r
2550 EdkLogger.verbose('')\r
2551 return self._DepexList\r
2552\r
2553 ## Merge dependency expression\r
2554 #\r
2555 # @retval list The token list of the dependency expression after parsed\r
2556 #\r
2557 def _GetDepexExpressionTokenList(self):\r
2558 if self._DepexExpressionList == None:\r
2559 self._DepexExpressionList = {}\r
b36d134f 2560 if self.DxsFile or self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:\r
52302d4d
LG		 2561 return self._DepexExpressionList\r
2562\r
2563 self._DepexExpressionList[self.ModuleType] = ''\r
2564\r
2565 for ModuleType in self._DepexExpressionList:\r
2566 DepexExpressionList = self._DepexExpressionList[ModuleType]\r
2567 #\r
2568 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion\r
2569 #\r
2570 for M in [self.Module] + self.DependentLibraryList:\r
2571 Inherited = False\r
2572 for D in M.DepexExpression[self.Arch, ModuleType]:\r
2573 if DepexExpressionList != '':\r
2574 DepexExpressionList += ' AND '\r
2575 DepexExpressionList += '('\r
2576 DepexExpressionList += D\r
2577 DepexExpressionList = DepexExpressionList.rstrip('END').strip()\r
2578 DepexExpressionList += ')'\r
2579 Inherited = True\r
2580 if Inherited:\r
2581 EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionList))\r
2582 if 'BEFORE' in DepexExpressionList or 'AFTER' in DepexExpressionList:\r
2583 break\r
2584 if len(DepexExpressionList) > 0:\r
2585 EdkLogger.verbose('')\r
2586 self._DepexExpressionList[ModuleType] = DepexExpressionList\r
2587 return self._DepexExpressionList\r
2588\r
2589 ## Return the list of specification version required for the module\r
2590 #\r
2591 # @retval list The list of specification defined in module file\r
2592 #\r
2593 def _GetSpecification(self):\r
2594 return self.Module.Specification\r
2595\r
2596 ## Tool option for the module build\r
2597 #\r
2598 # @param PlatformInfo The object of PlatformBuildInfo\r
2599 # @retval dict The dict containing valid options\r
2600 #\r
2601 def _GetModuleBuildOption(self):\r
2602 if self._BuildOption == None:\r
fe4bf2f9
YL		 2603 self._BuildOption, self.BuildRuleOrder = self.PlatformInfo.ApplyBuildOption(self.Module)\r
2604 if self.BuildRuleOrder:\r
2605 self.BuildRuleOrder = ['.%s' % Ext for Ext in self.BuildRuleOrder.split()]\r
52302d4d
LG		 2606 return self._BuildOption\r
2607\r
79b74a03
LG		 2608 ## Get include path list from tool option for the module build\r
2609 #\r
2610 # @retval list The include path list\r
2611 #\r
2612 def _GetBuildOptionIncPathList(self):\r
2613 if self._BuildOptionIncPathList == None:\r
2614 #\r
d40b2ee6 2615 # Regular expression for finding Include Directories, the difference between MSFT and INTEL/GCC/RVCT\r
79b74a03
LG		 2616 # is the former use /I , the Latter used -I to specify include directories\r
2617 #\r
2618 if self.PlatformInfo.ToolChainFamily in ('MSFT'):\r
2619 gBuildOptIncludePattern = re.compile(r"(?:.*?)/I[ \t]*([^ ]*)", re.MULTILINE|re.DOTALL)\r
d40b2ee6 2620 elif self.PlatformInfo.ToolChainFamily in ('INTEL', 'GCC', 'RVCT'):\r
79b74a03 2621 gBuildOptIncludePattern = re.compile(r"(?:.*?)-I[ \t]*([^ ]*)", re.MULTILINE|re.DOTALL)\r
d40b2ee6
LG		 2622 else:\r
2623 #\r
2624 # New ToolChainFamily, don't known whether there is option to specify include directories\r
2625 #\r
2626 self._BuildOptionIncPathList = []\r
2627 return self._BuildOptionIncPathList\r
79b74a03
LG		 2628 \r
2629 BuildOptionIncPathList = []\r
2630 for Tool in ('CC', 'PP', 'VFRPP', 'ASLPP', 'ASLCC', 'APP', 'ASM'):\r
2631 Attr = 'FLAGS'\r
2632 try:\r
2633 FlagOption = self.BuildOption[Tool][Attr]\r
2634 except KeyError:\r
2635 FlagOption = ''\r
2636 \r
d40b2ee6
LG		 2637 if self.PlatformInfo.ToolChainFamily != 'RVCT':\r
2638 IncPathList = [NormPath(Path, self.Macros) for Path in gBuildOptIncludePattern.findall(FlagOption)]\r
2639 else:\r
2640 #\r
2641 # RVCT may specify a list of directory seperated by commas\r
2642 #\r
2643 IncPathList = []\r
2644 for Path in gBuildOptIncludePattern.findall(FlagOption):\r
2645 PathList = GetSplitList(Path, TAB_COMMA_SPLIT)\r
2646 IncPathList += [NormPath(PathEntry, self.Macros) for PathEntry in PathList]\r
2647\r
79b74a03
LG		 2648 #\r
2649 # EDK II modules must not reference header files outside of the packages they depend on or \r
2650 # within the module's directory tree. Report error if violation.\r
2651 #\r
2652 if self.AutoGenVersion >= 0x00010005 and len(IncPathList) > 0:\r
2653 for Path in IncPathList:\r
2654 if (Path not in self.IncludePathList) and (CommonPath([Path, self.MetaFile.Dir]) != self.MetaFile.Dir):\r
2655 ErrMsg = "The include directory for the EDK II module in this line is invalid %s specified in %s FLAGS '%s'" % (Path, Tool, FlagOption) \r
2656 EdkLogger.error("build", \r
2657 PARAMETER_INVALID,\r
2658 ExtraData = ErrMsg, \r
2659 File = str(self.MetaFile))\r
2660\r
2661 \r
2662 BuildOptionIncPathList += IncPathList\r
2663 \r
2664 self._BuildOptionIncPathList = BuildOptionIncPathList\r
2665 \r
2666 return self._BuildOptionIncPathList\r
2667 \r
52302d4d
LG		 2668 ## Return a list of files which can be built from source\r
2669 #\r
2670 # What kind of files can be built is determined by build rules in\r
97fa0ee9 2671 # $(CONF_DIRECTORY)/build_rule.txt and toolchain family.\r
52302d4d
LG		 2672 #\r
2673 def _GetSourceFileList(self):\r
2674 if self._SourceFileList == None:\r
2675 self._SourceFileList = []\r
2676 for F in self.Module.Sources:\r
2677 # match tool chain\r
08dd311f 2678 if F.TagName not in ("", "*", self.ToolChain):\r
52302d4d
LG		 2679 EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "\r
2680 "but [%s] is needed" % (F.TagName, str(F), self.ToolChain))\r
2681 continue\r
2682 # match tool chain family\r
08dd311f 2683 if F.ToolChainFamily not in ("", "*", self.ToolChainFamily):\r
52302d4d
LG		 2684 EdkLogger.debug(\r
2685 EdkLogger.DEBUG_0,\r
2686 "The file [%s] must be built by tools of [%s], " \\r
2687 "but current toolchain family is [%s]" \\r
2688 % (str(F), F.ToolChainFamily, self.ToolChainFamily))\r
2689 continue\r
2690\r
2691 # add the file path into search path list for file including\r
2692 if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:\r
2693 self.IncludePathList.insert(0, F.Dir)\r
2694 self._SourceFileList.append(F)\r
2695 self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)\r
2696 return self._SourceFileList\r
2697\r
2698 ## Return the list of unicode files\r
2699 def _GetUnicodeFileList(self):\r
2700 if self._UnicodeFileList == None:\r
2701 if TAB_UNICODE_FILE in self.FileTypes:\r
2702 self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE]\r
2703 else:\r
2704 self._UnicodeFileList = []\r
2705 return self._UnicodeFileList\r
2706\r
2707 ## Return a list of files which can be built from binary\r
2708 #\r
2709 # "Build" binary files are just to copy them to build directory.\r
2710 #\r
2711 # @retval list The list of files which can be built later\r
2712 #\r
2713 def _GetBinaryFiles(self):\r
2714 if self._BinaryFileList == None:\r
2715 self._BinaryFileList = []\r
2716 for F in self.Module.Binaries:\r
2717 if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget:\r
2718 continue\r
2719 self._BinaryFileList.append(F)\r
2720 self._ApplyBuildRule(F, F.Type)\r
2721 return self._BinaryFileList\r
2722\r
2723 def _GetBuildRules(self):\r
2724 if self._BuildRules == None:\r
2725 BuildRules = {}\r
2726 BuildRuleDatabase = self.PlatformInfo.BuildRule\r
2727 for Type in BuildRuleDatabase.FileTypeList:\r
2728 #first try getting build rule by BuildRuleFamily\r
2729 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]\r
2730 if not RuleObject:\r
2731 # build type is always module type, but ...\r
2732 if self.ModuleType != self.BuildType:\r
2733 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]\r
2734 #second try getting build rule by ToolChainFamily\r
2735 if not RuleObject:\r
2736 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]\r
2737 if not RuleObject:\r
2738 # build type is always module type, but ...\r
2739 if self.ModuleType != self.BuildType:\r
2740 RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]\r
2741 if not RuleObject:\r
2742 continue\r
2743 RuleObject = RuleObject.Instantiate(self.Macros)\r
2744 BuildRules[Type] = RuleObject\r
2745 for Ext in RuleObject.SourceFileExtList:\r
2746 BuildRules[Ext] = RuleObject\r
2747 self._BuildRules = BuildRules\r
2748 return self._BuildRules\r
2749\r
2750 def _ApplyBuildRule(self, File, FileType):\r
2751 if self._BuildTargets == None:\r
2752 self._IntroBuildTargetList = set()\r
2753 self._FinalBuildTargetList = set()\r
2754 self._BuildTargets = {}\r
2755 self._FileTypes = {}\r
2756\r
fcd4fbf3
YL		 2757 SubDirectory = os.path.join(self.OutputDir, File.SubDir)\r
2758 if not os.path.exists(SubDirectory):\r
2759 CreateDirectory(SubDirectory)\r
52302d4d
LG		 2760 LastTarget = None\r
2761 RuleChain = []\r
2762 SourceList = [File]\r
2763 Index = 0\r
fe4bf2f9
YL		 2764 #\r
2765 # Make sure to get build rule order value\r
2766 #\r
2767 self._GetModuleBuildOption()\r
2768\r
52302d4d
LG		 2769 while Index < len(SourceList):\r
2770 Source = SourceList[Index]\r
2771 Index = Index + 1\r
2772\r
2773 if Source != File:\r
2774 CreateDirectory(Source.Dir)\r
2775\r
2776 if File.IsBinary and File == Source and self._BinaryFileList != None and File in self._BinaryFileList:\r
da92f276
LG		 2777 # Skip all files that are not binary libraries\r
2778 if not self.IsLibrary:\r
0d2711a6 2779 continue \r
52302d4d
LG		 2780 RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]\r
2781 elif FileType in self.BuildRules:\r
2782 RuleObject = self.BuildRules[FileType]\r
2783 elif Source.Ext in self.BuildRules:\r
2784 RuleObject = self.BuildRules[Source.Ext]\r
2785 else:\r
2786 # stop at no more rules\r
2787 if LastTarget:\r
2788 self._FinalBuildTargetList.add(LastTarget)\r
2789 break\r
2790\r
2791 FileType = RuleObject.SourceFileType\r
2792 if FileType not in self._FileTypes:\r
2793 self._FileTypes[FileType] = set()\r
2794 self._FileTypes[FileType].add(Source)\r
2795\r
2796 # stop at STATIC_LIBRARY for library\r
2797 if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:\r
2798 if LastTarget:\r
2799 self._FinalBuildTargetList.add(LastTarget)\r
2800 break\r
2801\r
fe4bf2f9 2802 Target = RuleObject.Apply(Source, self.BuildRuleOrder)\r
52302d4d
LG		 2803 if not Target:\r
2804 if LastTarget:\r
2805 self._FinalBuildTargetList.add(LastTarget)\r
2806 break\r
2807 elif not Target.Outputs:\r
2808 # Only do build for target with outputs\r
2809 self._FinalBuildTargetList.add(Target)\r
2810\r
2811 if FileType not in self._BuildTargets:\r
2812 self._BuildTargets[FileType] = set()\r
2813 self._BuildTargets[FileType].add(Target)\r
2814\r
2815 if not Source.IsBinary and Source == File:\r
2816 self._IntroBuildTargetList.add(Target)\r
2817\r
2818 # to avoid cyclic rule\r
2819 if FileType in RuleChain:\r
2820 break\r
2821\r
2822 RuleChain.append(FileType)\r
2823 SourceList.extend(Target.Outputs)\r
2824 LastTarget = Target\r
2825 FileType = TAB_UNKNOWN_FILE\r
2826\r
2827 def _GetTargets(self):\r
2828 if self._BuildTargets == None:\r
2829 self._IntroBuildTargetList = set()\r
2830 self._FinalBuildTargetList = set()\r
2831 self._BuildTargets = {}\r
2832 self._FileTypes = {}\r
2833\r
b36d134f 2834 #TRICK: call _GetSourceFileList to apply build rule for source files\r
52302d4d
LG		 2835 if self.SourceFileList:\r
2836 pass\r
2837\r
2838 #TRICK: call _GetBinaryFileList to apply build rule for binary files\r
2839 if self.BinaryFileList:\r
2840 pass\r
2841\r
2842 return self._BuildTargets\r
2843\r
2844 def _GetIntroTargetList(self):\r
2845 self._GetTargets()\r
2846 return self._IntroBuildTargetList\r
2847\r
2848 def _GetFinalTargetList(self):\r
2849 self._GetTargets()\r
2850 return self._FinalBuildTargetList\r
2851\r
2852 def _GetFileTypes(self):\r
2853 self._GetTargets()\r
2854 return self._FileTypes\r
2855\r
2856 ## Get the list of package object the module depends on\r
2857 #\r
2858 # @retval list The package object list\r
2859 #\r
2860 def _GetDependentPackageList(self):\r
2861 return self.Module.Packages\r
2862\r
2863 ## Return the list of auto-generated code file\r
2864 #\r
2865 # @retval list The list of auto-generated file\r
2866 #\r
2867 def _GetAutoGenFileList(self):\r
2868 UniStringAutoGenC = True\r
4234283c 2869 UniStringBinBuffer = StringIO()\r
52302d4d 2870 if self.BuildType == 'UEFI_HII':\r
52302d4d
LG		 2871 UniStringAutoGenC = False\r
2872 if self._AutoGenFileList == None:\r
2873 self._AutoGenFileList = {}\r
2874 AutoGenC = TemplateString()\r
2875 AutoGenH = TemplateString()\r
2876 StringH = TemplateString()\r
2877 GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer)\r
07b8564b
YL		 2878 #\r
2879 # AutoGen.c is generated if there are library classes in inf, or there are object files\r
2880 #\r
2881 if str(AutoGenC) != "" and (len(self.Module.LibraryClasses) > 0\r
2882 or TAB_OBJECT_FILE in self.FileTypes):\r
52302d4d
LG		 2883 AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)\r
2884 self._AutoGenFileList[AutoFile] = str(AutoGenC)\r
2885 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
2886 if str(AutoGenH) != "":\r
2887 AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)\r
2888 self._AutoGenFileList[AutoFile] = str(AutoGenH)\r
2889 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
2890 if str(StringH) != "":\r
2891 AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)\r
2892 self._AutoGenFileList[AutoFile] = str(StringH)\r
2893 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
2894 if UniStringBinBuffer != None and UniStringBinBuffer.getvalue() != "":\r
2895 AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)\r
2896 self._AutoGenFileList[AutoFile] = UniStringBinBuffer.getvalue()\r
2897 AutoFile.IsBinary = True\r
2898 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)\r
2899 if UniStringBinBuffer != None:\r
2900 UniStringBinBuffer.close()\r
2901 return self._AutoGenFileList\r
2902\r
2903 ## Return the list of library modules explicitly or implicityly used by this module\r
2904 def _GetLibraryList(self):\r
2905 if self._DependentLibraryList == None:\r
2906 # only merge library classes and PCD for non-library module\r
2907 if self.IsLibrary:\r
2908 self._DependentLibraryList = []\r
2909 else:\r
2910 if self.AutoGenVersion < 0x00010005:\r
2911 self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)\r
2912 else:\r
2913 self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)\r
2914 return self._DependentLibraryList\r
2915\r
e8a47801
LG		 2916 @staticmethod\r
2917 def UpdateComments(Recver, Src):\r
2918 for Key in Src:\r
2919 if Key not in Recver:\r
2920 Recver[Key] = []\r
2921 Recver[Key].extend(Src[Key])\r
52302d4d
LG		 2922 ## Get the list of PCDs from current module\r
2923 #\r
2924 # @retval list The list of PCD\r
2925 #\r
2926 def _GetModulePcdList(self):\r
2927 if self._ModulePcdList == None:\r
2928 # apply PCD settings from platform\r
2929 self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)\r
e8a47801 2930 self.UpdateComments(self._PcdComments, self.Module.PcdComments)\r
52302d4d
LG		 2931 return self._ModulePcdList\r
2932\r
2933 ## Get the list of PCDs from dependent libraries\r
2934 #\r
2935 # @retval list The list of PCD\r
2936 #\r
2937 def _GetLibraryPcdList(self):\r
2938 if self._LibraryPcdList == None:\r
79b74a03 2939 Pcds = sdict()\r
52302d4d
LG		 2940 if not self.IsLibrary:\r
2941 # get PCDs from dependent libraries\r
2942 for Library in self.DependentLibraryList:\r
e8a47801 2943 self.UpdateComments(self._PcdComments, Library.PcdComments)\r
52302d4d
LG		 2944 for Key in Library.Pcds:\r
2945 # skip duplicated PCDs\r
2946 if Key in self.Module.Pcds or Key in Pcds:\r
2947 continue\r
2948 Pcds[Key] = copy.copy(Library.Pcds[Key])\r
2949 # apply PCD settings from platform\r
2950 self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds)\r
2951 else:\r
2952 self._LibraryPcdList = []\r
2953 return self._LibraryPcdList\r
2954\r
2955 ## Get the GUID value mapping\r
2956 #\r
2957 # @retval dict The mapping between GUID cname and its value\r
2958 #\r
2959 def _GetGuidList(self):\r
2960 if self._GuidList == None:\r
8200fcfe
YL		 2961 self._GuidList = sdict()\r
2962 self._GuidList.update(self.Module.Guids)\r
52302d4d
LG		 2963 for Library in self.DependentLibraryList:\r
2964 self._GuidList.update(Library.Guids)\r
e8a47801
LG		 2965 self.UpdateComments(self._GuidComments, Library.GuidComments)\r
2966 self.UpdateComments(self._GuidComments, self.Module.GuidComments)\r
52302d4d
LG		 2967 return self._GuidList\r
2968\r
e8a47801
LG		 2969 def GetGuidsUsedByPcd(self):\r
2970 if self._GuidsUsedByPcd == None:\r
2971 self._GuidsUsedByPcd = sdict()\r
2972 self._GuidsUsedByPcd.update(self.Module.GetGuidsUsedByPcd())\r
2973 for Library in self.DependentLibraryList:\r
2974 self._GuidsUsedByPcd.update(Library.GetGuidsUsedByPcd())\r
2975 return self._GuidsUsedByPcd\r
52302d4d
LG		 2976 ## Get the protocol value mapping\r
2977 #\r
2978 # @retval dict The mapping between protocol cname and its value\r
2979 #\r
2980 def _GetProtocolList(self):\r
2981 if self._ProtocolList == None:\r
8200fcfe
YL		 2982 self._ProtocolList = sdict()\r
2983 self._ProtocolList.update(self.Module.Protocols)\r
52302d4d
LG		 2984 for Library in self.DependentLibraryList:\r
2985 self._ProtocolList.update(Library.Protocols)\r
e8a47801
LG		 2986 self.UpdateComments(self._ProtocolComments, Library.ProtocolComments)\r
2987 self.UpdateComments(self._ProtocolComments, self.Module.ProtocolComments)\r
52302d4d
LG		 2988 return self._ProtocolList\r
2989\r
2990 ## Get the PPI value mapping\r
2991 #\r
2992 # @retval dict The mapping between PPI cname and its value\r
2993 #\r
2994 def _GetPpiList(self):\r
2995 if self._PpiList == None:\r
8200fcfe
YL		 2996 self._PpiList = sdict()\r
2997 self._PpiList.update(self.Module.Ppis)\r
52302d4d
LG		 2998 for Library in self.DependentLibraryList:\r
2999 self._PpiList.update(Library.Ppis)\r
e8a47801
LG		 3000 self.UpdateComments(self._PpiComments, Library.PpiComments)\r
3001 self.UpdateComments(self._PpiComments, self.Module.PpiComments)\r
52302d4d
LG		 3002 return self._PpiList\r
3003\r
3004 ## Get the list of include search path\r
3005 #\r
3006 # @retval list The list path\r
3007 #\r
3008 def _GetIncludePathList(self):\r
3009 if self._IncludePathList == None:\r
3010 self._IncludePathList = []\r
3011 if self.AutoGenVersion < 0x00010005:\r
3012 for Inc in self.Module.Includes:\r
3013 if Inc not in self._IncludePathList:\r
3014 self._IncludePathList.append(Inc)\r
b36d134f 3015 # for Edk modules\r
52302d4d
LG		 3016 Inc = path.join(Inc, self.Arch.capitalize())\r
3017 if os.path.exists(Inc) and Inc not in self._IncludePathList:\r
3018 self._IncludePathList.append(Inc)\r
b36d134f 3019 # Edk module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time\r
52302d4d
LG		 3020 self._IncludePathList.append(self.DebugDir)\r
3021 else:\r
3022 self._IncludePathList.append(self.MetaFile.Dir)\r
3023 self._IncludePathList.append(self.DebugDir)\r
3024\r
3025 for Package in self.Module.Packages:\r
3026 PackageDir = path.join(self.WorkspaceDir, Package.MetaFile.Dir)\r
3027 if PackageDir not in self._IncludePathList:\r
3028 self._IncludePathList.append(PackageDir)\r
3029 for Inc in Package.Includes:\r
3030 if Inc not in self._IncludePathList:\r
3031 self._IncludePathList.append(str(Inc))\r
3032 return self._IncludePathList\r
3033\r
97fa0ee9
YL		 3034 ## Get HII EX PCDs which maybe used by VFR\r
3035 #\r
3036 # efivarstore used by VFR may relate with HII EX PCDs\r
3037 # Get the variable name and GUID from efivarstore and HII EX PCD\r
3038 # List the HII EX PCDs in As Built INF if both name and GUID match.\r
3039 #\r
3040 # @retval list HII EX PCDs\r
3041 #\r
3042 def _GetPcdsMaybeUsedByVfr(self):\r
3043 if not self.SourceFileList:\r
3044 return []\r
3045\r
3046 NameGuids = []\r
3047 for SrcFile in self.SourceFileList:\r
3048 if SrcFile.Ext.lower() != '.vfr':\r
3049 continue\r
3050 Vfri = os.path.join(self.OutputDir, SrcFile.BaseName + '.i')\r
3051 if not os.path.exists(Vfri):\r
3052 continue\r
3053 VfriFile = open(Vfri, 'r')\r
3054 Content = VfriFile.read()\r
3055 VfriFile.close()\r
3056 Pos = Content.find('efivarstore')\r
3057 while Pos != -1:\r
3058 #\r
3059 # Make sure 'efivarstore' is the start of efivarstore statement\r
3060 # In case of the value of 'name' (name = efivarstore) is equal to 'efivarstore'\r
3061 #\r
3062 Index = Pos - 1\r
3063 while Index >= 0 and Content[Index] in ' \t\r\n':\r
3064 Index -= 1\r
3065 if Index >= 0 and Content[Index] != ';':\r
3066 Pos = Content.find('efivarstore', Pos + len('efivarstore'))\r
3067 continue\r
3068 #\r
3069 # 'efivarstore' must be followed by name and guid\r
3070 #\r
3071 Name = gEfiVarStoreNamePattern.search(Content, Pos)\r
3072 if not Name:\r
3073 break\r
3074 Guid = gEfiVarStoreGuidPattern.search(Content, Pos)\r
3075 if not Guid:\r
3076 break\r
3077 NameArray = ConvertStringToByteArray('L"' + Name.group(1) + '"')\r
3078 NameGuids.append((NameArray, GuidStructureStringToGuidString(Guid.group(1))))\r
3079 Pos = Content.find('efivarstore', Name.end())\r
3080 if not NameGuids:\r
3081 return []\r
3082 HiiExPcds = []\r
3083 for Pcd in self.PlatformInfo.Platform.Pcds.values():\r
3084 if Pcd.Type != TAB_PCDS_DYNAMIC_EX_HII:\r
3085 continue\r
3086 for SkuName in Pcd.SkuInfoList:\r
3087 SkuInfo = Pcd.SkuInfoList[SkuName]\r
3088 Name = ConvertStringToByteArray(SkuInfo.VariableName)\r
3089 Value = GuidValue(SkuInfo.VariableGuid, self.PlatformInfo.PackageList)\r
3090 if not Value:\r
3091 continue\r
3092 Guid = GuidStructureStringToGuidString(Value)\r
3093 if (Name, Guid) in NameGuids and Pcd not in HiiExPcds:\r
3094 HiiExPcds.append(Pcd)\r
3095 break\r
3096\r
3097 return HiiExPcds\r
3098\r
da92f276
LG		 3099 ## Create AsBuilt INF file the module\r
3100 #\r
3101 def CreateAsBuiltInf(self):\r
3102 if self.IsAsBuiltInfCreated:\r
3103 return\r
3104 \r
3105 # Skip the following code for EDK I inf\r
3106 if self.AutoGenVersion < 0x00010005:\r
3107 return\r
3108 \r
3109 # Skip the following code for libraries\r
3110 if self.IsLibrary:\r
3111 return\r
3112 \r
3113 # Skip the following code for modules with no source files\r
3114 if self.SourceFileList == None or self.SourceFileList == []:\r
3115 return\r
3116\r
3117 # Skip the following code for modules without any binary files\r
3118 if self.BinaryFileList <> None and self.BinaryFileList <> []:\r
3119 return\r
3120 \r
3121 ### TODO: How to handles mixed source and binary modules\r
3122\r
e8a47801 3123 # Find all DynamicEx and PatchableInModule PCDs used by this module and dependent libraries\r
da92f276
LG		 3124 # Also find all packages that the DynamicEx PCDs depend on\r
3125 Pcds = []\r
e8a47801 3126 PatchablePcds = {}\r
da92f276 3127 Packages = [] \r
e8a47801
LG		 3128 PcdCheckList = []\r
3129 PcdTokenSpaceList = []\r
da92f276 3130 for Pcd in self.ModulePcdList + self.LibraryPcdList:\r
e8a47801
LG		 3131 if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
3132 PatchablePcds[Pcd.TokenCName] = Pcd\r
3133 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'PatchableInModule'))\r
3134 elif Pcd.Type in GenC.gDynamicExPcd:\r
3135 if Pcd not in Pcds:\r
3136 Pcds += [Pcd]\r
3137 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'DynamicEx'))\r
3138 PcdCheckList.append((Pcd.TokenCName, Pcd.TokenSpaceGuidCName, 'Dynamic'))\r
3139 PcdTokenSpaceList.append(Pcd.TokenSpaceGuidCName)\r
3140 GuidList = sdict()\r
3141 GuidList.update(self.GuidList)\r
3142 for TokenSpace in self.GetGuidsUsedByPcd():\r
3143 # If token space is not referred by patch PCD or Ex PCD, remove the GUID from GUID list\r
3144 # The GUIDs in GUIDs section should really be the GUIDs in source INF or referred by Ex an patch PCDs\r
3145 if TokenSpace not in PcdTokenSpaceList and TokenSpace in GuidList:\r
3146 GuidList.pop(TokenSpace)\r
3147 CheckList = (GuidList, self.PpiList, self.ProtocolList, PcdCheckList)\r
3148 for Package in self.DerivedPackageList:\r
3149 if Package in Packages:\r
3150 continue\r
3151 BeChecked = (Package.Guids, Package.Ppis, Package.Protocols, Package.Pcds)\r
3152 Found = False\r
3153 for Index in range(len(BeChecked)):\r
3154 for Item in CheckList[Index]:\r
3155 if Item in BeChecked[Index]:\r
3156 Packages += [Package]\r
3157 Found = True\r
3158 break\r
3159 if Found: break\r
da92f276 3160\r
97fa0ee9
YL		 3161 VfrPcds = self._GetPcdsMaybeUsedByVfr()\r
3162 for Pkg in self.PlatformInfo.PackageList:\r
3163 if Pkg in Packages:\r
3164 continue\r
3165 for VfrPcd in VfrPcds:\r
3166 if ((VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'DynamicEx') in Pkg.Pcds or\r
3167 (VfrPcd.TokenCName, VfrPcd.TokenSpaceGuidCName, 'Dynamic') in Pkg.Pcds):\r
3168 Packages += [Pkg]\r
3169 break\r
3170\r
da92f276
LG		 3171 ModuleType = self.ModuleType\r
3172 if ModuleType == 'UEFI_DRIVER' and self.DepexGenerated:\r
e8a47801
LG		 3173 ModuleType = 'DXE_DRIVER'\r
3174\r
3175 DriverType = ''\r
3176 if self.PcdIsDriver != '':\r
3177 DriverType = self.PcdIsDriver\r
da92f276 3178\r
97fa0ee9
YL		 3179 Guid = self.Guid\r
3180 MDefs = self.Module.Defines\r
3181\r
da92f276
LG		 3182 AsBuiltInfDict = {\r
3183 'module_name' : self.Name,\r
97fa0ee9 3184 'module_guid' : Guid,\r
da92f276 3185 'module_module_type' : ModuleType,\r
97fa0ee9 3186 'module_version_string' : [MDefs['VERSION_STRING']] if 'VERSION_STRING' in MDefs else [],\r
e8a47801 3187 'pcd_is_driver_string' : [],\r
da92f276
LG		 3188 'module_uefi_specification_version' : [],\r
3189 'module_pi_specification_version' : [],\r
97fa0ee9
YL		 3190 'module_entry_point' : self.Module.ModuleEntryPointList,\r
3191 'module_unload_image' : self.Module.ModuleUnloadImageList,\r
3192 'module_constructor' : self.Module.ConstructorList,\r
3193 'module_destructor' : self.Module.DestructorList,\r
3194 'module_shadow' : [MDefs['SHADOW']] if 'SHADOW' in MDefs else [],\r
3195 'module_pci_vendor_id' : [MDefs['PCI_VENDOR_ID']] if 'PCI_VENDOR_ID' in MDefs else [],\r
3196 'module_pci_device_id' : [MDefs['PCI_DEVICE_ID']] if 'PCI_DEVICE_ID' in MDefs else [],\r
3197 'module_pci_class_code' : [MDefs['PCI_CLASS_CODE']] if 'PCI_CLASS_CODE' in MDefs else [],\r
3198 'module_pci_revision' : [MDefs['PCI_REVISION']] if 'PCI_REVISION' in MDefs else [],\r
3199 'module_build_number' : [MDefs['BUILD_NUMBER']] if 'BUILD_NUMBER' in MDefs else [],\r
3200 'module_spec' : [MDefs['SPEC']] if 'SPEC' in MDefs else [],\r
3201 'module_uefi_hii_resource_section' : [MDefs['UEFI_HII_RESOURCE_SECTION']] if 'UEFI_HII_RESOURCE_SECTION' in MDefs else [],\r
3202 'module_uni_file' : [MDefs['MODULE_UNI_FILE']] if 'MODULE_UNI_FILE' in MDefs else [],\r
da92f276
LG		 3203 'module_arch' : self.Arch,\r
3204 'package_item' : ['%s' % (Package.MetaFile.File.replace('\\','/')) for Package in Packages],\r
3205 'binary_item' : [],\r
e8a47801 3206 'patchablepcd_item' : [],\r
da92f276 3207 'pcd_item' : [],\r
e8a47801
LG		 3208 'protocol_item' : [],\r
3209 'ppi_item' : [],\r
3210 'guid_item' : [],\r
3211 'flags_item' : [],\r
3212 'libraryclasses_item' : []\r
da92f276 3213 }\r
97fa0ee9
YL		 3214\r
3215 if self.AutoGenVersion > int(gInfSpecVersion, 0):\r
3216 AsBuiltInfDict['module_inf_version'] = '0x%08x' % self.AutoGenVersion\r
3217 else:\r
3218 AsBuiltInfDict['module_inf_version'] = gInfSpecVersion\r
3219\r
e8a47801
LG		 3220 if DriverType:\r
3221 AsBuiltInfDict['pcd_is_driver_string'] += [DriverType]\r
da92f276
LG		 3222\r
3223 if 'UEFI_SPECIFICATION_VERSION' in self.Specification:\r
3224 AsBuiltInfDict['module_uefi_specification_version'] += [self.Specification['UEFI_SPECIFICATION_VERSION']]\r
3225 if 'PI_SPECIFICATION_VERSION' in self.Specification:\r
3226 AsBuiltInfDict['module_pi_specification_version'] += [self.Specification['PI_SPECIFICATION_VERSION']]\r
3227\r
3228 OutputDir = self.OutputDir.replace('\\','/').strip('/')\r
3229 if self.ModuleType in ['BASE', 'USER_DEFINED']:\r
3230 for Item in self.CodaTargetList:\r
3231 File = Item.Target.Path.replace('\\','/').strip('/').replace(OutputDir,'').strip('/')\r
3232 if Item.Target.Ext.lower() == '.aml': \r
3233 AsBuiltInfDict['binary_item'] += ['ASL|' + File]\r
3234 elif Item.Target.Ext.lower() == '.acpi': \r
3235 AsBuiltInfDict['binary_item'] += ['ACPI|' + File]\r
3236 else:\r
3237 AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
3238 else:\r
3239 for Item in self.CodaTargetList:\r
3240 File = Item.Target.Path.replace('\\','/').strip('/').replace(OutputDir,'').strip('/')\r
3241 if Item.Target.Ext.lower() == '.efi': \r
3242 AsBuiltInfDict['binary_item'] += ['PE32|' + self.Name + '.efi']\r
3243 else:\r
3244 AsBuiltInfDict['binary_item'] += ['BIN|' + File]\r
3245 if self.DepexGenerated:\r
3246 if self.ModuleType in ['PEIM']:\r
3247 AsBuiltInfDict['binary_item'] += ['PEI_DEPEX|' + self.Name + '.depex']\r
3248 if self.ModuleType in ['DXE_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:\r
3249 AsBuiltInfDict['binary_item'] += ['DXE_DEPEX|' + self.Name + '.depex']\r
3250 if self.ModuleType in ['DXE_SMM_DRIVER']:\r
3251 AsBuiltInfDict['binary_item'] += ['SMM_DEPEX|' + self.Name + '.depex']\r
3252\r
e8a47801
LG		 3253 for Root, Dirs, Files in os.walk(OutputDir):\r
3254 for File in Files:\r
3255 if File.lower().endswith('.pdb'):\r
3256 AsBuiltInfDict['binary_item'] += ['DISPOSABLE|' + File]\r
3257 HeaderComments = self.Module.HeaderComments\r
3258 StartPos = 0\r
3259 for Index in range(len(HeaderComments)):\r
3260 if HeaderComments[Index].find('@BinaryHeader') != -1:\r
3261 HeaderComments[Index] = HeaderComments[Index].replace('@BinaryHeader', '@file')\r
3262 StartPos = Index\r
3263 break\r
3264 AsBuiltInfDict['header_comments'] = '\n'.join(HeaderComments[StartPos:]).replace(':#', '://')\r
97fa0ee9
YL		 3265 AsBuiltInfDict['tail_comments'] = '\n'.join(self.Module.TailComments)\r
3266\r
e8a47801
LG		 3267 GenList = [\r
3268 (self.ProtocolList, self._ProtocolComments, 'protocol_item'),\r
3269 (self.PpiList, self._PpiComments, 'ppi_item'),\r
3270 (GuidList, self._GuidComments, 'guid_item')\r
3271 ]\r
3272 for Item in GenList:\r
3273 for CName in Item[0]:\r
3274 Comments = ''\r
3275 if CName in Item[1]:\r
3276 Comments = '\n '.join(Item[1][CName])\r
3277 Entry = CName\r
3278 if Comments:\r
3279 Entry = Comments + '\n ' + CName\r
3280 AsBuiltInfDict[Item[2]].append(Entry)\r
3281 PatchList = parsePcdInfoFromMapFile(\r
3282 os.path.join(self.OutputDir, self.Name + '.map'),\r
3283 os.path.join(self.OutputDir, self.Name + '.efi')\r
3284 )\r
3285 if PatchList:\r
3286 for PatchPcd in PatchList:\r
3287 if PatchPcd[0] not in PatchablePcds:\r
3288 continue\r
3289 Pcd = PatchablePcds[PatchPcd[0]]\r
3290 PcdValue = ''\r
3291 if Pcd.DatumType != 'VOID*':\r
3292 HexFormat = '0x%02x'\r
3293 if Pcd.DatumType == 'UINT16':\r
3294 HexFormat = '0x%04x'\r
3295 elif Pcd.DatumType == 'UINT32':\r
3296 HexFormat = '0x%08x'\r
3297 elif Pcd.DatumType == 'UINT64':\r
3298 HexFormat = '0x%016x'\r
3299 PcdValue = HexFormat % int(Pcd.DefaultValue, 0)\r
3300 else:\r
3301 if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
3302 EdkLogger.error("build", AUTOGEN_ERROR,\r
3303 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
3304 )\r
3305 ArraySize = int(Pcd.MaxDatumSize, 0)\r
3306 PcdValue = Pcd.DefaultValue\r
3307 if PcdValue[0] != '{':\r
3308 Unicode = False\r
3309 if PcdValue[0] == 'L':\r
3310 Unicode = True\r
3311 PcdValue = PcdValue.lstrip('L')\r
3312 PcdValue = eval(PcdValue)\r
3313 NewValue = '{'\r
3314 for Index in range(0, len(PcdValue)):\r
3315 if Unicode:\r
3316 CharVal = ord(PcdValue[Index])\r
3317 NewValue = NewValue + '0x%02x' % (CharVal & 0x00FF) + ', ' \\r
3318 + '0x%02x' % (CharVal >> 8) + ', '\r
3319 else:\r
3320 NewValue = NewValue + '0x%02x' % (ord(PcdValue[Index]) % 0x100) + ', '\r
3321 Padding = '0x00, '\r
3322 if Unicode:\r
3323 Padding = Padding * 2\r
3324 ArraySize = ArraySize / 2\r
3325 if ArraySize < (len(PcdValue) + 1):\r
3326 EdkLogger.error("build", AUTOGEN_ERROR,\r
3327 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
3328 )\r
3329 if ArraySize > len(PcdValue) + 1:\r
3330 NewValue = NewValue + Padding * (ArraySize - len(PcdValue) - 1)\r
3331 PcdValue = NewValue + Padding.strip().rstrip(',') + '}'\r
3332 elif len(PcdValue.split(',')) <= ArraySize:\r
3333 PcdValue = PcdValue.rstrip('}') + ', 0x00' * (ArraySize - len(PcdValue.split(',')))\r
3334 PcdValue += '}'\r
3335 else:\r
3336 EdkLogger.error("build", AUTOGEN_ERROR,\r
3337 "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName)\r
3338 )\r
3339 PcdItem = '%s.%s|%s|0x%X' % \\r
3340 (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, PcdValue, PatchPcd[1])\r
3341 PcdComments = ''\r
3342 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
3343 PcdComments = '\n '.join(self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName])\r
3344 if PcdComments:\r
3345 PcdItem = PcdComments + '\n ' + PcdItem\r
3346 AsBuiltInfDict['patchablepcd_item'].append(PcdItem)\r
97fa0ee9
YL		 3347\r
3348 HiiPcds = []\r
3349 for Pcd in Pcds + VfrPcds:\r
e8a47801
LG		 3350 PcdComments = ''\r
3351 PcdCommentList = []\r
3352 HiiInfo = ''\r
97fa0ee9 3353 SkuId = ''\r
e8a47801
LG		 3354 if Pcd.Type == TAB_PCDS_DYNAMIC_EX_HII:\r
3355 for SkuName in Pcd.SkuInfoList:\r
3356 SkuInfo = Pcd.SkuInfoList[SkuName]\r
97fa0ee9 3357 SkuId = SkuInfo.SkuId\r
e8a47801
LG		 3358 HiiInfo = '## %s|%s|%s' % (SkuInfo.VariableName, SkuInfo.VariableGuid, SkuInfo.VariableOffset)\r
3359 break\r
97fa0ee9
YL		 3360 if SkuId:\r
3361 #\r
3362 # Don't generate duplicated HII PCD\r
3363 #\r
3364 if (SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in HiiPcds:\r
3365 continue\r
3366 else:\r
3367 HiiPcds.append((SkuId, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
e8a47801
LG		 3368 if (Pcd.TokenSpaceGuidCName, Pcd.TokenCName) in self._PcdComments:\r
3369 PcdCommentList = self._PcdComments[Pcd.TokenSpaceGuidCName, Pcd.TokenCName][:]\r
3370 if HiiInfo:\r
3371 UsageIndex = -1\r
97fa0ee9 3372 UsageStr = ''\r
e8a47801
LG		 3373 for Index, Comment in enumerate(PcdCommentList):\r
3374 for Usage in UsageList:\r
3375 if Comment.find(Usage) != -1:\r
97fa0ee9 3376 UsageStr = Usage\r
e8a47801
LG		 3377 UsageIndex = Index\r
3378 break\r
3379 if UsageIndex != -1:\r
97fa0ee9 3380 PcdCommentList[UsageIndex] = '## %s %s %s' % (UsageStr, HiiInfo, PcdCommentList[UsageIndex].replace(UsageStr, '')) \r
e8a47801 3381 else:\r
97fa0ee9 3382 PcdCommentList.append('## UNDEFINED ' + HiiInfo)\r
e8a47801
LG		 3383 PcdComments = '\n '.join(PcdCommentList)\r
3384 PcdEntry = Pcd.TokenSpaceGuidCName + '.' + Pcd.TokenCName\r
3385 if PcdComments:\r
3386 PcdEntry = PcdComments + '\n ' + PcdEntry\r
3387 AsBuiltInfDict['pcd_item'] += [PcdEntry]\r
da92f276
LG		 3388 for Item in self.BuildOption:\r
3389 if 'FLAGS' in self.BuildOption[Item]:\r
3390 AsBuiltInfDict['flags_item'] += ['%s:%s_%s_%s_%s_FLAGS = %s' % (self.ToolChainFamily, self.BuildTarget, self.ToolChain, self.Arch, Item, self.BuildOption[Item]['FLAGS'].strip())]\r
97fa0ee9
YL		 3391\r
3392 # Generated LibraryClasses section in comments.\r
3393 for Library in self.LibraryAutoGenList:\r
3394 AsBuiltInfDict['libraryclasses_item'] += [Library.MetaFile.File.replace('\\', '/')]\r
3395 \r
3396 # Generated depex expression section in comments.\r
3397 AsBuiltInfDict['depexsection_item'] = ''\r
3398 DepexExpresion = self._GetDepexExpresionString()\r
3399 if DepexExpresion:\r
3400 AsBuiltInfDict['depexsection_item'] = DepexExpresion\r
da92f276
LG		 3401 \r
3402 AsBuiltInf = TemplateString()\r
3403 AsBuiltInf.Append(gAsBuiltInfHeaderString.Replace(AsBuiltInfDict))\r
3404 \r
3405 SaveFileOnChange(os.path.join(self.OutputDir, self.Name + '.inf'), str(AsBuiltInf), False)\r
3406 \r
3407 self.IsAsBuiltInfCreated = True\r
3408 \r
52302d4d
LG		 3409 ## Create makefile for the module and its dependent libraries\r
3410 #\r
3411 # @param CreateLibraryMakeFile Flag indicating if or not the makefiles of\r
3412 # dependent libraries will be created\r
3413 #\r
3414 def CreateMakeFile(self, CreateLibraryMakeFile=True):\r
fae62ff2 3415 # Ignore generating makefile when it is a binary module\r
a0a2cd1e
FB		 3416 if self.IsBinaryModule:\r
3417 return\r
fae62ff2 3418\r
52302d4d
LG		 3419 if self.IsMakeFileCreated:\r
3420 return\r
3421\r
3422 if not self.IsLibrary and CreateLibraryMakeFile:\r
3423 for LibraryAutoGen in self.LibraryAutoGenList:\r
3424 LibraryAutoGen.CreateMakeFile()\r
3425\r
3426 if len(self.CustomMakefile) == 0:\r
3427 Makefile = GenMake.ModuleMakefile(self)\r
3428 else:\r
3429 Makefile = GenMake.CustomMakefile(self)\r
3430 if Makefile.Generate():\r
3431 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %\r
3432 (self.Name, self.Arch))\r
3433 else:\r
3434 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %\r
3435 (self.Name, self.Arch))\r
3436\r
3437 self.IsMakeFileCreated = True\r
3438\r
a0a2cd1e
FB		 3439 def CopyBinaryFiles(self):\r
3440 for File in self.Module.Binaries:\r
3441 SrcPath = File.Path\r
3442 DstPath = os.path.join(self.OutputDir , os.path.basename(SrcPath))\r
3443 CopyLongFilePath(SrcPath, DstPath)\r
52302d4d
LG		 3444 ## Create autogen code for the module and its dependent libraries\r
3445 #\r
3446 # @param CreateLibraryCodeFile Flag indicating if or not the code of\r
3447 # dependent libraries will be created\r
3448 #\r
3449 def CreateCodeFile(self, CreateLibraryCodeFile=True):\r
3450 if self.IsCodeFileCreated:\r
3451 return\r
3452\r
e8a47801
LG		 3453 # Need to generate PcdDatabase even PcdDriver is binarymodule\r
3454 if self.IsBinaryModule and self.PcdIsDriver != '':\r
3455 CreatePcdDatabaseCode(self, TemplateString(), TemplateString())\r
3456 return\r
a0a2cd1e 3457 if self.IsBinaryModule:\r
49d9b71d
HC		 3458 if self.IsLibrary:\r
3459 self.CopyBinaryFiles()\r
a0a2cd1e 3460 return\r
e8a47801 3461\r
52302d4d
LG		 3462 if not self.IsLibrary and CreateLibraryCodeFile:\r
3463 for LibraryAutoGen in self.LibraryAutoGenList:\r
3464 LibraryAutoGen.CreateCodeFile()\r
3465\r
3466 AutoGenList = []\r
3467 IgoredAutoGenList = []\r
3468\r
3469 for File in self.AutoGenFileList:\r
3470 if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):\r
b36d134f 3471 #Ignore Edk AutoGen.c\r
52302d4d
LG		 3472 if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':\r
3473 continue\r
3474\r
3475 AutoGenList.append(str(File))\r
3476 else:\r
3477 IgoredAutoGenList.append(str(File))\r
3478\r
3479 # Skip the following code for EDK I inf\r
3480 if self.AutoGenVersion < 0x00010005:\r
3481 return\r
3482\r
3483 for ModuleType in self.DepexList:\r
40d841f6
LG		 3484 # Ignore empty [depex] section or [depex] section for "USER_DEFINED" module\r
3485 if len(self.DepexList[ModuleType]) == 0 or ModuleType == "USER_DEFINED":\r
52302d4d 3486 continue\r
40d841f6 3487\r
52302d4d
LG		 3488 Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)\r
3489 DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}\r
3490\r
da92f276 3491 if len(Dpx.PostfixNotation) <> 0:\r
0d2711a6 3492 self.DepexGenerated = True\r
da92f276 3493\r
52302d4d
LG		 3494 if Dpx.Generate(path.join(self.OutputDir, DpxFile)):\r
3495 AutoGenList.append(str(DpxFile))\r
3496 else:\r
3497 IgoredAutoGenList.append(str(DpxFile))\r
3498\r
3499 if IgoredAutoGenList == []:\r
3500 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %\r
3501 (" ".join(AutoGenList), self.Name, self.Arch))\r
3502 elif AutoGenList == []:\r
3503 EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %\r
3504 (" ".join(IgoredAutoGenList), self.Name, self.Arch))\r
3505 else:\r
3506 EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %\r
3507 (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))\r
3508\r
3509 self.IsCodeFileCreated = True\r
3510 return AutoGenList\r
3511\r
3512 ## Summarize the ModuleAutoGen objects of all libraries used by this module\r
3513 def _GetLibraryAutoGenList(self):\r
3514 if self._LibraryAutoGenList == None:\r
3515 self._LibraryAutoGenList = []\r
3516 for Library in self.DependentLibraryList:\r
3517 La = ModuleAutoGen(\r
3518 self.Workspace,\r
3519 Library.MetaFile,\r
3520 self.BuildTarget,\r
3521 self.ToolChain,\r
3522 self.Arch,\r
3523 self.PlatformInfo.MetaFile\r
3524 )\r
3525 if La not in self._LibraryAutoGenList:\r
3526 self._LibraryAutoGenList.append(La)\r
3527 for Lib in La.CodaTargetList:\r
3528 self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)\r
3529 return self._LibraryAutoGenList\r
3530\r
52302d4d
LG		 3531 Module = property(_GetModule)\r
3532 Name = property(_GetBaseName)\r
3533 Guid = property(_GetGuid)\r
3534 Version = property(_GetVersion)\r
3535 ModuleType = property(_GetModuleType)\r
3536 ComponentType = property(_GetComponentType)\r
3537 BuildType = property(_GetBuildType)\r
3538 PcdIsDriver = property(_GetPcdIsDriver)\r
3539 AutoGenVersion = property(_GetAutoGenVersion)\r
3540 Macros = property(_GetMacros)\r
3541 Specification = property(_GetSpecification)\r
3542\r
3543 IsLibrary = property(_IsLibrary)\r
e8a47801 3544 IsBinaryModule = property(_IsBinaryModule)\r
52302d4d
LG		 3545 BuildDir = property(_GetBuildDir)\r
3546 OutputDir = property(_GetOutputDir)\r
3547 DebugDir = property(_GetDebugDir)\r
3548 MakeFileDir = property(_GetMakeFileDir)\r
3549 CustomMakefile = property(_GetCustomMakefile)\r
3550\r
3551 IncludePathList = property(_GetIncludePathList)\r
3552 AutoGenFileList = property(_GetAutoGenFileList)\r
3553 UnicodeFileList = property(_GetUnicodeFileList)\r
3554 SourceFileList = property(_GetSourceFileList)\r
3555 BinaryFileList = property(_GetBinaryFiles) # FileType : [File List]\r
3556 Targets = property(_GetTargets)\r
3557 IntroTargetList = property(_GetIntroTargetList)\r
3558 CodaTargetList = property(_GetFinalTargetList)\r
3559 FileTypes = property(_GetFileTypes)\r
3560 BuildRules = property(_GetBuildRules)\r
3561\r
3562 DependentPackageList = property(_GetDependentPackageList)\r
3563 DependentLibraryList = property(_GetLibraryList)\r
3564 LibraryAutoGenList = property(_GetLibraryAutoGenList)\r
3565 DerivedPackageList = property(_GetDerivedPackageList)\r
3566\r
3567 ModulePcdList = property(_GetModulePcdList)\r
3568 LibraryPcdList = property(_GetLibraryPcdList)\r
3569 GuidList = property(_GetGuidList)\r
3570 ProtocolList = property(_GetProtocolList)\r
3571 PpiList = property(_GetPpiList)\r
3572 DepexList = property(_GetDepexTokenList)\r
b36d134f 3573 DxsFile = property(_GetDxsFile)\r
52302d4d
LG		 3574 DepexExpressionList = property(_GetDepexExpressionTokenList)\r
3575 BuildOption = property(_GetModuleBuildOption)\r
79b74a03 3576 BuildOptionIncPathList = property(_GetBuildOptionIncPathList)\r
52302d4d 3577 BuildCommand = property(_GetBuildCommand)\r
2bc3256c
LG		 3578 \r
3579 FixedAtBuildPcds = property(_GetFixedAtBuildPcds)\r
52302d4d
LG		 3580\r
3581# This acts like the main() function for the script, unless it is 'import'ed into another script.\r
3582if __name__ == '__main__':\r
3583 pass\r
3584\r
EFI Development Kit II mirror for PVE