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