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
is not 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
is 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
, DscDefaultValue
:
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
is not 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]):
983 Pcd
.DefaultValue
= PcdValue
984 BuildOptionMatch
= True
988 if ModulePcdSet
is None:
994 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
995 PcdValueNumber
= int(PcdValue
.strip(), 0)
996 if DecDefaultValue
is None:
999 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
1000 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1002 if InfDefaultValue
is None:
1005 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1006 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1008 if DscDefaultValue
is None:
1011 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1012 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1014 if DecDefaultValue
is None:
1017 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1019 if InfDefaultValue
is None:
1022 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1024 if DscDefaultValue
is None:
1027 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1030 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1032 if TypeName
in ('DYNVPD', 'DEXVPD'):
1033 SkuInfoList
= Pcd
.SkuInfoList
1034 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1035 Pcd
.DatumType
= Pcd
.StructName
1036 if TypeName
in ('DYNVPD', 'DEXVPD'):
1037 Pcd
.SkuInfoList
= SkuInfoList
1038 if Pcd
.PcdFieldValueFromComm
:
1039 BuildOptionMatch
= True
1041 elif Pcd
.SkuOverrideValues
:
1043 if not Pcd
.SkuInfoList
:
1044 OverrideValues
= Pcd
.SkuOverrideValues
1046 Keys
= OverrideValues
.keys()
1047 Data
= OverrideValues
[Keys
[0]]
1048 Struct
= Data
.values()[0]
1049 DscOverride
= self
.ParseStruct(Struct
)
1051 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1053 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1054 if TypeName
in ('DYNHII', 'DEXHII'):
1055 if SkuInfo
.DefaultStoreDict
:
1056 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1057 for DefaultStore
in DefaultStoreList
:
1058 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1059 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1063 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1065 Keys
= OverrideValues
.keys()
1066 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1067 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1075 # Report PCD item according to their override relationship
1077 if DecMatch
and InfMatch
:
1078 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1079 elif BuildOptionMatch
:
1080 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1083 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1084 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1086 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1088 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1090 if ModulePcdSet
is None:
1093 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1095 if not BuildOptionMatch
:
1096 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1097 for ModulePath
in ModuleOverride
:
1098 ModuleDefault
= ModuleOverride
[ModulePath
]
1099 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1100 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1101 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1103 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1106 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1108 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1109 for Array
in ArrayList
:
1110 FileWrite(File
, '%s' % (Array
))
1112 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1114 if ModulePcdSet
is None:
1115 FileWrite(File
, gSectionEnd
)
1117 if not ReportSubType
and ModulePcdSet
:
1118 FileWrite(File
, gSubSectionEnd
)
1120 def ParseStruct(self
, struct
):
1121 HasDscOverride
= False
1123 for _
, Values
in struct
.items():
1124 if Values
[1] and Values
[1].endswith('.dsc'):
1125 HasDscOverride
= True
1127 return HasDscOverride
1129 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1130 if not DscMatch
and DscDefaultValue
is not None:
1131 Value
= DscDefaultValue
.strip()
1132 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1134 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1135 for Array
in ArrayList
:
1136 FileWrite(File
, '%s' % (Array
))
1138 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1139 if not InfMatch
and InfDefaultValue
is not None:
1140 Value
= InfDefaultValue
.strip()
1141 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1143 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1144 for Array
in ArrayList
:
1145 FileWrite(File
, '%s' % (Array
))
1147 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1149 if not DecMatch
and DecDefaultValue
is not None:
1150 Value
= DecDefaultValue
.strip()
1151 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1153 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1154 for Array
in ArrayList
:
1155 FileWrite(File
, '%s' % (Array
))
1157 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1159 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1160 if DecMatch
and IsStructure
:
1161 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1163 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1164 if not Pcd
.SkuInfoList
:
1165 Value
= Pcd
.DefaultValue
1166 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1168 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1169 for Array
in ArrayList
:
1170 FileWrite(File
, '%s' % (Array
))
1172 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1174 OverrideValues
= Pcd
.SkuOverrideValues
1176 Keys
= OverrideValues
.keys()
1177 Data
= OverrideValues
[Keys
[0]]
1178 Struct
= Data
.values()[0]
1179 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1180 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1181 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1184 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1186 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1187 SkuIdName
= SkuInfo
.SkuIdName
1188 if TypeName
in ('DYNHII', 'DEXHII'):
1189 if SkuInfo
.DefaultStoreDict
:
1190 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1191 for DefaultStore
in DefaultStoreList
:
1192 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1193 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1197 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1198 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1199 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1200 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1201 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1202 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1204 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1205 for Array
in ArrayList
:
1206 FileWrite(File
, '%s' % (Array
))
1208 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1209 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1210 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1211 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1212 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1213 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1215 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1218 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1219 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1220 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1221 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1222 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1223 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1225 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1226 for Array
in ArrayList
:
1227 FileWrite(File
, '%s' % (Array
))
1229 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1230 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1231 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1232 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1233 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1234 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1236 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1237 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1239 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1240 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1241 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1242 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1244 Value
= SkuInfo
.DefaultValue
1245 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1250 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1252 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1253 for Array
in ArrayList
:
1254 FileWrite(File
, '%s' % (Array
))
1257 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1259 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1263 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1265 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1266 for Array
in ArrayList
:
1267 FileWrite(File
, '%s' % (Array
))
1270 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1272 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1273 if TypeName
in ('DYNVPD', 'DEXVPD'):
1274 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1276 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1278 Keys
= OverrideValues
.keys()
1279 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1280 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1281 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1283 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1284 OverrideFieldStruct
= collections
.OrderedDict()
1286 for Key
, Values
in OverrideStruct
.items():
1287 if Values
[1] and Values
[1].endswith('.dsc'):
1288 OverrideFieldStruct
[Key
] = Values
1289 if Pcd
.PcdFieldValueFromComm
:
1290 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1291 OverrideFieldStruct
[Key
] = Values
1292 return OverrideFieldStruct
1294 def PrintStructureInfo(self
, File
, Struct
):
1295 for Key
, Value
in Struct
.items():
1296 if Value
[1] and 'build command options' in Value
[1]:
1297 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1299 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1301 def StrtoHex(self
, value
):
1303 value
= hex(int(value
))
1306 if value
.startswith("L\"") and value
.endswith("\""):
1308 for ch
in value
[2:-1]:
1309 valuelist
.append(hex(ord(ch
)))
1310 valuelist
.append('0x00')
1312 elif value
.startswith("\"") and value
.endswith("\""):
1313 return hex(ord(value
[1:-1]))
1314 elif value
.startswith("{") and value
.endswith("}"):
1316 if ',' not in value
:
1318 for ch
in value
[1:-1].split(','):
1320 if ch
.startswith('0x') or ch
.startswith('0X'):
1321 valuelist
.append(ch
)
1324 valuelist
.append(hex(int(ch
.strip())))
1332 # Reports platform and module Prediction information
1334 # This class reports the platform execution order prediction section and
1335 # module load fixed address prediction subsection in the build report file.
1337 class PredictionReport(object):
1339 # Constructor function for class PredictionReport
1341 # This constructor function generates PredictionReport object for the platform.
1343 # @param self: The object pointer
1344 # @param Wa Workspace context information
1346 def __init__(self
, Wa
):
1347 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1348 self
._MapFileParsed
= False
1349 self
._EotToolInvoked
= False
1350 self
._FvDir
= Wa
.FvDir
1351 self
._EotDir
= Wa
.BuildDir
1352 self
._FfsEntryPoint
= {}
1354 self
._SourceList
= []
1355 self
.FixedMapDict
= {}
1360 # Collect all platform reference source files and GUID C Name
1362 for Pa
in Wa
.AutoGenObjectList
:
1363 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1365 # BASE typed modules are EFI agnostic, so we need not scan
1366 # their source code to find PPI/Protocol produce or consume
1369 if Module
.ModuleType
== "BASE":
1372 # Add module referenced source files
1374 self
._SourceList
.append(str(Module
))
1376 for Source
in Module
.SourceFileList
:
1377 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1378 self
._SourceList
.append(" " + str(Source
))
1379 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1380 for IncludeFile
in IncludeList
.values():
1381 self
._SourceList
.append(" " + IncludeFile
)
1383 for Guid
in Module
.PpiList
:
1384 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1385 for Guid
in Module
.ProtocolList
:
1386 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1387 for Guid
in Module
.GuidList
:
1388 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1390 if Module
.Guid
and not Module
.IsLibrary
:
1391 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1392 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1393 RealEntryPoint
= "_ModuleEntryPoint"
1395 RealEntryPoint
= EntryPoint
1396 if EntryPoint
== "_ModuleEntryPoint":
1397 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1398 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1400 EntryPoint
= Match
.group(1)
1402 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1406 # Collect platform firmware volume list as the input of EOT.
1410 for Fd
in Wa
.FdfProfile
.FdDict
:
1411 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1412 if FdRegion
.RegionType
!= "FV":
1414 for FvName
in FdRegion
.RegionDataList
:
1415 if FvName
in self
._FvList
:
1417 self
._FvList
.append(FvName
)
1418 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1419 for Section
in Ffs
.SectionList
:
1421 for FvSection
in Section
.SectionList
:
1422 if FvSection
.FvName
in self
._FvList
:
1424 self
._FvList
.append(FvSection
.FvName
)
1425 except AttributeError:
1430 # Parse platform fixed address map files
1432 # This function parses the platform final fixed address map file to get
1433 # the database of predicted fixed address for module image base, entry point
1436 # @param self: The object pointer
1438 def _ParseMapFile(self
):
1439 if self
._MapFileParsed
:
1441 self
._MapFileParsed
= True
1442 if os
.path
.isfile(self
._MapFileName
):
1444 FileContents
= open(self
._MapFileName
).read()
1445 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1446 AddressType
= Match
.group(1)
1447 BaseAddress
= Match
.group(2)
1448 EntryPoint
= Match
.group(3)
1449 Guid
= Match
.group(4).upper()
1450 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1451 List
.append((AddressType
, BaseAddress
, "*I"))
1452 List
.append((AddressType
, EntryPoint
, "*E"))
1454 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1457 # Invokes EOT tool to get the predicted the execution order.
1459 # This function invokes EOT tool to calculate the predicted dispatch order
1461 # @param self: The object pointer
1463 def _InvokeEotTool(self
):
1464 if self
._EotToolInvoked
:
1467 self
._EotToolInvoked
= True
1469 for FvName
in self
._FvList
:
1470 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1471 if os
.path
.isfile(FvFile
):
1472 FvFileList
.append(FvFile
)
1474 if len(FvFileList
) == 0:
1477 # Write source file list and GUID file list to an intermediate file
1478 # as the input for EOT tool and dispatch List as the output file
1481 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1482 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1483 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1485 TempFile
= open(SourceList
, "w+")
1486 for Item
in self
._SourceList
:
1487 FileWrite(TempFile
, Item
)
1489 TempFile
= open(GuidList
, "w+")
1490 for Key
in self
._GuidMap
:
1491 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1495 from Eot
.Eot
import Eot
1498 # Invoke EOT tool and echo its runtime performance
1500 EotStartTime
= time
.time()
1501 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1502 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1503 EotEndTime
= time
.time()
1504 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1505 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1508 # Parse the output of EOT tool
1510 for Line
in open(DispatchList
):
1511 if len(Line
.split()) < 4:
1513 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1514 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1515 if len(Symbol
) > self
.MaxLen
:
1516 self
.MaxLen
= len(Symbol
)
1517 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1519 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1520 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1524 # Generate platform execution order report
1526 # This function generates the predicted module execution order.
1528 # @param self The object pointer
1529 # @param File The file object for report
1531 def _GenerateExecutionOrderReport(self
, File
):
1532 self
._InvokeEotTool
()
1533 if len(self
.ItemList
) == 0:
1535 FileWrite(File
, gSectionStart
)
1536 FileWrite(File
, "Execution Order Prediction")
1537 FileWrite(File
, "*P PEI phase")
1538 FileWrite(File
, "*D DXE phase")
1539 FileWrite(File
, "*E Module INF entry point name")
1540 FileWrite(File
, "*N Module notification function name")
1542 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1543 FileWrite(File
, gSectionSep
)
1544 for Item
in self
.ItemList
:
1545 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1547 FileWrite(File
, gSectionStart
)
1550 # Generate Fixed Address report.
1552 # This function generate the predicted fixed address report for a module
1553 # specified by Guid.
1555 # @param self The object pointer
1556 # @param File The file object for report
1557 # @param Guid The module Guid value.
1558 # @param NotifyList The list of all notify function in a module
1560 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1561 self
._ParseMapFile
()
1562 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1563 if not FixedAddressList
:
1566 FileWrite(File
, gSubSectionStart
)
1567 FileWrite(File
, "Fixed Address Prediction")
1568 FileWrite(File
, "*I Image Loading Address")
1569 FileWrite(File
, "*E Entry Point Address")
1570 FileWrite(File
, "*N Notification Function Address")
1571 FileWrite(File
, "*F Flash Address")
1572 FileWrite(File
, "*M Memory Address")
1573 FileWrite(File
, "*S SMM RAM Offset")
1574 FileWrite(File
, "TOM Top of Memory")
1576 FileWrite(File
, "Type Address Name")
1577 FileWrite(File
, gSubSectionSep
)
1578 for Item
in FixedAddressList
:
1583 Name
= "(Image Base)"
1584 elif Symbol
== "*E":
1585 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1586 elif Symbol
in NotifyList
:
1594 elif "Memory" in Type
:
1600 Value
= "TOM" + Value
1602 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1605 # Generate report for the prediction part
1607 # This function generate the predicted fixed address report for a module or
1608 # predicted module execution order for a platform.
1609 # If the input Guid is None, then, it generates the predicted module execution order;
1610 # otherwise it generated the module fixed loading address for the module specified by
1613 # @param self The object pointer
1614 # @param File The file object for report
1615 # @param Guid The module Guid value.
1617 def GenerateReport(self
, File
, Guid
):
1619 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1621 self
._GenerateExecutionOrderReport
(File
)
1624 # Reports FD region information
1626 # This class reports the FD subsection in the build report file.
1627 # It collects region information of platform flash device.
1628 # If the region is a firmware volume, it lists the set of modules
1629 # and its space information; otherwise, it only lists its region name,
1630 # base address and size in its sub-section header.
1631 # If there are nesting FVs, the nested FVs will list immediate after
1632 # this FD region subsection
1634 class FdRegionReport(object):
1636 # Discover all the nested FV name list.
1638 # This is an internal worker function to discover the all the nested FV information
1639 # in the parent firmware volume. It uses deep first search algorithm recursively to
1640 # find all the FV list name and append them to the list.
1642 # @param self The object pointer
1643 # @param FvName The name of current firmware file system
1644 # @param Wa Workspace context information
1646 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1647 FvDictKey
=FvName
.upper()
1648 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1649 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1650 for Section
in Ffs
.SectionList
:
1652 for FvSection
in Section
.SectionList
:
1653 if FvSection
.FvName
in self
.FvList
:
1655 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1656 self
.FvList
.append(FvSection
.FvName
)
1657 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1658 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1659 except AttributeError:
1663 # Constructor function for class FdRegionReport
1665 # This constructor function generates FdRegionReport object for a specified FdRegion.
1666 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1667 # volume list. This function also collects GUID map in order to dump module identification
1668 # in the final report.
1670 # @param self: The object pointer
1671 # @param FdRegion The current FdRegion object
1672 # @param Wa Workspace context information
1674 def __init__(self
, FdRegion
, Wa
):
1675 self
.Type
= FdRegion
.RegionType
1676 self
.BaseAddress
= FdRegion
.Offset
1677 self
.Size
= FdRegion
.Size
1681 self
._FvDir
= Wa
.FvDir
1682 self
._WorkspaceDir
= Wa
.WorkspaceDir
1685 # If the input FdRegion is not a firmware volume,
1688 if self
.Type
!= "FV":
1692 # Find all nested FVs in the FdRegion
1694 for FvName
in FdRegion
.RegionDataList
:
1695 if FvName
in self
.FvList
:
1697 self
.FvList
.append(FvName
)
1698 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1699 self
._DiscoverNestedFvList
(FvName
, Wa
)
1703 # Collect PCDs declared in DEC files.
1705 for Pa
in Wa
.AutoGenObjectList
:
1706 for Package
in Pa
.PackageList
:
1707 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1708 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1709 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1711 # Collect PCDs defined in DSC file
1713 for Pa
in Wa
.AutoGenObjectList
:
1714 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1715 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1716 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1719 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1721 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1722 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1724 # Add ACPI table storage file
1726 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1728 for Pa
in Wa
.AutoGenObjectList
:
1729 for ModuleKey
in Pa
.Platform
.Modules
:
1730 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1731 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1732 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1735 # Collect the GUID map in the FV firmware volume
1737 for FvName
in self
.FvList
:
1738 FvDictKey
=FvName
.upper()
1739 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1740 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1743 # collect GUID map for binary EFI file in FDF file.
1745 Guid
= Ffs
.NameGuid
.upper()
1746 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1748 PcdTokenspace
= Match
.group(1)
1749 PcdToken
= Match
.group(2)
1750 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1751 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1752 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1753 for Section
in Ffs
.SectionList
:
1755 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1756 self
._GuidsDb
[Guid
] = ModuleSectFile
1757 except AttributeError:
1759 except AttributeError:
1764 # Internal worker function to generate report for the FD region
1766 # This internal worker function to generate report for the FD region.
1767 # It the type is firmware volume, it lists offset and module identification.
1769 # @param self The object pointer
1770 # @param File The file object for report
1771 # @param Title The title for the FD subsection
1772 # @param BaseAddress The base address for the FD region
1773 # @param Size The size of the FD region
1774 # @param FvName The FV name if the FD region is a firmware volume
1776 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1777 FileWrite(File
, gSubSectionStart
)
1778 FileWrite(File
, Title
)
1779 FileWrite(File
, "Type: %s" % Type
)
1780 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1782 if self
.Type
== "FV":
1786 if FvName
.upper().endswith('.FV'):
1787 FileExt
= FvName
+ ".txt"
1789 FileExt
= FvName
+ ".Fv.txt"
1791 if not os
.path
.isfile(FileExt
):
1792 FvReportFileName
= mws
.join(self
._WorkspaceDir
, FileExt
)
1793 if not os
.path
.isfile(FvReportFileName
):
1794 FvReportFileName
= os
.path
.join(self
._FvDir
, FileExt
)
1797 # Collect size info in the firmware volume.
1799 FvReport
= open(FvReportFileName
).read()
1800 Match
= gFvTotalSizePattern
.search(FvReport
)
1802 FvTotalSize
= int(Match
.group(1), 16)
1803 Match
= gFvTakenSizePattern
.search(FvReport
)
1805 FvTakenSize
= int(Match
.group(1), 16)
1806 FvFreeSize
= FvTotalSize
- FvTakenSize
1808 # Write size information to the report file.
1810 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1811 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1812 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1813 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1814 FileWrite(File
, "Offset Module")
1815 FileWrite(File
, gSubSectionSep
)
1817 # Write module offset and module identification to the report file.
1820 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1821 Guid
= Match
.group(2).upper()
1822 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1823 OffsetList
= OffsetInfo
.keys()
1825 for Offset
in OffsetList
:
1826 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1828 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1830 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1831 FileWrite(File
, gSubSectionEnd
)
1834 # Generate report for the FD region
1836 # This function generates report for the FD region.
1838 # @param self The object pointer
1839 # @param File The file object for report
1841 def GenerateReport(self
, File
):
1842 if (len(self
.FvList
) > 0):
1843 for FvItem
in self
.FvList
:
1844 Info
= self
.FvInfo
[FvItem
]
1845 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1847 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1850 # Reports FD information
1852 # This class reports the FD section in the build report file.
1853 # It collects flash device information for a platform.
1855 class FdReport(object):
1857 # Constructor function for class FdReport
1859 # This constructor function generates FdReport object for a specified
1862 # @param self The object pointer
1863 # @param Fd The current Firmware device object
1864 # @param Wa Workspace context information
1866 def __init__(self
, Fd
, Wa
):
1867 self
.FdName
= Fd
.FdUiName
1868 self
.BaseAddress
= Fd
.BaseAddress
1870 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1871 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1872 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1873 self
.VPDBaseAddress
= 0
1875 self
.VPDInfoList
= []
1876 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1877 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1878 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1879 self
.VPDSize
= self
.FdRegionList
[index
].Size
1882 if os
.path
.isfile(self
.VpdFilePath
):
1883 fd
= open(self
.VpdFilePath
, "r")
1884 Lines
= fd
.readlines()
1887 if len(Line
) == 0 or Line
.startswith("#"):
1890 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1891 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1892 if Offset
.lower().startswith('0x'):
1893 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1895 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1896 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1898 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1902 # Generate report for the firmware device.
1904 # This function generates report for the firmware device.
1906 # @param self The object pointer
1907 # @param File The file object for report
1909 def GenerateReport(self
, File
):
1910 FileWrite(File
, gSectionStart
)
1911 FileWrite(File
, "Firmware Device (FD)")
1912 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1913 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1914 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1915 if len(self
.FdRegionList
) > 0:
1916 FileWrite(File
, gSectionSep
)
1917 for FdRegionItem
in self
.FdRegionList
:
1918 FdRegionItem
.GenerateReport(File
)
1920 if len(self
.VPDInfoList
) > 0:
1921 FileWrite(File
, gSubSectionStart
)
1922 FileWrite(File
, "FD VPD Region")
1923 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1924 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1925 FileWrite(File
, gSubSectionSep
)
1926 for item
in self
.VPDInfoList
:
1927 ValueList
= item
.split('|')
1928 Value
= ValueList
[-1].strip()
1929 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1931 ValueList
[-1] = ' {'
1932 FileWrite(File
, '|'.join(ValueList
))
1933 for Array
in ArrayList
:
1934 FileWrite(File
, '%s' % (Array
))
1936 FileWrite(File
, item
)
1937 FileWrite(File
, gSubSectionEnd
)
1938 FileWrite(File
, gSectionEnd
)
1943 # Reports platform information
1945 # This class reports the whole platform information
1947 class PlatformReport(object):
1949 # Constructor function for class PlatformReport
1951 # This constructor function generates PlatformReport object a platform build.
1952 # It generates report for platform summary, flash, global PCDs and detailed
1953 # module information for modules involved in platform build.
1955 # @param self The object pointer
1956 # @param Wa Workspace context information
1957 # @param MaList The list of modules in the platform build
1959 def __init__(self
, Wa
, MaList
, ReportType
):
1960 self
._WorkspaceDir
= Wa
.WorkspaceDir
1961 self
.PlatformName
= Wa
.Name
1962 self
.PlatformDscPath
= Wa
.Platform
1963 self
.Architectures
= " ".join(Wa
.ArchList
)
1964 self
.ToolChain
= Wa
.ToolChain
1965 self
.Target
= Wa
.BuildTarget
1966 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1967 self
.BuildEnvironment
= platform
.platform()
1969 self
.PcdReport
= None
1970 if "PCD" in ReportType
:
1971 self
.PcdReport
= PcdReport(Wa
)
1973 self
.FdReportList
= []
1974 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
is None:
1975 for Fd
in Wa
.FdfProfile
.FdDict
:
1976 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1978 self
.PredictionReport
= None
1979 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1980 self
.PredictionReport
= PredictionReport(Wa
)
1982 self
.DepexParser
= None
1983 if "DEPEX" in ReportType
:
1984 self
.DepexParser
= DepexParser(Wa
)
1986 self
.ModuleReportList
= []
1987 if MaList
is not None:
1988 self
._IsModuleBuild
= True
1990 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1992 self
._IsModuleBuild
= False
1993 for Pa
in Wa
.AutoGenObjectList
:
1994 ModuleAutoGenList
= []
1995 for ModuleKey
in Pa
.Platform
.Modules
:
1996 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1997 if GlobalData
.gFdfParser
is not None:
1998 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
1999 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
2000 for InfName
in INFList
:
2001 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
2002 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2005 if Ma
not in ModuleAutoGenList
:
2006 ModuleAutoGenList
.append(Ma
)
2007 for MGen
in ModuleAutoGenList
:
2008 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2013 # Generate report for the whole platform.
2015 # This function generates report for platform information.
2016 # It comprises of platform summary, global PCD, flash and
2017 # module list sections.
2019 # @param self The object pointer
2020 # @param File The file object for report
2021 # @param BuildDuration The total time to build the modules
2022 # @param AutoGenTime The total time of AutoGen Phase
2023 # @param MakeTime The total time of Make Phase
2024 # @param GenFdsTime The total time of GenFds Phase
2025 # @param ReportType The kind of report items in the final report file
2027 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2028 FileWrite(File
, "Platform Summary")
2029 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2030 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2031 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2032 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2033 FileWrite(File
, "Target: %s" % self
.Target
)
2034 if GlobalData
.gSkuids
:
2035 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2036 if GlobalData
.gDefaultStores
:
2037 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2038 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2039 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2040 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2042 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2044 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2046 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2047 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2049 if GlobalData
.MixedPcd
:
2050 FileWrite(File
, gSectionStart
)
2051 FileWrite(File
, "The following PCDs use different access methods:")
2052 FileWrite(File
, gSectionSep
)
2053 for PcdItem
in GlobalData
.MixedPcd
:
2054 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2055 FileWrite(File
, gSectionEnd
)
2057 if not self
._IsModuleBuild
:
2058 if "PCD" in ReportType
:
2059 self
.PcdReport
.GenerateReport(File
, None)
2061 if "FLASH" in ReportType
:
2062 for FdReportListItem
in self
.FdReportList
:
2063 FdReportListItem
.GenerateReport(File
)
2065 for ModuleReportItem
in self
.ModuleReportList
:
2066 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2068 if not self
._IsModuleBuild
:
2069 if "EXECUTION_ORDER" in ReportType
:
2070 self
.PredictionReport
.GenerateReport(File
, None)
2072 ## BuildReport class
2074 # This base class contain the routines to collect data and then
2075 # applies certain format to the output report
2077 class BuildReport(object):
2079 # Constructor function for class BuildReport
2081 # This constructor function generates BuildReport object a platform build.
2082 # It generates report for platform summary, flash, global PCDs and detailed
2083 # module information for modules involved in platform build.
2085 # @param self The object pointer
2086 # @param ReportFile The file name to save report file
2087 # @param ReportType The kind of report items in the final report file
2089 def __init__(self
, ReportFile
, ReportType
):
2090 self
.ReportFile
= ReportFile
2092 self
.ReportList
= []
2093 self
.ReportType
= []
2095 for ReportTypeItem
in ReportType
:
2096 if ReportTypeItem
not in self
.ReportType
:
2097 self
.ReportType
.append(ReportTypeItem
)
2099 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2101 # Adds platform report to the list
2103 # This function adds a platform report to the final report list.
2105 # @param self The object pointer
2106 # @param Wa Workspace context information
2107 # @param MaList The list of modules in the platform build
2109 def AddPlatformReport(self
, Wa
, MaList
=None):
2111 self
.ReportList
.append((Wa
, MaList
))
2114 # Generates the final report.
2116 # This function generates platform build report. It invokes GenerateReport()
2117 # method for every platform report in the list.
2119 # @param self The object pointer
2120 # @param BuildDuration The total time to build the modules
2121 # @param AutoGenTime The total time of AutoGen phase
2122 # @param MakeTime The total time of Make phase
2123 # @param GenFdsTime The total time of GenFds phase
2125 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2129 for (Wa
, MaList
) in self
.ReportList
:
2130 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2131 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2132 SaveFileOnChange(self
.ReportFile
, Content
, True)
2133 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2135 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2137 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2138 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2141 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2142 if __name__
== '__main__':