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