]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/GenFds/GenFdsGlobalVariable.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
BaseTools: Cleanup unneeded code
[mirror_edk2.git] / BaseTools / Source / Python / GenFds / GenFdsGlobalVariable.py
... / ...
CommitLineData
1## @file\r
2# Global variables for GenFds\r
3#\r
4# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
5#\r
6# This program and the accompanying materials\r
7# are licensed and made available under the terms and conditions of the BSD License\r
8# which accompanies this distribution. The full text of the license may be found at\r
9# http://opensource.org/licenses/bsd-license.php\r
10#\r
11# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
12# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
13#\r
14\r
15##\r
16# Import Modules\r
17#\r
18import Common.LongFilePathOs as os\r
19import sys\r
20import subprocess\r
21import struct\r
22import array\r
23\r
24from Common.BuildToolError import *\r
25from Common import EdkLogger\r
26from Common.Misc import SaveFileOnChange\r
27\r
28from Common.TargetTxtClassObject import TargetTxtClassObject\r
29from Common.ToolDefClassObject import ToolDefClassObject\r
30from AutoGen.BuildEngine import BuildRule\r
31import Common.DataType as DataType\r
32from Common.Misc import PathClass\r
33from Common.LongFilePathSupport import OpenLongFilePath as open\r
34from Common.MultipleWorkspace import MultipleWorkspace as mws\r
35\r
36## Global variables\r
37#\r
38#\r
39class GenFdsGlobalVariable:\r
40 FvDir = ''\r
41 OutputDirDict = {}\r
42 BinDir = ''\r
43 # will be FvDir + os.sep + 'Ffs'\r
44 FfsDir = ''\r
45 FdfParser = None\r
46 LibDir = ''\r
47 WorkSpace = None\r
48 WorkSpaceDir = ''\r
49 ConfDir = ''\r
50 EdkSourceDir = ''\r
51 OutputDirFromDscDict = {}\r
52 TargetName = ''\r
53 ToolChainTag = ''\r
54 RuleDict = {}\r
55 ArchList = None\r
56 VtfDict = {}\r
57 ActivePlatform = None\r
58 FvAddressFileName = ''\r
59 VerboseMode = False\r
60 DebugLevel = -1\r
61 SharpCounter = 0\r
62 SharpNumberPerLine = 40\r
63 FdfFile = ''\r
64 FdfFileTimeStamp = 0\r
65 FixedLoadAddress = False\r
66 PlatformName = ''\r
67 \r
68 BuildRuleFamily = "MSFT"\r
69 ToolChainFamily = "MSFT"\r
70 __BuildRuleDatabase = None\r
71 GuidToolDefinition = {}\r
72 FfsCmdDict = {}\r
73 SecCmdList = []\r
74 CopyList = []\r
75 ModuleFile = ''\r
76 EnableGenfdsMultiThread = False\r
77 \r
78 #\r
79 # The list whose element are flags to indicate if large FFS or SECTION files exist in FV.\r
80 # At the beginning of each generation of FV, false flag is appended to the list,\r
81 # after the call to GenerateSection returns, check the size of the output file,\r
82 # if it is greater than 0xFFFFFF, the tail flag in list is set to true,\r
83 # and EFI_FIRMWARE_FILE_SYSTEM3_GUID is passed to C GenFv.\r
84 # At the end of generation of FV, pop the flag.\r
85 # List is used as a stack to handle nested FV generation.\r
86 #\r
87 LargeFileInFvFlags = []\r
88 EFI_FIRMWARE_FILE_SYSTEM3_GUID = '5473C07A-3DCB-4dca-BD6F-1E9689E7349A'\r
89 LARGE_FILE_SIZE = 0x1000000\r
90\r
91 SectionHeader = struct.Struct("3B 1B")\r
92 \r
93 ## LoadBuildRule\r
94 #\r
95 @staticmethod\r
96 def __LoadBuildRule():\r
97 if GenFdsGlobalVariable.__BuildRuleDatabase:\r
98 return GenFdsGlobalVariable.__BuildRuleDatabase\r
99 BuildConfigurationFile = os.path.normpath(os.path.join(GenFdsGlobalVariable.ConfDir, "target.txt"))\r
100 TargetTxt = TargetTxtClassObject()\r
101 if os.path.isfile(BuildConfigurationFile) == True:\r
102 TargetTxt.LoadTargetTxtFile(BuildConfigurationFile)\r
103 if DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF in TargetTxt.TargetTxtDictionary:\r
104 BuildRuleFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_BUILD_RULE_CONF]\r
105 if not BuildRuleFile:\r
106 BuildRuleFile = 'Conf/build_rule.txt'\r
107 GenFdsGlobalVariable.__BuildRuleDatabase = BuildRule(BuildRuleFile)\r
108 ToolDefinitionFile = TargetTxt.TargetTxtDictionary[DataType.TAB_TAT_DEFINES_TOOL_CHAIN_CONF]\r
109 if ToolDefinitionFile == '':\r
110 ToolDefinitionFile = "Conf/tools_def.txt"\r
111 if os.path.isfile(ToolDefinitionFile):\r
112 ToolDef = ToolDefClassObject()\r
113 ToolDef.LoadToolDefFile(ToolDefinitionFile)\r
114 ToolDefinition = ToolDef.ToolsDefTxtDatabase\r
115 if DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY in ToolDefinition \\r
116 and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY] \\r
117 and ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]:\r
118 GenFdsGlobalVariable.BuildRuleFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_BUILDRULEFAMILY][GenFdsGlobalVariable.ToolChainTag]\r
119 \r
120 if DataType.TAB_TOD_DEFINES_FAMILY in ToolDefinition \\r
121 and GenFdsGlobalVariable.ToolChainTag in ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY] \\r
122 and ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]:\r
123 GenFdsGlobalVariable.ToolChainFamily = ToolDefinition[DataType.TAB_TOD_DEFINES_FAMILY][GenFdsGlobalVariable.ToolChainTag]\r
124 return GenFdsGlobalVariable.__BuildRuleDatabase\r
125\r
126 ## GetBuildRules\r
127 # @param Inf: object of InfBuildData\r
128 # @param Arch: current arch\r
129 #\r
130 @staticmethod\r
131 def GetBuildRules(Inf, Arch):\r
132 if not Arch:\r
133 Arch = DataType.TAB_COMMON\r
134\r
135 if not Arch in GenFdsGlobalVariable.OutputDirDict:\r
136 return {}\r
137\r
138 BuildRuleDatabase = GenFdsGlobalVariable.__LoadBuildRule()\r
139 if not BuildRuleDatabase:\r
140 return {}\r
141\r
142 PathClassObj = PathClass(Inf.MetaFile.File,\r
143 GenFdsGlobalVariable.WorkSpaceDir)\r
144 Macro = {}\r
145 Macro["WORKSPACE" ] = GenFdsGlobalVariable.WorkSpaceDir\r
146 Macro["MODULE_NAME" ] = Inf.BaseName\r
147 Macro["MODULE_GUID" ] = Inf.Guid\r
148 Macro["MODULE_VERSION" ] = Inf.Version\r
149 Macro["MODULE_TYPE" ] = Inf.ModuleType\r
150 Macro["MODULE_FILE" ] = str(PathClassObj)\r
151 Macro["MODULE_FILE_BASE_NAME" ] = PathClassObj.BaseName\r
152 Macro["MODULE_RELATIVE_DIR" ] = PathClassObj.SubDir\r
153 Macro["MODULE_DIR" ] = PathClassObj.SubDir\r
154\r
155 Macro["BASE_NAME" ] = Inf.BaseName\r
156\r
157 Macro["ARCH" ] = Arch\r
158 Macro["TOOLCHAIN" ] = GenFdsGlobalVariable.ToolChainTag\r
159 Macro["TOOLCHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag\r
160 Macro["TOOL_CHAIN_TAG" ] = GenFdsGlobalVariable.ToolChainTag\r
161 Macro["TARGET" ] = GenFdsGlobalVariable.TargetName\r
162\r
163 Macro["BUILD_DIR" ] = GenFdsGlobalVariable.OutputDirDict[Arch]\r
164 Macro["BIN_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)\r
165 Macro["LIB_DIR" ] = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch], Arch)\r
166 BuildDir = os.path.join(\r
167 GenFdsGlobalVariable.OutputDirDict[Arch],\r
168 Arch,\r
169 PathClassObj.SubDir,\r
170 PathClassObj.BaseName\r
171 )\r
172 Macro["MODULE_BUILD_DIR" ] = BuildDir\r
173 Macro["OUTPUT_DIR" ] = os.path.join(BuildDir, "OUTPUT")\r
174 Macro["DEBUG_DIR" ] = os.path.join(BuildDir, "DEBUG")\r
175\r
176 BuildRules = {}\r
177 for Type in BuildRuleDatabase.FileTypeList:\r
178 #first try getting build rule by BuildRuleFamily\r
179 RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.BuildRuleFamily]\r
180 if not RuleObject:\r
181 # build type is always module type, but ...\r
182 if Inf.ModuleType != Inf.BuildType:\r
183 RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.BuildRuleFamily]\r
184 #second try getting build rule by ToolChainFamily\r
185 if not RuleObject:\r
186 RuleObject = BuildRuleDatabase[Type, Inf.BuildType, Arch, GenFdsGlobalVariable.ToolChainFamily]\r
187 if not RuleObject:\r
188 # build type is always module type, but ...\r
189 if Inf.ModuleType != Inf.BuildType:\r
190 RuleObject = BuildRuleDatabase[Type, Inf.ModuleType, Arch, GenFdsGlobalVariable.ToolChainFamily]\r
191 if not RuleObject:\r
192 continue\r
193 RuleObject = RuleObject.Instantiate(Macro)\r
194 BuildRules[Type] = RuleObject\r
195 for Ext in RuleObject.SourceFileExtList:\r
196 BuildRules[Ext] = RuleObject\r
197 return BuildRules\r
198\r
199 ## GetModuleCodaTargetList\r
200 #\r
201 # @param Inf: object of InfBuildData\r
202 # @param Arch: current arch\r
203 #\r
204 @staticmethod\r
205 def GetModuleCodaTargetList(Inf, Arch):\r
206 BuildRules = GenFdsGlobalVariable.GetBuildRules(Inf, Arch)\r
207 if not BuildRules:\r
208 return []\r
209\r
210 TargetList = set()\r
211 FileList = []\r
212\r
213 if not Inf.IsBinaryModule:\r
214 for File in Inf.Sources:\r
215 if File.TagName in ("", "*", GenFdsGlobalVariable.ToolChainTag) and \\r
216 File.ToolChainFamily in ("", "*", GenFdsGlobalVariable.ToolChainFamily):\r
217 FileList.append((File, DataType.TAB_UNKNOWN_FILE))\r
218\r
219 for File in Inf.Binaries:\r
220 if File.Target in [DataType.TAB_COMMON, '*', GenFdsGlobalVariable.TargetName]:\r
221 FileList.append((File, File.Type))\r
222\r
223 for File, FileType in FileList:\r
224 LastTarget = None\r
225 RuleChain = []\r
226 SourceList = [File]\r
227 Index = 0\r
228 while Index < len(SourceList):\r
229 Source = SourceList[Index]\r
230 Index = Index + 1\r
231 \r
232 if File.IsBinary and File == Source and Inf.Binaries is not None and File in Inf.Binaries:\r
233 # Skip all files that are not binary libraries\r
234 if not Inf.LibraryClass:\r
235 continue \r
236 RuleObject = BuildRules[DataType.TAB_DEFAULT_BINARY_FILE]\r
237 elif FileType in BuildRules:\r
238 RuleObject = BuildRules[FileType]\r
239 elif Source.Ext in BuildRules:\r
240 RuleObject = BuildRules[Source.Ext]\r
241 else:\r
242 # stop at no more rules\r
243 if LastTarget:\r
244 TargetList.add(str(LastTarget))\r
245 break\r
246 \r
247 FileType = RuleObject.SourceFileType\r
248 \r
249 # stop at STATIC_LIBRARY for library\r
250 if Inf.LibraryClass and FileType == DataType.TAB_STATIC_LIBRARY:\r
251 if LastTarget:\r
252 TargetList.add(str(LastTarget))\r
253 break\r
254 \r
255 Target = RuleObject.Apply(Source)\r
256 if not Target:\r
257 if LastTarget:\r
258 TargetList.add(str(LastTarget))\r
259 break\r
260 elif not Target.Outputs:\r
261 # Only do build for target with outputs\r
262 TargetList.add(str(Target))\r
263 \r
264 # to avoid cyclic rule\r
265 if FileType in RuleChain:\r
266 break\r
267 \r
268 RuleChain.append(FileType)\r
269 SourceList.extend(Target.Outputs)\r
270 LastTarget = Target\r
271 FileType = DataType.TAB_UNKNOWN_FILE\r
272 for Cmd in Target.Commands:\r
273 if "$(CP)" == Cmd.split()[0]:\r
274 CpTarget = Cmd.split()[2]\r
275 TargetList.add(CpTarget)\r
276\r
277 return list(TargetList)\r
278\r
279 ## SetDir()\r
280 #\r
281 # @param OutputDir Output directory\r
282 # @param FdfParser FDF contents parser\r
283 # @param Workspace The directory of workspace\r
284 # @param ArchList The Arch list of platform\r
285 #\r
286 def SetDir (OutputDir, FdfParser, WorkSpace, ArchList):\r
287 GenFdsGlobalVariable.VerboseLogger("GenFdsGlobalVariable.OutputDir :%s" % OutputDir)\r
288# GenFdsGlobalVariable.OutputDirDict = OutputDir\r
289 GenFdsGlobalVariable.FdfParser = FdfParser\r
290 GenFdsGlobalVariable.WorkSpace = WorkSpace\r
291 GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], DataType.TAB_FV_DIRECTORY)\r
292 if not os.path.exists(GenFdsGlobalVariable.FvDir) :\r
293 os.makedirs(GenFdsGlobalVariable.FvDir)\r
294 GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')\r
295 if not os.path.exists(GenFdsGlobalVariable.FfsDir) :\r
296 os.makedirs(GenFdsGlobalVariable.FfsDir)\r
297\r
298 T_CHAR_LF = '\n'\r
299 #\r
300 # Create FV Address inf file\r
301 #\r
302 GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')\r
303 FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')\r
304 #\r
305 # Add [Options]\r
306 #\r
307 FvAddressFile.writelines("[options]" + T_CHAR_LF)\r
308 BsAddress = '0'\r
309 for Arch in ArchList:\r
310 if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress:\r
311 BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].BsBaseAddress\r
312 break\r
313\r
314 FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \\r
315 BsAddress + \\r
316 T_CHAR_LF)\r
317\r
318 RtAddress = '0'\r
319 for Arch in ArchList:\r
320 if GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress:\r
321 RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag].RtBaseAddress\r
322\r
323 FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \\r
324 RtAddress + \\r
325 T_CHAR_LF)\r
326\r
327 FvAddressFile.close()\r
328\r
329 def SetEnv(FdfParser, WorkSpace, ArchList, GlobalData):\r
330 GenFdsGlobalVariable.ModuleFile = WorkSpace.ModuleFile\r
331 GenFdsGlobalVariable.FdfParser = FdfParser\r
332 GenFdsGlobalVariable.WorkSpace = WorkSpace.Db\r
333 GenFdsGlobalVariable.ArchList = ArchList\r
334 GenFdsGlobalVariable.ToolChainTag = GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]\r
335 GenFdsGlobalVariable.TargetName = GlobalData.gGlobalDefines["TARGET"]\r
336 GenFdsGlobalVariable.ActivePlatform = GlobalData.gActivePlatform\r
337 GenFdsGlobalVariable.EdkSourceDir = GlobalData.gGlobalDefines["EDK_SOURCE"]\r
338 GenFdsGlobalVariable.ConfDir = GlobalData.gConfDirectory\r
339 GenFdsGlobalVariable.EnableGenfdsMultiThread = GlobalData.gEnableGenfdsMultiThread\r
340 for Arch in ArchList:\r
341 GenFdsGlobalVariable.OutputDirDict[Arch] = os.path.normpath(\r
342 os.path.join(GlobalData.gWorkspace,\r
343 WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,GlobalData.gGlobalDefines['TARGET'],\r
344 GlobalData.gGlobalDefines['TOOLCHAIN']].OutputDirectory,\r
345 GlobalData.gGlobalDefines['TARGET'] +'_' + GlobalData.gGlobalDefines['TOOLCHAIN']))\r
346 GenFdsGlobalVariable.OutputDirFromDscDict[Arch] = os.path.normpath(\r
347 WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,\r
348 GlobalData.gGlobalDefines['TARGET'], GlobalData.gGlobalDefines['TOOLCHAIN']].OutputDirectory)\r
349 GenFdsGlobalVariable.PlatformName = WorkSpace.Db.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,\r
350 GlobalData.gGlobalDefines['TARGET'],\r
351 GlobalData.gGlobalDefines['TOOLCHAIN']].PlatformName\r
352 GenFdsGlobalVariable.FvDir = os.path.join(GenFdsGlobalVariable.OutputDirDict[ArchList[0]], DataType.TAB_FV_DIRECTORY)\r
353 if not os.path.exists(GenFdsGlobalVariable.FvDir):\r
354 os.makedirs(GenFdsGlobalVariable.FvDir)\r
355 GenFdsGlobalVariable.FfsDir = os.path.join(GenFdsGlobalVariable.FvDir, 'Ffs')\r
356 if not os.path.exists(GenFdsGlobalVariable.FfsDir):\r
357 os.makedirs(GenFdsGlobalVariable.FfsDir)\r
358\r
359 T_CHAR_LF = '\n'\r
360 #\r
361 # Create FV Address inf file\r
362 #\r
363 GenFdsGlobalVariable.FvAddressFileName = os.path.join(GenFdsGlobalVariable.FfsDir, 'FvAddress.inf')\r
364 FvAddressFile = open(GenFdsGlobalVariable.FvAddressFileName, 'w')\r
365 #\r
366 # Add [Options]\r
367 #\r
368 FvAddressFile.writelines("[options]" + T_CHAR_LF)\r
369 BsAddress = '0'\r
370 for Arch in ArchList:\r
371 BsAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch,\r
372 GlobalData.gGlobalDefines['TARGET'],\r
373 GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].BsBaseAddress\r
374 if BsAddress:\r
375 break\r
376\r
377 FvAddressFile.writelines("EFI_BOOT_DRIVER_BASE_ADDRESS = " + \\r
378 BsAddress + \\r
379 T_CHAR_LF)\r
380\r
381 RtAddress = '0'\r
382 for Arch in ArchList:\r
383 if GenFdsGlobalVariable.WorkSpace.BuildObject[\r
384 GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'],\r
385 GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress:\r
386 RtAddress = GenFdsGlobalVariable.WorkSpace.BuildObject[\r
387 GenFdsGlobalVariable.ActivePlatform, Arch, GlobalData.gGlobalDefines['TARGET'],\r
388 GlobalData.gGlobalDefines["TOOL_CHAIN_TAG"]].RtBaseAddress\r
389\r
390 FvAddressFile.writelines("EFI_RUNTIME_DRIVER_BASE_ADDRESS = " + \\r
391 RtAddress + \\r
392 T_CHAR_LF)\r
393\r
394 FvAddressFile.close()\r
395\r
396 ## ReplaceWorkspaceMacro()\r
397 #\r
398 # @param String String that may contain macro\r
399 #\r
400 def ReplaceWorkspaceMacro(String):\r
401 String = mws.handleWsMacro(String)\r
402 Str = String.replace('$(WORKSPACE)', GenFdsGlobalVariable.WorkSpaceDir)\r
403 if os.path.exists(Str):\r
404 if not os.path.isabs(Str):\r
405 Str = os.path.abspath(Str)\r
406 else:\r
407 Str = mws.join(GenFdsGlobalVariable.WorkSpaceDir, String)\r
408 return os.path.normpath(Str)\r
409\r
410 ## Check if the input files are newer than output files\r
411 #\r
412 # @param Output Path of output file\r
413 # @param Input Path list of input files\r
414 #\r
415 # @retval True if Output doesn't exist, or any Input is newer\r
416 # @retval False if all Input is older than Output\r
417 #\r
418 @staticmethod\r
419 def NeedsUpdate(Output, Input):\r
420 if not os.path.exists(Output):\r
421 return True\r
422 # always update "Output" if no "Input" given\r
423 if Input is None or len(Input) == 0:\r
424 return True\r
425\r
426 # if fdf file is changed after the 'Output" is generated, update the 'Output'\r
427 OutputTime = os.path.getmtime(Output)\r
428 if GenFdsGlobalVariable.FdfFileTimeStamp > OutputTime:\r
429 return True\r
430\r
431 for F in Input:\r
432 # always update "Output" if any "Input" doesn't exist\r
433 if not os.path.exists(F):\r
434 return True\r
435 # always update "Output" if any "Input" is newer than "Output"\r
436 if os.path.getmtime(F) > OutputTime:\r
437 return True\r
438 return False\r
439\r
440 @staticmethod\r
441 def GenerateSection(Output, Input, Type=None, CompressionType=None, Guid=None,\r
442 GuidHdrLen=None, GuidAttr=[], Ui=None, Ver=None, InputAlign=[], BuildNumber=None, DummyFile=None, IsMakefile=False):\r
443 Cmd = ["GenSec"]\r
444 if Type:\r
445 Cmd += ("-s", Type)\r
446 if CompressionType:\r
447 Cmd += ("-c", CompressionType)\r
448 if Guid is not None:\r
449 Cmd += ("-g", Guid)\r
450 if DummyFile is not None:\r
451 Cmd += ("--dummy", DummyFile)\r
452 if GuidHdrLen:\r
453 Cmd += ("-l", GuidHdrLen)\r
454 #Add each guided attribute\r
455 for Attr in GuidAttr:\r
456 Cmd += ("-r", Attr)\r
457 #Section Align is only for dummy section without section type\r
458 for SecAlign in InputAlign:\r
459 Cmd += ("--sectionalign", SecAlign)\r
460\r
461 CommandFile = Output + '.txt'\r
462 if Ui:\r
463 if IsMakefile:\r
464 if Ui == "$(MODULE_NAME)":\r
465 Cmd += ('-n', Ui)\r
466 else:\r
467 Cmd += ("-n", '"' + Ui + '"')\r
468 Cmd += ("-o", Output)\r
469 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
470 GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())\r
471 else:\r
472 SectionData = array.array('B', [0, 0, 0, 0])\r
473 SectionData.fromstring(Ui.encode("utf_16_le"))\r
474 SectionData.append(0)\r
475 SectionData.append(0)\r
476 Len = len(SectionData)\r
477 GenFdsGlobalVariable.SectionHeader.pack_into(SectionData, 0, Len & 0xff, (Len >> 8) & 0xff, (Len >> 16) & 0xff, 0x15)\r
478 SaveFileOnChange(Output, SectionData.tostring())\r
479\r
480 elif Ver:\r
481 Cmd += ("-n", Ver)\r
482 if BuildNumber:\r
483 Cmd += ("-j", BuildNumber)\r
484 Cmd += ("-o", Output)\r
485\r
486 SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
487 if IsMakefile:\r
488 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
489 GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())\r
490 else:\r
491 if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
492 return\r
493 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")\r
494 else:\r
495 Cmd += ("-o", Output)\r
496 Cmd += Input\r
497\r
498 SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
499 if IsMakefile:\r
500 if ' '.join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
501 GenFdsGlobalVariable.SecCmdList.append(' '.join(Cmd).strip())\r
502 elif GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
503 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
504 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate section")\r
505 if (os.path.getsize(Output) >= GenFdsGlobalVariable.LARGE_FILE_SIZE and\r
506 GenFdsGlobalVariable.LargeFileInFvFlags):\r
507 GenFdsGlobalVariable.LargeFileInFvFlags[-1] = True\r
508\r
509 @staticmethod\r
510 def GetAlignment (AlignString):\r
511 if AlignString is None:\r
512 return 0\r
513 if AlignString in ("1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K"):\r
514 return int (AlignString.rstrip('K')) * 1024\r
515 elif AlignString in ("1M", "2M", "4M", "8M", "16M"):\r
516 return int (AlignString.rstrip('M')) * 1024 * 1024\r
517 else:\r
518 return int (AlignString)\r
519\r
520 @staticmethod\r
521 def GenerateFfs(Output, Input, Type, Guid, Fixed=False, CheckSum=False, Align=None,\r
522 SectionAlign=None, MakefilePath=None):\r
523 Cmd = ["GenFfs", "-t", Type, "-g", Guid]\r
524 mFfsValidAlign = ["0", "8", "16", "128", "512", "1K", "4K", "32K", "64K", "128K", "256K", "512K", "1M", "2M", "4M", "8M", "16M"]\r
525 if Fixed == True:\r
526 Cmd.append("-x")\r
527 if CheckSum:\r
528 Cmd.append("-s")\r
529 if Align:\r
530 if Align not in mFfsValidAlign:\r
531 Align = GenFdsGlobalVariable.GetAlignment (Align)\r
532 for index in range(0, len(mFfsValidAlign) - 1):\r
533 if ((Align > GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index])) and (Align <= GenFdsGlobalVariable.GetAlignment(mFfsValidAlign[index + 1]))):\r
534 break\r
535 Align = mFfsValidAlign[index + 1]\r
536 Cmd += ("-a", Align)\r
537\r
538 Cmd += ("-o", Output)\r
539 for I in range(0, len(Input)):\r
540 Cmd += ("-i", Input[I])\r
541 if SectionAlign and SectionAlign[I]:\r
542 Cmd += ("-n", SectionAlign[I])\r
543\r
544 CommandFile = Output + '.txt'\r
545 SaveFileOnChange(CommandFile, ' '.join(Cmd), False)\r
546\r
547 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
548 if MakefilePath:\r
549 if (tuple(Cmd),tuple(GenFdsGlobalVariable.SecCmdList),tuple(GenFdsGlobalVariable.CopyList)) not in GenFdsGlobalVariable.FfsCmdDict:\r
550 GenFdsGlobalVariable.FfsCmdDict[tuple(Cmd), tuple(GenFdsGlobalVariable.SecCmdList), tuple(GenFdsGlobalVariable.CopyList)] = MakefilePath\r
551 GenFdsGlobalVariable.SecCmdList = []\r
552 GenFdsGlobalVariable.CopyList = []\r
553 else:\r
554 if not GenFdsGlobalVariable.NeedsUpdate(Output, list(Input) + [CommandFile]):\r
555 return\r
556 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FFS")\r
557\r
558 @staticmethod\r
559 def GenerateFirmwareVolume(Output, Input, BaseAddress=None, ForceRebase=None, Capsule=False, Dump=False,\r
560 AddressFile=None, MapFile=None, FfsList=[], FileSystemGuid=None):\r
561 if not GenFdsGlobalVariable.NeedsUpdate(Output, Input+FfsList):\r
562 return\r
563 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
564\r
565 Cmd = ["GenFv"]\r
566 if BaseAddress:\r
567 Cmd += ("-r", BaseAddress)\r
568\r
569 if ForceRebase == False:\r
570 Cmd += ("-F", "FALSE")\r
571 elif ForceRebase == True:\r
572 Cmd += ("-F", "TRUE")\r
573\r
574 if Capsule:\r
575 Cmd.append("-c")\r
576 if Dump:\r
577 Cmd.append("-p")\r
578 if AddressFile:\r
579 Cmd += ("-a", AddressFile)\r
580 if MapFile:\r
581 Cmd += ("-m", MapFile)\r
582 if FileSystemGuid:\r
583 Cmd += ("-g", FileSystemGuid)\r
584 Cmd += ("-o", Output)\r
585 for I in Input:\r
586 Cmd += ("-i", I)\r
587\r
588 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate FV")\r
589\r
590 @staticmethod\r
591 def GenerateVtf(Output, Input, BaseAddress=None, FvSize=None):\r
592 if not GenFdsGlobalVariable.NeedsUpdate(Output, Input):\r
593 return\r
594 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
595\r
596 Cmd = ["GenVtf"]\r
597 if BaseAddress and FvSize \\r
598 and len(BaseAddress) == len(FvSize):\r
599 for I in range(0, len(BaseAddress)):\r
600 Cmd += ("-r", BaseAddress[I], "-s", FvSize[I])\r
601 Cmd += ("-o", Output)\r
602 for F in Input:\r
603 Cmd += ("-f", F)\r
604\r
605 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate VTF")\r
606\r
607 @staticmethod\r
608 def GenerateFirmwareImage(Output, Input, Type="efi", SubType=None, Zero=False,\r
609 Strip=False, Replace=False, TimeStamp=None, Join=False,\r
610 Align=None, Padding=None, Convert=False, IsMakefile=False):\r
611 if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:\r
612 return\r
613 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
614\r
615 Cmd = ["GenFw"]\r
616 if Type.lower() == "te":\r
617 Cmd.append("-t")\r
618 if SubType:\r
619 Cmd += ("-e", SubType)\r
620 if TimeStamp:\r
621 Cmd += ("-s", TimeStamp)\r
622 if Align:\r
623 Cmd += ("-a", Align)\r
624 if Padding:\r
625 Cmd += ("-p", Padding)\r
626 if Zero:\r
627 Cmd.append("-z")\r
628 if Strip:\r
629 Cmd.append("-l")\r
630 if Replace:\r
631 Cmd.append("-r")\r
632 if Join:\r
633 Cmd.append("-j")\r
634 if Convert:\r
635 Cmd.append("-m")\r
636 Cmd += ("-o", Output)\r
637 Cmd += Input\r
638 if IsMakefile:\r
639 if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
640 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())\r
641 else:\r
642 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate firmware image")\r
643\r
644 @staticmethod\r
645 def GenerateOptionRom(Output, EfiInput, BinaryInput, Compress=False, ClassCode=None,\r
646 Revision=None, DeviceId=None, VendorId=None, IsMakefile=False):\r
647 InputList = [] \r
648 Cmd = ["EfiRom"]\r
649 if len(EfiInput) > 0:\r
650 \r
651 if Compress:\r
652 Cmd.append("-ec")\r
653 else:\r
654 Cmd.append("-e")\r
655 \r
656 for EfiFile in EfiInput:\r
657 Cmd.append(EfiFile)\r
658 InputList.append (EfiFile)\r
659 \r
660 if len(BinaryInput) > 0:\r
661 Cmd.append("-b")\r
662 for BinFile in BinaryInput:\r
663 Cmd.append(BinFile)\r
664 InputList.append (BinFile)\r
665\r
666 # Check List\r
667 if not GenFdsGlobalVariable.NeedsUpdate(Output, InputList) and not IsMakefile:\r
668 return\r
669 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, InputList))\r
670 \r
671 if ClassCode is not None:\r
672 Cmd += ("-l", ClassCode)\r
673 if Revision is not None:\r
674 Cmd += ("-r", Revision)\r
675 if DeviceId is not None:\r
676 Cmd += ("-i", DeviceId)\r
677 if VendorId is not None:\r
678 Cmd += ("-f", VendorId)\r
679\r
680 Cmd += ("-o", Output)\r
681 if IsMakefile:\r
682 if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
683 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())\r
684 else:\r
685 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to generate option rom")\r
686\r
687 @staticmethod\r
688 def GuidTool(Output, Input, ToolPath, Options='', returnValue=[], IsMakefile=False):\r
689 if not GenFdsGlobalVariable.NeedsUpdate(Output, Input) and not IsMakefile:\r
690 return\r
691 GenFdsGlobalVariable.DebugLogger(EdkLogger.DEBUG_5, "%s needs update because of newer %s" % (Output, Input))\r
692\r
693 Cmd = [ToolPath, ]\r
694 Cmd += Options.split(' ')\r
695 Cmd += ("-o", Output)\r
696 Cmd += Input\r
697 if IsMakefile:\r
698 if " ".join(Cmd).strip() not in GenFdsGlobalVariable.SecCmdList:\r
699 GenFdsGlobalVariable.SecCmdList.append(" ".join(Cmd).strip())\r
700 else:\r
701 GenFdsGlobalVariable.CallExternalTool(Cmd, "Failed to call " + ToolPath, returnValue)\r
702\r
703 def CallExternalTool (cmd, errorMess, returnValue=[]):\r
704\r
705 if type(cmd) not in (tuple, list):\r
706 GenFdsGlobalVariable.ErrorLogger("ToolError! Invalid parameter type in call to CallExternalTool")\r
707\r
708 if GenFdsGlobalVariable.DebugLevel != -1:\r
709 cmd += ('--debug', str(GenFdsGlobalVariable.DebugLevel))\r
710 GenFdsGlobalVariable.InfLogger (cmd)\r
711\r
712 if GenFdsGlobalVariable.VerboseMode:\r
713 cmd += ('-v',)\r
714 GenFdsGlobalVariable.InfLogger (cmd)\r
715 else:\r
716 sys.stdout.write ('#')\r
717 sys.stdout.flush()\r
718 GenFdsGlobalVariable.SharpCounter = GenFdsGlobalVariable.SharpCounter + 1\r
719 if GenFdsGlobalVariable.SharpCounter % GenFdsGlobalVariable.SharpNumberPerLine == 0:\r
720 sys.stdout.write('\n')\r
721\r
722 try:\r
723 PopenObject = subprocess.Popen(' '.join(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\r
724 except Exception, X:\r
725 EdkLogger.error("GenFds", COMMAND_FAILURE, ExtraData="%s: %s" % (str(X), cmd[0]))\r
726 (out, error) = PopenObject.communicate()\r
727\r
728 while PopenObject.returncode is None :\r
729 PopenObject.wait()\r
730 if returnValue != [] and returnValue[0] != 0:\r
731 #get command return value\r
732 returnValue[0] = PopenObject.returncode\r
733 return\r
734 if PopenObject.returncode != 0 or GenFdsGlobalVariable.VerboseMode or GenFdsGlobalVariable.DebugLevel != -1:\r
735 GenFdsGlobalVariable.InfLogger ("Return Value = %d" % PopenObject.returncode)\r
736 GenFdsGlobalVariable.InfLogger (out)\r
737 GenFdsGlobalVariable.InfLogger (error)\r
738 if PopenObject.returncode != 0:\r
739 print "###", cmd\r
740 EdkLogger.error("GenFds", COMMAND_FAILURE, errorMess)\r
741\r
742 def VerboseLogger (msg):\r
743 EdkLogger.verbose(msg)\r
744\r
745 def InfLogger (msg):\r
746 EdkLogger.info(msg)\r
747\r
748 def ErrorLogger (msg, File=None, Line=None, ExtraData=None):\r
749 EdkLogger.error('GenFds', GENFDS_ERROR, msg, File, Line, ExtraData)\r
750\r
751 def DebugLogger (Level, msg):\r
752 EdkLogger.debug(Level, msg)\r
753\r
754 ## ReplaceWorkspaceMacro()\r
755 #\r
756 # @param Str String that may contain macro\r
757 # @param MacroDict Dictionary that contains macro value pair\r
758 #\r
759 def MacroExtend (Str, MacroDict={}, Arch=DataType.TAB_COMMON):\r
760 if Str is None :\r
761 return None\r
762\r
763 Dict = {'$(WORKSPACE)' : GenFdsGlobalVariable.WorkSpaceDir,\r
764 '$(EDK_SOURCE)' : GenFdsGlobalVariable.EdkSourceDir,\r
765# '$(OUTPUT_DIRECTORY)': GenFdsGlobalVariable.OutputDirFromDsc,\r
766 '$(TARGET)' : GenFdsGlobalVariable.TargetName,\r
767 '$(TOOL_CHAIN_TAG)' : GenFdsGlobalVariable.ToolChainTag,\r
768 '$(SPACE)' : ' '\r
769 }\r
770 OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[GenFdsGlobalVariable.ArchList[0]]\r
771 if Arch != DataType.TAB_COMMON and Arch in GenFdsGlobalVariable.ArchList:\r
772 OutputDir = GenFdsGlobalVariable.OutputDirFromDscDict[Arch]\r
773\r
774 Dict['$(OUTPUT_DIRECTORY)'] = OutputDir\r
775\r
776 if MacroDict is not None and len (MacroDict) != 0:\r
777 Dict.update(MacroDict)\r
778\r
779 for key in Dict:\r
780 if Str.find(key) >= 0 :\r
781 Str = Str.replace (key, Dict[key])\r
782\r
783 if Str.find('$(ARCH)') >= 0:\r
784 if len(GenFdsGlobalVariable.ArchList) == 1:\r
785 Str = Str.replace('$(ARCH)', GenFdsGlobalVariable.ArchList[0])\r
786 else:\r
787 EdkLogger.error("GenFds", GENFDS_ERROR, "No way to determine $(ARCH) for %s" % Str)\r
788\r
789 return Str\r
790\r
791 ## GetPcdValue()\r
792 #\r
793 # @param PcdPattern pattern that labels a PCD.\r
794 #\r
795 def GetPcdValue (PcdPattern):\r
796 if PcdPattern is None :\r
797 return None\r
798 PcdPair = PcdPattern.lstrip('PCD(').rstrip(')').strip().split('.')\r
799 TokenSpace = PcdPair[0]\r
800 TokenCName = PcdPair[1]\r
801\r
802 PcdValue = ''\r
803 for Arch in GenFdsGlobalVariable.ArchList:\r
804 Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
805 PcdDict = Platform.Pcds\r
806 for Key in PcdDict:\r
807 PcdObj = PcdDict[Key]\r
808 if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):\r
809 if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:\r
810 EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)\r
811 if PcdObj.DatumType != DataType.TAB_VOID:\r
812 EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)\r
813 \r
814 PcdValue = PcdObj.DefaultValue\r
815 return PcdValue\r
816\r
817 for Package in GenFdsGlobalVariable.WorkSpace.GetPackageList(GenFdsGlobalVariable.ActivePlatform,\r
818 Arch,\r
819 GenFdsGlobalVariable.TargetName,\r
820 GenFdsGlobalVariable.ToolChainTag):\r
821 PcdDict = Package.Pcds\r
822 for Key in PcdDict:\r
823 PcdObj = PcdDict[Key]\r
824 if (PcdObj.TokenCName == TokenCName) and (PcdObj.TokenSpaceGuidCName == TokenSpace):\r
825 if PcdObj.Type != DataType.TAB_PCDS_FIXED_AT_BUILD:\r
826 EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not FixedAtBuild type." % PcdPattern)\r
827 if PcdObj.DatumType != DataType.TAB_VOID:\r
828 EdkLogger.error("GenFds", GENFDS_ERROR, "%s is not VOID* datum type." % PcdPattern)\r
829 \r
830 PcdValue = PcdObj.DefaultValue\r
831 return PcdValue\r
832\r
833 return PcdValue\r
834\r
835 SetDir = staticmethod(SetDir)\r
836 SetEnv = staticmethod(SetEnv)\r
837 ReplaceWorkspaceMacro = staticmethod(ReplaceWorkspaceMacro)\r
838 CallExternalTool = staticmethod(CallExternalTool)\r
839 VerboseLogger = staticmethod(VerboseLogger)\r
840 InfLogger = staticmethod(InfLogger)\r
841 ErrorLogger = staticmethod(ErrorLogger)\r
842 DebugLogger = staticmethod(DebugLogger)\r
843 MacroExtend = staticmethod (MacroExtend)\r
844 GetPcdValue = staticmethod(GetPcdValue)\r
EFI Development Kit II mirror for PVE