]> git.proxmox.com Git - mirror_edk2.git/blame - BaseTools/Source/Python/AutoGen/WorkspaceAutoGen.py
projects / mirror_edk2.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
BaseTools: add '-p' for Linux 'cp' command.
[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / WorkspaceAutoGen.py
CommitLineData
e8449e1d
FB		 1## @file\r
2# Create makefile for MS nmake and GNU make\r
3#\r
4# Copyright (c) 2019, Intel Corporation. All rights reserved.<BR>\r
5# SPDX-License-Identifier: BSD-2-Clause-Patent\r
6#\r
7\r
8## Import Modules\r
9#\r
10from __future__ import print_function\r
11from __future__ import absolute_import\r
12import os.path as path\r
13import hashlib\r
14from collections import defaultdict\r
15from GenFds.FdfParser import FdfParser\r
16from Workspace.WorkspaceCommon import GetModuleLibInstances\r
17from AutoGen import GenMake\r
18from AutoGen.AutoGen import AutoGen\r
19from AutoGen.PlatformAutoGen import PlatformAutoGen\r
20from AutoGen.BuildEngine import gDefaultBuildRuleFile\r
21from Common.ToolDefClassObject import gDefaultToolsDefFile\r
22from Common.StringUtils import NormPath\r
23from Common.BuildToolError import *\r
24from Common.DataType import *\r
25from Common.Misc import *\r
fc8b8dea 26import json\r
e8449e1d
FB		 27\r
28## Regular expression for splitting Dependency Expression string into tokens\r
29gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")\r
30\r
31## Regular expression for match: PCD(xxxx.yyy)\r
32gPCDAsGuidPattern = re.compile(r"^PCD\(.+\..+\)$")\r
33\r
34## Workspace AutoGen class\r
35#\r
36# This class is used mainly to control the whole platform build for different\r
37# architecture. This class will generate top level makefile.\r
38#\r
39class WorkspaceAutoGen(AutoGen):\r
40 # call super().__init__ then call the worker function with different parameter count\r
41 def __init__(self, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):\r
42 if not hasattr(self, "_Init"):\r
43 self._InitWorker(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs)\r
44 self._Init = True\r
45\r
46 ## Initialize WorkspaceAutoGen\r
47 #\r
48 # @param WorkspaceDir Root directory of workspace\r
49 # @param ActivePlatform Meta-file of active platform\r
50 # @param Target Build target\r
51 # @param Toolchain Tool chain name\r
52 # @param ArchList List of architecture of current build\r
53 # @param MetaFileDb Database containing meta-files\r
54 # @param BuildConfig Configuration of build\r
55 # @param ToolDefinition Tool chain definitions\r
56 # @param FlashDefinitionFile File of flash definition\r
57 # @param Fds FD list to be generated\r
58 # @param Fvs FV list to be generated\r
59 # @param Caps Capsule list to be generated\r
60 # @param SkuId SKU id from command line\r
61 #\r
62 def _InitWorker(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,\r
63 BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=None, Fvs=None, Caps=None, SkuId='', UniFlag=None,\r
64 Progress=None, BuildModule=None):\r
65 self.BuildDatabase = MetaFileDb\r
66 self.MetaFile = ActivePlatform\r
67 self.WorkspaceDir = WorkspaceDir\r
68 self.Platform = self.BuildDatabase[self.MetaFile, TAB_ARCH_COMMON, Target, Toolchain]\r
69 GlobalData.gActivePlatform = self.Platform\r
70 self.BuildTarget = Target\r
71 self.ToolChain = Toolchain\r
72 self.ArchList = ArchList\r
73 self.SkuId = SkuId\r
74 self.UniFlag = UniFlag\r
75\r
76 self.TargetTxt = BuildConfig\r
77 self.ToolDef = ToolDefinition\r
78 self.FdfFile = FlashDefinitionFile\r
79 self.FdTargetList = Fds if Fds else []\r
80 self.FvTargetList = Fvs if Fvs else []\r
81 self.CapTargetList = Caps if Caps else []\r
82 self.AutoGenObjectList = []\r
83 self._GuidDict = {}\r
84\r
85 # there's many relative directory operations, so ...\r
86 os.chdir(self.WorkspaceDir)\r
87\r
88 self.MergeArch()\r
89 self.ValidateBuildTarget()\r
90\r
91 EdkLogger.info("")\r
92 if self.ArchList:\r
93 EdkLogger.info('%-16s = %s' % ("Architecture(s)", ' '.join(self.ArchList)))\r
94 EdkLogger.info('%-16s = %s' % ("Build target", self.BuildTarget))\r
95 EdkLogger.info('%-16s = %s' % ("Toolchain", self.ToolChain))\r
96\r
97 EdkLogger.info('\n%-24s = %s' % ("Active Platform", self.Platform))\r
98 if BuildModule:\r
99 EdkLogger.info('%-24s = %s' % ("Active Module", BuildModule))\r
100\r
101 if self.FdfFile:\r
102 EdkLogger.info('%-24s = %s' % ("Flash Image Definition", self.FdfFile))\r
103\r
104 EdkLogger.verbose("\nFLASH_DEFINITION = %s" % self.FdfFile)\r
105\r
106 if Progress:\r
107 Progress.Start("\nProcessing meta-data")\r
108 #\r
109 # Mark now build in AutoGen Phase\r
110 #\r
d35773d5
YC		 111 #\r
112 # Collect Platform Guids to support Guid name in Fdfparser.\r
113 #\r
114 self.CollectPlatformGuids()\r
e8449e1d
FB		 115 GlobalData.gAutoGenPhase = True\r
116 self.ProcessModuleFromPdf()\r
117 self.ProcessPcdType()\r
118 self.ProcessMixedPcd()\r
119 self.VerifyPcdsFromFDF()\r
120 self.CollectAllPcds()\r
673d09a2
FB		 121 for Pa in self.AutoGenObjectList:\r
122 Pa.FillData_LibConstPcd()\r
e8449e1d
FB		 123 self.GeneratePkgLevelHash()\r
124 #\r
125 # Check PCDs token value conflict in each DEC file.\r
126 #\r
127 self._CheckAllPcdsTokenValueConflict()\r
128 #\r
129 # Check PCD type and definition between DSC and DEC\r
130 #\r
131 self._CheckPcdDefineAndType()\r
132\r
133 self.CreateBuildOptionsFile()\r
134 self.CreatePcdTokenNumberFile()\r
fc8b8dea 135 self.GeneratePlatformLevelHash()\r
e8449e1d
FB		 136\r
137 #\r
138 # Merge Arch\r
139 #\r
140 def MergeArch(self):\r
141 if not self.ArchList:\r
142 ArchList = set(self.Platform.SupArchList)\r
143 else:\r
144 ArchList = set(self.ArchList) & set(self.Platform.SupArchList)\r
145 if not ArchList:\r
146 EdkLogger.error("build", PARAMETER_INVALID,\r
147 ExtraData = "Invalid ARCH specified. [Valid ARCH: %s]" % (" ".join(self.Platform.SupArchList)))\r
148 elif self.ArchList and len(ArchList) != len(self.ArchList):\r
149 SkippedArchList = set(self.ArchList).symmetric_difference(set(self.Platform.SupArchList))\r
150 EdkLogger.verbose("\nArch [%s] is ignored because the platform supports [%s] only!"\r
151 % (" ".join(SkippedArchList), " ".join(self.Platform.SupArchList)))\r
152 self.ArchList = tuple(ArchList)\r
153\r
154 # Validate build target\r
155 def ValidateBuildTarget(self):\r
156 if self.BuildTarget not in self.Platform.BuildTargets:\r
157 EdkLogger.error("build", PARAMETER_INVALID,\r
158 ExtraData="Build target [%s] is not supported by the platform. [Valid target: %s]"\r
159 % (self.BuildTarget, " ".join(self.Platform.BuildTargets)))\r
d35773d5
YC		 160\r
161 def CollectPlatformGuids(self):\r
162 oriInfList = []\r
163 oriPkgSet = set()\r
164 PlatformPkg = set()\r
165 for Arch in self.ArchList:\r
166 Platform = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
167 oriInfList = Platform.Modules\r
168 for ModuleFile in oriInfList:\r
169 ModuleData = self.BuildDatabase[ModuleFile, Platform._Arch, Platform._Target, Platform._Toolchain]\r
170 oriPkgSet.update(ModuleData.Packages)\r
171 for Pkg in oriPkgSet:\r
172 Guids = Pkg.Guids\r
173 GlobalData.gGuidDict.update(Guids)\r
174 if Platform.Packages:\r
175 PlatformPkg.update(Platform.Packages)\r
176 for Pkg in PlatformPkg:\r
177 Guids = Pkg.Guids\r
178 GlobalData.gGuidDict.update(Guids)\r
179\r
e8449e1d
FB		 180 @cached_property\r
181 def FdfProfile(self):\r
182 if not self.FdfFile:\r
183 self.FdfFile = self.Platform.FlashDefinition\r
184\r
185 FdfProfile = None\r
186 if self.FdfFile:\r
187 Fdf = FdfParser(self.FdfFile.Path)\r
188 Fdf.ParseFile()\r
189 GlobalData.gFdfParser = Fdf\r
190 if Fdf.CurrentFdName and Fdf.CurrentFdName in Fdf.Profile.FdDict:\r
191 FdDict = Fdf.Profile.FdDict[Fdf.CurrentFdName]\r
192 for FdRegion in FdDict.RegionList:\r
490a62be 193 if str(FdRegion.RegionType) == 'FILE' and self.Platform.VpdToolGuid in str(FdRegion.RegionDataList):\r
e8449e1d
FB		 194 if int(FdRegion.Offset) % 8 != 0:\r
195 EdkLogger.error("build", FORMAT_INVALID, 'The VPD Base Address %s must be 8-byte aligned.' % (FdRegion.Offset))\r
196 FdfProfile = Fdf.Profile\r
197 else:\r
198 if self.FdTargetList:\r
199 EdkLogger.info("No flash definition file found. FD [%s] will be ignored." % " ".join(self.FdTargetList))\r
200 self.FdTargetList = []\r
201 if self.FvTargetList:\r
202 EdkLogger.info("No flash definition file found. FV [%s] will be ignored." % " ".join(self.FvTargetList))\r
203 self.FvTargetList = []\r
204 if self.CapTargetList:\r
205 EdkLogger.info("No flash definition file found. Capsule [%s] will be ignored." % " ".join(self.CapTargetList))\r
206 self.CapTargetList = []\r
207\r
208 return FdfProfile\r
209\r
210 def ProcessModuleFromPdf(self):\r
211\r
212 if self.FdfProfile:\r
213 for fvname in self.FvTargetList:\r
214 if fvname.upper() not in self.FdfProfile.FvDict:\r
215 EdkLogger.error("build", OPTION_VALUE_INVALID,\r
216 "No such an FV in FDF file: %s" % fvname)\r
217\r
218 # In DSC file may use FILE_GUID to override the module, then in the Platform.Modules use FILE_GUIDmodule.inf as key,\r
219 # but the path (self.MetaFile.Path) is the real path\r
220 for key in self.FdfProfile.InfDict:\r
221 if key == 'ArchTBD':\r
222 MetaFile_cache = defaultdict(set)\r
223 for Arch in self.ArchList:\r
224 Current_Platform_cache = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
225 for Pkey in Current_Platform_cache.Modules:\r
226 MetaFile_cache[Arch].add(Current_Platform_cache.Modules[Pkey].MetaFile)\r
227 for Inf in self.FdfProfile.InfDict[key]:\r
228 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
229 for Arch in self.ArchList:\r
230 if ModuleFile in MetaFile_cache[Arch]:\r
231 break\r
232 else:\r
233 ModuleData = self.BuildDatabase[ModuleFile, Arch, self.BuildTarget, self.ToolChain]\r
234 if not ModuleData.IsBinaryModule:\r
235 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)\r
236\r
237 else:\r
238 for Arch in self.ArchList:\r
239 if Arch == key:\r
240 Platform = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
241 MetaFileList = set()\r
242 for Pkey in Platform.Modules:\r
243 MetaFileList.add(Platform.Modules[Pkey].MetaFile)\r
244 for Inf in self.FdfProfile.InfDict[key]:\r
245 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
246 if ModuleFile in MetaFileList:\r
247 continue\r
248 ModuleData = self.BuildDatabase[ModuleFile, Arch, self.BuildTarget, self.ToolChain]\r
249 if not ModuleData.IsBinaryModule:\r
250 EdkLogger.error('build', PARSER_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % ModuleFile)\r
251\r
252\r
253\r
254 # parse FDF file to get PCDs in it, if any\r
255 def VerifyPcdsFromFDF(self):\r
256\r
257 if self.FdfProfile:\r
258 PcdSet = self.FdfProfile.PcdDict\r
259 self.VerifyPcdDeclearation(PcdSet)\r
260\r
261 def ProcessPcdType(self):\r
262 for Arch in self.ArchList:\r
263 Platform = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
264 Platform.Pcds\r
265 # generate the SourcePcdDict and BinaryPcdDict\r
266 Libs = []\r
267 for BuildData in list(self.BuildDatabase._CACHE_.values()):\r
268 if BuildData.Arch != Arch:\r
269 continue\r
270 if BuildData.MetaFile.Ext == '.inf' and str(BuildData) in Platform.Modules :\r
271 Libs.extend(GetModuleLibInstances(BuildData, Platform,\r
272 self.BuildDatabase,\r
273 Arch,\r
274 self.BuildTarget,\r
abc0155b
FB		 275 self.ToolChain,\r
276 self.Platform.MetaFile,\r
277 EdkLogger\r
e8449e1d
FB		 278 ))\r
279 for BuildData in list(self.BuildDatabase._CACHE_.values()):\r
280 if BuildData.Arch != Arch:\r
281 continue\r
282 if BuildData.MetaFile.Ext == '.inf':\r
283 for key in BuildData.Pcds:\r
284 if BuildData.Pcds[key].Pending:\r
285 if key in Platform.Pcds:\r
286 PcdInPlatform = Platform.Pcds[key]\r
287 if PcdInPlatform.Type:\r
288 BuildData.Pcds[key].Type = PcdInPlatform.Type\r
289 BuildData.Pcds[key].Pending = False\r
290\r
291 if BuildData.MetaFile in Platform.Modules:\r
292 PlatformModule = Platform.Modules[str(BuildData.MetaFile)]\r
293 if key in PlatformModule.Pcds:\r
294 PcdInPlatform = PlatformModule.Pcds[key]\r
295 if PcdInPlatform.Type:\r
296 BuildData.Pcds[key].Type = PcdInPlatform.Type\r
297 BuildData.Pcds[key].Pending = False\r
298 else:\r
299 #Pcd used in Library, Pcd Type from reference module if Pcd Type is Pending\r
300 if BuildData.Pcds[key].Pending:\r
301 if bool(BuildData.LibraryClass):\r
302 if BuildData in set(Libs):\r
303 ReferenceModules = BuildData.ReferenceModules\r
304 for ReferenceModule in ReferenceModules:\r
305 if ReferenceModule.MetaFile in Platform.Modules:\r
306 RefPlatformModule = Platform.Modules[str(ReferenceModule.MetaFile)]\r
307 if key in RefPlatformModule.Pcds:\r
308 PcdInReferenceModule = RefPlatformModule.Pcds[key]\r
309 if PcdInReferenceModule.Type:\r
310 BuildData.Pcds[key].Type = PcdInReferenceModule.Type\r
311 BuildData.Pcds[key].Pending = False\r
312 break\r
313\r
314 def ProcessMixedPcd(self):\r
315 for Arch in self.ArchList:\r
316 SourcePcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set(),TAB_PCDS_DYNAMIC:set(),TAB_PCDS_FIXED_AT_BUILD:set()}\r
317 BinaryPcdDict = {TAB_PCDS_DYNAMIC_EX:set(), TAB_PCDS_PATCHABLE_IN_MODULE:set()}\r
318 SourcePcdDict_Keys = SourcePcdDict.keys()\r
319 BinaryPcdDict_Keys = BinaryPcdDict.keys()\r
320\r
321 # generate the SourcePcdDict and BinaryPcdDict\r
322\r
323 for BuildData in list(self.BuildDatabase._CACHE_.values()):\r
324 if BuildData.Arch != Arch:\r
325 continue\r
326 if BuildData.MetaFile.Ext == '.inf':\r
327 for key in BuildData.Pcds:\r
328 if TAB_PCDS_DYNAMIC_EX in BuildData.Pcds[key].Type:\r
329 if BuildData.IsBinaryModule:\r
330 BinaryPcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
331 else:\r
332 SourcePcdDict[TAB_PCDS_DYNAMIC_EX].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
333\r
334 elif TAB_PCDS_PATCHABLE_IN_MODULE in BuildData.Pcds[key].Type:\r
335 if BuildData.MetaFile.Ext == '.inf':\r
336 if BuildData.IsBinaryModule:\r
337 BinaryPcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
338 else:\r
339 SourcePcdDict[TAB_PCDS_PATCHABLE_IN_MODULE].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
340\r
341 elif TAB_PCDS_DYNAMIC in BuildData.Pcds[key].Type:\r
342 SourcePcdDict[TAB_PCDS_DYNAMIC].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
343 elif TAB_PCDS_FIXED_AT_BUILD in BuildData.Pcds[key].Type:\r
344 SourcePcdDict[TAB_PCDS_FIXED_AT_BUILD].add((BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName))\r
345\r
346 #\r
347 # A PCD can only use one type for all source modules\r
348 #\r
349 for i in SourcePcdDict_Keys:\r
350 for j in SourcePcdDict_Keys:\r
351 if i != j:\r
352 Intersections = SourcePcdDict[i].intersection(SourcePcdDict[j])\r
353 if len(Intersections) > 0:\r
354 EdkLogger.error(\r
355 'build',\r
356 FORMAT_INVALID,\r
357 "Building modules from source INFs, following PCD use %s and %s access method. It must be corrected to use only one access method." % (i, j),\r
358 ExtraData='\n\t'.join(str(P[1]+'.'+P[0]) for P in Intersections)\r
359 )\r
360\r
361 #\r
362 # intersection the BinaryPCD for Mixed PCD\r
363 #\r
364 for i in BinaryPcdDict_Keys:\r
365 for j in BinaryPcdDict_Keys:\r
366 if i != j:\r
367 Intersections = BinaryPcdDict[i].intersection(BinaryPcdDict[j])\r
368 for item in Intersections:\r
369 NewPcd1 = (item[0] + '_' + i, item[1])\r
370 NewPcd2 = (item[0] + '_' + j, item[1])\r
371 if item not in GlobalData.MixedPcd:\r
372 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]\r
373 else:\r
374 if NewPcd1 not in GlobalData.MixedPcd[item]:\r
375 GlobalData.MixedPcd[item].append(NewPcd1)\r
376 if NewPcd2 not in GlobalData.MixedPcd[item]:\r
377 GlobalData.MixedPcd[item].append(NewPcd2)\r
378\r
379 #\r
380 # intersection the SourcePCD and BinaryPCD for Mixed PCD\r
381 #\r
382 for i in SourcePcdDict_Keys:\r
383 for j in BinaryPcdDict_Keys:\r
384 if i != j:\r
385 Intersections = SourcePcdDict[i].intersection(BinaryPcdDict[j])\r
386 for item in Intersections:\r
387 NewPcd1 = (item[0] + '_' + i, item[1])\r
388 NewPcd2 = (item[0] + '_' + j, item[1])\r
389 if item not in GlobalData.MixedPcd:\r
390 GlobalData.MixedPcd[item] = [NewPcd1, NewPcd2]\r
391 else:\r
392 if NewPcd1 not in GlobalData.MixedPcd[item]:\r
393 GlobalData.MixedPcd[item].append(NewPcd1)\r
394 if NewPcd2 not in GlobalData.MixedPcd[item]:\r
395 GlobalData.MixedPcd[item].append(NewPcd2)\r
396\r
397 BuildData = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
398 for key in BuildData.Pcds:\r
399 for SinglePcd in GlobalData.MixedPcd:\r
400 if (BuildData.Pcds[key].TokenCName, BuildData.Pcds[key].TokenSpaceGuidCName) == SinglePcd:\r
401 for item in GlobalData.MixedPcd[SinglePcd]:\r
402 Pcd_Type = item[0].split('_')[-1]\r
403 if (Pcd_Type == BuildData.Pcds[key].Type) or (Pcd_Type == TAB_PCDS_DYNAMIC_EX and BuildData.Pcds[key].Type in PCD_DYNAMIC_EX_TYPE_SET) or \\r
404 (Pcd_Type == TAB_PCDS_DYNAMIC and BuildData.Pcds[key].Type in PCD_DYNAMIC_TYPE_SET):\r
405 Value = BuildData.Pcds[key]\r
406 Value.TokenCName = BuildData.Pcds[key].TokenCName + '_' + Pcd_Type\r
407 if len(key) == 2:\r
408 newkey = (Value.TokenCName, key[1])\r
409 elif len(key) == 3:\r
410 newkey = (Value.TokenCName, key[1], key[2])\r
411 del BuildData.Pcds[key]\r
412 BuildData.Pcds[newkey] = Value\r
413 break\r
414 break\r
415\r
416 if self.FdfProfile:\r
417 PcdSet = self.FdfProfile.PcdDict\r
418 # handle the mixed pcd in FDF file\r
419 for key in PcdSet:\r
420 if key in GlobalData.MixedPcd:\r
421 Value = PcdSet[key]\r
422 del PcdSet[key]\r
423 for item in GlobalData.MixedPcd[key]:\r
424 PcdSet[item] = Value\r
425\r
426 #Collect package set information from INF of FDF\r
427 @cached_property\r
428 def PkgSet(self):\r
429 if not self.FdfFile:\r
430 self.FdfFile = self.Platform.FlashDefinition\r
431\r
432 if self.FdfFile:\r
433 ModuleList = self.FdfProfile.InfList\r
434 else:\r
435 ModuleList = []\r
436 Pkgs = {}\r
437 for Arch in self.ArchList:\r
438 Platform = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
439 PkgSet = set()\r
440 for mb in [self.BuildDatabase[m, Arch, self.BuildTarget, self.ToolChain] for m in Platform.Modules]:\r
441 PkgSet.update(mb.Packages)\r
442 for Inf in ModuleList:\r
443 ModuleFile = PathClass(NormPath(Inf), GlobalData.gWorkspace, Arch)\r
444 if ModuleFile in Platform.Modules:\r
445 continue\r
446 ModuleData = self.BuildDatabase[ModuleFile, Arch, self.BuildTarget, self.ToolChain]\r
447 PkgSet.update(ModuleData.Packages)\r
bf1ea933 448 PkgSet.update(Platform.Packages)\r
e8449e1d
FB		 449 Pkgs[Arch] = list(PkgSet)\r
450 return Pkgs\r
451\r
452 def VerifyPcdDeclearation(self,PcdSet):\r
453 for Arch in self.ArchList:\r
454 Platform = self.BuildDatabase[self.MetaFile, Arch, self.BuildTarget, self.ToolChain]\r
455 Pkgs = self.PkgSet[Arch]\r
456 DecPcds = set()\r
457 DecPcdsKey = set()\r
458 for Pkg in Pkgs:\r
459 for Pcd in Pkg.Pcds:\r
460 DecPcds.add((Pcd[0], Pcd[1]))\r
461 DecPcdsKey.add((Pcd[0], Pcd[1], Pcd[2]))\r
462\r
463 Platform.SkuName = self.SkuId\r
464 for Name, Guid,Fileds in PcdSet:\r
465 if (Name, Guid) not in DecPcds:\r
466 EdkLogger.error(\r
467 'build',\r
468 PARSER_ERROR,\r
469 "PCD (%s.%s) used in FDF is not declared in DEC files." % (Guid, Name),\r
470 File = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][0],\r
471 Line = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][1]\r
472 )\r
473 else:\r
474 # Check whether Dynamic or DynamicEx PCD used in FDF file. If used, build break and give a error message.\r
475 if (Name, Guid, TAB_PCDS_FIXED_AT_BUILD) in DecPcdsKey \\r
476 or (Name, Guid, TAB_PCDS_PATCHABLE_IN_MODULE) in DecPcdsKey \\r
477 or (Name, Guid, TAB_PCDS_FEATURE_FLAG) in DecPcdsKey:\r
478 continue\r
479 elif (Name, Guid, TAB_PCDS_DYNAMIC) in DecPcdsKey or (Name, Guid, TAB_PCDS_DYNAMIC_EX) in DecPcdsKey:\r
480 EdkLogger.error(\r
481 'build',\r
482 PARSER_ERROR,\r
483 "Using Dynamic or DynamicEx type of PCD [%s.%s] in FDF file is not allowed." % (Guid, Name),\r
484 File = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][0],\r
485 Line = self.FdfProfile.PcdFileLineDict[Name, Guid, Fileds][1]\r
486 )\r
487 def CollectAllPcds(self):\r
488\r
489 for Arch in self.ArchList:\r
490 Pa = PlatformAutoGen(self, self.MetaFile, self.BuildTarget, self.ToolChain, Arch)\r
491 #\r
492 # Explicitly collect platform's dynamic PCDs\r
493 #\r
494 Pa.CollectPlatformDynamicPcds()\r
495 Pa.CollectFixedAtBuildPcds()\r
496 self.AutoGenObjectList.append(Pa)\r
497 # We need to calculate the PcdTokenNumber after all Arch Pcds are collected.\r
498 for Arch in self.ArchList:\r
499 #Pcd TokenNumber\r
500 Pa = PlatformAutoGen(self, self.MetaFile, self.BuildTarget, self.ToolChain, Arch)\r
501 self.UpdateModuleDataPipe(Arch, {"PCD_TNUM":Pa.PcdTokenNumber})\r
502\r
503 def UpdateModuleDataPipe(self,arch, attr_dict):\r
504 for (Target, Toolchain, Arch, MetaFile) in AutoGen.Cache():\r
505 if Arch != arch:\r
506 continue\r
507 try:\r
508 AutoGen.Cache()[(Target, Toolchain, Arch, MetaFile)].DataPipe.DataContainer = attr_dict\r
509 except Exception:\r
510 pass\r
511 #\r
512 # Generate Package level hash value\r
513 #\r
514 def GeneratePkgLevelHash(self):\r
515 for Arch in self.ArchList:\r
516 GlobalData.gPackageHash = {}\r
517 if GlobalData.gUseHashCache:\r
518 for Pkg in self.PkgSet[Arch]:\r
519 self._GenPkgLevelHash(Pkg)\r
520\r
521\r
522 def CreateBuildOptionsFile(self):\r
523 #\r
524 # Create BuildOptions Macro & PCD metafile, also add the Active Platform and FDF file.\r
525 #\r
526 content = 'gCommandLineDefines: '\r
527 content += str(GlobalData.gCommandLineDefines)\r
528 content += TAB_LINE_BREAK\r
529 content += 'BuildOptionPcd: '\r
530 content += str(GlobalData.BuildOptionPcd)\r
531 content += TAB_LINE_BREAK\r
532 content += 'Active Platform: '\r
533 content += str(self.Platform)\r
534 content += TAB_LINE_BREAK\r
535 if self.FdfFile:\r
536 content += 'Flash Image Definition: '\r
537 content += str(self.FdfFile)\r
538 content += TAB_LINE_BREAK\r
539 SaveFileOnChange(os.path.join(self.BuildDir, 'BuildOptions'), content, False)\r
540\r
541 def CreatePcdTokenNumberFile(self):\r
542 #\r
543 # Create PcdToken Number file for Dynamic/DynamicEx Pcd.\r
544 #\r
545 PcdTokenNumber = 'PcdTokenNumber: '\r
546 Pa = self.AutoGenObjectList[0]\r
547 if Pa.PcdTokenNumber:\r
548 if Pa.DynamicPcdList:\r
549 for Pcd in Pa.DynamicPcdList:\r
550 PcdTokenNumber += TAB_LINE_BREAK\r
551 PcdTokenNumber += str((Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
552 PcdTokenNumber += ' : '\r
553 PcdTokenNumber += str(Pa.PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName])\r
554 SaveFileOnChange(os.path.join(self.BuildDir, 'PcdTokenNumber'), PcdTokenNumber, False)\r
555\r
fc8b8dea 556 def GeneratePlatformLevelHash(self):\r
e8449e1d
FB		 557 #\r
558 # Get set of workspace metafiles\r
559 #\r
560 AllWorkSpaceMetaFiles = self._GetMetaFiles(self.BuildTarget, self.ToolChain)\r
fc8b8dea 561 AllWorkSpaceMetaFileList = sorted(AllWorkSpaceMetaFiles, key=lambda x: str(x))\r
e8449e1d
FB		 562 #\r
563 # Retrieve latest modified time of all metafiles\r
564 #\r
565 SrcTimeStamp = 0\r
566 for f in AllWorkSpaceMetaFiles:\r
567 if os.stat(f)[8] > SrcTimeStamp:\r
568 SrcTimeStamp = os.stat(f)[8]\r
569 self._SrcTimeStamp = SrcTimeStamp\r
570\r
571 if GlobalData.gUseHashCache:\r
fc8b8dea 572 FileList = []\r
e8449e1d 573 m = hashlib.md5()\r
fc8b8dea
SS		 574 for file in AllWorkSpaceMetaFileList:\r
575 if file.endswith('.dec'):\r
e8449e1d 576 continue\r
fc8b8dea 577 f = open(file, 'rb')\r
e8449e1d
FB		 578 Content = f.read()\r
579 f.close()\r
580 m.update(Content)\r
fc8b8dea
SS		 581 FileList.append((str(file), hashlib.md5(Content).hexdigest()))\r
582\r
583 HashDir = path.join(self.BuildDir, "Hash_Platform")\r
584 HashFile = path.join(HashDir, 'Platform.hash.' + m.hexdigest())\r
585 SaveFileOnChange(HashFile, m.hexdigest(), False)\r
586 HashChainFile = path.join(HashDir, 'Platform.hashchain.' + m.hexdigest())\r
587 GlobalData.gPlatformHashFile = HashChainFile\r
588 try:\r
589 with open(HashChainFile, 'w') as f:\r
590 json.dump(FileList, f, indent=2)\r
591 except:\r
592 EdkLogger.quiet("[cache warning]: fail to save hashchain file:%s" % HashChainFile)\r
593\r
594 if GlobalData.gBinCacheDest:\r
595 # Copy platform hash files to cache destination\r
596 FileDir = path.join(GlobalData.gBinCacheDest, self.OutputDir, self.BuildTarget + "_" + self.ToolChain, "Hash_Platform")\r
597 CacheFileDir = FileDir\r
598 CreateDirectory(CacheFileDir)\r
599 CopyFileOnChange(HashFile, CacheFileDir)\r
600 CopyFileOnChange(HashChainFile, CacheFileDir)\r
e8449e1d
FB		 601\r
602 #\r
603 # Write metafile list to build directory\r
604 #\r
605 AutoGenFilePath = os.path.join(self.BuildDir, 'AutoGen')\r
606 if os.path.exists (AutoGenFilePath):\r
607 os.remove(AutoGenFilePath)\r
608 if not os.path.exists(self.BuildDir):\r
609 os.makedirs(self.BuildDir)\r
610 with open(os.path.join(self.BuildDir, 'AutoGen'), 'w+') as file:\r
fc8b8dea 611 for f in AllWorkSpaceMetaFileList:\r
e8449e1d
FB		 612 print(f, file=file)\r
613 return True\r
614\r
615 def _GenPkgLevelHash(self, Pkg):\r
616 if Pkg.PackageName in GlobalData.gPackageHash:\r
617 return\r
618\r
fc8b8dea 619 PkgDir = os.path.join(self.BuildDir, Pkg.Arch, "Hash_Pkg", Pkg.PackageName)\r
e8449e1d 620 CreateDirectory(PkgDir)\r
fc8b8dea 621 FileList = []\r
e8449e1d
FB		 622 m = hashlib.md5()\r
623 # Get .dec file's hash value\r
624 f = open(Pkg.MetaFile.Path, 'rb')\r
625 Content = f.read()\r
626 f.close()\r
627 m.update(Content)\r
fc8b8dea 628 FileList.append((str(Pkg.MetaFile.Path), hashlib.md5(Content).hexdigest()))\r
e8449e1d
FB		 629 # Get include files hash value\r
630 if Pkg.Includes:\r
631 for inc in sorted(Pkg.Includes, key=lambda x: str(x)):\r
632 for Root, Dirs, Files in os.walk(str(inc)):\r
633 for File in sorted(Files):\r
634 File_Path = os.path.join(Root, File)\r
635 f = open(File_Path, 'rb')\r
636 Content = f.read()\r
637 f.close()\r
638 m.update(Content)\r
fc8b8dea 639 FileList.append((str(File_Path), hashlib.md5(Content).hexdigest()))\r
e8449e1d
FB		 640 GlobalData.gPackageHash[Pkg.PackageName] = m.hexdigest()\r
641\r
fc8b8dea
SS		 642 HashDir = PkgDir\r
643 HashFile = path.join(HashDir, Pkg.PackageName + '.hash.' + m.hexdigest())\r
644 SaveFileOnChange(HashFile, m.hexdigest(), False)\r
645 HashChainFile = path.join(HashDir, Pkg.PackageName + '.hashchain.' + m.hexdigest())\r
646 GlobalData.gPackageHashFile[(Pkg.PackageName, Pkg.Arch)] = HashChainFile\r
647 try:\r
648 with open(HashChainFile, 'w') as f:\r
649 json.dump(FileList, f, indent=2)\r
650 except:\r
651 EdkLogger.quiet("[cache warning]: fail to save hashchain file:%s" % HashChainFile)\r
652\r
653 if GlobalData.gBinCacheDest:\r
654 # Copy Pkg hash files to cache destination dir\r
655 FileDir = path.join(GlobalData.gBinCacheDest, self.OutputDir, self.BuildTarget + "_" + self.ToolChain, Pkg.Arch, "Hash_Pkg", Pkg.PackageName)\r
656 CacheFileDir = FileDir\r
657 CreateDirectory(CacheFileDir)\r
658 CopyFileOnChange(HashFile, CacheFileDir)\r
659 CopyFileOnChange(HashChainFile, CacheFileDir)\r
660\r
e8449e1d
FB		 661 def _GetMetaFiles(self, Target, Toolchain):\r
662 AllWorkSpaceMetaFiles = set()\r
663 #\r
664 # add fdf\r
665 #\r
666 if self.FdfFile:\r
667 AllWorkSpaceMetaFiles.add (self.FdfFile.Path)\r
668 for f in GlobalData.gFdfParser.GetAllIncludedFile():\r
669 AllWorkSpaceMetaFiles.add (f.FileName)\r
670 #\r
671 # add dsc\r
672 #\r
673 AllWorkSpaceMetaFiles.add(self.MetaFile.Path)\r
674\r
675 #\r
676 # add build_rule.txt & tools_def.txt\r
677 #\r
678 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultBuildRuleFile))\r
679 AllWorkSpaceMetaFiles.add(os.path.join(GlobalData.gConfDirectory, gDefaultToolsDefFile))\r
680\r
681 # add BuildOption metafile\r
682 #\r
683 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'BuildOptions'))\r
684\r
685 # add PcdToken Number file for Dynamic/DynamicEx Pcd\r
686 #\r
687 AllWorkSpaceMetaFiles.add(os.path.join(self.BuildDir, 'PcdTokenNumber'))\r
688\r
689 for Pa in self.AutoGenObjectList:\r
690 AllWorkSpaceMetaFiles.add(Pa.ToolDefinitionFile)\r
691\r
692 for Arch in self.ArchList:\r
693 #\r
694 # add dec\r
695 #\r
696 for Package in PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch).PackageList:\r
697 AllWorkSpaceMetaFiles.add(Package.MetaFile.Path)\r
698\r
699 #\r
700 # add included dsc\r
701 #\r
702 for filePath in self.BuildDatabase[self.MetaFile, Arch, Target, Toolchain]._RawData.IncludedFiles:\r
703 AllWorkSpaceMetaFiles.add(filePath.Path)\r
704\r
705 return AllWorkSpaceMetaFiles\r
706\r
707 def _CheckPcdDefineAndType(self):\r
708 PcdTypeSet = {TAB_PCDS_FIXED_AT_BUILD,\r
709 TAB_PCDS_PATCHABLE_IN_MODULE,\r
710 TAB_PCDS_FEATURE_FLAG,\r
711 TAB_PCDS_DYNAMIC,\r
712 TAB_PCDS_DYNAMIC_EX}\r
713\r
714 # This dict store PCDs which are not used by any modules with specified arches\r
715 UnusedPcd = OrderedDict()\r
716 for Pa in self.AutoGenObjectList:\r
717 # Key of DSC's Pcds dictionary is PcdCName, TokenSpaceGuid\r
718 for Pcd in Pa.Platform.Pcds:\r
719 PcdType = Pa.Platform.Pcds[Pcd].Type\r
720\r
721 # If no PCD type, this PCD comes from FDF\r
722 if not PcdType:\r
723 continue\r
724\r
725 # Try to remove Hii and Vpd suffix\r
726 if PcdType.startswith(TAB_PCDS_DYNAMIC_EX):\r
727 PcdType = TAB_PCDS_DYNAMIC_EX\r
728 elif PcdType.startswith(TAB_PCDS_DYNAMIC):\r
729 PcdType = TAB_PCDS_DYNAMIC\r
730\r
731 for Package in Pa.PackageList:\r
732 # Key of DEC's Pcds dictionary is PcdCName, TokenSpaceGuid, PcdType\r
733 if (Pcd[0], Pcd[1], PcdType) in Package.Pcds:\r
734 break\r
735 for Type in PcdTypeSet:\r
736 if (Pcd[0], Pcd[1], Type) in Package.Pcds:\r
737 EdkLogger.error(\r
738 'build',\r
739 FORMAT_INVALID,\r
740 "Type [%s] of PCD [%s.%s] in DSC file doesn't match the type [%s] defined in DEC file." \\r
741 % (Pa.Platform.Pcds[Pcd].Type, Pcd[1], Pcd[0], Type),\r
742 ExtraData=None\r
743 )\r
744 return\r
745 else:\r
746 UnusedPcd.setdefault(Pcd, []).append(Pa.Arch)\r
747\r
748 for Pcd in UnusedPcd:\r
749 EdkLogger.warn(\r
750 'build',\r
751 "The PCD was not specified by any INF module in the platform for the given architecture.\n"\r
752 "\tPCD: [%s.%s]\n\tPlatform: [%s]\n\tArch: %s"\r
753 % (Pcd[1], Pcd[0], os.path.basename(str(self.MetaFile)), str(UnusedPcd[Pcd])),\r
754 ExtraData=None\r
755 )\r
756\r
757 def __repr__(self):\r
758 return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))\r
759\r
760 ## Return the directory to store FV files\r
761 @cached_property\r
762 def FvDir(self):\r
763 return path.join(self.BuildDir, TAB_FV_DIRECTORY)\r
764\r
765 ## Return the directory to store all intermediate and final files built\r
766 @cached_property\r
767 def BuildDir(self):\r
768 return self.AutoGenObjectList[0].BuildDir\r
769\r
770 ## Return the build output directory platform specifies\r
771 @cached_property\r
772 def OutputDir(self):\r
773 return self.Platform.OutputDirectory\r
774\r
775 ## Return platform name\r
776 @cached_property\r
777 def Name(self):\r
778 return self.Platform.PlatformName\r
779\r
780 ## Return meta-file GUID\r
781 @cached_property\r
782 def Guid(self):\r
783 return self.Platform.Guid\r
784\r
785 ## Return platform version\r
786 @cached_property\r
787 def Version(self):\r
788 return self.Platform.Version\r
789\r
790 ## Return paths of tools\r
791 @cached_property\r
792 def ToolDefinition(self):\r
793 return self.AutoGenObjectList[0].ToolDefinition\r
794\r
795 ## Return directory of platform makefile\r
796 #\r
797 # @retval string Makefile directory\r
798 #\r
799 @cached_property\r
800 def MakeFileDir(self):\r
801 return self.BuildDir\r
802\r
803 ## Return build command string\r
804 #\r
805 # @retval string Build command string\r
806 #\r
807 @cached_property\r
808 def BuildCommand(self):\r
809 # BuildCommand should be all the same. So just get one from platform AutoGen\r
810 return self.AutoGenObjectList[0].BuildCommand\r
811\r
812 ## Check the PCDs token value conflict in each DEC file.\r
813 #\r
814 # Will cause build break and raise error message while two PCDs conflict.\r
815 #\r
816 # @return None\r
817 #\r
818 def _CheckAllPcdsTokenValueConflict(self):\r
819 for Pa in self.AutoGenObjectList:\r
820 for Package in Pa.PackageList:\r
821 PcdList = list(Package.Pcds.values())\r
822 PcdList.sort(key=lambda x: int(x.TokenValue, 0))\r
823 Count = 0\r
824 while (Count < len(PcdList) - 1) :\r
825 Item = PcdList[Count]\r
826 ItemNext = PcdList[Count + 1]\r
827 #\r
828 # Make sure in the same token space the TokenValue should be unique\r
829 #\r
830 if (int(Item.TokenValue, 0) == int(ItemNext.TokenValue, 0)):\r
831 SameTokenValuePcdList = []\r
832 SameTokenValuePcdList.append(Item)\r
833 SameTokenValuePcdList.append(ItemNext)\r
834 RemainPcdListLength = len(PcdList) - Count - 2\r
835 for ValueSameCount in range(RemainPcdListLength):\r
836 if int(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount].TokenValue, 0) == int(Item.TokenValue, 0):\r
837 SameTokenValuePcdList.append(PcdList[len(PcdList) - RemainPcdListLength + ValueSameCount])\r
838 else:\r
839 break;\r
840 #\r
841 # Sort same token value PCD list with TokenGuid and TokenCName\r
842 #\r
843 SameTokenValuePcdList.sort(key=lambda x: "%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName))\r
844 SameTokenValuePcdListCount = 0\r
845 while (SameTokenValuePcdListCount < len(SameTokenValuePcdList) - 1):\r
846 Flag = False\r
847 TemListItem = SameTokenValuePcdList[SameTokenValuePcdListCount]\r
848 TemListItemNext = SameTokenValuePcdList[SameTokenValuePcdListCount + 1]\r
849\r
850 if (TemListItem.TokenSpaceGuidCName == TemListItemNext.TokenSpaceGuidCName) and (TemListItem.TokenCName != TemListItemNext.TokenCName):\r
851 for PcdItem in GlobalData.MixedPcd:\r
852 if (TemListItem.TokenCName, TemListItem.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem] or \\r
853 (TemListItemNext.TokenCName, TemListItemNext.TokenSpaceGuidCName) in GlobalData.MixedPcd[PcdItem]:\r
854 Flag = True\r
855 if not Flag:\r
856 EdkLogger.error(\r
857 'build',\r
858 FORMAT_INVALID,\r
859 "The TokenValue [%s] of PCD [%s.%s] is conflict with: [%s.%s] in %s"\\r
860 % (TemListItem.TokenValue, TemListItem.TokenSpaceGuidCName, TemListItem.TokenCName, TemListItemNext.TokenSpaceGuidCName, TemListItemNext.TokenCName, Package),\r
861 ExtraData=None\r
862 )\r
863 SameTokenValuePcdListCount += 1\r
864 Count += SameTokenValuePcdListCount\r
865 Count += 1\r
866\r
867 PcdList = list(Package.Pcds.values())\r
868 PcdList.sort(key=lambda x: "%s.%s" % (x.TokenSpaceGuidCName, x.TokenCName))\r
869 Count = 0\r
870 while (Count < len(PcdList) - 1) :\r
871 Item = PcdList[Count]\r
872 ItemNext = PcdList[Count + 1]\r
873 #\r
874 # Check PCDs with same TokenSpaceGuidCName.TokenCName have same token value as well.\r
875 #\r
876 if (Item.TokenSpaceGuidCName == ItemNext.TokenSpaceGuidCName) and (Item.TokenCName == ItemNext.TokenCName) and (int(Item.TokenValue, 0) != int(ItemNext.TokenValue, 0)):\r
877 EdkLogger.error(\r
878 'build',\r
879 FORMAT_INVALID,\r
880 "The TokenValue [%s] of PCD [%s.%s] in %s defined in two places should be same as well."\\r
881 % (Item.TokenValue, Item.TokenSpaceGuidCName, Item.TokenCName, Package),\r
882 ExtraData=None\r
883 )\r
884 Count += 1\r
885 ## Generate fds command\r
886 @property\r
887 def GenFdsCommand(self):\r
888 return (GenMake.TopLevelMakefile(self)._TEMPLATE_.Replace(GenMake.TopLevelMakefile(self)._TemplateDict)).strip()\r
889\r
890 @property\r
891 def GenFdsCommandDict(self):\r
892 FdsCommandDict = {}\r
893 LogLevel = EdkLogger.GetLevel()\r
894 if LogLevel == EdkLogger.VERBOSE:\r
895 FdsCommandDict["verbose"] = True\r
896 elif LogLevel <= EdkLogger.DEBUG_9:\r
897 FdsCommandDict["debug"] = LogLevel - 1\r
898 elif LogLevel == EdkLogger.QUIET:\r
899 FdsCommandDict["quiet"] = True\r
900\r
7809492c 901 FdsCommandDict["GenfdsMultiThread"] = GlobalData.gEnableGenfdsMultiThread\r
e8449e1d
FB		 902 if GlobalData.gIgnoreSource:\r
903 FdsCommandDict["IgnoreSources"] = True\r
904\r
905 FdsCommandDict["OptionPcd"] = []\r
906 for pcd in GlobalData.BuildOptionPcd:\r
907 if pcd[2]:\r
908 pcdname = '.'.join(pcd[0:3])\r
909 else:\r
910 pcdname = '.'.join(pcd[0:2])\r
911 if pcd[3].startswith('{'):\r
912 FdsCommandDict["OptionPcd"].append(pcdname + '=' + 'H' + '"' + pcd[3] + '"')\r
913 else:\r
914 FdsCommandDict["OptionPcd"].append(pcdname + '=' + pcd[3])\r
915\r
916 MacroList = []\r
917 # macros passed to GenFds\r
918 MacroDict = {}\r
919 MacroDict.update(GlobalData.gGlobalDefines)\r
920 MacroDict.update(GlobalData.gCommandLineDefines)\r
921 for MacroName in MacroDict:\r
922 if MacroDict[MacroName] != "":\r
923 MacroList.append('"%s=%s"' % (MacroName, MacroDict[MacroName].replace('\\', '\\\\')))\r
924 else:\r
925 MacroList.append('"%s"' % MacroName)\r
926 FdsCommandDict["macro"] = MacroList\r
927\r
928 FdsCommandDict["fdf_file"] = [self.FdfFile]\r
929 FdsCommandDict["build_target"] = self.BuildTarget\r
930 FdsCommandDict["toolchain_tag"] = self.ToolChain\r
931 FdsCommandDict["active_platform"] = str(self)\r
932\r
933 FdsCommandDict["conf_directory"] = GlobalData.gConfDirectory\r
934 FdsCommandDict["build_architecture_list"] = ','.join(self.ArchList)\r
935 FdsCommandDict["platform_build_directory"] = self.BuildDir\r
936\r
937 FdsCommandDict["fd"] = self.FdTargetList\r
938 FdsCommandDict["fv"] = self.FvTargetList\r
939 FdsCommandDict["cap"] = self.CapTargetList\r
940 return FdsCommandDict\r
941\r
942 ## Create makefile for the platform and modules in it\r
943 #\r
944 # @param CreateDepsMakeFile Flag indicating if the makefile for\r
945 # modules will be created as well\r
946 #\r
947 def CreateMakeFile(self, CreateDepsMakeFile=False):\r
948 if not CreateDepsMakeFile:\r
949 return\r
950 for Pa in self.AutoGenObjectList:\r
673d09a2 951 Pa.CreateMakeFile(CreateDepsMakeFile)\r
e8449e1d
FB		 952\r
953 ## Create autogen code for platform and modules\r
954 #\r
955 # Since there's no autogen code for platform, this method will do nothing\r
956 # if CreateModuleCodeFile is set to False.\r
957 #\r
958 # @param CreateDepsCodeFile Flag indicating if creating module's\r
959 # autogen code file or not\r
960 #\r
961 def CreateCodeFile(self, CreateDepsCodeFile=False):\r
962 if not CreateDepsCodeFile:\r
963 return\r
964 for Pa in self.AutoGenObjectList:\r
673d09a2 965 Pa.CreateCodeFile(CreateDepsCodeFile)\r
e8449e1d
FB		 966\r
967 ## Create AsBuilt INF file the platform\r
968 #\r
969 def CreateAsBuiltInf(self):\r
970 return\r
971\r
EFI Development Kit II mirror for PVE