2 # Routines for generating build report.
4 # This module contains the functionality to generate build report after
5 # build all target completes successfully.
7 # Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
8 # This program and the accompanying materials
9 # are licensed and made available under the terms and conditions of the BSD License
10 # which accompanies this distribution. The full text of the license may be found at
11 # http://opensource.org/licenses/bsd-license.php
13 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
14 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
19 import Common
.LongFilePathOs
as os
30 from datetime
import datetime
31 from StringIO
import StringIO
32 from Common
import EdkLogger
33 from Common
.Misc
import SaveFileOnChange
34 from Common
.Misc
import GuidStructureByteArrayToGuidString
35 from Common
.Misc
import GuidStructureStringToGuidString
36 from Common
.InfClassObject
import gComponentType2ModuleType
37 from Common
.BuildToolError
import FILE_WRITE_FAILURE
38 from Common
.BuildToolError
import CODE_ERROR
39 from Common
.BuildToolError
import COMMAND_FAILURE
40 from Common
.BuildToolError
import FORMAT_INVALID
41 from Common
.LongFilePathSupport
import OpenLongFilePath
as open
42 from Common
.MultipleWorkspace
import MultipleWorkspace
as mws
43 import Common
.GlobalData
as GlobalData
44 from AutoGen
.AutoGen
import ModuleAutoGen
45 from Common
.Misc
import PathClass
46 from Common
.String
import NormPath
47 from Common
.DataType
import *
49 from Common
.Expression
import *
51 ## Pattern to extract contents in EDK DXS files
52 gDxsDependencyPattern
= re
.compile(r
"DEPENDENCY_START(.+)DEPENDENCY_END", re
.DOTALL
)
54 ## Pattern to find total FV total size, occupied size in flash report intermediate file
55 gFvTotalSizePattern
= re
.compile(r
"EFI_FV_TOTAL_SIZE = (0x[0-9a-fA-F]+)")
56 gFvTakenSizePattern
= re
.compile(r
"EFI_FV_TAKEN_SIZE = (0x[0-9a-fA-F]+)")
58 ## Pattern to find module size and time stamp in module summary report intermediate file
59 gModuleSizePattern
= re
.compile(r
"MODULE_SIZE = (\d+)")
60 gTimeStampPattern
= re
.compile(r
"TIME_STAMP = (\d+)")
62 ## Pattern to find GUID value in flash description files
63 gPcdGuidPattern
= re
.compile(r
"PCD\((\w+)[.](\w+)\)")
65 ## Pattern to collect offset, GUID value pair in the flash report intermediate file
66 gOffsetGuidPattern
= re
.compile(r
"(0x[0-9A-Fa-f]+) ([-A-Fa-f0-9]+)")
68 ## Pattern to find module base address and entry point in fixed flash map file
69 gModulePattern
= r
"\n[-\w]+\s*\(([^,]+),\s*BaseAddress=%(Address)s,\s*EntryPoint=%(Address)s\)\s*\(GUID=([-0-9A-Fa-f]+)[^)]*\)"
70 gMapFileItemPattern
= re
.compile(gModulePattern
% {"Address" : "(-?0[xX][0-9A-Fa-f]+)"})
72 ## Pattern to find all module referenced header files in source files
73 gIncludePattern
= re
.compile(r
'#include\s*["<]([^">]+)[">]')
74 gIncludePattern2
= re
.compile(r
"#include\s+EFI_([A-Z_]+)\s*[(]\s*(\w+)\s*[)]")
76 ## Pattern to find the entry point for EDK module using EDKII Glue library
77 gGlueLibEntryPoint
= re
.compile(r
"__EDKII_GLUE_MODULE_ENTRY_POINT__\s*=\s*(\w+)")
79 ## Tags for MaxLength of line in report
82 ## Tags for end of line in report
85 ## Tags for section start, end and separator
86 gSectionStart
= ">" + "=" * (gLineMaxLength
- 2) + "<"
87 gSectionEnd
= "<" + "=" * (gLineMaxLength
- 2) + ">" + "\n"
88 gSectionSep
= "=" * gLineMaxLength
90 ## Tags for subsection start, end and separator
91 gSubSectionStart
= ">" + "-" * (gLineMaxLength
- 2) + "<"
92 gSubSectionEnd
= "<" + "-" * (gLineMaxLength
- 2) + ">"
93 gSubSectionSep
= "-" * gLineMaxLength
96 ## The look up table to map PCD type to pair of report display type and DEC type
98 'FixedAtBuild' : ('FIXED', 'FixedAtBuild'),
99 'PatchableInModule': ('PATCH', 'PatchableInModule'),
100 'FeatureFlag' : ('FLAG', 'FeatureFlag'),
101 'Dynamic' : ('DYN', 'Dynamic'),
102 'DynamicHii' : ('DYNHII', 'Dynamic'),
103 'DynamicVpd' : ('DYNVPD', 'Dynamic'),
104 'DynamicEx' : ('DEX', 'DynamicEx'),
105 'DynamicExHii' : ('DEXHII', 'DynamicEx'),
106 'DynamicExVpd' : ('DEXVPD', 'DynamicEx'),
109 ## The look up table to map module type to driver type
111 'SEC' : '0x3 (SECURITY_CORE)',
112 'PEI_CORE' : '0x4 (PEI_CORE)',
113 'PEIM' : '0x6 (PEIM)',
114 'DXE_CORE' : '0x5 (DXE_CORE)',
115 'DXE_DRIVER' : '0x7 (DRIVER)',
116 'DXE_SAL_DRIVER' : '0x7 (DRIVER)',
117 'DXE_SMM_DRIVER' : '0x7 (DRIVER)',
118 'DXE_RUNTIME_DRIVER': '0x7 (DRIVER)',
119 'UEFI_DRIVER' : '0x7 (DRIVER)',
120 'UEFI_APPLICATION' : '0x9 (APPLICATION)',
121 'SMM_CORE' : '0xD (SMM_CORE)',
122 'SMM_DRIVER' : '0xA (SMM)', # Extension of module type to support PI 1.1 SMM drivers
123 'MM_STANDALONE' : '0xE (MM_STANDALONE)',
124 'MM_CORE_STANDALONE' : '0xF (MM_CORE_STANDALONE)'
127 ## The look up table of the supported opcode in the dependency expression binaries
128 gOpCodeList
= ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"]
131 # Writes a string to the file object.
133 # This function writes a string to the file object and a new line is appended
134 # afterwards. It may optionally wraps the string for better readability.
136 # @File The file object to write
137 # @String The string to be written to the file
138 # @Wrapper Indicates whether to wrap the string
140 def FileWrite(File
, String
, Wrapper
=False):
142 String
= textwrap
.fill(String
, 120)
143 File
.write(String
+ gEndOfLine
)
145 def ByteArrayForamt(Value
):
149 if Value
.startswith('{') and Value
.endswith('}'):
151 ValueList
= Value
.split(',')
152 if len(ValueList
) >= SplitNum
:
156 Len
= len(ValueList
)/SplitNum
157 for i
, element
in enumerate(ValueList
):
158 ValueList
[i
] = '0x%02X' % int(element
.strip(), 16)
162 End
= min(SplitNum
*(Id
+1), len(ValueList
))
163 Str
= ','.join(ValueList
[SplitNum
*Id
: End
])
164 if End
== len(ValueList
):
166 ArrayList
.append(Str
)
170 ArrayList
.append(Str
)
173 ArrayList
= [Value
+ '}']
174 return IsByteArray
, ArrayList
177 # Find all the header file that the module source directly includes.
179 # This function scans source code to find all header files the module may
180 # include. This is not accurate but very effective to find all the header
181 # file the module might include with #include statement.
183 # @Source The source file name
184 # @IncludePathList The list of include path to find the source file.
185 # @IncludeFiles The dictionary of current found include files.
187 def FindIncludeFiles(Source
, IncludePathList
, IncludeFiles
):
188 FileContents
= open(Source
).read()
190 # Find header files with pattern #include "XXX.h" or #include <XXX.h>
192 for Match
in gIncludePattern
.finditer(FileContents
):
193 FileName
= Match
.group(1).strip()
194 for Dir
in [os
.path
.dirname(Source
)] + IncludePathList
:
195 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
196 if os
.path
.exists(FullFileName
):
197 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
201 # Find header files with pattern like #include EFI_PPI_CONSUMER(XXX)
203 for Match
in gIncludePattern2
.finditer(FileContents
):
205 Type
= Match
.group(1)
206 if "ARCH_PROTOCOL" in Type
:
207 FileName
= "ArchProtocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
208 elif "PROTOCOL" in Type
:
209 FileName
= "Protocol/%(Key)s/%(Key)s.h" % {"Key" : Key
}
211 FileName
= "Ppi/%(Key)s/%(Key)s.h" % {"Key" : Key
}
213 FileName
= "Guid/%(Key)s/%(Key)s.h" % {"Key" : Key
}
216 for Dir
in IncludePathList
:
217 FullFileName
= os
.path
.normpath(os
.path
.join(Dir
, FileName
))
218 if os
.path
.exists(FullFileName
):
219 IncludeFiles
[FullFileName
.lower().replace("\\", "/")] = FullFileName
222 ## Split each lines in file
224 # This method is used to split the lines in file to make the length of each line
225 # less than MaxLength.
227 # @param Content The content of file
228 # @param MaxLength The Max Length of the line
230 def FileLinesSplit(Content
=None, MaxLength
=None):
231 ContentList
= Content
.split(TAB_LINE_BREAK
)
234 for Line
in ContentList
:
235 while len(Line
.rstrip()) > MaxLength
:
236 LineSpaceIndex
= Line
.rfind(TAB_SPACE_SPLIT
, 0, MaxLength
)
237 LineSlashIndex
= Line
.rfind(TAB_SLASH
, 0, MaxLength
)
238 LineBackSlashIndex
= Line
.rfind(TAB_BACK_SLASH
, 0, MaxLength
)
239 if max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
) > 0:
240 LineBreakIndex
= max(LineSpaceIndex
, LineSlashIndex
, LineBackSlashIndex
)
242 LineBreakIndex
= MaxLength
243 NewContentList
.append(Line
[:LineBreakIndex
])
244 Line
= Line
[LineBreakIndex
:]
246 NewContentList
.append(Line
)
247 for NewLine
in NewContentList
:
248 NewContent
+= NewLine
+ TAB_LINE_BREAK
250 NewContent
= NewContent
.replace(TAB_LINE_BREAK
, gEndOfLine
).replace('\r\r\n', gEndOfLine
)
256 # Parse binary dependency expression section
258 # This utility class parses the dependency expression section and translate the readable
259 # GUID name and value.
261 class DepexParser(object):
263 # Constructor function for class DepexParser
265 # This constructor function collect GUID values so that the readable
266 # GUID name can be translated.
268 # @param self The object pointer
269 # @param Wa Workspace context information
271 def __init__(self
, Wa
):
273 for Pa
in Wa
.AutoGenObjectList
:
274 for Package
in Pa
.PackageList
:
275 for Protocol
in Package
.Protocols
:
276 GuidValue
= GuidStructureStringToGuidString(Package
.Protocols
[Protocol
])
277 self
._GuidDb
[GuidValue
.upper()] = Protocol
278 for Ppi
in Package
.Ppis
:
279 GuidValue
= GuidStructureStringToGuidString(Package
.Ppis
[Ppi
])
280 self
._GuidDb
[GuidValue
.upper()] = Ppi
281 for Guid
in Package
.Guids
:
282 GuidValue
= GuidStructureStringToGuidString(Package
.Guids
[Guid
])
283 self
._GuidDb
[GuidValue
.upper()] = Guid
286 # Parse the binary dependency expression files.
288 # This function parses the binary dependency expression file and translate it
289 # to the instruction list.
291 # @param self The object pointer
292 # @param DepexFileName The file name of binary dependency expression file.
294 def ParseDepexFile(self
, DepexFileName
):
295 DepexFile
= open(DepexFileName
, "rb")
297 OpCode
= DepexFile
.read(1)
299 Statement
= gOpCodeList
[struct
.unpack("B", OpCode
)[0]]
300 if Statement
in ["BEFORE", "AFTER", "PUSH"]:
301 GuidValue
= "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X" % \
302 struct
.unpack("=LHHBBBBBBBB", DepexFile
.read(16))
303 GuidString
= self
._GuidDb
.get(GuidValue
, GuidValue
)
304 Statement
= "%s %s" % (Statement
, GuidString
)
305 DepexStatement
.append(Statement
)
306 OpCode
= DepexFile
.read(1)
308 return DepexStatement
311 # Reports library information
313 # This class reports the module library subsection in the build report file.
315 class LibraryReport(object):
317 # Constructor function for class LibraryReport
319 # This constructor function generates LibraryReport object for
322 # @param self The object pointer
323 # @param M Module context information
325 def __init__(self
, M
):
326 self
.LibraryList
= []
327 if int(str(M
.AutoGenVersion
), 0) >= 0x00010005:
328 self
._EdkIIModule
= True
330 self
._EdkIIModule
= False
332 for Lib
in M
.DependentLibraryList
:
333 LibInfPath
= str(Lib
)
334 LibClassList
= Lib
.LibraryClass
[0].LibraryClass
335 LibConstructorList
= Lib
.ConstructorList
336 LibDesstructorList
= Lib
.DestructorList
337 LibDepexList
= Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]
338 for LibAutoGen
in M
.LibraryAutoGenList
:
339 if LibInfPath
== LibAutoGen
.MetaFile
.Path
:
340 LibTime
= LibAutoGen
.BuildTime
342 self
.LibraryList
.append((LibInfPath
, LibClassList
, LibConstructorList
, LibDesstructorList
, LibDepexList
, LibTime
))
345 # Generate report for module library information
347 # This function generates report for the module library.
348 # If the module is EDKII style one, the additional library class, library
349 # constructor/destructor and dependency expression may also be reported.
351 # @param self The object pointer
352 # @param File The file object for report
354 def GenerateReport(self
, File
):
355 if len(self
.LibraryList
) > 0:
356 FileWrite(File
, gSubSectionStart
)
357 FileWrite(File
, TAB_BRG_LIBRARY
)
358 FileWrite(File
, gSubSectionSep
)
359 for LibraryItem
in self
.LibraryList
:
360 LibInfPath
= LibraryItem
[0]
361 FileWrite(File
, LibInfPath
)
364 # Report library class, library constructor and destructor for
365 # EDKII style module.
367 if self
._EdkIIModule
:
368 LibClass
= LibraryItem
[1]
370 LibConstructor
= " ".join(LibraryItem
[2])
372 EdkIILibInfo
+= " C = " + LibConstructor
373 LibDestructor
= " ".join(LibraryItem
[3])
375 EdkIILibInfo
+= " D = " + LibDestructor
376 LibDepex
= " ".join(LibraryItem
[4])
378 EdkIILibInfo
+= " Depex = " + LibDepex
380 EdkIILibInfo
+= " Time = " + LibraryItem
[5]
382 FileWrite(File
, "{%s: %s}" % (LibClass
, EdkIILibInfo
))
384 FileWrite(File
, "{%s}" % LibClass
)
386 FileWrite(File
, gSubSectionEnd
)
389 # Reports dependency expression information
391 # This class reports the module dependency expression subsection in the build report file.
393 class DepexReport(object):
395 # Constructor function for class DepexReport
397 # This constructor function generates DepexReport object for
398 # a module. If the module source contains the DXS file (usually EDK
399 # style module), it uses the dependency in DXS file; otherwise,
400 # it uses the dependency expression from its own INF [Depex] section
401 # and then merges with the ones from its dependent library INF.
403 # @param self The object pointer
404 # @param M Module context information
406 def __init__(self
, M
):
408 self
._DepexFileName
= os
.path
.join(M
.BuildDir
, "OUTPUT", M
.Module
.BaseName
+ ".depex")
409 ModuleType
= M
.ModuleType
411 ModuleType
= gComponentType2ModuleType
.get(M
.ComponentType
, "")
413 if ModuleType
in ["SEC", "PEI_CORE", "DXE_CORE", "SMM_CORE", "MM_CORE_STANDALONE", "UEFI_APPLICATION"]:
416 for Source
in M
.SourceFileList
:
417 if os
.path
.splitext(Source
.Path
)[1].lower() == ".dxs":
418 Match
= gDxsDependencyPattern
.search(open(Source
.Path
).read())
420 self
.Depex
= Match
.group(1).strip()
424 self
.Depex
= M
.DepexExpressionList
.get(M
.ModuleType
, "")
425 self
.ModuleDepex
= " ".join(M
.Module
.DepexExpression
[M
.Arch
, M
.ModuleType
])
426 if not self
.ModuleDepex
:
427 self
.ModuleDepex
= "(None)"
430 for Lib
in M
.DependentLibraryList
:
431 LibDepex
= " ".join(Lib
.DepexExpression
[M
.Arch
, M
.ModuleType
]).strip()
433 LibDepexList
.append("(" + LibDepex
+ ")")
434 self
.LibraryDepex
= " AND ".join(LibDepexList
)
435 if not self
.LibraryDepex
:
436 self
.LibraryDepex
= "(None)"
440 # Generate report for module dependency expression information
442 # This function generates report for the module dependency expression.
444 # @param self The object pointer
445 # @param File The file object for report
446 # @param GlobalDepexParser The platform global Dependency expression parser object
448 def GenerateReport(self
, File
, GlobalDepexParser
):
451 FileWrite(File
, gSubSectionStart
)
452 if os
.path
.isfile(self
._DepexFileName
):
454 DepexStatements
= GlobalDepexParser
.ParseDepexFile(self
._DepexFileName
)
455 FileWrite(File
, "Final Dependency Expression (DEPEX) Instructions")
456 for DepexStatement
in DepexStatements
:
457 FileWrite(File
, " %s" % DepexStatement
)
458 FileWrite(File
, gSubSectionSep
)
460 EdkLogger
.warn(None, "Dependency expression file is corrupted", self
._DepexFileName
)
462 FileWrite(File
, "Dependency Expression (DEPEX) from %s" % self
.Source
)
464 if self
.Source
== "INF":
465 FileWrite(File
, "%s" % self
.Depex
, True)
466 FileWrite(File
, gSubSectionSep
)
467 FileWrite(File
, "From Module INF: %s" % self
.ModuleDepex
, True)
468 FileWrite(File
, "From Library INF: %s" % self
.LibraryDepex
, True)
470 FileWrite(File
, "%s" % self
.Depex
)
471 FileWrite(File
, gSubSectionEnd
)
474 # Reports dependency expression information
476 # This class reports the module build flags subsection in the build report file.
478 class BuildFlagsReport(object):
480 # Constructor function for class BuildFlagsReport
482 # This constructor function generates BuildFlagsReport object for
483 # a module. It reports the build tool chain tag and all relevant
484 # build flags to build the module.
486 # @param self The object pointer
487 # @param M Module context information
489 def __init__(self
, M
):
492 # Add build flags according to source file extension so that
493 # irrelevant ones can be filtered out.
495 for Source
in M
.SourceFileList
:
496 Ext
= os
.path
.splitext(Source
.File
)[1].lower()
497 if Ext
in [".c", ".cc", ".cpp"]:
498 BuildOptions
["CC"] = 1
499 elif Ext
in [".s", ".asm"]:
500 BuildOptions
["PP"] = 1
501 BuildOptions
["ASM"] = 1
502 elif Ext
in [".vfr"]:
503 BuildOptions
["VFRPP"] = 1
504 BuildOptions
["VFR"] = 1
505 elif Ext
in [".dxs"]:
506 BuildOptions
["APP"] = 1
507 BuildOptions
["CC"] = 1
508 elif Ext
in [".asl"]:
509 BuildOptions
["ASLPP"] = 1
510 BuildOptions
["ASL"] = 1
511 elif Ext
in [".aslc"]:
512 BuildOptions
["ASLCC"] = 1
513 BuildOptions
["ASLDLINK"] = 1
514 BuildOptions
["CC"] = 1
515 elif Ext
in [".asm16"]:
516 BuildOptions
["ASMLINK"] = 1
517 BuildOptions
["SLINK"] = 1
518 BuildOptions
["DLINK"] = 1
521 # Save module build flags.
523 self
.ToolChainTag
= M
.ToolChain
525 for Tool
in BuildOptions
:
526 self
.BuildFlags
[Tool
+ "_FLAGS"] = M
.BuildOption
.get(Tool
, {}).get("FLAGS", "")
529 # Generate report for module build flags information
531 # This function generates report for the module build flags expression.
533 # @param self The object pointer
534 # @param File The file object for report
536 def GenerateReport(self
, File
):
537 FileWrite(File
, gSubSectionStart
)
538 FileWrite(File
, "Build Flags")
539 FileWrite(File
, "Tool Chain Tag: %s" % self
.ToolChainTag
)
540 for Tool
in self
.BuildFlags
:
541 FileWrite(File
, gSubSectionSep
)
542 FileWrite(File
, "%s = %s" % (Tool
, self
.BuildFlags
[Tool
]), True)
544 FileWrite(File
, gSubSectionEnd
)
548 # Reports individual module information
550 # This class reports the module section in the build report file.
551 # It comprises of module summary, module PCD, library, dependency expression,
552 # build flags sections.
554 class ModuleReport(object):
556 # Constructor function for class ModuleReport
558 # This constructor function generates ModuleReport object for
559 # a separate module in a platform build.
561 # @param self The object pointer
562 # @param M Module context information
563 # @param ReportType The kind of report items in the final report file
565 def __init__(self
, M
, ReportType
):
566 self
.ModuleName
= M
.Module
.BaseName
567 self
.ModuleInfPath
= M
.MetaFile
.File
568 self
.FileGuid
= M
.Guid
570 self
.BuildTimeStamp
= None
574 ModuleType
= M
.ModuleType
576 ModuleType
= gComponentType2ModuleType
.get(M
.ComponentType
, "")
578 # If a module complies to PI 1.1, promote Module type to "SMM_DRIVER"
580 if ModuleType
== "DXE_SMM_DRIVER":
581 PiSpec
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "0x00010000")
582 if int(PiSpec
, 0) >= 0x0001000A:
583 ModuleType
= "SMM_DRIVER"
584 self
.DriverType
= gDriverTypeMap
.get(ModuleType
, "0x2 (FREE_FORM)")
585 self
.UefiSpecVersion
= M
.Module
.Specification
.get("UEFI_SPECIFICATION_VERSION", "")
586 self
.PiSpecVersion
= M
.Module
.Specification
.get("PI_SPECIFICATION_VERSION", "")
587 self
.PciDeviceId
= M
.Module
.Defines
.get("PCI_DEVICE_ID", "")
588 self
.PciVendorId
= M
.Module
.Defines
.get("PCI_VENDOR_ID", "")
589 self
.PciClassCode
= M
.Module
.Defines
.get("PCI_CLASS_CODE", "")
590 self
.BuildTime
= M
.BuildTime
592 self
._BuildDir
= M
.BuildDir
593 self
.ModulePcdSet
= {}
594 if "PCD" in ReportType
:
596 # Collect all module used PCD set: module INF referenced directly or indirectly.
597 # It also saves module INF default values of them in case they exist.
599 for Pcd
in M
.ModulePcdList
+ M
.LibraryPcdList
:
600 self
.ModulePcdSet
.setdefault((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Pcd
.Type
), (Pcd
.InfDefaultValue
, Pcd
.DefaultValue
))
602 self
.LibraryReport
= None
603 if "LIBRARY" in ReportType
:
604 self
.LibraryReport
= LibraryReport(M
)
606 self
.DepexReport
= None
607 if "DEPEX" in ReportType
:
608 self
.DepexReport
= DepexReport(M
)
610 if "BUILD_FLAGS" in ReportType
:
611 self
.BuildFlagsReport
= BuildFlagsReport(M
)
615 # Generate report for module information
617 # This function generates report for separate module expression
618 # in a platform build.
620 # @param self The object pointer
621 # @param File The file object for report
622 # @param GlobalPcdReport The platform global PCD report object
623 # @param GlobalPredictionReport The platform global Prediction report object
624 # @param GlobalDepexParser The platform global Dependency expression parser object
625 # @param ReportType The kind of report items in the final report file
627 def GenerateReport(self
, File
, GlobalPcdReport
, GlobalPredictionReport
, GlobalDepexParser
, ReportType
):
628 FileWrite(File
, gSectionStart
)
630 FwReportFileName
= os
.path
.join(self
._BuildDir
, "DEBUG", self
.ModuleName
+ ".txt")
631 if os
.path
.isfile(FwReportFileName
):
633 FileContents
= open(FwReportFileName
).read()
634 Match
= gModuleSizePattern
.search(FileContents
)
636 self
.Size
= int(Match
.group(1))
638 Match
= gTimeStampPattern
.search(FileContents
)
640 self
.BuildTimeStamp
= datetime
.fromtimestamp(int(Match
.group(1)))
642 EdkLogger
.warn(None, "Fail to read report file", FwReportFileName
)
644 if "HASH" in ReportType
:
645 OutputDir
= os
.path
.join(self
._BuildDir
, "OUTPUT")
646 DefaultEFIfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ ".efi")
647 if os
.path
.isfile(DefaultEFIfile
):
648 Tempfile
= os
.path
.join(OutputDir
, self
.ModuleName
+ "_hash.tmp")
649 # rebase the efi image since its base address may not zero
650 cmd
= ["GenFw", "--rebase", str(0), "-o", Tempfile
, DefaultEFIfile
]
652 PopenObject
= subprocess
.Popen(' '.join(cmd
), stdout
=subprocess
.PIPE
, stderr
=subprocess
.PIPE
, shell
=True)
654 EdkLogger
.error("GenFw", COMMAND_FAILURE
, ExtraData
="%s: %s" % (str(X
), cmd
[0]))
655 EndOfProcedure
= threading
.Event()
656 EndOfProcedure
.clear()
657 if PopenObject
.stderr
:
658 StdErrThread
= threading
.Thread(target
=ReadMessage
, args
=(PopenObject
.stderr
, EdkLogger
.quiet
, EndOfProcedure
))
659 StdErrThread
.setName("STDERR-Redirector")
660 StdErrThread
.setDaemon(False)
662 # waiting for program exit
664 if PopenObject
.stderr
:
666 if PopenObject
.returncode
!= 0:
667 EdkLogger
.error("GenFw", COMMAND_FAILURE
, "Failed to generate firmware hash image for %s" % (DefaultEFIfile
))
668 if os
.path
.isfile(Tempfile
):
669 self
.Hash
= hashlib
.sha1()
670 buf
= open(Tempfile
, 'rb').read()
671 if self
.Hash
.update(buf
):
672 self
.Hash
= self
.Hash
.update(buf
)
673 self
.Hash
= self
.Hash
.hexdigest()
676 FileWrite(File
, "Module Summary")
677 FileWrite(File
, "Module Name: %s" % self
.ModuleName
)
678 FileWrite(File
, "Module INF Path: %s" % self
.ModuleInfPath
)
679 FileWrite(File
, "File GUID: %s" % self
.FileGuid
)
681 FileWrite(File
, "Size: 0x%X (%.2fK)" % (self
.Size
, self
.Size
/ 1024.0))
683 FileWrite(File
, "SHA1 HASH: %s *%s" % (self
.Hash
, self
.ModuleName
+ ".efi"))
684 if self
.BuildTimeStamp
:
685 FileWrite(File
, "Build Time Stamp: %s" % self
.BuildTimeStamp
)
687 FileWrite(File
, "Module Build Time: %s" % self
.BuildTime
)
689 FileWrite(File
, "Driver Type: %s" % self
.DriverType
)
690 if self
.UefiSpecVersion
:
691 FileWrite(File
, "UEFI Spec Version: %s" % self
.UefiSpecVersion
)
692 if self
.PiSpecVersion
:
693 FileWrite(File
, "PI Spec Version: %s" % self
.PiSpecVersion
)
695 FileWrite(File
, "PCI Device ID: %s" % self
.PciDeviceId
)
697 FileWrite(File
, "PCI Vendor ID: %s" % self
.PciVendorId
)
698 if self
.PciClassCode
:
699 FileWrite(File
, "PCI Class Code: %s" % self
.PciClassCode
)
701 FileWrite(File
, gSectionSep
)
703 if "PCD" in ReportType
:
704 GlobalPcdReport
.GenerateReport(File
, self
.ModulePcdSet
)
706 if "LIBRARY" in ReportType
:
707 self
.LibraryReport
.GenerateReport(File
)
709 if "DEPEX" in ReportType
:
710 self
.DepexReport
.GenerateReport(File
, GlobalDepexParser
)
712 if "BUILD_FLAGS" in ReportType
:
713 self
.BuildFlagsReport
.GenerateReport(File
)
715 if "FIXED_ADDRESS" in ReportType
and self
.FileGuid
:
716 GlobalPredictionReport
.GenerateReport(File
, self
.FileGuid
)
718 FileWrite(File
, gSectionEnd
)
720 def ReadMessage(From
, To
, ExitFlag
):
722 # read one line a time
723 Line
= From
.readline()
724 # empty string means "end"
725 if Line
!= None and Line
!= "":
733 # Reports platform and module PCD information
735 # This class reports the platform PCD section and module PCD subsection
736 # in the build report file.
738 class PcdReport(object):
740 # Constructor function for class PcdReport
742 # This constructor function generates PcdReport object a platform build.
743 # It collects the whole PCD database from platform DSC files, platform
744 # flash description file and package DEC files.
746 # @param self The object pointer
747 # @param Wa Workspace context information
749 def __init__(self
, Wa
):
752 self
.ConditionalPcds
= {}
756 self
.FdfPcdSet
= Wa
.FdfProfile
.PcdDict
760 self
.DefaultStoreSingle
= True
761 self
.SkuSingle
= True
762 if GlobalData
.gDefaultStores
and len(GlobalData
.gDefaultStores
) > 1:
763 self
.DefaultStoreSingle
= False
764 if GlobalData
.gSkuids
and len(GlobalData
.gSkuids
) > 1:
765 self
.SkuSingle
= False
767 self
.ModulePcdOverride
= {}
768 for Pa
in Wa
.AutoGenObjectList
:
771 # Collect all platform referenced PCDs and grouped them by PCD token space
774 for Pcd
in Pa
.AllPcdList
:
775 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
776 if Pcd
not in PcdList
:
778 if len(Pcd
.TokenCName
) > self
.MaxLen
:
779 self
.MaxLen
= len(Pcd
.TokenCName
)
781 # Collect the PCD defined in DSC/FDF file, but not used in module
783 UnusedPcdFullList
= []
784 for item
in Pa
.Platform
.Pcds
:
785 Pcd
= Pa
.Platform
.Pcds
[item
]
787 # check the Pcd in FDF file, whether it is used in module first
788 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
789 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(T
, [])
795 for package
in Pa
.PackageList
:
796 for T
in ["FixedAtBuild", "PatchableInModule", "FeatureFlag", "Dynamic", "DynamicEx"]:
797 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
) in package
.Pcds
:
800 if not Pcd
.DatumType
:
801 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, T
)].DatumType
805 if not Pcd
.DatumType
:
807 # Try to remove Hii and Vpd suffix
808 if PcdType
.startswith("DynamicEx"):
809 PcdType
= "DynamicEx"
810 elif PcdType
.startswith("Dynamic"):
812 for package
in Pa
.PackageList
:
813 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
) in package
.Pcds
:
814 Pcd
.DatumType
= package
.Pcds
[(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, PcdType
)].DatumType
817 PcdList
= self
.AllPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
818 if Pcd
not in PcdList
and Pcd
not in UnusedPcdFullList
:
819 UnusedPcdFullList
.append(Pcd
)
820 if len(Pcd
.TokenCName
) > self
.MaxLen
:
821 self
.MaxLen
= len(Pcd
.TokenCName
)
823 if GlobalData
.gConditionalPcds
:
824 for PcdItem
in GlobalData
.gConditionalPcds
:
826 (TokenSpaceGuidCName
, TokenCName
) = PcdItem
.split('.')
827 if (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
.keys():
828 Pcd
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)]
829 PcdList
= self
.ConditionalPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
830 if Pcd
not in PcdList
:
834 if UnusedPcdFullList
:
835 for Pcd
in UnusedPcdFullList
:
836 if Pcd
.TokenSpaceGuidCName
+ '.' + Pcd
.TokenCName
in GlobalData
.gConditionalPcds
:
838 UnusedPcdList
.append(Pcd
)
840 for Pcd
in UnusedPcdList
:
841 PcdList
= self
.UnusedPcds
.setdefault(Pcd
.TokenSpaceGuidCName
, {}).setdefault(Pcd
.Type
, [])
842 if Pcd
not in PcdList
:
845 for Module
in Pa
.Platform
.Modules
.values():
847 # Collect module override PCDs
849 for ModulePcd
in Module
.M
.ModulePcdList
+ Module
.M
.LibraryPcdList
:
850 TokenCName
= ModulePcd
.TokenCName
851 TokenSpaceGuid
= ModulePcd
.TokenSpaceGuidCName
852 ModuleDefault
= ModulePcd
.DefaultValue
853 ModulePath
= os
.path
.basename(Module
.M
.MetaFile
.File
)
854 self
.ModulePcdOverride
.setdefault((TokenCName
, TokenSpaceGuid
), {})[ModulePath
] = ModuleDefault
858 # Collect PCD DEC default value.
860 self
.DecPcdDefault
= {}
862 for Pa
in Wa
.AutoGenObjectList
:
863 for Package
in Pa
.PackageList
:
864 Guids
= Package
.Guids
865 self
._GuidDict
.update(Guids
)
866 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
867 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
868 self
.DecPcdDefault
.setdefault((TokenCName
, TokenSpaceGuidCName
, DecType
), DecDefaultValue
)
870 # Collect PCDs defined in DSC common section
872 self
.DscPcdDefault
= {}
873 for Pa
in Wa
.AutoGenObjectList
:
874 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
875 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DscDefaultValue
877 self
.DscPcdDefault
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
879 def GenerateReport(self
, File
, ModulePcdSet
):
880 if self
.ConditionalPcds
:
881 self
.GenerateReportDetail(File
, ModulePcdSet
, 1)
883 self
.GenerateReportDetail(File
, ModulePcdSet
, 2)
884 self
.GenerateReportDetail(File
, ModulePcdSet
)
887 # Generate report for PCD information
889 # This function generates report for separate module expression
890 # in a platform build.
892 # @param self The object pointer
893 # @param File The file object for report
894 # @param ModulePcdSet Set of all PCDs referenced by module or None for
895 # platform PCD report
896 # @param ReportySubType 0 means platform/module PCD report, 1 means Conditional
897 # directives section report, 2 means Unused Pcds section report
898 # @param DscOverridePcds Module DSC override PCDs set
900 def GenerateReportDetail(self
, File
, ModulePcdSet
, ReportSubType
= 0):
901 PcdDict
= self
.AllPcds
902 if ReportSubType
== 1:
903 PcdDict
= self
.ConditionalPcds
904 elif ReportSubType
== 2:
905 PcdDict
= self
.UnusedPcds
907 if ModulePcdSet
== None:
908 FileWrite(File
, gSectionStart
)
909 if ReportSubType
== 1:
910 FileWrite(File
, "Conditional Directives used by the build system")
911 elif ReportSubType
== 2:
912 FileWrite(File
, "PCDs not used by modules or in conditional directives")
914 FileWrite(File
, "Platform Configuration Database Report")
916 FileWrite(File
, " *B - PCD override in the build option")
917 FileWrite(File
, " *P - Platform scoped PCD override in DSC file")
918 FileWrite(File
, " *F - Platform scoped PCD override in FDF file")
919 if not ReportSubType
:
920 FileWrite(File
, " *M - Module scoped PCD override")
921 FileWrite(File
, gSectionSep
)
923 if not ReportSubType
and ModulePcdSet
:
925 # For module PCD sub-section
927 FileWrite(File
, gSubSectionStart
)
928 FileWrite(File
, TAB_BRG_PCD
)
929 FileWrite(File
, gSubSectionSep
)
933 # Group PCD by their token space GUID C Name
936 for Type
in PcdDict
[Key
]:
938 # Group PCD by their usage type
940 TypeName
, DecType
= gPcdTypeMap
.get(Type
, ("", Type
))
941 for Pcd
in PcdDict
[Key
][Type
]:
942 PcdTokenCName
= Pcd
.TokenCName
944 if GlobalData
.MixedPcd
:
945 for PcdKey
in GlobalData
.MixedPcd
:
946 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.MixedPcd
[PcdKey
]:
947 PcdTokenCName
= PcdKey
[0]
949 if MixedPcdFlag
and not ModulePcdSet
:
952 # Get PCD default value and their override relationship
954 DecDefaultValue
= self
.DecPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, DecType
))
955 DscDefaultValue
= self
.DscPcdDefault
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
))
956 DscDefaultValBak
= DscDefaultValue
957 DscDefaultValue
= self
.FdfPcdSet
.get((Pcd
.TokenCName
, Key
), DscDefaultValue
)
958 if DscDefaultValue
!= DscDefaultValBak
:
960 DscDefaultValue
= ValueExpressionEx(DscDefaultValue
, Pcd
.DatumType
, self
._GuidDict
)(True)
961 except BadExpression
, Value
:
962 EdkLogger
.error('BuildReport', FORMAT_INVALID
, "PCD Value: %s, Type: %s" %(DscDefaultValue
, Pcd
.DatumType
))
964 InfDefaultValue
= None
966 PcdValue
= DecDefaultValue
968 PcdValue
= DscDefaultValue
969 if ModulePcdSet
!= None:
970 if (Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
) not in ModulePcdSet
:
972 InfDefault
, PcdValue
= ModulePcdSet
[Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
, Type
]
976 BuildOptionMatch
= False
977 if GlobalData
.BuildOptionPcd
:
978 for pcd
in GlobalData
.BuildOptionPcd
:
979 if (Pcd
.TokenSpaceGuidCName
, Pcd
.TokenCName
) == (pcd
[0], pcd
[1]):
981 BuildOptionMatch
= True
985 if ModulePcdSet
== None:
991 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
992 PcdValueNumber
= int(PcdValue
.strip(), 0)
993 if DecDefaultValue
== None:
996 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
997 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
999 if InfDefaultValue
== None:
1002 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1003 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1005 if DscDefaultValue
== None:
1008 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1009 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1011 if DecDefaultValue
== None:
1014 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1016 if InfDefaultValue
== None:
1019 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1021 if DscDefaultValue
== None:
1024 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1027 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1029 if TypeName
in ('DYNVPD', 'DEXVPD'):
1030 SkuInfoList
= Pcd
.SkuInfoList
1031 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1032 Pcd
.DatumType
= Pcd
.StructName
1033 if TypeName
in ('DYNVPD', 'DEXVPD'):
1034 Pcd
.SkuInfoList
= SkuInfoList
1035 if Pcd
.SkuOverrideValues
:
1039 # Report PCD item according to their override relationship
1041 if DecMatch
and InfMatch
:
1042 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1043 elif BuildOptionMatch
:
1044 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1047 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1048 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1050 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1052 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1054 if ModulePcdSet
== None:
1057 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1059 if not BuildOptionMatch
:
1060 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1061 for ModulePath
in ModuleOverride
:
1062 ModuleDefault
= ModuleOverride
[ModulePath
]
1063 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1064 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1065 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1067 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1070 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1072 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1073 for Array
in ArrayList
:
1074 FileWrite(File
, '%s' % (Array
))
1076 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1078 if ModulePcdSet
== None:
1079 FileWrite(File
, gSectionEnd
)
1081 if not ReportSubType
and ModulePcdSet
:
1082 FileWrite(File
, gSubSectionEnd
)
1085 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1086 if not DscMatch
and DscDefaultValue
!= None:
1087 Value
= DscDefaultValue
.strip()
1088 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1090 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1091 for Array
in ArrayList
:
1092 FileWrite(File
, '%s' % (Array
))
1094 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1095 if not InfMatch
and InfDefaultValue
!= None:
1096 Value
= InfDefaultValue
.strip()
1097 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1099 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1100 for Array
in ArrayList
:
1101 FileWrite(File
, '%s' % (Array
))
1103 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1105 if not DecMatch
and DecDefaultValue
!= None:
1106 Value
= DecDefaultValue
.strip()
1107 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1109 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1110 for Array
in ArrayList
:
1111 FileWrite(File
, '%s' % (Array
))
1113 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1115 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1117 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1118 if not Pcd
.SkuInfoList
:
1119 Value
= Pcd
.DefaultValue
1120 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1122 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1123 for Array
in ArrayList
:
1124 FileWrite(File
, '%s' % (Array
))
1126 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1128 OverrideValues
= Pcd
.SkuOverrideValues
1130 Keys
= OverrideValues
.keys()
1131 Data
= OverrideValues
[Keys
[0]]
1132 Struct
= Data
.values()[0]
1133 self
.PrintStructureInfo(File
, Struct
)
1134 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1137 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1139 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1140 SkuIdName
= SkuInfo
.SkuIdName
1141 if TypeName
in ('DYNHII', 'DEXHII'):
1142 if SkuInfo
.DefaultStoreDict
:
1143 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1144 for DefaultStore
in DefaultStoreList
:
1145 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1146 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1150 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1151 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1152 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1153 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1154 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1155 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1157 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1158 for Array
in ArrayList
:
1159 FileWrite(File
, '%s' % (Array
))
1161 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1162 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1163 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1164 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1165 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1166 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1168 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1171 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1172 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1173 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1174 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1175 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1176 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1178 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1179 for Array
in ArrayList
:
1180 FileWrite(File
, '%s' % (Array
))
1182 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1183 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1184 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1185 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1186 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1187 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1189 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1190 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1192 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1193 Struct
= OverrideValues
[DefaultStore
]
1194 self
.PrintStructureInfo(File
, Struct
)
1195 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1197 Value
= SkuInfo
.DefaultValue
1198 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1203 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1205 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1206 for Array
in ArrayList
:
1207 FileWrite(File
, '%s' % (Array
))
1210 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1212 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1216 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1218 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1219 for Array
in ArrayList
:
1220 FileWrite(File
, '%s' % (Array
))
1223 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1225 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1226 if TypeName
in ('DYNVPD', 'DEXVPD'):
1227 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1229 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1231 Keys
= OverrideValues
.keys()
1232 Struct
= OverrideValues
[Keys
[0]]
1233 self
.PrintStructureInfo(File
, Struct
)
1234 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1236 def PrintStructureInfo(self
, File
, Struct
):
1237 NewInfo
= collections
.OrderedDict()
1238 for Key
, Value
in Struct
.items():
1239 if Key
not in NewInfo
:
1240 NewInfo
[Key
] = Value
[0]
1243 NewInfo
[Key
] = Value
[0]
1245 for item
in NewInfo
:
1246 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + item
, NewInfo
[item
]))
1248 def StrtoHex(self
, value
):
1250 value
= hex(int(value
))
1253 if value
.startswith("L\"") and value
.endswith("\""):
1255 for ch
in value
[2:-1]:
1256 valuelist
.append(hex(ord(ch
)))
1257 valuelist
.append('0x00')
1259 elif value
.startswith("\"") and value
.endswith("\""):
1260 return hex(ord(value
[1:-1]))
1261 elif value
.startswith("{") and value
.endswith("}"):
1263 if ',' not in value
:
1265 for ch
in value
[1:-1].split(','):
1267 if ch
.startswith('0x') or ch
.startswith('0X'):
1268 valuelist
.append(ch
)
1271 valuelist
.append(hex(int(ch
.strip())))
1279 # Reports platform and module Prediction information
1281 # This class reports the platform execution order prediction section and
1282 # module load fixed address prediction subsection in the build report file.
1284 class PredictionReport(object):
1286 # Constructor function for class PredictionReport
1288 # This constructor function generates PredictionReport object for the platform.
1290 # @param self: The object pointer
1291 # @param Wa Workspace context information
1293 def __init__(self
, Wa
):
1294 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1295 self
._MapFileParsed
= False
1296 self
._EotToolInvoked
= False
1297 self
._FvDir
= Wa
.FvDir
1298 self
._EotDir
= Wa
.BuildDir
1299 self
._FfsEntryPoint
= {}
1301 self
._SourceList
= []
1302 self
.FixedMapDict
= {}
1307 # Collect all platform reference source files and GUID C Name
1309 for Pa
in Wa
.AutoGenObjectList
:
1310 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1312 # BASE typed modules are EFI agnostic, so we need not scan
1313 # their source code to find PPI/Protocol produce or consume
1316 if Module
.ModuleType
== "BASE":
1319 # Add module referenced source files
1321 self
._SourceList
.append(str(Module
))
1323 for Source
in Module
.SourceFileList
:
1324 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1325 self
._SourceList
.append(" " + str(Source
))
1326 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1327 for IncludeFile
in IncludeList
.values():
1328 self
._SourceList
.append(" " + IncludeFile
)
1330 for Guid
in Module
.PpiList
:
1331 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1332 for Guid
in Module
.ProtocolList
:
1333 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1334 for Guid
in Module
.GuidList
:
1335 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1337 if Module
.Guid
and not Module
.IsLibrary
:
1338 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1339 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1340 RealEntryPoint
= "_ModuleEntryPoint"
1342 RealEntryPoint
= EntryPoint
1343 if EntryPoint
== "_ModuleEntryPoint":
1344 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1345 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1347 EntryPoint
= Match
.group(1)
1349 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1353 # Collect platform firmware volume list as the input of EOT.
1357 for Fd
in Wa
.FdfProfile
.FdDict
:
1358 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1359 if FdRegion
.RegionType
!= "FV":
1361 for FvName
in FdRegion
.RegionDataList
:
1362 if FvName
in self
._FvList
:
1364 self
._FvList
.append(FvName
)
1365 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1366 for Section
in Ffs
.SectionList
:
1368 for FvSection
in Section
.SectionList
:
1369 if FvSection
.FvName
in self
._FvList
:
1371 self
._FvList
.append(FvSection
.FvName
)
1372 except AttributeError:
1377 # Parse platform fixed address map files
1379 # This function parses the platform final fixed address map file to get
1380 # the database of predicted fixed address for module image base, entry point
1383 # @param self: The object pointer
1385 def _ParseMapFile(self
):
1386 if self
._MapFileParsed
:
1388 self
._MapFileParsed
= True
1389 if os
.path
.isfile(self
._MapFileName
):
1391 FileContents
= open(self
._MapFileName
).read()
1392 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1393 AddressType
= Match
.group(1)
1394 BaseAddress
= Match
.group(2)
1395 EntryPoint
= Match
.group(3)
1396 Guid
= Match
.group(4).upper()
1397 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1398 List
.append((AddressType
, BaseAddress
, "*I"))
1399 List
.append((AddressType
, EntryPoint
, "*E"))
1401 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1404 # Invokes EOT tool to get the predicted the execution order.
1406 # This function invokes EOT tool to calculate the predicted dispatch order
1408 # @param self: The object pointer
1410 def _InvokeEotTool(self
):
1411 if self
._EotToolInvoked
:
1414 self
._EotToolInvoked
= True
1416 for FvName
in self
._FvList
:
1417 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1418 if os
.path
.isfile(FvFile
):
1419 FvFileList
.append(FvFile
)
1421 if len(FvFileList
) == 0:
1424 # Write source file list and GUID file list to an intermediate file
1425 # as the input for EOT tool and dispatch List as the output file
1428 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1429 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1430 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1432 TempFile
= open(SourceList
, "w+")
1433 for Item
in self
._SourceList
:
1434 FileWrite(TempFile
, Item
)
1436 TempFile
= open(GuidList
, "w+")
1437 for Key
in self
._GuidMap
:
1438 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1442 from Eot
.Eot
import Eot
1445 # Invoke EOT tool and echo its runtime performance
1447 EotStartTime
= time
.time()
1448 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1449 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1450 EotEndTime
= time
.time()
1451 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1452 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1455 # Parse the output of EOT tool
1457 for Line
in open(DispatchList
):
1458 if len(Line
.split()) < 4:
1460 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1461 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1462 if len(Symbol
) > self
.MaxLen
:
1463 self
.MaxLen
= len(Symbol
)
1464 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1466 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1467 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1471 # Generate platform execution order report
1473 # This function generates the predicted module execution order.
1475 # @param self The object pointer
1476 # @param File The file object for report
1478 def _GenerateExecutionOrderReport(self
, File
):
1479 self
._InvokeEotTool
()
1480 if len(self
.ItemList
) == 0:
1482 FileWrite(File
, gSectionStart
)
1483 FileWrite(File
, "Execution Order Prediction")
1484 FileWrite(File
, "*P PEI phase")
1485 FileWrite(File
, "*D DXE phase")
1486 FileWrite(File
, "*E Module INF entry point name")
1487 FileWrite(File
, "*N Module notification function name")
1489 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1490 FileWrite(File
, gSectionSep
)
1491 for Item
in self
.ItemList
:
1492 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1494 FileWrite(File
, gSectionStart
)
1497 # Generate Fixed Address report.
1499 # This function generate the predicted fixed address report for a module
1500 # specified by Guid.
1502 # @param self The object pointer
1503 # @param File The file object for report
1504 # @param Guid The module Guid value.
1505 # @param NotifyList The list of all notify function in a module
1507 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1508 self
._ParseMapFile
()
1509 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1510 if not FixedAddressList
:
1513 FileWrite(File
, gSubSectionStart
)
1514 FileWrite(File
, "Fixed Address Prediction")
1515 FileWrite(File
, "*I Image Loading Address")
1516 FileWrite(File
, "*E Entry Point Address")
1517 FileWrite(File
, "*N Notification Function Address")
1518 FileWrite(File
, "*F Flash Address")
1519 FileWrite(File
, "*M Memory Address")
1520 FileWrite(File
, "*S SMM RAM Offset")
1521 FileWrite(File
, "TOM Top of Memory")
1523 FileWrite(File
, "Type Address Name")
1524 FileWrite(File
, gSubSectionSep
)
1525 for Item
in FixedAddressList
:
1530 Name
= "(Image Base)"
1531 elif Symbol
== "*E":
1532 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1533 elif Symbol
in NotifyList
:
1541 elif "Memory" in Type
:
1547 Value
= "TOM" + Value
1549 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1552 # Generate report for the prediction part
1554 # This function generate the predicted fixed address report for a module or
1555 # predicted module execution order for a platform.
1556 # If the input Guid is None, then, it generates the predicted module execution order;
1557 # otherwise it generated the module fixed loading address for the module specified by
1560 # @param self The object pointer
1561 # @param File The file object for report
1562 # @param Guid The module Guid value.
1564 def GenerateReport(self
, File
, Guid
):
1566 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1568 self
._GenerateExecutionOrderReport
(File
)
1571 # Reports FD region information
1573 # This class reports the FD subsection in the build report file.
1574 # It collects region information of platform flash device.
1575 # If the region is a firmware volume, it lists the set of modules
1576 # and its space information; otherwise, it only lists its region name,
1577 # base address and size in its sub-section header.
1578 # If there are nesting FVs, the nested FVs will list immediate after
1579 # this FD region subsection
1581 class FdRegionReport(object):
1583 # Discover all the nested FV name list.
1585 # This is an internal worker function to discover the all the nested FV information
1586 # in the parent firmware volume. It uses deep first search algorithm recursively to
1587 # find all the FV list name and append them to the list.
1589 # @param self The object pointer
1590 # @param FvName The name of current firmware file system
1591 # @param Wa Workspace context information
1593 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1594 FvDictKey
=FvName
.upper()
1595 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1596 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1597 for Section
in Ffs
.SectionList
:
1599 for FvSection
in Section
.SectionList
:
1600 if FvSection
.FvName
in self
.FvList
:
1602 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1603 self
.FvList
.append(FvSection
.FvName
)
1604 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1605 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1606 except AttributeError:
1610 # Constructor function for class FdRegionReport
1612 # This constructor function generates FdRegionReport object for a specified FdRegion.
1613 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1614 # volume list. This function also collects GUID map in order to dump module identification
1615 # in the final report.
1617 # @param self: The object pointer
1618 # @param FdRegion The current FdRegion object
1619 # @param Wa Workspace context information
1621 def __init__(self
, FdRegion
, Wa
):
1622 self
.Type
= FdRegion
.RegionType
1623 self
.BaseAddress
= FdRegion
.Offset
1624 self
.Size
= FdRegion
.Size
1628 self
._FvDir
= Wa
.FvDir
1631 # If the input FdRegion is not a firmware volume,
1634 if self
.Type
!= "FV":
1638 # Find all nested FVs in the FdRegion
1640 for FvName
in FdRegion
.RegionDataList
:
1641 if FvName
in self
.FvList
:
1643 self
.FvList
.append(FvName
)
1644 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1645 self
._DiscoverNestedFvList
(FvName
, Wa
)
1649 # Collect PCDs declared in DEC files.
1651 for Pa
in Wa
.AutoGenObjectList
:
1652 for Package
in Pa
.PackageList
:
1653 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1654 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1655 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1657 # Collect PCDs defined in DSC file
1659 for Pa
in Wa
.AutoGenObjectList
:
1660 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1661 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1662 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1665 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1667 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1668 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1670 # Add ACPI table storage file
1672 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1674 for Pa
in Wa
.AutoGenObjectList
:
1675 for ModuleKey
in Pa
.Platform
.Modules
:
1676 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1677 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1678 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1681 # Collect the GUID map in the FV firmware volume
1683 for FvName
in self
.FvList
:
1684 FvDictKey
=FvName
.upper()
1685 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1686 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1689 # collect GUID map for binary EFI file in FDF file.
1691 Guid
= Ffs
.NameGuid
.upper()
1692 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1694 PcdTokenspace
= Match
.group(1)
1695 PcdToken
= Match
.group(2)
1696 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1697 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1698 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1699 for Section
in Ffs
.SectionList
:
1701 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1702 self
._GuidsDb
[Guid
] = ModuleSectFile
1703 except AttributeError:
1705 except AttributeError:
1710 # Internal worker function to generate report for the FD region
1712 # This internal worker function to generate report for the FD region.
1713 # It the type is firmware volume, it lists offset and module identification.
1715 # @param self The object pointer
1716 # @param File The file object for report
1717 # @param Title The title for the FD subsection
1718 # @param BaseAddress The base address for the FD region
1719 # @param Size The size of the FD region
1720 # @param FvName The FV name if the FD region is a firmware volume
1722 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1723 FileWrite(File
, gSubSectionStart
)
1724 FileWrite(File
, Title
)
1725 FileWrite(File
, "Type: %s" % Type
)
1726 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1728 if self
.Type
== "FV":
1732 FvReportFileName
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv.txt")
1735 # Collect size info in the firmware volume.
1737 FvReport
= open(FvReportFileName
).read()
1738 Match
= gFvTotalSizePattern
.search(FvReport
)
1740 FvTotalSize
= int(Match
.group(1), 16)
1741 Match
= gFvTakenSizePattern
.search(FvReport
)
1743 FvTakenSize
= int(Match
.group(1), 16)
1744 FvFreeSize
= FvTotalSize
- FvTakenSize
1746 # Write size information to the report file.
1748 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1749 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1750 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1751 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1752 FileWrite(File
, "Offset Module")
1753 FileWrite(File
, gSubSectionSep
)
1755 # Write module offset and module identification to the report file.
1758 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1759 Guid
= Match
.group(2).upper()
1760 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1761 OffsetList
= OffsetInfo
.keys()
1763 for Offset
in OffsetList
:
1764 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1766 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1768 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1769 FileWrite(File
, gSubSectionEnd
)
1772 # Generate report for the FD region
1774 # This function generates report for the FD region.
1776 # @param self The object pointer
1777 # @param File The file object for report
1779 def GenerateReport(self
, File
):
1780 if (len(self
.FvList
) > 0):
1781 for FvItem
in self
.FvList
:
1782 Info
= self
.FvInfo
[FvItem
]
1783 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1785 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1788 # Reports FD information
1790 # This class reports the FD section in the build report file.
1791 # It collects flash device information for a platform.
1793 class FdReport(object):
1795 # Constructor function for class FdReport
1797 # This constructor function generates FdReport object for a specified
1800 # @param self The object pointer
1801 # @param Fd The current Firmware device object
1802 # @param Wa Workspace context information
1804 def __init__(self
, Fd
, Wa
):
1805 self
.FdName
= Fd
.FdUiName
1806 self
.BaseAddress
= Fd
.BaseAddress
1808 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1809 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1810 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1811 self
.VPDBaseAddress
= 0
1813 self
.VPDInfoList
= []
1814 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1815 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1816 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1817 self
.VPDSize
= self
.FdRegionList
[index
].Size
1820 if os
.path
.isfile(self
.VpdFilePath
):
1821 fd
= open(self
.VpdFilePath
, "r")
1822 Lines
= fd
.readlines()
1825 if len(Line
) == 0 or Line
.startswith("#"):
1828 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1829 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1830 if Offset
.lower().startswith('0x'):
1831 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1833 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1834 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1836 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1840 # Generate report for the firmware device.
1842 # This function generates report for the firmware device.
1844 # @param self The object pointer
1845 # @param File The file object for report
1847 def GenerateReport(self
, File
):
1848 FileWrite(File
, gSectionStart
)
1849 FileWrite(File
, "Firmware Device (FD)")
1850 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1851 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1852 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1853 if len(self
.FdRegionList
) > 0:
1854 FileWrite(File
, gSectionSep
)
1855 for FdRegionItem
in self
.FdRegionList
:
1856 FdRegionItem
.GenerateReport(File
)
1858 if len(self
.VPDInfoList
) > 0:
1859 FileWrite(File
, gSubSectionStart
)
1860 FileWrite(File
, "FD VPD Region")
1861 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1862 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1863 FileWrite(File
, gSubSectionSep
)
1864 for item
in self
.VPDInfoList
:
1865 ValueList
= item
.split('|')
1866 Value
= ValueList
[-1].strip()
1867 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1869 ValueList
[-1] = ' {'
1870 FileWrite(File
, '|'.join(ValueList
))
1871 for Array
in ArrayList
:
1872 FileWrite(File
, '%s' % (Array
))
1874 FileWrite(File
, item
)
1875 FileWrite(File
, gSubSectionEnd
)
1876 FileWrite(File
, gSectionEnd
)
1881 # Reports platform information
1883 # This class reports the whole platform information
1885 class PlatformReport(object):
1887 # Constructor function for class PlatformReport
1889 # This constructor function generates PlatformReport object a platform build.
1890 # It generates report for platform summary, flash, global PCDs and detailed
1891 # module information for modules involved in platform build.
1893 # @param self The object pointer
1894 # @param Wa Workspace context information
1895 # @param MaList The list of modules in the platform build
1897 def __init__(self
, Wa
, MaList
, ReportType
):
1898 self
._WorkspaceDir
= Wa
.WorkspaceDir
1899 self
.PlatformName
= Wa
.Name
1900 self
.PlatformDscPath
= Wa
.Platform
1901 self
.Architectures
= " ".join(Wa
.ArchList
)
1902 self
.ToolChain
= Wa
.ToolChain
1903 self
.Target
= Wa
.BuildTarget
1904 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1905 self
.BuildEnvironment
= platform
.platform()
1907 self
.PcdReport
= None
1908 if "PCD" in ReportType
:
1909 self
.PcdReport
= PcdReport(Wa
)
1911 self
.FdReportList
= []
1912 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
== None:
1913 for Fd
in Wa
.FdfProfile
.FdDict
:
1914 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1916 self
.PredictionReport
= None
1917 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1918 self
.PredictionReport
= PredictionReport(Wa
)
1920 self
.DepexParser
= None
1921 if "DEPEX" in ReportType
:
1922 self
.DepexParser
= DepexParser(Wa
)
1924 self
.ModuleReportList
= []
1926 self
._IsModuleBuild
= True
1928 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1930 self
._IsModuleBuild
= False
1931 for Pa
in Wa
.AutoGenObjectList
:
1932 ModuleAutoGenList
= []
1933 for ModuleKey
in Pa
.Platform
.Modules
:
1934 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1935 if GlobalData
.gFdfParser
!= None:
1936 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
1937 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
1938 for InfName
in INFList
:
1939 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
1940 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
1943 if Ma
not in ModuleAutoGenList
:
1944 ModuleAutoGenList
.append(Ma
)
1945 for MGen
in ModuleAutoGenList
:
1946 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
1951 # Generate report for the whole platform.
1953 # This function generates report for platform information.
1954 # It comprises of platform summary, global PCD, flash and
1955 # module list sections.
1957 # @param self The object pointer
1958 # @param File The file object for report
1959 # @param BuildDuration The total time to build the modules
1960 # @param AutoGenTime The total time of AutoGen Phase
1961 # @param MakeTime The total time of Make Phase
1962 # @param GenFdsTime The total time of GenFds Phase
1963 # @param ReportType The kind of report items in the final report file
1965 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
1966 FileWrite(File
, "Platform Summary")
1967 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
1968 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
1969 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
1970 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
1971 FileWrite(File
, "Target: %s" % self
.Target
)
1972 if GlobalData
.gSkuids
:
1973 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
1974 if GlobalData
.gDefaultStores
:
1975 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
1976 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
1977 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
1978 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
1980 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
1982 FileWrite(File
, "Make Duration: %s" % MakeTime
)
1984 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
1985 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
1987 if GlobalData
.MixedPcd
:
1988 FileWrite(File
, gSectionStart
)
1989 FileWrite(File
, "The following PCDs use different access methods:")
1990 FileWrite(File
, gSectionSep
)
1991 for PcdItem
in GlobalData
.MixedPcd
:
1992 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
1993 FileWrite(File
, gSectionEnd
)
1995 if not self
._IsModuleBuild
:
1996 if "PCD" in ReportType
:
1997 self
.PcdReport
.GenerateReport(File
, None)
1999 if "FLASH" in ReportType
:
2000 for FdReportListItem
in self
.FdReportList
:
2001 FdReportListItem
.GenerateReport(File
)
2003 for ModuleReportItem
in self
.ModuleReportList
:
2004 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2006 if not self
._IsModuleBuild
:
2007 if "EXECUTION_ORDER" in ReportType
:
2008 self
.PredictionReport
.GenerateReport(File
, None)
2010 ## BuildReport class
2012 # This base class contain the routines to collect data and then
2013 # applies certain format to the output report
2015 class BuildReport(object):
2017 # Constructor function for class BuildReport
2019 # This constructor function generates BuildReport object a platform build.
2020 # It generates report for platform summary, flash, global PCDs and detailed
2021 # module information for modules involved in platform build.
2023 # @param self The object pointer
2024 # @param ReportFile The file name to save report file
2025 # @param ReportType The kind of report items in the final report file
2027 def __init__(self
, ReportFile
, ReportType
):
2028 self
.ReportFile
= ReportFile
2030 self
.ReportList
= []
2031 self
.ReportType
= []
2033 for ReportTypeItem
in ReportType
:
2034 if ReportTypeItem
not in self
.ReportType
:
2035 self
.ReportType
.append(ReportTypeItem
)
2037 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2039 # Adds platform report to the list
2041 # This function adds a platform report to the final report list.
2043 # @param self The object pointer
2044 # @param Wa Workspace context information
2045 # @param MaList The list of modules in the platform build
2047 def AddPlatformReport(self
, Wa
, MaList
=None):
2049 self
.ReportList
.append((Wa
, MaList
))
2052 # Generates the final report.
2054 # This function generates platform build report. It invokes GenerateReport()
2055 # method for every platform report in the list.
2057 # @param self The object pointer
2058 # @param BuildDuration The total time to build the modules
2059 # @param AutoGenTime The total time of AutoGen phase
2060 # @param MakeTime The total time of Make phase
2061 # @param GenFdsTime The total time of GenFds phase
2063 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2067 for (Wa
, MaList
) in self
.ReportList
:
2068 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2069 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2070 SaveFileOnChange(self
.ReportFile
, Content
, True)
2071 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2073 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2075 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2076 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2079 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2080 if __name__
== '__main__':