2 # process FFS generation from INF statement
4 # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
5 # Copyright (c) 2014-2016 Hewlett-Packard Development Company, L.P.<BR>
7 # This program and the accompanying materials
8 # are licensed and made available under the terms and conditions of the BSD License
9 # which accompanies this distribution. The full text of the license may be found at
10 # http://opensource.org/licenses/bsd-license.php
12 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 import Common
.LongFilePathOs
as os
23 from GenFdsGlobalVariable
import GenFdsGlobalVariable
29 import RuleComplexFile
30 from CommonDataClass
.FdfClass
import FfsInfStatementClassObject
31 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
32 from Common
.String
import *
33 from Common
.Misc
import PathClass
34 from Common
.Misc
import GuidStructureByteArrayToGuidString
35 from Common
.Misc
import ProcessDuplicatedInf
36 from Common
.Misc
import GetVariableOffset
37 from Common
import EdkLogger
38 from Common
.BuildToolError
import *
39 from GuidSection
import GuidSection
40 from FvImageSection
import FvImageSection
41 from Common
.Misc
import PeImageClass
42 from AutoGen
.GenDepex
import DependencyExpression
43 from PatchPcdValue
.PatchPcdValue
import PatchBinaryFile
44 from Common
.LongFilePathSupport
import CopyLongFilePath
45 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
46 import Common
.GlobalData
as GlobalData
47 from DepexSection
import DepexSection
48 from Common
.Misc
import SaveFileOnChange
49 from Common
.Expression
import *
50 from Common
.DataType
import TAB_COMMON
52 ## generate FFS from INF
55 class FfsInfStatement(FfsInfStatementClassObject
):
56 ## The mapping dictionary from datum type to its maximum number.
57 _MAX_SIZE_TYPE
= {"BOOLEAN":0x01, "UINT8":0xFF, "UINT16":0xFFFF, "UINT32":0xFFFFFFFF, "UINT64":0xFFFFFFFFFFFFFFFF}
60 # @param self The object pointer
63 FfsInfStatementClassObject
.__init
__(self
)
64 self
.TargetOverrideList
= []
65 self
.ShadowFromInfFile
= None
66 self
.KeepRelocFromRule
= None
69 self
.PiSpecVersion
= '0x00000000'
71 self
.FinalTargetSuffixMap
= {}
72 self
.CurrentLineNum
= None
73 self
.CurrentLineContent
= None
75 self
.InfFileName
= None
76 self
.OverrideGuid
= None
77 self
.PatchedBinFile
= ''
81 ## GetFinalTargetSuffixMap() method
83 # Get final build target list
84 def GetFinalTargetSuffixMap(self
):
85 if not self
.InfModule
or not self
.CurrentArch
:
87 if not self
.FinalTargetSuffixMap
:
88 FinalBuildTargetList
= GenFdsGlobalVariable
.GetModuleCodaTargetList(self
.InfModule
, self
.CurrentArch
)
89 for File
in FinalBuildTargetList
:
90 self
.FinalTargetSuffixMap
.setdefault(os
.path
.splitext(File
)[1], []).append(File
)
92 # Check if current INF module has DEPEX
93 if '.depex' not in self
.FinalTargetSuffixMap
and self
.InfModule
.ModuleType
!= "USER_DEFINED" \
94 and not self
.InfModule
.DxsFile
and not self
.InfModule
.LibraryClass
:
95 ModuleType
= self
.InfModule
.ModuleType
96 PlatformDataBase
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[GenFdsGlobalVariable
.ActivePlatform
, self
.CurrentArch
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
98 if ModuleType
!= DataType
.SUP_MODULE_USER_DEFINED
:
99 for LibraryClass
in PlatformDataBase
.LibraryClasses
.GetKeys():
100 if LibraryClass
.startswith("NULL") and PlatformDataBase
.LibraryClasses
[LibraryClass
, ModuleType
]:
101 self
.InfModule
.LibraryClasses
[LibraryClass
] = PlatformDataBase
.LibraryClasses
[LibraryClass
, ModuleType
]
103 StrModule
= str(self
.InfModule
)
104 PlatformModule
= None
105 if StrModule
in PlatformDataBase
.Modules
:
106 PlatformModule
= PlatformDataBase
.Modules
[StrModule
]
107 for LibraryClass
in PlatformModule
.LibraryClasses
:
108 if LibraryClass
.startswith("NULL"):
109 self
.InfModule
.LibraryClasses
[LibraryClass
] = PlatformModule
.LibraryClasses
[LibraryClass
]
111 DependencyList
= [self
.InfModule
]
114 while len(DependencyList
) > 0:
115 Module
= DependencyList
.pop(0)
118 for Dep
in Module
.Depex
[self
.CurrentArch
, ModuleType
]:
120 DepexList
.append('AND')
121 DepexList
.append('(')
122 DepexList
.extend(Dep
)
123 if DepexList
[-1] == 'END': # no need of a END at this time
125 DepexList
.append(')')
126 if 'BEFORE' in DepexList
or 'AFTER' in DepexList
:
128 for LibName
in Module
.LibraryClasses
:
129 if LibName
in LibraryInstance
:
131 if PlatformModule
and LibName
in PlatformModule
.LibraryClasses
:
132 LibraryPath
= PlatformModule
.LibraryClasses
[LibName
]
134 LibraryPath
= PlatformDataBase
.LibraryClasses
[LibName
, ModuleType
]
136 LibraryPath
= Module
.LibraryClasses
[LibName
]
139 LibraryModule
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[LibraryPath
, self
.CurrentArch
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
140 LibraryInstance
[LibName
] = LibraryModule
141 DependencyList
.append(LibraryModule
)
143 Dpx
= DependencyExpression(DepexList
, ModuleType
, True)
144 if len(Dpx
.PostfixNotation
) != 0:
145 # It means this module has DEPEX
146 self
.FinalTargetSuffixMap
['.depex'] = [os
.path
.join(self
.EfiOutputPath
, self
.BaseName
) + '.depex']
147 return self
.FinalTargetSuffixMap
149 ## __InfParse() method
151 # Parse inf file to get module information
153 # @param self The object pointer
154 # @param Dict dictionary contains macro and value pair
156 def __InfParse__(self
, Dict
= {}):
158 GenFdsGlobalVariable
.VerboseLogger( " Begine parsing INf file : %s" %self
.InfFileName
)
160 self
.InfFileName
= self
.InfFileName
.replace('$(WORKSPACE)', '')
161 if len(self
.InfFileName
) > 1 and self
.InfFileName
[0] == '\\' and self
.InfFileName
[1] == '\\':
163 elif self
.InfFileName
[0] == '\\' or self
.InfFileName
[0] == '/' :
164 self
.InfFileName
= self
.InfFileName
[1:]
166 if self
.InfFileName
.find('$') == -1:
167 InfPath
= NormPath(self
.InfFileName
)
168 if not os
.path
.exists(InfPath
):
169 InfPath
= GenFdsGlobalVariable
.ReplaceWorkspaceMacro(InfPath
)
170 if not os
.path
.exists(InfPath
):
171 EdkLogger
.error("GenFds", GENFDS_ERROR
, "Non-existant Module %s !" % (self
.InfFileName
))
173 self
.CurrentArch
= self
.GetCurrentArch()
175 # Get the InfClass object
178 PathClassObj
= PathClass(self
.InfFileName
, GenFdsGlobalVariable
.WorkSpaceDir
)
179 ErrorCode
, ErrorInfo
= PathClassObj
.Validate(".inf")
181 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
184 # Cache lower case version of INF path before processing FILE_GUID override
186 InfLowerPath
= str(PathClassObj
).lower()
187 if self
.OverrideGuid
:
188 PathClassObj
= ProcessDuplicatedInf(PathClassObj
, self
.OverrideGuid
, GenFdsGlobalVariable
.WorkSpaceDir
)
189 if self
.CurrentArch
is not None:
191 Inf
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[PathClassObj
, self
.CurrentArch
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
193 # Set Ffs BaseName, MdouleGuid, ModuleType, Version, OutputPath
195 self
.BaseName
= Inf
.BaseName
196 self
.ModuleGuid
= Inf
.Guid
197 self
.ModuleType
= Inf
.ModuleType
198 if Inf
.Specification
is not None and 'PI_SPECIFICATION_VERSION' in Inf
.Specification
:
199 self
.PiSpecVersion
= Inf
.Specification
['PI_SPECIFICATION_VERSION']
200 if Inf
.AutoGenVersion
< 0x00010005:
201 self
.ModuleType
= Inf
.ComponentType
202 self
.VersionString
= Inf
.Version
203 self
.BinFileList
= Inf
.Binaries
204 self
.SourceFileList
= Inf
.Sources
205 if self
.KeepReloc
is None and Inf
.Shadow
:
206 self
.ShadowFromInfFile
= Inf
.Shadow
209 Inf
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[PathClassObj
, TAB_COMMON
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
210 self
.BaseName
= Inf
.BaseName
211 self
.ModuleGuid
= Inf
.Guid
212 self
.ModuleType
= Inf
.ModuleType
213 if Inf
.Specification
is not None and 'PI_SPECIFICATION_VERSION' in Inf
.Specification
:
214 self
.PiSpecVersion
= Inf
.Specification
['PI_SPECIFICATION_VERSION']
215 self
.VersionString
= Inf
.Version
216 self
.BinFileList
= Inf
.Binaries
217 self
.SourceFileList
= Inf
.Sources
218 if self
.BinFileList
== []:
219 EdkLogger
.error("GenFds", GENFDS_ERROR
,
220 "INF %s specified in FDF could not be found in build ARCH %s!" \
221 % (self
.InfFileName
, GenFdsGlobalVariable
.ArchList
))
223 if self
.OverrideGuid
:
224 self
.ModuleGuid
= self
.OverrideGuid
226 if len(self
.SourceFileList
) != 0 and not self
.InDsc
:
227 EdkLogger
.warn("GenFds", GENFDS_ERROR
, "Module %s NOT found in DSC file; Is it really a binary module?" % (self
.InfFileName
))
229 if self
.ModuleType
== 'SMM_CORE' and int(self
.PiSpecVersion
, 16) < 0x0001000A:
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
)
232 if self
.ModuleType
== 'MM_CORE_STANDALONE' and int(self
.PiSpecVersion
, 16) < 0x00010032:
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
)
235 if Inf
._Defs
is not None and len(Inf
._Defs
) > 0:
236 self
.OptRomDefs
.update(Inf
._Defs
)
240 Platform
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[GenFdsGlobalVariable
.ActivePlatform
, self
.CurrentArch
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
241 FdfPcdDict
= GenFdsGlobalVariable
.FdfParser
.Profile
.PcdDict
242 PlatformPcds
= Platform
.Pcds
244 # Workaround here: both build and GenFds tool convert the workspace path to lower case
245 # But INF file path in FDF and DSC file may have real case characters.
246 # Try to convert the path to lower case to see if PCDs value are override by DSC.
248 for DscModule
in Platform
.Modules
:
249 DscModules
[str(DscModule
).lower()] = Platform
.Modules
[DscModule
]
250 for PcdKey
in InfPcds
:
251 Pcd
= InfPcds
[PcdKey
]
252 if not hasattr(Pcd
, 'Offset'):
254 if Pcd
.Type
!= 'PatchableInModule':
256 # Override Patchable PCD value by the value from DSC
258 if InfLowerPath
in DscModules
and PcdKey
in DscModules
[InfLowerPath
].Pcds
:
259 PatchPcd
= DscModules
[InfLowerPath
].Pcds
[PcdKey
]
260 elif PcdKey
in Platform
.Pcds
:
261 PatchPcd
= Platform
.Pcds
[PcdKey
]
263 if PatchPcd
and Pcd
.Type
== PatchPcd
.Type
:
264 DefaultValue
= PatchPcd
.DefaultValue
267 # Override Patchable PCD value by the value from FDF
269 if PcdKey
in FdfPcdDict
:
270 DefaultValue
= FdfPcdDict
[PcdKey
]
273 # Override Patchable PCD value by the value from Build Option
274 BuildOptionOverride
= False
275 if GlobalData
.BuildOptionPcd
:
276 for pcd
in GlobalData
.BuildOptionPcd
:
277 if PcdKey
== (pcd
[1], pcd
[0]):
280 DefaultValue
= pcd
[3]
281 BuildOptionOverride
= True
284 if not DscOverride
and not FdfOverride
and not BuildOptionOverride
:
287 # Support Flexible PCD format
290 DefaultValue
= ValueExpressionEx(DefaultValue
, Pcd
.DatumType
, Platform
._GuidDict
)(True)
291 except BadExpression
:
292 EdkLogger
.error("GenFds", GENFDS_ERROR
, 'PCD [%s.%s] Value "%s"' %(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, DefaultValue
), File
=self
.InfFileName
)
294 if Pcd
.InfDefaultValue
:
296 Pcd
.InfDefaultValue
= ValueExpressionEx(Pcd
.InfDefaultValue
, Pcd
.DatumType
, Platform
._GuidDict
)(True)
297 except BadExpression
:
298 EdkLogger
.error("GenFds", GENFDS_ERROR
, 'PCD [%s.%s] Value "%s"' %(Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, Pcd
.DefaultValue
),File
=self
.InfFileName
)
300 # Check value, if value are equal, no need to patch
301 if Pcd
.DatumType
== "VOID*":
302 if Pcd
.InfDefaultValue
== DefaultValue
or DefaultValue
in [None, '']:
304 # Get the string size from FDF or DSC
305 if DefaultValue
[0] == 'L':
306 # Remove L"", but the '\0' must be appended
307 MaxDatumSize
= str((len(DefaultValue
) - 2) * 2)
308 elif DefaultValue
[0] == '{':
309 MaxDatumSize
= str(len(DefaultValue
.split(',')))
311 MaxDatumSize
= str(len(DefaultValue
) - 1)
313 Pcd
.MaxDatumSize
= PatchPcd
.MaxDatumSize
314 # If no defined the maximum size in DSC, try to get current size from INF
315 if Pcd
.MaxDatumSize
in ['', None]:
316 Pcd
.MaxDatumSize
= str(len(Pcd
.InfDefaultValue
.split(',')))
319 if Pcd
.InfDefaultValue
.upper().startswith('0X'):
321 if DefaultValue
.upper().startswith('0X'):
324 PcdValueInImg
= int(Pcd
.InfDefaultValue
, Base1
)
325 PcdValueInDscOrFdf
= int(DefaultValue
, Base2
)
326 if PcdValueInImg
== PcdValueInDscOrFdf
:
330 # Check the Pcd size and data type
331 if Pcd
.DatumType
== "VOID*":
332 if int(MaxDatumSize
) > int(Pcd
.MaxDatumSize
):
333 EdkLogger
.error("GenFds", GENFDS_ERROR
, "The size of VOID* type PCD '%s.%s' exceeds its maximum size %d bytes." \
334 % (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
, int(MaxDatumSize
) - int(Pcd
.MaxDatumSize
)))
336 if PcdValueInDscOrFdf
> FfsInfStatement
._MAX
_SIZE
_TYPE
[Pcd
.DatumType
] \
337 or PcdValueInImg
> FfsInfStatement
._MAX
_SIZE
_TYPE
[Pcd
.DatumType
]:
338 EdkLogger
.error("GenFds", GENFDS_ERROR
, "The size of %s type PCD '%s.%s' doesn't match its data type." \
339 % (Pcd
.DatumType
, Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
))
340 self
.PatchPcds
.append((Pcd
, DefaultValue
))
343 self
.PcdIsDriver
= Inf
.PcdIsDriver
344 self
.IsBinaryModule
= Inf
.IsBinaryModule
346 Inf
._GetDepexExpression
()
347 if len(Inf
._Depex
.data
) > 0 and len(Inf
._DepexExpression
.data
) > 0:
350 GenFdsGlobalVariable
.VerboseLogger("BaseName : %s" % self
.BaseName
)
351 GenFdsGlobalVariable
.VerboseLogger("ModuleGuid : %s" % self
.ModuleGuid
)
352 GenFdsGlobalVariable
.VerboseLogger("ModuleType : %s" % self
.ModuleType
)
353 GenFdsGlobalVariable
.VerboseLogger("VersionString : %s" % self
.VersionString
)
354 GenFdsGlobalVariable
.VerboseLogger("InfFileName :%s" % self
.InfFileName
)
357 # Set OutputPath = ${WorkSpace}\Build\Fv\Ffs\${ModuleGuid}+ ${MdouleName}\
360 self
.OutputPath
= os
.path
.join(GenFdsGlobalVariable
.FfsDir
, \
361 self
.ModuleGuid
+ self
.BaseName
)
362 if not os
.path
.exists(self
.OutputPath
) :
363 os
.makedirs(self
.OutputPath
)
365 self
.EfiOutputPath
, self
.EfiDebugPath
= self
.__GetEFIOutPutPath
__()
366 GenFdsGlobalVariable
.VerboseLogger( "ModuelEFIPath: " + self
.EfiOutputPath
)
370 # Patch EFI file with patch PCD
372 # @param EfiFile: EFI file needs to be patched.
373 # @retval: Full path of patched EFI file: self.OutputPath + EfiFile base name
374 # If passed in file does not end with efi, return as is
376 def PatchEfiFile(self
, EfiFile
, FileType
):
378 # If the module does not have any patches, then return path to input file
380 if not self
.PatchPcds
:
384 # Only patch file if FileType is PE32 or ModuleType is USER_DEFINED
386 if FileType
!= 'PE32' and self
.ModuleType
!= "USER_DEFINED":
390 # Generate path to patched output file
392 Basename
= os
.path
.basename(EfiFile
)
393 Output
= os
.path
.normpath (os
.path
.join(self
.OutputPath
, Basename
))
396 # If this file has already been patched, then return the path to the patched file
398 if self
.PatchedBinFile
== Output
:
402 # If a different file from the same module has already been patched, then generate an error
404 if self
.PatchedBinFile
:
405 EdkLogger
.error("GenFds", GENFDS_ERROR
,
406 'Only one binary file can be patched:\n'
407 ' a binary file has been patched: %s\n'
408 ' current file: %s' % (self
.PatchedBinFile
, EfiFile
),
409 File
=self
.InfFileName
)
412 # Copy unpatched file contents to output file location to perform patching
414 CopyLongFilePath(EfiFile
, Output
)
417 # Apply patches to patched output file
419 for Pcd
, Value
in self
.PatchPcds
:
420 RetVal
, RetStr
= PatchBinaryFile(Output
, int(Pcd
.Offset
, 0), Pcd
.DatumType
, Value
, Pcd
.MaxDatumSize
)
422 EdkLogger
.error("GenFds", GENFDS_ERROR
, RetStr
, File
=self
.InfFileName
)
425 # Save the path of the patched output file
427 self
.PatchedBinFile
= Output
430 # Return path to patched output file
438 # @param self The object pointer
439 # @param Dict dictionary contains macro and value pair
440 # @param FvChildAddr Array of the inside FvImage base address
441 # @param FvParentAddr Parent Fv base address
442 # @retval string Generated FFS file name
444 def GenFfs(self
, Dict
= {}, FvChildAddr
= [], FvParentAddr
=None, IsMakefile
=False, FvName
=None):
446 # Parse Inf file get Module related information
449 self
.__InfParse
__(Dict
)
450 Arch
= self
.GetCurrentArch()
451 SrcFile
= mws
.join( GenFdsGlobalVariable
.WorkSpaceDir
, self
.InfFileName
);
452 DestFile
= os
.path
.join( self
.OutputPath
, self
.ModuleGuid
+ '.ffs')
455 SrcPath
= os
.path
.dirname(SrcFile
)
456 SrcFileName
= os
.path
.basename(SrcFile
)
457 SrcFileBase
, SrcFileExt
= os
.path
.splitext(SrcFileName
)
458 DestPath
= os
.path
.dirname(DestFile
)
459 DestFileName
= os
.path
.basename(DestFile
)
460 DestFileBase
, DestFileExt
= os
.path
.splitext(DestFileName
)
464 "${s_path}" : SrcPath
,
465 "${s_dir}" : SrcFileDir
,
466 "${s_name}" : SrcFileName
,
467 "${s_base}" : SrcFileBase
,
468 "${s_ext}" : SrcFileExt
,
471 "${d_path}" : DestPath
,
472 "${d_name}" : DestFileName
,
473 "${d_base}" : DestFileBase
,
474 "${d_ext}" : DestFileExt
477 # Allow binary type module not specify override rule in FDF file.
479 if len(self
.BinFileList
) > 0:
480 if self
.Rule
is None or self
.Rule
== "":
483 if not IsMakefile
and GenFdsGlobalVariable
.EnableGenfdsMultiThread
and self
.Rule
!= 'BINARY':
486 # Get the rule of how to generate Ffs file
488 Rule
= self
.__GetRule
__()
489 GenFdsGlobalVariable
.VerboseLogger( "Packing binaries from inf file : %s" %self
.InfFileName
)
491 # Convert Fv File Type for PI1.1 SMM driver.
493 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) >= 0x0001000A:
494 if Rule
.FvFileType
== 'DRIVER':
495 Rule
.FvFileType
= 'SMM'
497 # Framework SMM Driver has no SMM FV file type
499 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) < 0x0001000A:
500 if Rule
.FvFileType
== 'SMM' or Rule
.FvFileType
== 'SMM_CORE':
501 EdkLogger
.error("GenFds", FORMAT_NOT_SUPPORTED
, "Framework SMM module doesn't support SMM or SMM_CORE FV file type", File
=self
.InfFileName
)
503 # For the rule only has simpleFile
506 if self
.IsBinaryModule
:
509 MakefilePath
= self
.InfFileName
, Arch
510 if isinstance (Rule
, RuleSimpleFile
.RuleSimpleFile
):
511 SectionOutputList
= self
.__GenSimpleFileSection
__(Rule
, IsMakefile
=IsMakefile
)
512 FfsOutput
= self
.__GenSimpleFileFfs
__(Rule
, SectionOutputList
, MakefilePath
=MakefilePath
)
515 # For Rule has ComplexFile
517 elif isinstance(Rule
, RuleComplexFile
.RuleComplexFile
):
518 InputSectList
, InputSectAlignments
= self
.__GenComplexFileSection
__(Rule
, FvChildAddr
, FvParentAddr
, IsMakefile
=IsMakefile
)
519 FfsOutput
= self
.__GenComplexFileFfs
__(Rule
, InputSectList
, InputSectAlignments
, MakefilePath
=MakefilePath
)
522 ## __ExtendMacro__() method
524 # Replace macro with its value
526 # @param self The object pointer
527 # @param String The string to be replaced
528 # @retval string Macro replaced string
530 def __ExtendMacro__ (self
, String
):
532 '$(INF_OUTPUT)' : self
.EfiOutputPath
,
533 '$(MODULE_NAME)' : self
.BaseName
,
534 '$(BUILD_NUMBER)': self
.BuildNum
,
535 '$(INF_VERSION)' : self
.VersionString
,
536 '$(NAMED_GUID)' : self
.ModuleGuid
538 String
= GenFdsGlobalVariable
.MacroExtend(String
, MacroDict
)
539 String
= GenFdsGlobalVariable
.MacroExtend(String
, self
.MacroDict
)
542 ## __GetRule__() method
544 # Get correct rule for generating FFS for this INF
546 # @param self The object pointer
547 # @retval Rule Rule object
549 def __GetRule__ (self
) :
551 if self
.CurrentArch
is None:
552 CurrentArchList
= ['common']
554 CurrentArchList
.append(self
.CurrentArch
)
556 for CurrentArch
in CurrentArchList
:
557 RuleName
= 'RULE' + \
559 CurrentArch
.upper() + \
561 self
.ModuleType
.upper()
562 if self
.Rule
is not None:
563 RuleName
= RuleName
+ \
567 Rule
= GenFdsGlobalVariable
.FdfParser
.Profile
.RuleDict
.get(RuleName
)
569 GenFdsGlobalVariable
.VerboseLogger ("Want To Find Rule Name is : " + RuleName
)
572 RuleName
= 'RULE' + \
576 self
.ModuleType
.upper()
578 if self
.Rule
is not None:
579 RuleName
= RuleName
+ \
583 GenFdsGlobalVariable
.VerboseLogger ('Trying to apply common rule %s for INF %s' % (RuleName
, self
.InfFileName
))
585 Rule
= GenFdsGlobalVariable
.FdfParser
.Profile
.RuleDict
.get(RuleName
)
587 GenFdsGlobalVariable
.VerboseLogger ("Want To Find Rule Name is : " + RuleName
)
591 EdkLogger
.error("GenFds", GENFDS_ERROR
, 'Don\'t Find common rule %s for INF %s' \
592 % (RuleName
, self
.InfFileName
))
594 ## __GetPlatformArchList__() method
596 # Get Arch list this INF built under
598 # @param self The object pointer
599 # @retval list Arch list
601 def __GetPlatformArchList__(self
):
603 InfFileKey
= os
.path
.normpath(mws
.join(GenFdsGlobalVariable
.WorkSpaceDir
, self
.InfFileName
))
605 for Arch
in GenFdsGlobalVariable
.ArchList
:
606 PlatformDataBase
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[GenFdsGlobalVariable
.ActivePlatform
, Arch
, GenFdsGlobalVariable
.TargetName
, GenFdsGlobalVariable
.ToolChainTag
]
607 if PlatformDataBase
is not None:
608 if InfFileKey
in PlatformDataBase
.Modules
:
609 DscArchList
.append (Arch
)
612 # BaseTools support build same module more than once, the module path with FILE_GUID overridden has
613 # the file name FILE_GUIDmodule.inf, then PlatformDataBase.Modules use FILE_GUIDmodule.inf as key,
614 # but the path (self.MetaFile.Path) is the real path
616 for key
in PlatformDataBase
.Modules
.keys():
617 if InfFileKey
== str((PlatformDataBase
.Modules
[key
]).MetaFile
.Path
):
618 DscArchList
.append (Arch
)
623 ## GetCurrentArch() method
625 # Get Arch list of the module from this INF is to be placed into flash
627 # @param self The object pointer
628 # @retval list Arch list
630 def GetCurrentArch(self
) :
632 TargetArchList
= GenFdsGlobalVariable
.ArchList
634 PlatformArchList
= self
.__GetPlatformArchList
__()
636 CurArchList
= TargetArchList
637 if PlatformArchList
!= []:
638 CurArchList
= list(set (TargetArchList
) & set (PlatformArchList
))
639 GenFdsGlobalVariable
.VerboseLogger ("Valid target architecture(s) is : " + " ".join(CurArchList
))
642 if self
.KeyStringList
!= []:
643 for Key
in self
.KeyStringList
:
644 Key
= GenFdsGlobalVariable
.MacroExtend(Key
)
645 Target
, Tag
, Arch
= Key
.split('_')
646 if Arch
in CurArchList
:
647 ArchList
.append(Arch
)
648 if Target
not in self
.TargetOverrideList
:
649 self
.TargetOverrideList
.append(Target
)
651 ArchList
= CurArchList
653 UseArchList
= TargetArchList
654 if self
.UseArch
is not None:
656 UseArchList
.append(self
.UseArch
)
657 ArchList
= list(set (UseArchList
) & set (ArchList
))
659 self
.InfFileName
= NormPath(self
.InfFileName
)
660 if len(PlatformArchList
) == 0:
662 PathClassObj
= PathClass(self
.InfFileName
, GenFdsGlobalVariable
.WorkSpaceDir
)
663 ErrorCode
, ErrorInfo
= PathClassObj
.Validate(".inf")
665 EdkLogger
.error("GenFds", ErrorCode
, ExtraData
=ErrorInfo
)
666 if len(ArchList
) == 1:
669 elif len(ArchList
) > 1:
670 if len(PlatformArchList
) == 0:
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
))
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
))
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." \
676 % (self
.InfFileName
, str(PlatformArchList
), GenFdsGlobalVariable
.ActivePlatform
, str(set (UseArchList
) & set (TargetArchList
))))
678 ## __GetEFIOutPutPath__() method
680 # Get the output path for generated files
682 # @param self The object pointer
683 # @retval string Path that output files from this INF go to
685 def __GetEFIOutPutPath__(self
):
689 (ModulePath
, FileName
) = os
.path
.split(self
.InfFileName
)
690 Index
= FileName
.rfind('.')
691 FileName
= FileName
[0:Index
]
692 if self
.OverrideGuid
:
693 FileName
= self
.OverrideGuid
695 if self
.CurrentArch
is not None:
696 Arch
= self
.CurrentArch
698 OutputPath
= os
.path
.join(GenFdsGlobalVariable
.OutputDirDict
[Arch
],
704 DebugPath
= os
.path
.join(GenFdsGlobalVariable
.OutputDirDict
[Arch
],
710 OutputPath
= os
.path
.realpath(OutputPath
)
711 DebugPath
= os
.path
.realpath(DebugPath
)
712 return OutputPath
, DebugPath
714 ## __GenSimpleFileSection__() method
716 # Generate section by specified file name or a list of files with file extension
718 # @param self The object pointer
719 # @param Rule The rule object used to generate section
720 # @retval string File name of the generated section file
722 def __GenSimpleFileSection__(self
, Rule
, IsMakefile
= False):
724 # Prepare the parameter of GenSection
728 GenSecInputFile
= None
729 if Rule
.FileName
is not None:
730 GenSecInputFile
= self
.__ExtendMacro
__(Rule
.FileName
)
731 if os
.path
.isabs(GenSecInputFile
):
732 GenSecInputFile
= os
.path
.normpath(GenSecInputFile
)
734 GenSecInputFile
= os
.path
.normpath(os
.path
.join(self
.EfiOutputPath
, GenSecInputFile
))
736 FileList
, IsSect
= Section
.Section
.GetFileList(self
, '', Rule
.FileExtension
)
739 SectionType
= Rule
.SectionType
741 # Convert Fv Section Type for PI1.1 SMM driver.
743 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) >= 0x0001000A:
744 if SectionType
== 'DXE_DEPEX':
745 SectionType
= 'SMM_DEPEX'
747 # Framework SMM Driver has no SMM_DEPEX section type
749 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) < 0x0001000A:
750 if SectionType
== 'SMM_DEPEX':
751 EdkLogger
.error("GenFds", FORMAT_NOT_SUPPORTED
, "Framework SMM module doesn't support SMM_DEPEX section type", File
=self
.InfFileName
)
753 if self
.ModuleType
in ('SEC', 'PEI_CORE', 'PEIM'):
754 if self
.KeepReloc
is not None:
755 NoStrip
= self
.KeepReloc
756 elif Rule
.KeepReloc
is not None:
757 NoStrip
= Rule
.KeepReloc
758 elif self
.ShadowFromInfFile
is not None:
759 NoStrip
= self
.ShadowFromInfFile
762 for File
in FileList
:
765 GenSecOutputFile
= self
.__ExtendMacro
__(Rule
.NameGuid
) + \
766 Ffs
.Ffs
.SectionSuffix
[SectionType
] + 'SEC' + SecNum
768 OutputFile
= os
.path
.join(self
.OutputPath
, GenSecOutputFile
)
769 File
= GenFdsGlobalVariable
.MacroExtend(File
, Dict
, self
.CurrentArch
)
771 #Get PE Section alignment when align is set to AUTO
772 if self
.Alignment
== 'Auto' and (SectionType
== 'PE32' or SectionType
== 'TE'):
773 ImageObj
= PeImageClass (File
)
774 if ImageObj
.SectionAlignment
< 0x400:
775 self
.Alignment
= str (ImageObj
.SectionAlignment
)
776 elif ImageObj
.SectionAlignment
< 0x100000:
777 self
.Alignment
= str (ImageObj
.SectionAlignment
/ 0x400) + 'K'
779 self
.Alignment
= str (ImageObj
.SectionAlignment
/ 0x100000) + 'M'
782 FileBeforeStrip
= os
.path
.join(self
.OutputPath
, ModuleName
+ '.reloc')
783 if not os
.path
.exists(FileBeforeStrip
) or \
784 (os
.path
.getmtime(File
) > os
.path
.getmtime(FileBeforeStrip
)):
785 CopyLongFilePath(File
, FileBeforeStrip
)
786 StrippedFile
= os
.path
.join(self
.OutputPath
, ModuleName
+ '.stipped')
787 GenFdsGlobalVariable
.GenerateFirmwareImage(
791 IsMakefile
=IsMakefile
795 if SectionType
== 'TE':
796 TeFile
= os
.path
.join( self
.OutputPath
, self
.ModuleGuid
+ 'Te.raw')
797 GenFdsGlobalVariable
.GenerateFirmwareImage(
801 IsMakefile
=IsMakefile
804 GenFdsGlobalVariable
.GenerateSection(OutputFile
, [File
], Section
.Section
.SectionType
[SectionType
], IsMakefile
=IsMakefile
)
805 OutputFileList
.append(OutputFile
)
808 GenSecOutputFile
= self
.__ExtendMacro
__(Rule
.NameGuid
) + \
809 Ffs
.Ffs
.SectionSuffix
[SectionType
] + 'SEC' + SecNum
810 OutputFile
= os
.path
.join(self
.OutputPath
, GenSecOutputFile
)
811 GenSecInputFile
= GenFdsGlobalVariable
.MacroExtend(GenSecInputFile
, Dict
, self
.CurrentArch
)
813 #Get PE Section alignment when align is set to AUTO
814 if self
.Alignment
== 'Auto' and (SectionType
== 'PE32' or SectionType
== 'TE'):
815 ImageObj
= PeImageClass (GenSecInputFile
)
816 if ImageObj
.SectionAlignment
< 0x400:
817 self
.Alignment
= str (ImageObj
.SectionAlignment
)
818 elif ImageObj
.SectionAlignment
< 0x100000:
819 self
.Alignment
= str (ImageObj
.SectionAlignment
/ 0x400) + 'K'
821 self
.Alignment
= str (ImageObj
.SectionAlignment
/ 0x100000) + 'M'
824 FileBeforeStrip
= os
.path
.join(self
.OutputPath
, ModuleName
+ '.reloc')
825 if not os
.path
.exists(FileBeforeStrip
) or \
826 (os
.path
.getmtime(GenSecInputFile
) > os
.path
.getmtime(FileBeforeStrip
)):
827 CopyLongFilePath(GenSecInputFile
, FileBeforeStrip
)
829 StrippedFile
= os
.path
.join(self
.OutputPath
, ModuleName
+ '.stipped')
830 GenFdsGlobalVariable
.GenerateFirmwareImage(
834 IsMakefile
=IsMakefile
836 GenSecInputFile
= StrippedFile
838 if SectionType
== 'TE':
839 TeFile
= os
.path
.join( self
.OutputPath
, self
.ModuleGuid
+ 'Te.raw')
840 GenFdsGlobalVariable
.GenerateFirmwareImage(
844 IsMakefile
=IsMakefile
846 GenSecInputFile
= TeFile
847 GenFdsGlobalVariable
.GenerateSection(OutputFile
, [GenSecInputFile
], Section
.Section
.SectionType
[SectionType
], IsMakefile
=IsMakefile
)
848 OutputFileList
.append(OutputFile
)
850 return OutputFileList
852 ## __GenSimpleFileFfs__() method
856 # @param self The object pointer
857 # @param Rule The rule object used to generate section
858 # @param InputFileList The output file list from GenSection
859 # @retval string Generated FFS file name
861 def __GenSimpleFileFfs__(self
, Rule
, InputFileList
, MakefilePath
= None):
862 FfsOutput
= self
.OutputPath
+ \
864 self
.__ExtendMacro
__(Rule
.NameGuid
) + \
867 GenFdsGlobalVariable
.VerboseLogger(self
.__ExtendMacro
__(Rule
.NameGuid
))
869 SectionAlignments
= []
870 for InputFile
in InputFileList
:
871 InputSection
.append(InputFile
)
872 SectionAlignments
.append(Rule
.SectAlignment
)
874 if Rule
.NameGuid
is not None and Rule
.NameGuid
.startswith('PCD('):
875 PcdValue
= GenFdsGlobalVariable
.GetPcdValue(Rule
.NameGuid
)
876 if len(PcdValue
) == 0:
877 EdkLogger
.error("GenFds", GENFDS_ERROR
, '%s NOT defined.' \
879 if PcdValue
.startswith('{'):
880 PcdValue
= GuidStructureByteArrayToGuidString(PcdValue
)
881 RegistryGuidStr
= PcdValue
882 if len(RegistryGuidStr
) == 0:
883 EdkLogger
.error("GenFds", GENFDS_ERROR
, 'GUID value for %s in wrong format.' \
885 self
.ModuleGuid
= RegistryGuidStr
887 GenFdsGlobalVariable
.GenerateFfs(FfsOutput
, InputSection
,
888 Ffs
.Ffs
.FdfFvFileTypeToFileType
[Rule
.FvFileType
],
889 self
.ModuleGuid
, Fixed
=Rule
.Fixed
,
890 CheckSum
=Rule
.CheckSum
, Align
=Rule
.Alignment
,
891 SectionAlign
=SectionAlignments
,
892 MakefilePath
=MakefilePath
896 ## __GenComplexFileSection__() method
898 # Generate section by sections in Rule
900 # @param self The object pointer
901 # @param Rule The rule object used to generate section
902 # @param FvChildAddr Array of the inside FvImage base address
903 # @param FvParentAddr Parent Fv base address
904 # @retval string File name of the generated section file
906 def __GenComplexFileSection__(self
, Rule
, FvChildAddr
, FvParentAddr
, IsMakefile
= False):
907 if self
.ModuleType
in ('SEC', 'PEI_CORE', 'PEIM'):
908 if Rule
.KeepReloc
is not None:
909 self
.KeepRelocFromRule
= Rule
.KeepReloc
913 HasGeneratedFlag
= False
914 if self
.PcdIsDriver
== 'PEI_PCD_DRIVER':
915 if self
.IsBinaryModule
:
916 PcdExDbFileName
= os
.path
.join(GenFdsGlobalVariable
.FvDir
, "PEIPcdDataBase.raw")
918 PcdExDbFileName
= os
.path
.join(self
.EfiOutputPath
, "PEIPcdDataBase.raw")
919 PcdExDbSecName
= os
.path
.join(self
.OutputPath
, "PEIPcdDataBaseSec.raw")
920 GenFdsGlobalVariable
.GenerateSection(PcdExDbSecName
,
923 IsMakefile
= IsMakefile
925 SectFiles
.append(PcdExDbSecName
)
926 SectAlignments
.append(None)
927 elif self
.PcdIsDriver
== 'DXE_PCD_DRIVER':
928 if self
.IsBinaryModule
:
929 PcdExDbFileName
= os
.path
.join(GenFdsGlobalVariable
.FvDir
, "DXEPcdDataBase.raw")
931 PcdExDbFileName
= os
.path
.join(self
.EfiOutputPath
, "DXEPcdDataBase.raw")
932 PcdExDbSecName
= os
.path
.join(self
.OutputPath
, "DXEPcdDataBaseSec.raw")
933 GenFdsGlobalVariable
.GenerateSection(PcdExDbSecName
,
936 IsMakefile
= IsMakefile
938 SectFiles
.append(PcdExDbSecName
)
939 SectAlignments
.append(None)
940 for Sect
in Rule
.SectionList
:
941 SecIndex
= '%d' %Index
944 # Convert Fv Section Type for PI1.1 SMM driver.
946 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) >= 0x0001000A:
947 if Sect
.SectionType
== 'DXE_DEPEX':
948 Sect
.SectionType
= 'SMM_DEPEX'
950 # Framework SMM Driver has no SMM_DEPEX section type
952 if self
.ModuleType
== 'DXE_SMM_DRIVER' and int(self
.PiSpecVersion
, 16) < 0x0001000A:
953 if Sect
.SectionType
== 'SMM_DEPEX':
954 EdkLogger
.error("GenFds", FORMAT_NOT_SUPPORTED
, "Framework SMM module doesn't support SMM_DEPEX section type", File
=self
.InfFileName
)
956 # process the inside FvImage from FvSection or GuidSection
958 if FvChildAddr
!= []:
959 if isinstance(Sect
, FvImageSection
):
960 Sect
.FvAddr
= FvChildAddr
.pop(0)
961 elif isinstance(Sect
, GuidSection
):
962 Sect
.FvAddr
= FvChildAddr
963 if FvParentAddr
is not None and isinstance(Sect
, GuidSection
):
964 Sect
.FvParentAddr
= FvParentAddr
966 if Rule
.KeyStringList
!= []:
967 SectList
, Align
= Sect
.GenSection(self
.OutputPath
, self
.ModuleGuid
, SecIndex
, Rule
.KeyStringList
, self
, IsMakefile
= IsMakefile
)
969 SectList
, Align
= Sect
.GenSection(self
.OutputPath
, self
.ModuleGuid
, SecIndex
, self
.KeyStringList
, self
, IsMakefile
= IsMakefile
)
971 if not HasGeneratedFlag
:
972 UniVfrOffsetFileSection
= ""
973 ModuleFileName
= mws
.join(GenFdsGlobalVariable
.WorkSpaceDir
, self
.InfFileName
)
974 InfData
= GenFdsGlobalVariable
.WorkSpace
.BuildObject
[PathClass(ModuleFileName
), self
.CurrentArch
]
976 # Search the source list in InfData to find if there are .vfr file exist.
979 VfrUniOffsetList
= []
980 for SourceFile
in InfData
.Sources
:
981 if SourceFile
.Type
.upper() == ".VFR" :
983 # search the .map file to find the offset of vfr binary in the PE32+/TE file.
985 VfrUniBaseName
[SourceFile
.BaseName
] = (SourceFile
.BaseName
+ "Bin")
986 if SourceFile
.Type
.upper() == ".UNI" :
988 # search the .map file to find the offset of Uni strings binary in the PE32+/TE file.
990 VfrUniBaseName
["UniOffsetName"] = (self
.BaseName
+ "Strings")
993 if len(VfrUniBaseName
) > 0:
995 if InfData
.BuildType
!= 'UEFI_HII':
996 UniVfrOffsetFileName
= os
.path
.join(self
.OutputPath
, self
.BaseName
+ '.offset')
997 UniVfrOffsetFileSection
= os
.path
.join(self
.OutputPath
, self
.BaseName
+ 'Offset' + '.raw')
998 UniVfrOffsetFileNameList
= []
999 UniVfrOffsetFileNameList
.append(UniVfrOffsetFileName
)
1000 TrimCmd
= "Trim --Vfr-Uni-Offset -o %s --ModuleName=%s --DebugDir=%s " % (UniVfrOffsetFileName
, self
.BaseName
, self
.EfiDebugPath
)
1001 GenFdsGlobalVariable
.SecCmdList
.append(TrimCmd
)
1002 GenFdsGlobalVariable
.GenerateSection(UniVfrOffsetFileSection
,
1003 [UniVfrOffsetFileName
],
1008 VfrUniOffsetList
= self
.__GetBuildOutputMapFileVfrUniInfo
(VfrUniBaseName
)
1010 # Generate the Raw data of raw section
1012 if VfrUniOffsetList
:
1013 UniVfrOffsetFileName
= os
.path
.join(self
.OutputPath
, self
.BaseName
+ '.offset')
1014 UniVfrOffsetFileSection
= os
.path
.join(self
.OutputPath
, self
.BaseName
+ 'Offset' + '.raw')
1015 FfsInfStatement
.__GenUniVfrOffsetFile
(VfrUniOffsetList
, UniVfrOffsetFileName
)
1016 UniVfrOffsetFileNameList
= []
1017 UniVfrOffsetFileNameList
.append(UniVfrOffsetFileName
)
1018 """Call GenSection"""
1020 GenFdsGlobalVariable
.GenerateSection(UniVfrOffsetFileSection
,
1021 UniVfrOffsetFileNameList
,
1024 #os.remove(UniVfrOffsetFileName)
1025 if UniVfrOffsetFileSection
:
1026 SectList
.append(UniVfrOffsetFileSection
)
1027 HasGeneratedFlag
= True
1029 for SecName
in SectList
:
1030 SectFiles
.append(SecName
)
1031 SectAlignments
.append(Align
)
1033 return SectFiles
, SectAlignments
1035 ## __GenComplexFileFfs__() method
1039 # @param self The object pointer
1040 # @param Rule The rule object used to generate section
1041 # @param InputFileList The output file list from GenSection
1042 # @retval string Generated FFS file name
1044 def __GenComplexFileFfs__(self
, Rule
, InputFile
, Alignments
, MakefilePath
= None):
1046 if Rule
.NameGuid
is not None and Rule
.NameGuid
.startswith('PCD('):
1047 PcdValue
= GenFdsGlobalVariable
.GetPcdValue(Rule
.NameGuid
)
1048 if len(PcdValue
) == 0:
1049 EdkLogger
.error("GenFds", GENFDS_ERROR
, '%s NOT defined.' \
1051 if PcdValue
.startswith('{'):
1052 PcdValue
= GuidStructureByteArrayToGuidString(PcdValue
)
1053 RegistryGuidStr
= PcdValue
1054 if len(RegistryGuidStr
) == 0:
1055 EdkLogger
.error("GenFds", GENFDS_ERROR
, 'GUID value for %s in wrong format.' \
1057 self
.ModuleGuid
= RegistryGuidStr
1059 FfsOutput
= os
.path
.join( self
.OutputPath
, self
.ModuleGuid
+ '.ffs')
1060 GenFdsGlobalVariable
.GenerateFfs(FfsOutput
, InputFile
,
1061 Ffs
.Ffs
.FdfFvFileTypeToFileType
[Rule
.FvFileType
],
1062 self
.ModuleGuid
, Fixed
=Rule
.Fixed
,
1063 CheckSum
=Rule
.CheckSum
, Align
=Rule
.Alignment
,
1064 SectionAlign
=Alignments
,
1065 MakefilePath
=MakefilePath
1069 ## __GetBuildOutputMapFileVfrUniInfo() method
1071 # Find the offset of UNI/INF object offset in the EFI image file.
1073 # @param self The object pointer
1074 # @param VfrUniBaseName A name list contain the UNI/INF object name.
1075 # @retval RetValue A list contain offset of UNI/INF object.
1077 def __GetBuildOutputMapFileVfrUniInfo(self
, VfrUniBaseName
):
1078 MapFileName
= os
.path
.join(self
.EfiOutputPath
, self
.BaseName
+ ".map")
1079 EfiFileName
= os
.path
.join(self
.EfiOutputPath
, self
.BaseName
+ ".efi")
1080 return GetVariableOffset(MapFileName
, EfiFileName
, VfrUniBaseName
.values())
1082 ## __GenUniVfrOffsetFile() method
1084 # Generate the offset file for the module which contain VFR or UNI file.
1086 # @param VfrUniOffsetList A list contain the VFR/UNI offsets in the EFI image file.
1087 # @param UniVfrOffsetFileName The output offset file name.
1090 def __GenUniVfrOffsetFile(VfrUniOffsetList
, UniVfrOffsetFileName
):
1092 # Use a instance of StringIO to cache data
1093 fStringIO
= StringIO
.StringIO('')
1095 for Item
in VfrUniOffsetList
:
1096 if (Item
[0].find("Strings") != -1):
1098 # UNI offset in image.
1100 # { 0x8913c5e0, 0x33f6, 0x4d86, { 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66 } }
1102 UniGuid
= [0xe0, 0xc5, 0x13, 0x89, 0xf6, 0x33, 0x86, 0x4d, 0x9b, 0xf1, 0x43, 0xef, 0x89, 0xfc, 0x6, 0x66]
1103 UniGuid
= [chr(ItemGuid
) for ItemGuid
in UniGuid
]
1104 fStringIO
.write(''.join(UniGuid
))
1105 UniValue
= pack ('Q', int (Item
[1], 16))
1106 fStringIO
.write (UniValue
)
1109 # VFR binary offset in image.
1111 # { 0xd0bc7cb4, 0x6a47, 0x495f, { 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2 } };
1113 VfrGuid
= [0xb4, 0x7c, 0xbc, 0xd0, 0x47, 0x6a, 0x5f, 0x49, 0xaa, 0x11, 0x71, 0x7, 0x46, 0xda, 0x6, 0xa2]
1114 VfrGuid
= [chr(ItemGuid
) for ItemGuid
in VfrGuid
]
1115 fStringIO
.write(''.join(VfrGuid
))
1117 VfrValue
= pack ('Q', int (Item
[1], 16))
1118 fStringIO
.write (VfrValue
)
1121 # write data into file.
1124 SaveFileOnChange(UniVfrOffsetFileName
, fStringIO
.getvalue())
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)