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
, 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
!= 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 Pcd
.DefaultValue
= PcdValue
982 BuildOptionMatch
= True
986 if ModulePcdSet
== None:
992 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
993 PcdValueNumber
= int(PcdValue
.strip(), 0)
994 if DecDefaultValue
== None:
997 DecDefaultValueNumber
= int(DecDefaultValue
.strip(), 0)
998 DecMatch
= (DecDefaultValueNumber
== PcdValueNumber
)
1000 if InfDefaultValue
== None:
1003 InfDefaultValueNumber
= int(InfDefaultValue
.strip(), 0)
1004 InfMatch
= (InfDefaultValueNumber
== PcdValueNumber
)
1006 if DscDefaultValue
== None:
1009 DscDefaultValueNumber
= int(DscDefaultValue
.strip(), 0)
1010 DscMatch
= (DscDefaultValueNumber
== PcdValueNumber
)
1012 if DecDefaultValue
== None:
1015 DecMatch
= (DecDefaultValue
.strip() == PcdValue
.strip())
1017 if InfDefaultValue
== None:
1020 InfMatch
= (InfDefaultValue
.strip() == PcdValue
.strip())
1022 if DscDefaultValue
== None:
1025 DscMatch
= (DscDefaultValue
.strip() == PcdValue
.strip())
1028 if GlobalData
.gStructurePcd
and (self
.Arch
in GlobalData
.gStructurePcd
.keys()) and ((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
) in GlobalData
.gStructurePcd
[self
.Arch
]):
1030 if TypeName
in ('DYNVPD', 'DEXVPD'):
1031 SkuInfoList
= Pcd
.SkuInfoList
1032 Pcd
= GlobalData
.gStructurePcd
[self
.Arch
][(Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
)]
1033 Pcd
.DatumType
= Pcd
.StructName
1034 if TypeName
in ('DYNVPD', 'DEXVPD'):
1035 Pcd
.SkuInfoList
= SkuInfoList
1036 if Pcd
.PcdFieldValueFromComm
:
1037 BuildOptionMatch
= True
1039 elif Pcd
.SkuOverrideValues
:
1041 if not Pcd
.SkuInfoList
:
1042 OverrideValues
= Pcd
.SkuOverrideValues
1044 Keys
= OverrideValues
.keys()
1045 Data
= OverrideValues
[Keys
[0]]
1046 Struct
= Data
.values()[0]
1047 DscOverride
= self
.ParseStruct(Struct
)
1049 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1051 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1052 if TypeName
in ('DYNHII', 'DEXHII'):
1053 if SkuInfo
.DefaultStoreDict
:
1054 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1055 for DefaultStore
in DefaultStoreList
:
1056 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1057 DscOverride
= self
.ParseStruct(OverrideValues
[DefaultStore
])
1061 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1063 Keys
= OverrideValues
.keys()
1064 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1065 DscOverride
= self
.ParseStruct(OverrideFieldStruct
)
1073 # Report PCD item according to their override relationship
1075 if DecMatch
and InfMatch
:
1076 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, ' ')
1077 elif BuildOptionMatch
:
1078 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*B')
1081 if (Pcd
.TokenCName
, Key
) in self
.FdfPcdSet
:
1082 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*F')
1084 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*P')
1086 self
.PrintPcdValue(File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValBak
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, '*M')
1088 if ModulePcdSet
== None:
1091 if not TypeName
in ('PATCH', 'FLAG', 'FIXED'):
1093 if not BuildOptionMatch
:
1094 ModuleOverride
= self
.ModulePcdOverride
.get((Pcd
.TokenCName
, Pcd
.TokenSpaceGuidCName
), {})
1095 for ModulePath
in ModuleOverride
:
1096 ModuleDefault
= ModuleOverride
[ModulePath
]
1097 if Pcd
.DatumType
in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
1098 ModulePcdDefaultValueNumber
= int(ModuleDefault
.strip(), 0)
1099 Match
= (ModulePcdDefaultValueNumber
== PcdValueNumber
)
1101 Match
= (ModuleDefault
.strip() == PcdValue
.strip())
1104 IsByteArray
, ArrayList
= ByteArrayForamt(ModuleDefault
.strip())
1106 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, '{'))
1107 for Array
in ArrayList
:
1108 FileWrite(File
, '%s' % (Array
))
1110 FileWrite(File
, ' *M %-*s = %s' % (self
.MaxLen
+ 19, ModulePath
, ModuleDefault
.strip()))
1112 if ModulePcdSet
== None:
1113 FileWrite(File
, gSectionEnd
)
1115 if not ReportSubType
and ModulePcdSet
:
1116 FileWrite(File
, gSubSectionEnd
)
1118 def ParseStruct(self
, struct
):
1119 HasDscOverride
= False
1121 for _
, Values
in struct
.items():
1122 if Values
[1] and Values
[1].endswith('.dsc'):
1123 HasDscOverride
= True
1125 return HasDscOverride
1127 def PrintPcdDefault(self
, File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
):
1128 if not DscMatch
and DscDefaultValue
!= None:
1129 Value
= DscDefaultValue
.strip()
1130 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1132 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', "{"))
1133 for Array
in ArrayList
:
1134 FileWrite(File
, '%s' % (Array
))
1136 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DSC DEFAULT', Value
))
1137 if not InfMatch
and InfDefaultValue
!= None:
1138 Value
= InfDefaultValue
.strip()
1139 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1141 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', "{"))
1142 for Array
in ArrayList
:
1143 FileWrite(File
, '%s' % (Array
))
1145 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'INF DEFAULT', Value
))
1147 if not DecMatch
and DecDefaultValue
!= None:
1148 Value
= DecDefaultValue
.strip()
1149 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1151 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', "{"))
1152 for Array
in ArrayList
:
1153 FileWrite(File
, '%s' % (Array
))
1155 FileWrite(File
, ' %*s = %s' % (self
.MaxLen
+ 19, 'DEC DEFAULT', Value
))
1157 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1158 if DecMatch
and IsStructure
:
1159 self
.PrintStructureInfo(File
, Pcd
.DefaultValues
)
1161 def PrintPcdValue(self
, File
, Pcd
, PcdTokenCName
, TypeName
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
, Flag
= ' '):
1162 if not Pcd
.SkuInfoList
:
1163 Value
= Pcd
.DefaultValue
1164 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1166 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1167 for Array
in ArrayList
:
1168 FileWrite(File
, '%s' % (Array
))
1170 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1172 OverrideValues
= Pcd
.SkuOverrideValues
1174 Keys
= OverrideValues
.keys()
1175 Data
= OverrideValues
[Keys
[0]]
1176 Struct
= Data
.values()[0]
1177 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, Struct
)
1178 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1179 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1182 SkuList
= sorted(Pcd
.SkuInfoList
.keys())
1184 SkuInfo
= Pcd
.SkuInfoList
[Sku
]
1185 SkuIdName
= SkuInfo
.SkuIdName
1186 if TypeName
in ('DYNHII', 'DEXHII'):
1187 if SkuInfo
.DefaultStoreDict
:
1188 DefaultStoreList
= sorted(SkuInfo
.DefaultStoreDict
.keys())
1189 for DefaultStore
in DefaultStoreList
:
1190 Value
= SkuInfo
.DefaultStoreDict
[DefaultStore
]
1191 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1195 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1196 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1197 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1198 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1199 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1200 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1202 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1203 for Array
in ArrayList
:
1204 FileWrite(File
, '%s' % (Array
))
1206 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1207 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1208 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1209 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1210 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1211 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1213 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1216 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1217 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '{'))
1218 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1219 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '{'))
1220 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1221 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', '{'))
1223 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', '{'))
1224 for Array
in ArrayList
:
1225 FileWrite(File
, '%s' % (Array
))
1227 if self
.DefaultStoreSingle
and self
.SkuSingle
:
1228 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1229 elif self
.DefaultStoreSingle
and not self
.SkuSingle
:
1230 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1231 elif not self
.DefaultStoreSingle
and self
.SkuSingle
:
1232 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + DefaultStore
+ ')', Value
))
1234 FileWrite(File
, ' %-*s : %6s %10s %10s %10s = %s' % (self
.MaxLen
, ' ', TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', '(' + DefaultStore
+ ')', Value
))
1235 FileWrite(File
, '%*s: %s: %s' % (self
.MaxLen
+ 4, SkuInfo
.VariableGuid
, SkuInfo
.VariableName
, SkuInfo
.VariableOffset
))
1237 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1238 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[DefaultStore
])
1239 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1240 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1242 Value
= SkuInfo
.DefaultValue
1243 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1248 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1250 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1251 for Array
in ArrayList
:
1252 FileWrite(File
, '%s' % (Array
))
1255 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1257 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, Flag
+ ' ' + PcdTokenCName
, TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1261 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', "{"))
1263 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', "{"))
1264 for Array
in ArrayList
:
1265 FileWrite(File
, '%s' % (Array
))
1268 FileWrite(File
, ' %-*s : %6s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', Value
))
1270 FileWrite(File
, ' %-*s : %6s %10s %10s = %s' % (self
.MaxLen
, ' ' , TypeName
, '(' + Pcd
.DatumType
+ ')', '(' + SkuIdName
+ ')', Value
))
1271 if TypeName
in ('DYNVPD', 'DEXVPD'):
1272 FileWrite(File
, '%*s' % (self
.MaxLen
+ 4, SkuInfo
.VpdOffset
))
1274 OverrideValues
= Pcd
.SkuOverrideValues
[Sku
]
1276 Keys
= OverrideValues
.keys()
1277 OverrideFieldStruct
= self
.OverrideFieldValue(Pcd
, OverrideValues
[Keys
[0]])
1278 self
.PrintStructureInfo(File
, OverrideFieldStruct
)
1279 self
.PrintPcdDefault(File
, Pcd
, IsStructure
, DscMatch
, DscDefaultValue
, InfMatch
, InfDefaultValue
, DecMatch
, DecDefaultValue
)
1281 def OverrideFieldValue(self
, Pcd
, OverrideStruct
):
1282 OverrideFieldStruct
= collections
.OrderedDict()
1284 for Key
, Values
in OverrideStruct
.items():
1285 if Values
[1] and Values
[1].endswith('.dsc'):
1286 OverrideFieldStruct
[Key
] = Values
1287 if Pcd
.PcdFieldValueFromComm
:
1288 for Key
, Values
in Pcd
.PcdFieldValueFromComm
.items():
1289 OverrideFieldStruct
[Key
] = Values
1290 return OverrideFieldStruct
1292 def PrintStructureInfo(self
, File
, Struct
):
1293 for Key
, Value
in Struct
.items():
1294 if Value
[1] and 'build command options' in Value
[1]:
1295 FileWrite(File
, ' *B %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1297 FileWrite(File
, ' %-*s = %s' % (self
.MaxLen
+ 4, '.' + Key
, Value
[0]))
1299 def StrtoHex(self
, value
):
1301 value
= hex(int(value
))
1304 if value
.startswith("L\"") and value
.endswith("\""):
1306 for ch
in value
[2:-1]:
1307 valuelist
.append(hex(ord(ch
)))
1308 valuelist
.append('0x00')
1310 elif value
.startswith("\"") and value
.endswith("\""):
1311 return hex(ord(value
[1:-1]))
1312 elif value
.startswith("{") and value
.endswith("}"):
1314 if ',' not in value
:
1316 for ch
in value
[1:-1].split(','):
1318 if ch
.startswith('0x') or ch
.startswith('0X'):
1319 valuelist
.append(ch
)
1322 valuelist
.append(hex(int(ch
.strip())))
1330 # Reports platform and module Prediction information
1332 # This class reports the platform execution order prediction section and
1333 # module load fixed address prediction subsection in the build report file.
1335 class PredictionReport(object):
1337 # Constructor function for class PredictionReport
1339 # This constructor function generates PredictionReport object for the platform.
1341 # @param self: The object pointer
1342 # @param Wa Workspace context information
1344 def __init__(self
, Wa
):
1345 self
._MapFileName
= os
.path
.join(Wa
.BuildDir
, Wa
.Name
+ ".map")
1346 self
._MapFileParsed
= False
1347 self
._EotToolInvoked
= False
1348 self
._FvDir
= Wa
.FvDir
1349 self
._EotDir
= Wa
.BuildDir
1350 self
._FfsEntryPoint
= {}
1352 self
._SourceList
= []
1353 self
.FixedMapDict
= {}
1358 # Collect all platform reference source files and GUID C Name
1360 for Pa
in Wa
.AutoGenObjectList
:
1361 for Module
in Pa
.LibraryAutoGenList
+ Pa
.ModuleAutoGenList
:
1363 # BASE typed modules are EFI agnostic, so we need not scan
1364 # their source code to find PPI/Protocol produce or consume
1367 if Module
.ModuleType
== "BASE":
1370 # Add module referenced source files
1372 self
._SourceList
.append(str(Module
))
1374 for Source
in Module
.SourceFileList
:
1375 if os
.path
.splitext(str(Source
))[1].lower() == ".c":
1376 self
._SourceList
.append(" " + str(Source
))
1377 FindIncludeFiles(Source
.Path
, Module
.IncludePathList
, IncludeList
)
1378 for IncludeFile
in IncludeList
.values():
1379 self
._SourceList
.append(" " + IncludeFile
)
1381 for Guid
in Module
.PpiList
:
1382 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.PpiList
[Guid
])
1383 for Guid
in Module
.ProtocolList
:
1384 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.ProtocolList
[Guid
])
1385 for Guid
in Module
.GuidList
:
1386 self
._GuidMap
[Guid
] = GuidStructureStringToGuidString(Module
.GuidList
[Guid
])
1388 if Module
.Guid
and not Module
.IsLibrary
:
1389 EntryPoint
= " ".join(Module
.Module
.ModuleEntryPointList
)
1390 if int(str(Module
.AutoGenVersion
), 0) >= 0x00010005:
1391 RealEntryPoint
= "_ModuleEntryPoint"
1393 RealEntryPoint
= EntryPoint
1394 if EntryPoint
== "_ModuleEntryPoint":
1395 CCFlags
= Module
.BuildOption
.get("CC", {}).get("FLAGS", "")
1396 Match
= gGlueLibEntryPoint
.search(CCFlags
)
1398 EntryPoint
= Match
.group(1)
1400 self
._FfsEntryPoint
[Module
.Guid
.upper()] = (EntryPoint
, RealEntryPoint
)
1404 # Collect platform firmware volume list as the input of EOT.
1408 for Fd
in Wa
.FdfProfile
.FdDict
:
1409 for FdRegion
in Wa
.FdfProfile
.FdDict
[Fd
].RegionList
:
1410 if FdRegion
.RegionType
!= "FV":
1412 for FvName
in FdRegion
.RegionDataList
:
1413 if FvName
in self
._FvList
:
1415 self
._FvList
.append(FvName
)
1416 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1417 for Section
in Ffs
.SectionList
:
1419 for FvSection
in Section
.SectionList
:
1420 if FvSection
.FvName
in self
._FvList
:
1422 self
._FvList
.append(FvSection
.FvName
)
1423 except AttributeError:
1428 # Parse platform fixed address map files
1430 # This function parses the platform final fixed address map file to get
1431 # the database of predicted fixed address for module image base, entry point
1434 # @param self: The object pointer
1436 def _ParseMapFile(self
):
1437 if self
._MapFileParsed
:
1439 self
._MapFileParsed
= True
1440 if os
.path
.isfile(self
._MapFileName
):
1442 FileContents
= open(self
._MapFileName
).read()
1443 for Match
in gMapFileItemPattern
.finditer(FileContents
):
1444 AddressType
= Match
.group(1)
1445 BaseAddress
= Match
.group(2)
1446 EntryPoint
= Match
.group(3)
1447 Guid
= Match
.group(4).upper()
1448 List
= self
.FixedMapDict
.setdefault(Guid
, [])
1449 List
.append((AddressType
, BaseAddress
, "*I"))
1450 List
.append((AddressType
, EntryPoint
, "*E"))
1452 EdkLogger
.warn(None, "Cannot open file to read", self
._MapFileName
)
1455 # Invokes EOT tool to get the predicted the execution order.
1457 # This function invokes EOT tool to calculate the predicted dispatch order
1459 # @param self: The object pointer
1461 def _InvokeEotTool(self
):
1462 if self
._EotToolInvoked
:
1465 self
._EotToolInvoked
= True
1467 for FvName
in self
._FvList
:
1468 FvFile
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv")
1469 if os
.path
.isfile(FvFile
):
1470 FvFileList
.append(FvFile
)
1472 if len(FvFileList
) == 0:
1475 # Write source file list and GUID file list to an intermediate file
1476 # as the input for EOT tool and dispatch List as the output file
1479 SourceList
= os
.path
.join(self
._EotDir
, "SourceFile.txt")
1480 GuidList
= os
.path
.join(self
._EotDir
, "GuidList.txt")
1481 DispatchList
= os
.path
.join(self
._EotDir
, "Dispatch.txt")
1483 TempFile
= open(SourceList
, "w+")
1484 for Item
in self
._SourceList
:
1485 FileWrite(TempFile
, Item
)
1487 TempFile
= open(GuidList
, "w+")
1488 for Key
in self
._GuidMap
:
1489 FileWrite(TempFile
, "%s %s" % (Key
, self
._GuidMap
[Key
]))
1493 from Eot
.Eot
import Eot
1496 # Invoke EOT tool and echo its runtime performance
1498 EotStartTime
= time
.time()
1499 Eot(CommandLineOption
=False, SourceFileList
=SourceList
, GuidList
=GuidList
,
1500 FvFileList
=' '.join(FvFileList
), Dispatch
=DispatchList
, IsInit
=True)
1501 EotEndTime
= time
.time()
1502 EotDuration
= time
.strftime("%H:%M:%S", time
.gmtime(int(round(EotEndTime
- EotStartTime
))))
1503 EdkLogger
.quiet("EOT run time: %s\n" % EotDuration
)
1506 # Parse the output of EOT tool
1508 for Line
in open(DispatchList
):
1509 if len(Line
.split()) < 4:
1511 (Guid
, Phase
, FfsName
, FilePath
) = Line
.split()
1512 Symbol
= self
._FfsEntryPoint
.get(Guid
, [FfsName
, ""])[0]
1513 if len(Symbol
) > self
.MaxLen
:
1514 self
.MaxLen
= len(Symbol
)
1515 self
.ItemList
.append((Phase
, Symbol
, FilePath
))
1517 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
1518 EdkLogger
.warn(None, "Failed to generate execution order prediction report, for some error occurred in executing EOT.")
1522 # Generate platform execution order report
1524 # This function generates the predicted module execution order.
1526 # @param self The object pointer
1527 # @param File The file object for report
1529 def _GenerateExecutionOrderReport(self
, File
):
1530 self
._InvokeEotTool
()
1531 if len(self
.ItemList
) == 0:
1533 FileWrite(File
, gSectionStart
)
1534 FileWrite(File
, "Execution Order Prediction")
1535 FileWrite(File
, "*P PEI phase")
1536 FileWrite(File
, "*D DXE phase")
1537 FileWrite(File
, "*E Module INF entry point name")
1538 FileWrite(File
, "*N Module notification function name")
1540 FileWrite(File
, "Type %-*s %s" % (self
.MaxLen
, "Symbol", "Module INF Path"))
1541 FileWrite(File
, gSectionSep
)
1542 for Item
in self
.ItemList
:
1543 FileWrite(File
, "*%sE %-*s %s" % (Item
[0], self
.MaxLen
, Item
[1], Item
[2]))
1545 FileWrite(File
, gSectionStart
)
1548 # Generate Fixed Address report.
1550 # This function generate the predicted fixed address report for a module
1551 # specified by Guid.
1553 # @param self The object pointer
1554 # @param File The file object for report
1555 # @param Guid The module Guid value.
1556 # @param NotifyList The list of all notify function in a module
1558 def _GenerateFixedAddressReport(self
, File
, Guid
, NotifyList
):
1559 self
._ParseMapFile
()
1560 FixedAddressList
= self
.FixedMapDict
.get(Guid
)
1561 if not FixedAddressList
:
1564 FileWrite(File
, gSubSectionStart
)
1565 FileWrite(File
, "Fixed Address Prediction")
1566 FileWrite(File
, "*I Image Loading Address")
1567 FileWrite(File
, "*E Entry Point Address")
1568 FileWrite(File
, "*N Notification Function Address")
1569 FileWrite(File
, "*F Flash Address")
1570 FileWrite(File
, "*M Memory Address")
1571 FileWrite(File
, "*S SMM RAM Offset")
1572 FileWrite(File
, "TOM Top of Memory")
1574 FileWrite(File
, "Type Address Name")
1575 FileWrite(File
, gSubSectionSep
)
1576 for Item
in FixedAddressList
:
1581 Name
= "(Image Base)"
1582 elif Symbol
== "*E":
1583 Name
= self
._FfsEntryPoint
.get(Guid
, ["", "_ModuleEntryPoint"])[1]
1584 elif Symbol
in NotifyList
:
1592 elif "Memory" in Type
:
1598 Value
= "TOM" + Value
1600 FileWrite(File
, "%s %-16s %s" % (Symbol
, Value
, Name
))
1603 # Generate report for the prediction part
1605 # This function generate the predicted fixed address report for a module or
1606 # predicted module execution order for a platform.
1607 # If the input Guid is None, then, it generates the predicted module execution order;
1608 # otherwise it generated the module fixed loading address for the module specified by
1611 # @param self The object pointer
1612 # @param File The file object for report
1613 # @param Guid The module Guid value.
1615 def GenerateReport(self
, File
, Guid
):
1617 self
._GenerateFixedAddressReport
(File
, Guid
.upper(), [])
1619 self
._GenerateExecutionOrderReport
(File
)
1622 # Reports FD region information
1624 # This class reports the FD subsection in the build report file.
1625 # It collects region information of platform flash device.
1626 # If the region is a firmware volume, it lists the set of modules
1627 # and its space information; otherwise, it only lists its region name,
1628 # base address and size in its sub-section header.
1629 # If there are nesting FVs, the nested FVs will list immediate after
1630 # this FD region subsection
1632 class FdRegionReport(object):
1634 # Discover all the nested FV name list.
1636 # This is an internal worker function to discover the all the nested FV information
1637 # in the parent firmware volume. It uses deep first search algorithm recursively to
1638 # find all the FV list name and append them to the list.
1640 # @param self The object pointer
1641 # @param FvName The name of current firmware file system
1642 # @param Wa Workspace context information
1644 def _DiscoverNestedFvList(self
, FvName
, Wa
):
1645 FvDictKey
=FvName
.upper()
1646 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1647 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1648 for Section
in Ffs
.SectionList
:
1650 for FvSection
in Section
.SectionList
:
1651 if FvSection
.FvName
in self
.FvList
:
1653 self
._GuidsDb
[Ffs
.NameGuid
.upper()] = FvSection
.FvName
1654 self
.FvList
.append(FvSection
.FvName
)
1655 self
.FvInfo
[FvSection
.FvName
] = ("Nested FV", 0, 0)
1656 self
._DiscoverNestedFvList
(FvSection
.FvName
, Wa
)
1657 except AttributeError:
1661 # Constructor function for class FdRegionReport
1663 # This constructor function generates FdRegionReport object for a specified FdRegion.
1664 # If the FdRegion is a firmware volume, it will recursively find all its nested Firmware
1665 # volume list. This function also collects GUID map in order to dump module identification
1666 # in the final report.
1668 # @param self: The object pointer
1669 # @param FdRegion The current FdRegion object
1670 # @param Wa Workspace context information
1672 def __init__(self
, FdRegion
, Wa
):
1673 self
.Type
= FdRegion
.RegionType
1674 self
.BaseAddress
= FdRegion
.Offset
1675 self
.Size
= FdRegion
.Size
1679 self
._FvDir
= Wa
.FvDir
1682 # If the input FdRegion is not a firmware volume,
1685 if self
.Type
!= "FV":
1689 # Find all nested FVs in the FdRegion
1691 for FvName
in FdRegion
.RegionDataList
:
1692 if FvName
in self
.FvList
:
1694 self
.FvList
.append(FvName
)
1695 self
.FvInfo
[FvName
] = ("Fd Region", self
.BaseAddress
, self
.Size
)
1696 self
._DiscoverNestedFvList
(FvName
, Wa
)
1700 # Collect PCDs declared in DEC files.
1702 for Pa
in Wa
.AutoGenObjectList
:
1703 for Package
in Pa
.PackageList
:
1704 for (TokenCName
, TokenSpaceGuidCName
, DecType
) in Package
.Pcds
:
1705 DecDefaultValue
= Package
.Pcds
[TokenCName
, TokenSpaceGuidCName
, DecType
].DefaultValue
1706 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DecDefaultValue
1708 # Collect PCDs defined in DSC file
1710 for Pa
in Wa
.AutoGenObjectList
:
1711 for (TokenCName
, TokenSpaceGuidCName
) in Pa
.Platform
.Pcds
:
1712 DscDefaultValue
= Pa
.Platform
.Pcds
[(TokenCName
, TokenSpaceGuidCName
)].DefaultValue
1713 PlatformPcds
[(TokenCName
, TokenSpaceGuidCName
)] = DscDefaultValue
1716 # Add PEI and DXE a priori files GUIDs defined in PI specification.
1718 self
._GuidsDb
["1B45CC0A-156A-428A-AF62-49864DA0E6E6"] = "PEI Apriori"
1719 self
._GuidsDb
["FC510EE7-FFDC-11D4-BD41-0080C73C8881"] = "DXE Apriori"
1721 # Add ACPI table storage file
1723 self
._GuidsDb
["7E374E25-8E01-4FEE-87F2-390C23C606CD"] = "ACPI table storage"
1725 for Pa
in Wa
.AutoGenObjectList
:
1726 for ModuleKey
in Pa
.Platform
.Modules
:
1727 M
= Pa
.Platform
.Modules
[ModuleKey
].M
1728 InfPath
= mws
.join(Wa
.WorkspaceDir
, M
.MetaFile
.File
)
1729 self
._GuidsDb
[M
.Guid
.upper()] = "%s (%s)" % (M
.Module
.BaseName
, InfPath
)
1732 # Collect the GUID map in the FV firmware volume
1734 for FvName
in self
.FvList
:
1735 FvDictKey
=FvName
.upper()
1736 if FvDictKey
in Wa
.FdfProfile
.FvDict
:
1737 for Ffs
in Wa
.FdfProfile
.FvDict
[FvName
.upper()].FfsList
:
1740 # collect GUID map for binary EFI file in FDF file.
1742 Guid
= Ffs
.NameGuid
.upper()
1743 Match
= gPcdGuidPattern
.match(Ffs
.NameGuid
)
1745 PcdTokenspace
= Match
.group(1)
1746 PcdToken
= Match
.group(2)
1747 if (PcdToken
, PcdTokenspace
) in PlatformPcds
:
1748 GuidValue
= PlatformPcds
[(PcdToken
, PcdTokenspace
)]
1749 Guid
= GuidStructureByteArrayToGuidString(GuidValue
).upper()
1750 for Section
in Ffs
.SectionList
:
1752 ModuleSectFile
= mws
.join(Wa
.WorkspaceDir
, Section
.SectFileName
)
1753 self
._GuidsDb
[Guid
] = ModuleSectFile
1754 except AttributeError:
1756 except AttributeError:
1761 # Internal worker function to generate report for the FD region
1763 # This internal worker function to generate report for the FD region.
1764 # It the type is firmware volume, it lists offset and module identification.
1766 # @param self The object pointer
1767 # @param File The file object for report
1768 # @param Title The title for the FD subsection
1769 # @param BaseAddress The base address for the FD region
1770 # @param Size The size of the FD region
1771 # @param FvName The FV name if the FD region is a firmware volume
1773 def _GenerateReport(self
, File
, Title
, Type
, BaseAddress
, Size
=0, FvName
=None):
1774 FileWrite(File
, gSubSectionStart
)
1775 FileWrite(File
, Title
)
1776 FileWrite(File
, "Type: %s" % Type
)
1777 FileWrite(File
, "Base Address: 0x%X" % BaseAddress
)
1779 if self
.Type
== "FV":
1783 if not os
.path
.isfile(FvName
):
1784 FvReportFileName
= os
.path
.join(self
._FvDir
, FvName
+ ".Fv.txt")
1786 if FvName
.upper().endswith('.FV'):
1787 FvReportFileName
= FvName
+ ".txt"
1789 FvReportFileName
= FvName
+ ".Fv.txt"
1792 # Collect size info in the firmware volume.
1794 FvReport
= open(FvReportFileName
).read()
1795 Match
= gFvTotalSizePattern
.search(FvReport
)
1797 FvTotalSize
= int(Match
.group(1), 16)
1798 Match
= gFvTakenSizePattern
.search(FvReport
)
1800 FvTakenSize
= int(Match
.group(1), 16)
1801 FvFreeSize
= FvTotalSize
- FvTakenSize
1803 # Write size information to the report file.
1805 FileWrite(File
, "Size: 0x%X (%.0fK)" % (FvTotalSize
, FvTotalSize
/ 1024.0))
1806 FileWrite(File
, "Fv Name: %s (%.1f%% Full)" % (FvName
, FvTakenSize
* 100.0 / FvTotalSize
))
1807 FileWrite(File
, "Occupied Size: 0x%X (%.0fK)" % (FvTakenSize
, FvTakenSize
/ 1024.0))
1808 FileWrite(File
, "Free Size: 0x%X (%.0fK)" % (FvFreeSize
, FvFreeSize
/ 1024.0))
1809 FileWrite(File
, "Offset Module")
1810 FileWrite(File
, gSubSectionSep
)
1812 # Write module offset and module identification to the report file.
1815 for Match
in gOffsetGuidPattern
.finditer(FvReport
):
1816 Guid
= Match
.group(2).upper()
1817 OffsetInfo
[Match
.group(1)] = self
._GuidsDb
.get(Guid
, Guid
)
1818 OffsetList
= OffsetInfo
.keys()
1820 for Offset
in OffsetList
:
1821 FileWrite (File
, "%s %s" % (Offset
, OffsetInfo
[Offset
]))
1823 EdkLogger
.warn(None, "Fail to read report file", FvReportFileName
)
1825 FileWrite(File
, "Size: 0x%X (%.0fK)" % (Size
, Size
/ 1024.0))
1826 FileWrite(File
, gSubSectionEnd
)
1829 # Generate report for the FD region
1831 # This function generates report for the FD region.
1833 # @param self The object pointer
1834 # @param File The file object for report
1836 def GenerateReport(self
, File
):
1837 if (len(self
.FvList
) > 0):
1838 for FvItem
in self
.FvList
:
1839 Info
= self
.FvInfo
[FvItem
]
1840 self
._GenerateReport
(File
, Info
[0], "FV", Info
[1], Info
[2], FvItem
)
1842 self
._GenerateReport
(File
, "FD Region", self
.Type
, self
.BaseAddress
, self
.Size
)
1845 # Reports FD information
1847 # This class reports the FD section in the build report file.
1848 # It collects flash device information for a platform.
1850 class FdReport(object):
1852 # Constructor function for class FdReport
1854 # This constructor function generates FdReport object for a specified
1857 # @param self The object pointer
1858 # @param Fd The current Firmware device object
1859 # @param Wa Workspace context information
1861 def __init__(self
, Fd
, Wa
):
1862 self
.FdName
= Fd
.FdUiName
1863 self
.BaseAddress
= Fd
.BaseAddress
1865 self
.FdRegionList
= [FdRegionReport(FdRegion
, Wa
) for FdRegion
in Fd
.RegionList
]
1866 self
.FvPath
= os
.path
.join(Wa
.BuildDir
, "FV")
1867 self
.VpdFilePath
= os
.path
.join(self
.FvPath
, "%s.map" % Wa
.Platform
.VpdToolGuid
)
1868 self
.VPDBaseAddress
= 0
1870 self
.VPDInfoList
= []
1871 for index
, FdRegion
in enumerate(Fd
.RegionList
):
1872 if str(FdRegion
.RegionType
) is 'FILE' and Wa
.Platform
.VpdToolGuid
in str(FdRegion
.RegionDataList
):
1873 self
.VPDBaseAddress
= self
.FdRegionList
[index
].BaseAddress
1874 self
.VPDSize
= self
.FdRegionList
[index
].Size
1877 if os
.path
.isfile(self
.VpdFilePath
):
1878 fd
= open(self
.VpdFilePath
, "r")
1879 Lines
= fd
.readlines()
1882 if len(Line
) == 0 or Line
.startswith("#"):
1885 PcdName
, SkuId
, Offset
, Size
, Value
= Line
.split("#")[0].split("|")
1886 PcdName
, SkuId
, Offset
, Size
, Value
= PcdName
.strip(), SkuId
.strip(), Offset
.strip(), Size
.strip(), Value
.strip()
1887 if Offset
.lower().startswith('0x'):
1888 Offset
= '0x%08X' % (int(Offset
, 16) + self
.VPDBaseAddress
)
1890 Offset
= '0x%08X' % (int(Offset
, 10) + self
.VPDBaseAddress
)
1891 self
.VPDInfoList
.append("%s | %s | %s | %s | %s" % (PcdName
, SkuId
, Offset
, Size
, Value
))
1893 EdkLogger
.error("BuildReport", CODE_ERROR
, "Fail to parse VPD information file %s" % self
.VpdFilePath
)
1897 # Generate report for the firmware device.
1899 # This function generates report for the firmware device.
1901 # @param self The object pointer
1902 # @param File The file object for report
1904 def GenerateReport(self
, File
):
1905 FileWrite(File
, gSectionStart
)
1906 FileWrite(File
, "Firmware Device (FD)")
1907 FileWrite(File
, "FD Name: %s" % self
.FdName
)
1908 FileWrite(File
, "Base Address: %s" % self
.BaseAddress
)
1909 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.Size
, self
.Size
/ 1024.0))
1910 if len(self
.FdRegionList
) > 0:
1911 FileWrite(File
, gSectionSep
)
1912 for FdRegionItem
in self
.FdRegionList
:
1913 FdRegionItem
.GenerateReport(File
)
1915 if len(self
.VPDInfoList
) > 0:
1916 FileWrite(File
, gSubSectionStart
)
1917 FileWrite(File
, "FD VPD Region")
1918 FileWrite(File
, "Base Address: 0x%X" % self
.VPDBaseAddress
)
1919 FileWrite(File
, "Size: 0x%X (%.0fK)" % (self
.VPDSize
, self
.VPDSize
/ 1024.0))
1920 FileWrite(File
, gSubSectionSep
)
1921 for item
in self
.VPDInfoList
:
1922 ValueList
= item
.split('|')
1923 Value
= ValueList
[-1].strip()
1924 IsByteArray
, ArrayList
= ByteArrayForamt(Value
)
1926 ValueList
[-1] = ' {'
1927 FileWrite(File
, '|'.join(ValueList
))
1928 for Array
in ArrayList
:
1929 FileWrite(File
, '%s' % (Array
))
1931 FileWrite(File
, item
)
1932 FileWrite(File
, gSubSectionEnd
)
1933 FileWrite(File
, gSectionEnd
)
1938 # Reports platform information
1940 # This class reports the whole platform information
1942 class PlatformReport(object):
1944 # Constructor function for class PlatformReport
1946 # This constructor function generates PlatformReport object a platform build.
1947 # It generates report for platform summary, flash, global PCDs and detailed
1948 # module information for modules involved in platform build.
1950 # @param self The object pointer
1951 # @param Wa Workspace context information
1952 # @param MaList The list of modules in the platform build
1954 def __init__(self
, Wa
, MaList
, ReportType
):
1955 self
._WorkspaceDir
= Wa
.WorkspaceDir
1956 self
.PlatformName
= Wa
.Name
1957 self
.PlatformDscPath
= Wa
.Platform
1958 self
.Architectures
= " ".join(Wa
.ArchList
)
1959 self
.ToolChain
= Wa
.ToolChain
1960 self
.Target
= Wa
.BuildTarget
1961 self
.OutputPath
= os
.path
.join(Wa
.WorkspaceDir
, Wa
.OutputDir
)
1962 self
.BuildEnvironment
= platform
.platform()
1964 self
.PcdReport
= None
1965 if "PCD" in ReportType
:
1966 self
.PcdReport
= PcdReport(Wa
)
1968 self
.FdReportList
= []
1969 if "FLASH" in ReportType
and Wa
.FdfProfile
and MaList
== None:
1970 for Fd
in Wa
.FdfProfile
.FdDict
:
1971 self
.FdReportList
.append(FdReport(Wa
.FdfProfile
.FdDict
[Fd
], Wa
))
1973 self
.PredictionReport
= None
1974 if "FIXED_ADDRESS" in ReportType
or "EXECUTION_ORDER" in ReportType
:
1975 self
.PredictionReport
= PredictionReport(Wa
)
1977 self
.DepexParser
= None
1978 if "DEPEX" in ReportType
:
1979 self
.DepexParser
= DepexParser(Wa
)
1981 self
.ModuleReportList
= []
1983 self
._IsModuleBuild
= True
1985 self
.ModuleReportList
.append(ModuleReport(Ma
, ReportType
))
1987 self
._IsModuleBuild
= False
1988 for Pa
in Wa
.AutoGenObjectList
:
1989 ModuleAutoGenList
= []
1990 for ModuleKey
in Pa
.Platform
.Modules
:
1991 ModuleAutoGenList
.append(Pa
.Platform
.Modules
[ModuleKey
].M
)
1992 if GlobalData
.gFdfParser
!= None:
1993 if Pa
.Arch
in GlobalData
.gFdfParser
.Profile
.InfDict
:
1994 INFList
= GlobalData
.gFdfParser
.Profile
.InfDict
[Pa
.Arch
]
1995 for InfName
in INFList
:
1996 InfClass
= PathClass(NormPath(InfName
), Wa
.WorkspaceDir
, Pa
.Arch
)
1997 Ma
= ModuleAutoGen(Wa
, InfClass
, Pa
.BuildTarget
, Pa
.ToolChain
, Pa
.Arch
, Wa
.MetaFile
)
2000 if Ma
not in ModuleAutoGenList
:
2001 ModuleAutoGenList
.append(Ma
)
2002 for MGen
in ModuleAutoGenList
:
2003 self
.ModuleReportList
.append(ModuleReport(MGen
, ReportType
))
2008 # Generate report for the whole platform.
2010 # This function generates report for platform information.
2011 # It comprises of platform summary, global PCD, flash and
2012 # module list sections.
2014 # @param self The object pointer
2015 # @param File The file object for report
2016 # @param BuildDuration The total time to build the modules
2017 # @param AutoGenTime The total time of AutoGen Phase
2018 # @param MakeTime The total time of Make Phase
2019 # @param GenFdsTime The total time of GenFds Phase
2020 # @param ReportType The kind of report items in the final report file
2022 def GenerateReport(self
, File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, ReportType
):
2023 FileWrite(File
, "Platform Summary")
2024 FileWrite(File
, "Platform Name: %s" % self
.PlatformName
)
2025 FileWrite(File
, "Platform DSC Path: %s" % self
.PlatformDscPath
)
2026 FileWrite(File
, "Architectures: %s" % self
.Architectures
)
2027 FileWrite(File
, "Tool Chain: %s" % self
.ToolChain
)
2028 FileWrite(File
, "Target: %s" % self
.Target
)
2029 if GlobalData
.gSkuids
:
2030 FileWrite(File
, "SKUID: %s" % " ".join(GlobalData
.gSkuids
))
2031 if GlobalData
.gDefaultStores
:
2032 FileWrite(File
, "DefaultStore: %s" % " ".join(GlobalData
.gDefaultStores
))
2033 FileWrite(File
, "Output Path: %s" % self
.OutputPath
)
2034 FileWrite(File
, "Build Environment: %s" % self
.BuildEnvironment
)
2035 FileWrite(File
, "Build Duration: %s" % BuildDuration
)
2037 FileWrite(File
, "AutoGen Duration: %s" % AutoGenTime
)
2039 FileWrite(File
, "Make Duration: %s" % MakeTime
)
2041 FileWrite(File
, "GenFds Duration: %s" % GenFdsTime
)
2042 FileWrite(File
, "Report Content: %s" % ", ".join(ReportType
))
2044 if GlobalData
.MixedPcd
:
2045 FileWrite(File
, gSectionStart
)
2046 FileWrite(File
, "The following PCDs use different access methods:")
2047 FileWrite(File
, gSectionSep
)
2048 for PcdItem
in GlobalData
.MixedPcd
:
2049 FileWrite(File
, "%s.%s" % (str(PcdItem
[1]), str(PcdItem
[0])))
2050 FileWrite(File
, gSectionEnd
)
2052 if not self
._IsModuleBuild
:
2053 if "PCD" in ReportType
:
2054 self
.PcdReport
.GenerateReport(File
, None)
2056 if "FLASH" in ReportType
:
2057 for FdReportListItem
in self
.FdReportList
:
2058 FdReportListItem
.GenerateReport(File
)
2060 for ModuleReportItem
in self
.ModuleReportList
:
2061 ModuleReportItem
.GenerateReport(File
, self
.PcdReport
, self
.PredictionReport
, self
.DepexParser
, ReportType
)
2063 if not self
._IsModuleBuild
:
2064 if "EXECUTION_ORDER" in ReportType
:
2065 self
.PredictionReport
.GenerateReport(File
, None)
2067 ## BuildReport class
2069 # This base class contain the routines to collect data and then
2070 # applies certain format to the output report
2072 class BuildReport(object):
2074 # Constructor function for class BuildReport
2076 # This constructor function generates BuildReport object a platform build.
2077 # It generates report for platform summary, flash, global PCDs and detailed
2078 # module information for modules involved in platform build.
2080 # @param self The object pointer
2081 # @param ReportFile The file name to save report file
2082 # @param ReportType The kind of report items in the final report file
2084 def __init__(self
, ReportFile
, ReportType
):
2085 self
.ReportFile
= ReportFile
2087 self
.ReportList
= []
2088 self
.ReportType
= []
2090 for ReportTypeItem
in ReportType
:
2091 if ReportTypeItem
not in self
.ReportType
:
2092 self
.ReportType
.append(ReportTypeItem
)
2094 self
.ReportType
= ["PCD", "LIBRARY", "BUILD_FLAGS", "DEPEX", "HASH", "FLASH", "FIXED_ADDRESS"]
2096 # Adds platform report to the list
2098 # This function adds a platform report to the final report list.
2100 # @param self The object pointer
2101 # @param Wa Workspace context information
2102 # @param MaList The list of modules in the platform build
2104 def AddPlatformReport(self
, Wa
, MaList
=None):
2106 self
.ReportList
.append((Wa
, MaList
))
2109 # Generates the final report.
2111 # This function generates platform build report. It invokes GenerateReport()
2112 # method for every platform report in the list.
2114 # @param self The object pointer
2115 # @param BuildDuration The total time to build the modules
2116 # @param AutoGenTime The total time of AutoGen phase
2117 # @param MakeTime The total time of Make phase
2118 # @param GenFdsTime The total time of GenFds phase
2120 def GenerateReport(self
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
):
2124 for (Wa
, MaList
) in self
.ReportList
:
2125 PlatformReport(Wa
, MaList
, self
.ReportType
).GenerateReport(File
, BuildDuration
, AutoGenTime
, MakeTime
, GenFdsTime
, self
.ReportType
)
2126 Content
= FileLinesSplit(File
.getvalue(), gLineMaxLength
)
2127 SaveFileOnChange(self
.ReportFile
, Content
, True)
2128 EdkLogger
.quiet("Build report can be found at %s" % os
.path
.abspath(self
.ReportFile
))
2130 EdkLogger
.error(None, FILE_WRITE_FAILURE
, ExtraData
=self
.ReportFile
)
2132 EdkLogger
.error("BuildReport", CODE_ERROR
, "Unknown fatal error when generating build report", ExtraData
=self
.ReportFile
, RaiseError
=False)
2133 EdkLogger
.quiet("(Python %s on %s\n%s)" % (platform
.python_version(), sys
.platform
, traceback
.format_exc()))
2136 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2137 if __name__
== '__main__':