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