]> git.proxmox.com Git - mirror_edk2.git/blame_incremental - BaseTools/Source/Python/GenFds/FfsInfStatement.py
projects / mirror_edk2.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
BaseTools: refactor and remove un-needed use of .keys() on dictionaries
[mirror_edk2.git] / BaseTools / Source / Python / GenFds / FfsInfStatement.py
... / ...
CommitLineData
1## @file\r
2# process FFS generation from INF statement\r
3#\r
4# Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
5# Copyright (c) 2014-2016 Hewlett-Packard Development Company, L.P.<BR>\r
6#\r
7# This program and the accompanying materials\r
8# are licensed and made available under the terms and conditions of the BSD License\r
9# which accompanies this distribution. The full text of the license may be found at\r
10# http://opensource.org/licenses/bsd-license.php\r
11#\r
12# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
13# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
14#\r
15\r
16##\r
17# Import Modules\r
18#\r
19import Rule\r
20import Common.LongFilePathOs as os\r
21import StringIO\r
22from struct import *\r
23from GenFdsGlobalVariable import GenFdsGlobalVariable\r
24import Ffs\r
25import subprocess\r
26import sys\r
27import Section\r
28import RuleSimpleFile\r
29import RuleComplexFile\r
30from CommonDataClass.FdfClass import FfsInfStatementClassObject\r
31from Common.MultipleWorkspace import MultipleWorkspace as mws\r
32from Common.String import *\r
33from Common.Misc import PathClass\r
34from Common.Misc import GuidStructureByteArrayToGuidString\r
35from Common.Misc import ProcessDuplicatedInf\r
36from Common.Misc import GetVariableOffset\r
37from Common import EdkLogger\r
38from Common.BuildToolError import *\r
39from GuidSection import GuidSection\r
40from FvImageSection import FvImageSection\r
41from Common.Misc import PeImageClass\r
42from AutoGen.GenDepex import DependencyExpression\r
43from PatchPcdValue.PatchPcdValue import PatchBinaryFile\r
44from Common.LongFilePathSupport import CopyLongFilePath\r
45from Common.LongFilePathSupport import OpenLongFilePath as open\r
46import Common.GlobalData as GlobalData\r
47from DepexSection import DepexSection\r
48from Common.Misc import SaveFileOnChange\r
49from Common.Expression import *\r
50from Common.DataType import TAB_COMMON\r
51\r
52## generate FFS from INF\r
53#\r
54#\r
55class FfsInfStatement(FfsInfStatementClassObject):\r
56 ## The mapping dictionary from datum type to its maximum number.\r
57 _MAX_SIZE_TYPE = {"BOOLEAN":0x01, "UINT8":0xFF, "UINT16":0xFFFF, "UINT32":0xFFFFFFFF, "UINT64":0xFFFFFFFFFFFFFFFF}\r
58 ## The constructor\r
59 #\r
60 # @param self The object pointer\r
61 #\r
62 def __init__(self):\r
63 FfsInfStatementClassObject.__init__(self)\r
64 self.TargetOverrideList = []\r
65 self.ShadowFromInfFile = None\r
66 self.KeepRelocFromRule = None\r
67 self.InDsc = True\r
68 self.OptRomDefs = {}\r
69 self.PiSpecVersion = '0x00000000'\r
70 self.InfModule = None\r
71 self.FinalTargetSuffixMap = {}\r
72 self.CurrentLineNum = None\r
73 self.CurrentLineContent = None\r
74 self.FileName = None\r
75 self.InfFileName = None\r
76 self.OverrideGuid = None\r
77 self.PatchedBinFile = ''\r
78 self.MacroDict = {}\r
79 self.Depex = False\r
80\r
81 ## GetFinalTargetSuffixMap() method\r
82 #\r
83 # Get final build target list\r
84 def GetFinalTargetSuffixMap(self):\r
85 if not self.InfModule or not self.CurrentArch:\r
86 return []\r
87 if not self.FinalTargetSuffixMap:\r
88 FinalBuildTargetList = GenFdsGlobalVariable.GetModuleCodaTargetList(self.InfModule, self.CurrentArch)\r
89 for File in FinalBuildTargetList:\r
90 self.FinalTargetSuffixMap.setdefault(os.path.splitext(File)[1], []).append(File)\r
91\r
92 # Check if current INF module has DEPEX\r
93 if '.depex' not in self.FinalTargetSuffixMap and self.InfModule.ModuleType != "USER_DEFINED" \\r
94 and not self.InfModule.DxsFile and not self.InfModule.LibraryClass:\r
95 ModuleType = self.InfModule.ModuleType\r
96 PlatformDataBase = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, self.CurrentArch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
97\r
98 if ModuleType != DataType.SUP_MODULE_USER_DEFINED:\r
99 for LibraryClass in PlatformDataBase.LibraryClasses.GetKeys():\r
100 if LibraryClass.startswith("NULL") and PlatformDataBase.LibraryClasses[LibraryClass, ModuleType]:\r
101 self.InfModule.LibraryClasses[LibraryClass] = PlatformDataBase.LibraryClasses[LibraryClass, ModuleType]\r
102\r
103 StrModule = str(self.InfModule)\r
104 PlatformModule = None\r
105 if StrModule in PlatformDataBase.Modules:\r
106 PlatformModule = PlatformDataBase.Modules[StrModule]\r
107 for LibraryClass in PlatformModule.LibraryClasses:\r
108 if LibraryClass.startswith("NULL"):\r
109 self.InfModule.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]\r
110\r
111 DependencyList = [self.InfModule]\r
112 LibraryInstance = {}\r
113 DepexList = []\r
114 while len(DependencyList) > 0:\r
115 Module = DependencyList.pop(0)\r
116 if not Module:\r
117 continue\r
118 for Dep in Module.Depex[self.CurrentArch, ModuleType]:\r
119 if DepexList != []:\r
120 DepexList.append('AND')\r
121 DepexList.append('(')\r
122 DepexList.extend(Dep)\r
123 if DepexList[-1] == 'END': # no need of a END at this time\r
124 DepexList.pop()\r
125 DepexList.append(')')\r
126 if 'BEFORE' in DepexList or 'AFTER' in DepexList:\r
127 break\r
128 for LibName in Module.LibraryClasses:\r
129 if LibName in LibraryInstance:\r
130 continue\r
131 if PlatformModule and LibName in PlatformModule.LibraryClasses:\r
132 LibraryPath = PlatformModule.LibraryClasses[LibName]\r
133 else:\r
134 LibraryPath = PlatformDataBase.LibraryClasses[LibName, ModuleType]\r
135 if not LibraryPath:\r
136 LibraryPath = Module.LibraryClasses[LibName]\r
137 if not LibraryPath:\r
138 continue\r
139 LibraryModule = GenFdsGlobalVariable.WorkSpace.BuildObject[LibraryPath, self.CurrentArch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
140 LibraryInstance[LibName] = LibraryModule\r
141 DependencyList.append(LibraryModule)\r
142 if DepexList:\r
143 Dpx = DependencyExpression(DepexList, ModuleType, True)\r
144 if len(Dpx.PostfixNotation) != 0:\r
145 # It means this module has DEPEX\r
146 self.FinalTargetSuffixMap['.depex'] = [os.path.join(self.EfiOutputPath, self.BaseName) + '.depex']\r
147 return self.FinalTargetSuffixMap\r
148\r
149 ## __InfParse() method\r
150 #\r
151 # Parse inf file to get module information\r
152 #\r
153 # @param self The object pointer\r
154 # @param Dict dictionary contains macro and value pair\r
155 #\r
156 def __InfParse__(self, Dict = {}):\r
157\r
158 GenFdsGlobalVariable.VerboseLogger( " Begine parsing INf file : %s" %self.InfFileName)\r
159\r
160 self.InfFileName = self.InfFileName.replace('$(WORKSPACE)', '')\r
161 if len(self.InfFileName) > 1 and self.InfFileName[0] == '\\' and self.InfFileName[1] == '\\':\r
162 pass\r
163 elif self.InfFileName[0] == '\\' or self.InfFileName[0] == '/' :\r
164 self.InfFileName = self.InfFileName[1:]\r
165\r
166 if self.InfFileName.find('$') == -1:\r
167 InfPath = NormPath(self.InfFileName)\r
168 if not os.path.exists(InfPath):\r
169 InfPath = GenFdsGlobalVariable.ReplaceWorkspaceMacro(InfPath)\r
170 if not os.path.exists(InfPath):\r
171 EdkLogger.error("GenFds", GENFDS_ERROR, "Non-existant Module %s !" % (self.InfFileName))\r
172\r
173 self.CurrentArch = self.GetCurrentArch()\r
174 #\r
175 # Get the InfClass object\r
176 #\r
177\r
178 PathClassObj = PathClass(self.InfFileName, GenFdsGlobalVariable.WorkSpaceDir)\r
179 ErrorCode, ErrorInfo = PathClassObj.Validate(".inf")\r
180 if ErrorCode != 0:\r
181 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
182\r
183 #\r
184 # Cache lower case version of INF path before processing FILE_GUID override\r
185 #\r
186 InfLowerPath = str(PathClassObj).lower()\r
187 if self.OverrideGuid:\r
188 PathClassObj = ProcessDuplicatedInf(PathClassObj, self.OverrideGuid, GenFdsGlobalVariable.WorkSpaceDir)\r
189 if self.CurrentArch is not None:\r
190\r
191 Inf = GenFdsGlobalVariable.WorkSpace.BuildObject[PathClassObj, self.CurrentArch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
192 #\r
193 # Set Ffs BaseName, MdouleGuid, ModuleType, Version, OutputPath\r
194 #\r
195 self.BaseName = Inf.BaseName\r
196 self.ModuleGuid = Inf.Guid\r
197 self.ModuleType = Inf.ModuleType\r
198 if Inf.Specification is not None and 'PI_SPECIFICATION_VERSION' in Inf.Specification:\r
199 self.PiSpecVersion = Inf.Specification['PI_SPECIFICATION_VERSION']\r
200 if Inf.AutoGenVersion < 0x00010005:\r
201 self.ModuleType = Inf.ComponentType\r
202 self.VersionString = Inf.Version\r
203 self.BinFileList = Inf.Binaries\r
204 self.SourceFileList = Inf.Sources\r
205 if self.KeepReloc is None and Inf.Shadow:\r
206 self.ShadowFromInfFile = Inf.Shadow\r
207\r
208 else:\r
209 Inf = GenFdsGlobalVariable.WorkSpace.BuildObject[PathClassObj, TAB_COMMON, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
210 self.BaseName = Inf.BaseName\r
211 self.ModuleGuid = Inf.Guid\r
212 self.ModuleType = Inf.ModuleType\r
213 if Inf.Specification is not None and 'PI_SPECIFICATION_VERSION' in Inf.Specification:\r
214 self.PiSpecVersion = Inf.Specification['PI_SPECIFICATION_VERSION']\r
215 self.VersionString = Inf.Version\r
216 self.BinFileList = Inf.Binaries\r
217 self.SourceFileList = Inf.Sources\r
218 if self.BinFileList == []:\r
219 EdkLogger.error("GenFds", GENFDS_ERROR,\r
220 "INF %s specified in FDF could not be found in build ARCH %s!" \\r
221 % (self.InfFileName, GenFdsGlobalVariable.ArchList))\r
222\r
223 if self.OverrideGuid:\r
224 self.ModuleGuid = self.OverrideGuid\r
225\r
226 if len(self.SourceFileList) != 0 and not self.InDsc:\r
227 EdkLogger.warn("GenFds", GENFDS_ERROR, "Module %s NOT found in DSC file; Is it really a binary module?" % (self.InfFileName))\r
228\r
229 if self.ModuleType == 'SMM_CORE' and int(self.PiSpecVersion, 16) < 0x0001000A:\r
230 EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "SMM_CORE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x0001000A", File=self.InfFileName) \r
231\r
232 if self.ModuleType == 'MM_CORE_STANDALONE' and int(self.PiSpecVersion, 16) < 0x00010032:\r
233 EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "MM_CORE_STANDALONE module type can't be used in the module with PI_SPECIFICATION_VERSION less than 0x00010032", File=self.InfFileName)\r
234\r
235 if Inf._Defs is not None and len(Inf._Defs) > 0:\r
236 self.OptRomDefs.update(Inf._Defs)\r
237\r
238 self.PatchPcds = []\r
239 InfPcds = Inf.Pcds\r
240 Platform = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, self.CurrentArch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
241 FdfPcdDict = GenFdsGlobalVariable.FdfParser.Profile.PcdDict\r
242 PlatformPcds = Platform.Pcds\r
243\r
244 # Workaround here: both build and GenFds tool convert the workspace path to lower case\r
245 # But INF file path in FDF and DSC file may have real case characters.\r
246 # Try to convert the path to lower case to see if PCDs value are override by DSC.\r
247 DscModules = {}\r
248 for DscModule in Platform.Modules:\r
249 DscModules[str(DscModule).lower()] = Platform.Modules[DscModule]\r
250 for PcdKey in InfPcds:\r
251 Pcd = InfPcds[PcdKey]\r
252 if not hasattr(Pcd, 'Offset'):\r
253 continue\r
254 if Pcd.Type != 'PatchableInModule':\r
255 continue\r
256 # Override Patchable PCD value by the value from DSC\r
257 PatchPcd = None\r
258 if InfLowerPath in DscModules and PcdKey in DscModules[InfLowerPath].Pcds:\r
259 PatchPcd = DscModules[InfLowerPath].Pcds[PcdKey]\r
260 elif PcdKey in Platform.Pcds:\r
261 PatchPcd = Platform.Pcds[PcdKey]\r
262 DscOverride = False\r
263 if PatchPcd and Pcd.Type == PatchPcd.Type:\r
264 DefaultValue = PatchPcd.DefaultValue\r
265 DscOverride = True\r
266\r
267 # Override Patchable PCD value by the value from FDF\r
268 FdfOverride = False\r
269 if PcdKey in FdfPcdDict:\r
270 DefaultValue = FdfPcdDict[PcdKey]\r
271 FdfOverride = True\r
272\r
273 # Override Patchable PCD value by the value from Build Option\r
274 BuildOptionOverride = False\r
275 if GlobalData.BuildOptionPcd:\r
276 for pcd in GlobalData.BuildOptionPcd:\r
277 if PcdKey == (pcd[1], pcd[0]):\r
278 if pcd[2]:\r
279 continue\r
280 DefaultValue = pcd[3]\r
281 BuildOptionOverride = True\r
282 break\r
283\r
284 if not DscOverride and not FdfOverride and not BuildOptionOverride:\r
285 continue\r
286\r
287 # Support Flexible PCD format\r
288 if DefaultValue:\r
289 try:\r
290 DefaultValue = ValueExpressionEx(DefaultValue, Pcd.DatumType, Platform._GuidDict)(True)\r
291 except BadExpression:\r
292 EdkLogger.error("GenFds", GENFDS_ERROR, 'PCD [%s.%s] Value "%s"' %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName, DefaultValue), File=self.InfFileName)\r
293\r
294 if Pcd.InfDefaultValue:\r
295 try:\r
296 Pcd.InfDefaultValue = ValueExpressionEx(Pcd.InfDefaultValue, Pcd.DatumType, Platform._GuidDict)(True)\r
297 except BadExpression:\r
298 EdkLogger.error("GenFds", GENFDS_ERROR, 'PCD [%s.%s] Value "%s"' %(Pcd.TokenSpaceGuidCName, Pcd.TokenCName, Pcd.DefaultValue),File=self.InfFileName)\r
299\r
300 # Check value, if value are equal, no need to patch\r
301 if Pcd.DatumType == "VOID*":\r
302 if Pcd.InfDefaultValue == DefaultValue or DefaultValue in [None, '']:\r
303 continue\r
304 # Get the string size from FDF or DSC\r
305 if DefaultValue[0] == 'L':\r
306 # Remove L"", but the '\0' must be appended\r
307 MaxDatumSize = str((len(DefaultValue) - 2) * 2)\r
308 elif DefaultValue[0] == '{':\r
309 MaxDatumSize = str(len(DefaultValue.split(',')))\r
310 else:\r
311 MaxDatumSize = str(len(DefaultValue) - 1)\r
312 if DscOverride:\r
313 Pcd.MaxDatumSize = PatchPcd.MaxDatumSize\r
314 # If no defined the maximum size in DSC, try to get current size from INF\r
315 if Pcd.MaxDatumSize in ['', None]:\r
316 Pcd.MaxDatumSize = str(len(Pcd.InfDefaultValue.split(',')))\r
317 else:\r
318 Base1 = Base2 = 10\r
319 if Pcd.InfDefaultValue.upper().startswith('0X'):\r
320 Base1 = 16\r
321 if DefaultValue.upper().startswith('0X'):\r
322 Base2 = 16\r
323 try:\r
324 PcdValueInImg = int(Pcd.InfDefaultValue, Base1)\r
325 PcdValueInDscOrFdf = int(DefaultValue, Base2)\r
326 if PcdValueInImg == PcdValueInDscOrFdf:\r
327 continue\r
328 except:\r
329 continue\r
330 # Check the Pcd size and data type\r
331 if Pcd.DatumType == "VOID*":\r
332 if int(MaxDatumSize) > int(Pcd.MaxDatumSize):\r
333 EdkLogger.error("GenFds", GENFDS_ERROR, "The size of VOID* type PCD '%s.%s' exceeds its maximum size %d bytes." \\r
334 % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName, int(MaxDatumSize) - int(Pcd.MaxDatumSize)))\r
335 else:\r
336 if PcdValueInDscOrFdf > FfsInfStatement._MAX_SIZE_TYPE[Pcd.DatumType] \\r
337 or PcdValueInImg > FfsInfStatement._MAX_SIZE_TYPE[Pcd.DatumType]:\r
338 EdkLogger.error("GenFds", GENFDS_ERROR, "The size of %s type PCD '%s.%s' doesn't match its data type." \\r
339 % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
340 self.PatchPcds.append((Pcd, DefaultValue))\r
341\r
342 self.InfModule = Inf\r
343 self.PcdIsDriver = Inf.PcdIsDriver\r
344 self.IsBinaryModule = Inf.IsBinaryModule\r
345 Inf._GetDepex()\r
346 Inf._GetDepexExpression()\r
347 if len(Inf._Depex.data) > 0 and len(Inf._DepexExpression.data) > 0:\r
348 self.Depex = True\r
349\r
350 GenFdsGlobalVariable.VerboseLogger("BaseName : %s" % self.BaseName)\r
351 GenFdsGlobalVariable.VerboseLogger("ModuleGuid : %s" % self.ModuleGuid)\r
352 GenFdsGlobalVariable.VerboseLogger("ModuleType : %s" % self.ModuleType)\r
353 GenFdsGlobalVariable.VerboseLogger("VersionString : %s" % self.VersionString)\r
354 GenFdsGlobalVariable.VerboseLogger("InfFileName :%s" % self.InfFileName)\r
355\r
356 #\r
357 # Set OutputPath = ${WorkSpace}\Build\Fv\Ffs\${ModuleGuid}+ ${MdouleName}\\r
358 #\r
359\r
360 self.OutputPath = os.path.join(GenFdsGlobalVariable.FfsDir, \\r
361 self.ModuleGuid + self.BaseName)\r
362 if not os.path.exists(self.OutputPath) :\r
363 os.makedirs(self.OutputPath)\r
364\r
365 self.EfiOutputPath, self.EfiDebugPath = self.__GetEFIOutPutPath__()\r
366 GenFdsGlobalVariable.VerboseLogger( "ModuelEFIPath: " + self.EfiOutputPath)\r
367\r
368 ## PatchEfiFile\r
369 #\r
370 # Patch EFI file with patch PCD\r
371 #\r
372 # @param EfiFile: EFI file needs to be patched.\r
373 # @retval: Full path of patched EFI file: self.OutputPath + EfiFile base name\r
374 # If passed in file does not end with efi, return as is\r
375 #\r
376 def PatchEfiFile(self, EfiFile, FileType):\r
377 #\r
378 # If the module does not have any patches, then return path to input file\r
379 # \r
380 if not self.PatchPcds:\r
381 return EfiFile\r
382\r
383 #\r
384 # Only patch file if FileType is PE32 or ModuleType is USER_DEFINED\r
385 # \r
386 if FileType != 'PE32' and self.ModuleType != "USER_DEFINED":\r
387 return EfiFile\r
388\r
389 #\r
390 # Generate path to patched output file\r
391 #\r
392 Basename = os.path.basename(EfiFile)\r
393 Output = os.path.normpath (os.path.join(self.OutputPath, Basename))\r
394\r
395 #\r
396 # If this file has already been patched, then return the path to the patched file\r
397 #\r
398 if self.PatchedBinFile == Output:\r
399 return Output\r
400\r
401 #\r
402 # If a different file from the same module has already been patched, then generate an error\r
403 # \r
404 if self.PatchedBinFile:\r
405 EdkLogger.error("GenFds", GENFDS_ERROR,\r
406 'Only one binary file can be patched:\n'\r
407 ' a binary file has been patched: %s\n'\r
408 ' current file: %s' % (self.PatchedBinFile, EfiFile),\r
409 File=self.InfFileName)\r
410\r
411 #\r
412 # Copy unpatched file contents to output file location to perform patching\r
413 # \r
414 CopyLongFilePath(EfiFile, Output)\r
415\r
416 #\r
417 # Apply patches to patched output file\r
418 # \r
419 for Pcd, Value in self.PatchPcds:\r
420 RetVal, RetStr = PatchBinaryFile(Output, int(Pcd.Offset, 0), Pcd.DatumType, Value, Pcd.MaxDatumSize)\r
421 if RetVal:\r
422 EdkLogger.error("GenFds", GENFDS_ERROR, RetStr, File=self.InfFileName)\r
423\r
424 #\r
425 # Save the path of the patched output file\r
426 # \r
427 self.PatchedBinFile = Output\r
428\r
429 #\r
430 # Return path to patched output file\r
431 # \r
432 return Output\r
433\r
434 ## GenFfs() method\r
435 #\r
436 # Generate FFS\r
437 #\r
438 # @param self The object pointer\r
439 # @param Dict dictionary contains macro and value pair\r
440 # @param FvChildAddr Array of the inside FvImage base address\r
441 # @param FvParentAddr Parent Fv base address\r
442 # @retval string Generated FFS file name\r
443 #\r
444 def GenFfs(self, Dict = {}, FvChildAddr = [], FvParentAddr=None, IsMakefile=False, FvName=None):\r
445 #\r
446 # Parse Inf file get Module related information\r
447 #\r
448\r
449 self.__InfParse__(Dict)\r
450 Arch = self.GetCurrentArch()\r
451 SrcFile = mws.join( GenFdsGlobalVariable.WorkSpaceDir , self.InfFileName);\r
452 DestFile = os.path.join( self.OutputPath, self.ModuleGuid + '.ffs')\r
453 \r
454 SrcFileDir = "."\r
455 SrcPath = os.path.dirname(SrcFile)\r
456 SrcFileName = os.path.basename(SrcFile)\r
457 SrcFileBase, SrcFileExt = os.path.splitext(SrcFileName) \r
458 DestPath = os.path.dirname(DestFile)\r
459 DestFileName = os.path.basename(DestFile)\r
460 DestFileBase, DestFileExt = os.path.splitext(DestFileName) \r
461 self.MacroDict = {\r
462 # source file\r
463 "${src}" : SrcFile,\r
464 "${s_path}" : SrcPath,\r
465 "${s_dir}" : SrcFileDir,\r
466 "${s_name}" : SrcFileName,\r
467 "${s_base}" : SrcFileBase,\r
468 "${s_ext}" : SrcFileExt,\r
469 # destination file\r
470 "${dst}" : DestFile,\r
471 "${d_path}" : DestPath,\r
472 "${d_name}" : DestFileName,\r
473 "${d_base}" : DestFileBase,\r
474 "${d_ext}" : DestFileExt\r
475 }\r
476 #\r
477 # Allow binary type module not specify override rule in FDF file.\r
478 # \r
479 if len(self.BinFileList) > 0:\r
480 if self.Rule is None or self.Rule == "":\r
481 self.Rule = "BINARY"\r
482\r
483 if not IsMakefile and GenFdsGlobalVariable.EnableGenfdsMultiThread and self.Rule != 'BINARY':\r
484 IsMakefile = True\r
485 #\r
486 # Get the rule of how to generate Ffs file\r
487 #\r
488 Rule = self.__GetRule__()\r
489 GenFdsGlobalVariable.VerboseLogger( "Packing binaries from inf file : %s" %self.InfFileName)\r
490 #\r
491 # Convert Fv File Type for PI1.1 SMM driver.\r
492 #\r
493 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) >= 0x0001000A:\r
494 if Rule.FvFileType == 'DRIVER':\r
495 Rule.FvFileType = 'SMM'\r
496 #\r
497 # Framework SMM Driver has no SMM FV file type\r
498 #\r
499 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) < 0x0001000A:\r
500 if Rule.FvFileType == 'SMM' or Rule.FvFileType == 'SMM_CORE':\r
501 EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Framework SMM module doesn't support SMM or SMM_CORE FV file type", File=self.InfFileName)\r
502 #\r
503 # For the rule only has simpleFile\r
504 #\r
505 MakefilePath = None\r
506 if self.IsBinaryModule:\r
507 IsMakefile = False\r
508 if IsMakefile:\r
509 MakefilePath = self.InfFileName, Arch\r
510 if isinstance (Rule, RuleSimpleFile.RuleSimpleFile):\r
511 SectionOutputList = self.__GenSimpleFileSection__(Rule, IsMakefile=IsMakefile)\r
512 FfsOutput = self.__GenSimpleFileFfs__(Rule, SectionOutputList, MakefilePath=MakefilePath)\r
513 return FfsOutput\r
514 #\r
515 # For Rule has ComplexFile\r
516 #\r
517 elif isinstance(Rule, RuleComplexFile.RuleComplexFile):\r
518 InputSectList, InputSectAlignments = self.__GenComplexFileSection__(Rule, FvChildAddr, FvParentAddr, IsMakefile=IsMakefile)\r
519 FfsOutput = self.__GenComplexFileFfs__(Rule, InputSectList, InputSectAlignments, MakefilePath=MakefilePath)\r
520 return FfsOutput\r
521\r
522 ## __ExtendMacro__() method\r
523 #\r
524 # Replace macro with its value\r
525 #\r
526 # @param self The object pointer\r
527 # @param String The string to be replaced\r
528 # @retval string Macro replaced string\r
529 #\r
530 def __ExtendMacro__ (self, String):\r
531 MacroDict = {\r
532 '$(INF_OUTPUT)' : self.EfiOutputPath,\r
533 '$(MODULE_NAME)' : self.BaseName,\r
534 '$(BUILD_NUMBER)': self.BuildNum,\r
535 '$(INF_VERSION)' : self.VersionString,\r
536 '$(NAMED_GUID)' : self.ModuleGuid\r
537 }\r
538 String = GenFdsGlobalVariable.MacroExtend(String, MacroDict)\r
539 String = GenFdsGlobalVariable.MacroExtend(String, self.MacroDict) \r
540 return String\r
541\r
542 ## __GetRule__() method\r
543 #\r
544 # Get correct rule for generating FFS for this INF\r
545 #\r
546 # @param self The object pointer\r
547 # @retval Rule Rule object\r
548 #\r
549 def __GetRule__ (self) :\r
550 CurrentArchList = []\r
551 if self.CurrentArch is None:\r
552 CurrentArchList = ['common']\r
553 else:\r
554 CurrentArchList.append(self.CurrentArch)\r
555\r
556 for CurrentArch in CurrentArchList:\r
557 RuleName = 'RULE' + \\r
558 '.' + \\r
559 CurrentArch.upper() + \\r
560 '.' + \\r
561 self.ModuleType.upper()\r
562 if self.Rule is not None:\r
563 RuleName = RuleName + \\r
564 '.' + \\r
565 self.Rule.upper()\r
566\r
567 Rule = GenFdsGlobalVariable.FdfParser.Profile.RuleDict.get(RuleName)\r
568 if Rule is not None:\r
569 GenFdsGlobalVariable.VerboseLogger ("Want To Find Rule Name is : " + RuleName)\r
570 return Rule\r
571\r
572 RuleName = 'RULE' + \\r
573 '.' + \\r
574 TAB_COMMON + \\r
575 '.' + \\r
576 self.ModuleType.upper()\r
577\r
578 if self.Rule is not None:\r
579 RuleName = RuleName + \\r
580 '.' + \\r
581 self.Rule.upper()\r
582\r
583 GenFdsGlobalVariable.VerboseLogger ('Trying to apply common rule %s for INF %s' % (RuleName, self.InfFileName))\r
584\r
585 Rule = GenFdsGlobalVariable.FdfParser.Profile.RuleDict.get(RuleName)\r
586 if Rule is not None:\r
587 GenFdsGlobalVariable.VerboseLogger ("Want To Find Rule Name is : " + RuleName)\r
588 return Rule\r
589\r
590 if Rule is None :\r
591 EdkLogger.error("GenFds", GENFDS_ERROR, 'Don\'t Find common rule %s for INF %s' \\r
592 % (RuleName, self.InfFileName))\r
593\r
594 ## __GetPlatformArchList__() method\r
595 #\r
596 # Get Arch list this INF built under\r
597 #\r
598 # @param self The object pointer\r
599 # @retval list Arch list\r
600 #\r
601 def __GetPlatformArchList__(self):\r
602\r
603 InfFileKey = os.path.normpath(mws.join(GenFdsGlobalVariable.WorkSpaceDir, self.InfFileName))\r
604 DscArchList = []\r
605 for Arch in GenFdsGlobalVariable.ArchList :\r
606 PlatformDataBase = GenFdsGlobalVariable.WorkSpace.BuildObject[GenFdsGlobalVariable.ActivePlatform, Arch, GenFdsGlobalVariable.TargetName, GenFdsGlobalVariable.ToolChainTag]\r
607 if PlatformDataBase is not None:\r
608 if InfFileKey in PlatformDataBase.Modules:\r
609 DscArchList.append (Arch)\r
610 else:\r
611 #\r
612 # BaseTools support build same module more than once, the module path with FILE_GUID overridden has\r
613 # the file name FILE_GUIDmodule.inf, then PlatformDataBase.Modules use FILE_GUIDmodule.inf as key,\r
614 # but the path (self.MetaFile.Path) is the real path\r
615 #\r
616 for key in PlatformDataBase.Modules:\r
617 if InfFileKey == str((PlatformDataBase.Modules[key]).MetaFile.Path):\r
618 DscArchList.append (Arch)\r
619 break\r
620\r
621 return DscArchList\r
622\r
623 ## GetCurrentArch() method\r
624 #\r
625 # Get Arch list of the module from this INF is to be placed into flash\r
626 #\r
627 # @param self The object pointer\r
628 # @retval list Arch list\r
629 #\r
630 def GetCurrentArch(self) :\r
631\r
632 TargetArchList = GenFdsGlobalVariable.ArchList\r
633\r
634 PlatformArchList = self.__GetPlatformArchList__()\r
635\r
636 CurArchList = TargetArchList\r
637 if PlatformArchList != []:\r
638 CurArchList = list(set (TargetArchList) & set (PlatformArchList))\r
639 GenFdsGlobalVariable.VerboseLogger ("Valid target architecture(s) is : " + " ".join(CurArchList))\r
640\r
641 ArchList = []\r
642 if self.KeyStringList != []:\r
643 for Key in self.KeyStringList:\r
644 Key = GenFdsGlobalVariable.MacroExtend(Key)\r
645 Target, Tag, Arch = Key.split('_')\r
646 if Arch in CurArchList:\r
647 ArchList.append(Arch)\r
648 if Target not in self.TargetOverrideList:\r
649 self.TargetOverrideList.append(Target)\r
650 else:\r
651 ArchList = CurArchList\r
652\r
653 UseArchList = TargetArchList\r
654 if self.UseArch is not None:\r
655 UseArchList = []\r
656 UseArchList.append(self.UseArch)\r
657 ArchList = list(set (UseArchList) & set (ArchList))\r
658\r
659 self.InfFileName = NormPath(self.InfFileName)\r
660 if len(PlatformArchList) == 0:\r
661 self.InDsc = False\r
662 PathClassObj = PathClass(self.InfFileName, GenFdsGlobalVariable.WorkSpaceDir)\r
663 ErrorCode, ErrorInfo = PathClassObj.Validate(".inf")\r
664 if ErrorCode != 0:\r
665 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
666 if len(ArchList) == 1:\r
667 Arch = ArchList[0]\r
668 return Arch\r
669 elif len(ArchList) > 1:\r
670 if len(PlatformArchList) == 0:\r
671 EdkLogger.error("GenFds", GENFDS_ERROR, "GenFds command line option has multiple ARCHs %s. Not able to determine which ARCH is valid for Module %s !" % (str(ArchList), self.InfFileName))\r
672 else:\r
673 EdkLogger.error("GenFds", GENFDS_ERROR, "Module built under multiple ARCHs %s. Not able to determine which output to put into flash for Module %s !" % (str(ArchList), self.InfFileName))\r
674 else:\r
675 EdkLogger.error("GenFds", GENFDS_ERROR, "Module %s appears under ARCH %s in platform %s, but current deduced ARCH is %s, so NO build output could be put into flash." \\r
676 % (self.InfFileName, str(PlatformArchList), GenFdsGlobalVariable.ActivePlatform, str(set (UseArchList) & set (TargetArchList))))\r
677\r
678 ## __GetEFIOutPutPath__() method\r
679 #\r
680 # Get the output path for generated files\r
681 #\r
682 # @param self The object pointer\r
683 # @retval string Path that output files from this INF go to\r
684 #\r
685 def __GetEFIOutPutPath__(self):\r
686 Arch = ''\r
687 OutputPath = ''\r
688 DebugPath = ''\r
689 (ModulePath, FileName) = os.path.split(self.InfFileName)\r
690 Index = FileName.rfind('.')\r
691 FileName = FileName[0:Index]\r
692 if self.OverrideGuid:\r
693 FileName = self.OverrideGuid\r
694 Arch = "NoneArch"\r
695 if self.CurrentArch is not None:\r
696 Arch = self.CurrentArch\r
697\r
698 OutputPath = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch],\r
699 Arch ,\r
700 ModulePath,\r
701 FileName,\r
702 'OUTPUT'\r
703 )\r
704 DebugPath = os.path.join(GenFdsGlobalVariable.OutputDirDict[Arch],\r
705 Arch ,\r
706 ModulePath,\r
707 FileName,\r
708 'DEBUG'\r
709 )\r
710 OutputPath = os.path.realpath(OutputPath)\r
711 DebugPath = os.path.realpath(DebugPath)\r
712 return OutputPath, DebugPath\r
713\r
714 ## __GenSimpleFileSection__() method\r
715 #\r
716 # Generate section by specified file name or a list of files with file extension\r
717 #\r
718 # @param self The object pointer\r
719 # @param Rule The rule object used to generate section\r
720 # @retval string File name of the generated section file\r
721 #\r
722 def __GenSimpleFileSection__(self, Rule, IsMakefile = False):\r
723 #\r
724 # Prepare the parameter of GenSection\r
725 #\r
726 FileList = []\r
727 OutputFileList = []\r
728 GenSecInputFile = None\r
729 if Rule.FileName is not None:\r
730 GenSecInputFile = self.__ExtendMacro__(Rule.FileName)\r
731 if os.path.isabs(GenSecInputFile):\r
732 GenSecInputFile = os.path.normpath(GenSecInputFile)\r
733 else:\r
734 GenSecInputFile = os.path.normpath(os.path.join(self.EfiOutputPath, GenSecInputFile))\r
735 else:\r
736 FileList, IsSect = Section.Section.GetFileList(self, '', Rule.FileExtension)\r
737\r
738 Index = 1\r
739 SectionType = Rule.SectionType\r
740 #\r
741 # Convert Fv Section Type for PI1.1 SMM driver.\r
742 #\r
743 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) >= 0x0001000A:\r
744 if SectionType == 'DXE_DEPEX':\r
745 SectionType = 'SMM_DEPEX'\r
746 #\r
747 # Framework SMM Driver has no SMM_DEPEX section type\r
748 #\r
749 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) < 0x0001000A:\r
750 if SectionType == 'SMM_DEPEX':\r
751 EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Framework SMM module doesn't support SMM_DEPEX section type", File=self.InfFileName)\r
752 NoStrip = True\r
753 if self.ModuleType in ('SEC', 'PEI_CORE', 'PEIM'):\r
754 if self.KeepReloc is not None:\r
755 NoStrip = self.KeepReloc\r
756 elif Rule.KeepReloc is not None:\r
757 NoStrip = Rule.KeepReloc\r
758 elif self.ShadowFromInfFile is not None:\r
759 NoStrip = self.ShadowFromInfFile\r
760\r
761 if FileList != [] :\r
762 for File in FileList:\r
763\r
764 SecNum = '%d' %Index\r
765 GenSecOutputFile= self.__ExtendMacro__(Rule.NameGuid) + \\r
766 Ffs.Ffs.SectionSuffix[SectionType] + 'SEC' + SecNum\r
767 Index = Index + 1\r
768 OutputFile = os.path.join(self.OutputPath, GenSecOutputFile)\r
769 File = GenFdsGlobalVariable.MacroExtend(File, Dict, self.CurrentArch)\r
770\r
771 #Get PE Section alignment when align is set to AUTO\r
772 if self.Alignment == 'Auto' and (SectionType == 'PE32' or SectionType == 'TE'):\r
773 ImageObj = PeImageClass (File)\r
774 if ImageObj.SectionAlignment < 0x400:\r
775 self.Alignment = str (ImageObj.SectionAlignment)\r
776 elif ImageObj.SectionAlignment < 0x100000:\r
777 self.Alignment = str (ImageObj.SectionAlignment / 0x400) + 'K'\r
778 else:\r
779 self.Alignment = str (ImageObj.SectionAlignment / 0x100000) + 'M'\r
780\r
781 if not NoStrip:\r
782 FileBeforeStrip = os.path.join(self.OutputPath, ModuleName + '.reloc')\r
783 if not os.path.exists(FileBeforeStrip) or \\r
784 (os.path.getmtime(File) > os.path.getmtime(FileBeforeStrip)):\r
785 CopyLongFilePath(File, FileBeforeStrip)\r
786 StrippedFile = os.path.join(self.OutputPath, ModuleName + '.stipped')\r
787 GenFdsGlobalVariable.GenerateFirmwareImage(\r
788 StrippedFile,\r
789 [File],\r
790 Strip=True,\r
791 IsMakefile=IsMakefile\r
792 )\r
793 File = StrippedFile\r
794\r
795 if SectionType == 'TE':\r
796 TeFile = os.path.join( self.OutputPath, self.ModuleGuid + 'Te.raw')\r
797 GenFdsGlobalVariable.GenerateFirmwareImage(\r
798 TeFile,\r
799 [File],\r
800 Type='te',\r
801 IsMakefile=IsMakefile\r
802 )\r
803 File = TeFile\r
804 GenFdsGlobalVariable.GenerateSection(OutputFile, [File], Section.Section.SectionType[SectionType], IsMakefile=IsMakefile)\r
805 OutputFileList.append(OutputFile)\r
806 else:\r
807 SecNum = '%d' %Index\r
808 GenSecOutputFile= self.__ExtendMacro__(Rule.NameGuid) + \\r
809 Ffs.Ffs.SectionSuffix[SectionType] + 'SEC' + SecNum\r
810 OutputFile = os.path.join(self.OutputPath, GenSecOutputFile)\r
811 GenSecInputFile = GenFdsGlobalVariable.MacroExtend(GenSecInputFile, Dict, self.CurrentArch)\r
812\r
813 #Get PE Section alignment when align is set to AUTO\r
814 if self.Alignment == 'Auto' and (SectionType == 'PE32' or SectionType == 'TE'):\r
815 ImageObj = PeImageClass (GenSecInputFile)\r
816 if ImageObj.SectionAlignment < 0x400:\r
817 self.Alignment = str (ImageObj.SectionAlignment)\r
818 elif ImageObj.SectionAlignment < 0x100000:\r
819 self.Alignment = str (ImageObj.SectionAlignment / 0x400) + 'K'\r
820 else:\r
821 self.Alignment = str (ImageObj.SectionAlignment / 0x100000) + 'M'\r
822\r
823 if not NoStrip:\r
824 FileBeforeStrip = os.path.join(self.OutputPath, ModuleName + '.reloc')\r
825 if not os.path.exists(FileBeforeStrip) or \\r
826 (os.path.getmtime(GenSecInputFile) > os.path.getmtime(FileBeforeStrip)):\r
827 CopyLongFilePath(GenSecInputFile, FileBeforeStrip)\r
828\r
829 StrippedFile = os.path.join(self.OutputPath, ModuleName + '.stipped')\r
830 GenFdsGlobalVariable.GenerateFirmwareImage(\r
831 StrippedFile,\r
832 [GenSecInputFile],\r
833 Strip=True,\r
834 IsMakefile=IsMakefile\r
835 )\r
836 GenSecInputFile = StrippedFile\r
837\r
838 if SectionType == 'TE':\r
839 TeFile = os.path.join( self.OutputPath, self.ModuleGuid + 'Te.raw')\r
840 GenFdsGlobalVariable.GenerateFirmwareImage(\r
841 TeFile,\r
842 [GenSecInputFile],\r
843 Type='te',\r
844 IsMakefile=IsMakefile\r
845 )\r
846 GenSecInputFile = TeFile\r
847 GenFdsGlobalVariable.GenerateSection(OutputFile, [GenSecInputFile], Section.Section.SectionType[SectionType], IsMakefile=IsMakefile)\r
848 OutputFileList.append(OutputFile)\r
849\r
850 return OutputFileList\r
851\r
852 ## __GenSimpleFileFfs__() method\r
853 #\r
854 # Generate FFS\r
855 #\r
856 # @param self The object pointer\r
857 # @param Rule The rule object used to generate section\r
858 # @param InputFileList The output file list from GenSection\r
859 # @retval string Generated FFS file name\r
860 #\r
861 def __GenSimpleFileFfs__(self, Rule, InputFileList, MakefilePath = None):\r
862 FfsOutput = self.OutputPath + \\r
863 os.sep + \\r
864 self.__ExtendMacro__(Rule.NameGuid) + \\r
865 '.ffs'\r
866\r
867 GenFdsGlobalVariable.VerboseLogger(self.__ExtendMacro__(Rule.NameGuid))\r
868 InputSection = []\r
869 SectionAlignments = []\r
870 for InputFile in InputFileList:\r
871 InputSection.append(InputFile)\r
872 SectionAlignments.append(Rule.SectAlignment)\r
873\r
874 if Rule.NameGuid is not None and Rule.NameGuid.startswith('PCD('):\r
875 PcdValue = GenFdsGlobalVariable.GetPcdValue(Rule.NameGuid)\r
876 if len(PcdValue) == 0:\r
877 EdkLogger.error("GenFds", GENFDS_ERROR, '%s NOT defined.' \\r
878 % (Rule.NameGuid))\r
879 if PcdValue.startswith('{'):\r
880 PcdValue = GuidStructureByteArrayToGuidString(PcdValue)\r
881 RegistryGuidStr = PcdValue\r
882 if len(RegistryGuidStr) == 0:\r
883 EdkLogger.error("GenFds", GENFDS_ERROR, 'GUID value for %s in wrong format.' \\r
884 % (Rule.NameGuid))\r
885 self.ModuleGuid = RegistryGuidStr\r
886\r
887 GenFdsGlobalVariable.GenerateFfs(FfsOutput, InputSection,\r
888 Ffs.Ffs.FdfFvFileTypeToFileType[Rule.FvFileType],\r
889 self.ModuleGuid, Fixed=Rule.Fixed,\r
890 CheckSum=Rule.CheckSum, Align=Rule.Alignment,\r
891 SectionAlign=SectionAlignments,\r
892 MakefilePath=MakefilePath\r
893 )\r
894 return FfsOutput\r
895\r
896 ## __GenComplexFileSection__() method\r
897 #\r
898 # Generate section by sections in Rule\r
899 #\r
900 # @param self The object pointer\r
901 # @param Rule The rule object used to generate section\r
902 # @param FvChildAddr Array of the inside FvImage base address\r
903 # @param FvParentAddr Parent Fv base address\r
904 # @retval string File name of the generated section file\r
905 #\r
906 def __GenComplexFileSection__(self, Rule, FvChildAddr, FvParentAddr, IsMakefile = False):\r
907 if self.ModuleType in ('SEC', 'PEI_CORE', 'PEIM'):\r
908 if Rule.KeepReloc is not None:\r
909 self.KeepRelocFromRule = Rule.KeepReloc\r
910 SectFiles = []\r
911 SectAlignments = []\r
912 Index = 1\r
913 HasGeneratedFlag = False\r
914 if self.PcdIsDriver == 'PEI_PCD_DRIVER':\r
915 if self.IsBinaryModule:\r
916 PcdExDbFileName = os.path.join(GenFdsGlobalVariable.FvDir, "PEIPcdDataBase.raw")\r
917 else:\r
918 PcdExDbFileName = os.path.join(self.EfiOutputPath, "PEIPcdDataBase.raw")\r
919 PcdExDbSecName = os.path.join(self.OutputPath, "PEIPcdDataBaseSec.raw")\r
920 GenFdsGlobalVariable.GenerateSection(PcdExDbSecName,\r
921 [PcdExDbFileName],\r
922 "EFI_SECTION_RAW",\r
923 IsMakefile = IsMakefile\r
924 )\r
925 SectFiles.append(PcdExDbSecName)\r
926 SectAlignments.append(None)\r
927 elif self.PcdIsDriver == 'DXE_PCD_DRIVER':\r
928 if self.IsBinaryModule:\r
929 PcdExDbFileName = os.path.join(GenFdsGlobalVariable.FvDir, "DXEPcdDataBase.raw")\r
930 else:\r
931 PcdExDbFileName = os.path.join(self.EfiOutputPath, "DXEPcdDataBase.raw")\r
932 PcdExDbSecName = os.path.join(self.OutputPath, "DXEPcdDataBaseSec.raw")\r
933 GenFdsGlobalVariable.GenerateSection(PcdExDbSecName,\r
934 [PcdExDbFileName],\r
935 "EFI_SECTION_RAW",\r
936 IsMakefile = IsMakefile\r
937 )\r
938 SectFiles.append(PcdExDbSecName)\r
939 SectAlignments.append(None)\r
940 for Sect in Rule.SectionList:\r
941 SecIndex = '%d' %Index\r
942 SectList = []\r
943 #\r
944 # Convert Fv Section Type for PI1.1 SMM driver.\r
945 #\r
946 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) >= 0x0001000A:\r
947 if Sect.SectionType == 'DXE_DEPEX':\r
948 Sect.SectionType = 'SMM_DEPEX'\r
949 #\r
950 # Framework SMM Driver has no SMM_DEPEX section type\r
951 #\r
952 if self.ModuleType == 'DXE_SMM_DRIVER' and int(self.PiSpecVersion, 16) < 0x0001000A:\r
953 if Sect.SectionType == 'SMM_DEPEX':\r
954 EdkLogger.error("GenFds", FORMAT_NOT_SUPPORTED, "Framework SMM module doesn't support SMM_DEPEX section type", File=self.InfFileName)\r
955 #\r
956 # process the inside FvImage from FvSection or GuidSection\r
957 #\r
958 if FvChildAddr != []:\r
959 if isinstance(Sect, FvImageSection):\r
960 Sect.FvAddr = FvChildAddr.pop(0)\r
961 elif isinstance(Sect, GuidSection):\r
962 Sect.FvAddr = FvChildAddr\r
963 if FvParentAddr is not None and isinstance(Sect, GuidSection):\r
964 Sect.FvParentAddr = FvParentAddr\r
965 \r
966 if Rule.KeyStringList != []:\r
967 SectList, Align = Sect.GenSection(self.OutputPath , self.ModuleGuid, SecIndex, Rule.KeyStringList, self, IsMakefile = IsMakefile)\r
968 else :\r
969 SectList, Align = Sect.GenSection(self.OutputPath , self.ModuleGuid, SecIndex, self.KeyStringList, self, IsMakefile = IsMakefile)\r
970 \r
971 if not HasGeneratedFlag:\r
972 UniVfrOffsetFileSection = "" \r
973 ModuleFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, self.InfFileName)\r
974 InfData = GenFdsGlobalVariable.WorkSpace.BuildObject[PathClass(ModuleFileName), self.CurrentArch]\r
975 #\r
976 # Search the source list in InfData to find if there are .vfr file exist.\r
977 #\r
978 VfrUniBaseName = {}\r
979 VfrUniOffsetList = []\r
980 for SourceFile in InfData.Sources:\r
981 if SourceFile.Type.upper() == ".VFR" :\r
982 #\r
983 # search the .map file to find the offset of vfr binary in the PE32+/TE file. \r
984 #\r
985 VfrUniBaseName[SourceFile.BaseName] = (SourceFile.BaseName + "Bin")\r
986 if SourceFile.Type.upper() == ".UNI" :\r
987 #\r
988 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file. \r
989 #\r
990 VfrUniBaseName["UniOffsetName"] = (self.BaseName + "Strings")\r
991 \r
992 \r
993 if len(VfrUniBaseName) > 0:\r
994 if IsMakefile:\r
995 if InfData.BuildType != 'UEFI_HII':\r
996 UniVfrOffsetFileName = os.path.join(self.OutputPath, self.BaseName + '.offset')\r
997 UniVfrOffsetFileSection = os.path.join(self.OutputPath, self.BaseName + 'Offset' + '.raw')\r
998 UniVfrOffsetFileNameList = []\r
999 UniVfrOffsetFileNameList.append(UniVfrOffsetFileName)\r
1000 TrimCmd = "Trim --Vfr-Uni-Offset -o %s --ModuleName=%s --DebugDir=%s " % (UniVfrOffsetFileName, self.BaseName, self.EfiDebugPath)\r
1001 GenFdsGlobalVariable.SecCmdList.append(TrimCmd)\r
1002 GenFdsGlobalVariable.GenerateSection(UniVfrOffsetFileSection,\r
1003 [UniVfrOffsetFileName],\r
1004 "EFI_SECTION_RAW",\r
1005 IsMakefile = True\r
1006 )\r
1007 else:\r
1008 VfrUniOffsetList = self.__GetBuildOutputMapFileVfrUniInfo(VfrUniBaseName)\r
1009 #\r
1010 # Generate the Raw data of raw section\r
1011 #\r
1012 if VfrUniOffsetList:\r
1013 UniVfrOffsetFileName = os.path.join(self.OutputPath, self.BaseName + '.offset')\r
1014 UniVfrOffsetFileSection = os.path.join(self.OutputPath, self.BaseName + 'Offset' + '.raw')\r
1015 FfsInfStatement.__GenUniVfrOffsetFile (VfrUniOffsetList, UniVfrOffsetFileName)\r
1016 UniVfrOffsetFileNameList = []\r
1017 UniVfrOffsetFileNameList.append(UniVfrOffsetFileName)\r
1018 """Call GenSection"""\r
1019\r
1020 GenFdsGlobalVariable.GenerateSection(UniVfrOffsetFileSection,\r
1021 UniVfrOffsetFileNameList,\r
1022 "EFI_SECTION_RAW"\r
1023 )\r
1024 #os.remove(UniVfrOffsetFileName)\r
1025 if UniVfrOffsetFileSection:\r
1026 SectList.append(UniVfrOffsetFileSection)\r
1027 HasGeneratedFlag = True\r
1028 \r
1029 for SecName in SectList :\r
1030 SectFiles.append(SecName)\r
1031 SectAlignments.append(Align)\r
1032 Index = Index + 1\r
1033 return SectFiles, SectAlignments\r
1034\r
1035 ## __GenComplexFileFfs__() method\r
1036 #\r
1037 # Generate FFS\r
1038 #\r
1039 # @param self The object pointer\r
1040 # @param Rule The rule object used to generate section\r
1041 # @param InputFileList The output file list from GenSection\r
1042 # @retval string Generated FFS file name\r
1043 #\r
1044 def __GenComplexFileFfs__(self, Rule, InputFile, Alignments, MakefilePath = None):\r
1045\r
1046 if Rule.NameGuid is not None and Rule.NameGuid.startswith('PCD('):\r
1047 PcdValue = GenFdsGlobalVariable.GetPcdValue(Rule.NameGuid)\r
1048 if len(PcdValue) == 0:\r
1049 EdkLogger.error("GenFds", GENFDS_ERROR, '%s NOT defined.' \\r
1050 % (Rule.NameGuid))\r
1051 if PcdValue.startswith('{'):\r
1052 PcdValue = GuidStructureByteArrayToGuidString(PcdValue)\r
1053 RegistryGuidStr = PcdValue\r
1054 if len(RegistryGuidStr) == 0:\r
1055 EdkLogger.error("GenFds", GENFDS_ERROR, 'GUID value for %s in wrong format.' \\r
1056 % (Rule.NameGuid))\r
1057 self.ModuleGuid = RegistryGuidStr\r
1058\r
1059 FfsOutput = os.path.join( self.OutputPath, self.ModuleGuid + '.ffs')\r
1060 GenFdsGlobalVariable.GenerateFfs(FfsOutput, InputFile,\r
1061 Ffs.Ffs.FdfFvFileTypeToFileType[Rule.FvFileType],\r
1062 self.ModuleGuid, Fixed=Rule.Fixed,\r
1063 CheckSum=Rule.CheckSum, Align=Rule.Alignment,\r
1064 SectionAlign=Alignments,\r
1065 MakefilePath=MakefilePath\r
1066 )\r
1067 return FfsOutput\r
1068\r
1069 ## __GetBuildOutputMapFileVfrUniInfo() method\r
1070 #\r
1071 # Find the offset of UNI/INF object offset in the EFI image file.\r
1072 #\r
1073 # @param self The object pointer\r
1074 # @param VfrUniBaseName A name list contain the UNI/INF object name.\r
1075 # @retval RetValue A list contain offset of UNI/INF object.\r
1076 # \r
1077 def __GetBuildOutputMapFileVfrUniInfo(self, VfrUniBaseName):\r
1078 MapFileName = os.path.join(self.EfiOutputPath, self.BaseName + ".map")\r
1079 EfiFileName = os.path.join(self.EfiOutputPath, self.BaseName + ".efi")\r
1080 return GetVariableOffset(MapFileName, EfiFileName, VfrUniBaseName.values())\r
1081 \r
1082 ## __GenUniVfrOffsetFile() method\r
1083 #\r
1084 # Generate the offset file for the module which contain VFR or UNI file.\r
1085 #\r
1086 # @param VfrUniOffsetList A list contain the VFR/UNI offsets in the EFI image file.\r
1087 # @param UniVfrOffsetFileName The output offset file name.\r
1088 #\r
1089 @staticmethod\r
1090 def __GenUniVfrOffsetFile(VfrUniOffsetList, UniVfrOffsetFileName):\r
1091\r
1092 # Use a instance of StringIO to cache data\r
1093 fStringIO = StringIO.StringIO('') \r
1094 \r
1095 for Item in VfrUniOffsetList:\r
1096 if (Item[0].find("Strings") != -1):\r
1097 #\r
1098 # UNI offset in image.\r
1099 # GUID + Offset\r
1100 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }\r
1101 #\r
1102 UniGuid = [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]\r
1103 UniGuid = [chr(ItemGuid) for ItemGuid in UniGuid]\r
1104 fStringIO.write(''.join(UniGuid)) \r
1105 UniValue = pack ('Q', int (Item[1], 16))\r
1106 fStringIO.write (UniValue)\r
1107 else:\r
1108 #\r
1109 # VFR binary offset in image.\r
1110 # GUID + Offset\r
1111 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };\r
1112 #\r
1113 VfrGuid = [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]\r
1114 VfrGuid = [chr(ItemGuid) for ItemGuid in VfrGuid]\r
1115 fStringIO.write(''.join(VfrGuid)) \r
1116 type (Item[1]) \r
1117 VfrValue = pack ('Q', int (Item[1], 16))\r
1118 fStringIO.write (VfrValue)\r
1119 \r
1120 #\r
1121 # write data into file.\r
1122 #\r
1123 try :\r
1124 SaveFileOnChange(UniVfrOffsetFileName, fStringIO.getvalue())\r
1125 except:\r
1126 EdkLogger.error("GenFds", FILE_WRITE_FAILURE, "Write data to file %s failed, please check whether the file been locked or using by other applications." %UniVfrOffsetFileName,None)\r
1127 \r
1128 fStringIO.close ()\r
1129\r
1130 \r
EFI Development Kit II mirror for PVE